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

package/dist/runtime/quickjs-serde.js

@@ -0,0 +1,2098 @@
+/**
+ * Host-side serialization for the QuickJS engine.
+ *
+ * Implements the workflow wire codec (format-prefixed devalue, identical to
+ * `codec-devalue-vm.ts` / the node:vm engine's workflow-mode codec) as
+ * host code operating on `JSValueHandle`s, using devalue 5.9's pluggable
+ * operations (quickjs-wasi's host-side introspection primitives underneath).
+ * The serde bundle previously evaluated inside the VM is gone: guest values
+ * are read and built through handles, so no serializer code lives in — or
+ * can be tampered with from — the guest realm.
+ *
+ * Side-effect discipline mirrors the node:vm engine's hardened codec
+ * (serialization/hardened.ts):
+ *
+ * - classification is by engine brand (`classId` against boot-captured
+ *   samples, `isError`, `isProxy`), never `instanceof` or
+ *   `Symbol.toStringTag`;
+ * - extraction goes through intrinsics captured at boot (before any user
+ *   code runs) invoked with explicit receivers, or through own-property
+ *   descriptor reads — patched prototypes and inherited accessors never
+ *   run;
+ * - the only guest code serialization can execute is the same code the
+ *   previous in-VM codec executed by contract: a class's static
+ *   `WORKFLOW_SERIALIZE` method, a step proxy's `__closureVarsFn`, and
+ *   `WORKFLOW_USE_STEP` / `WORKFLOW_DESERIALIZE` on revival.
+ *
+ * Wire-format parity with the previous in-VM codec is REQUIRED and covered
+ * by tests: event logs written by either codec must be readable by the
+ * other (steps serialized by the node runtime feed VM revival and vice
+ * versa).
+ *
+ * Hybrid value space: reducers return host shapes (plain objects, strings,
+ * numbers) whose leaves may be guest handles — exactly how the node:vm
+ * codec mixes host shapes with sandbox-realm leaves. Every stringify
+ * operation therefore dispatches on `JSValueHandle` and falls back to
+ * devalue's default host operations for host values. Parse operations
+ * always build guest values, so the parse side is handle-only.
+ */
+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 { defaultStringifyOperations, filterArrayIndices, parse, stringify, } from 'devalue';
+import { JSValueHandle } from 'quickjs-wasi';
+import { SerializationFormat } from '../serialization/types.js';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const FORMAT_PREFIX_LENGTH = 4;
+const hasNativeBase64 = typeof Uint8Array.fromBase64 === 'function' &&
+    typeof Uint8Array.prototype.toBase64 === 'function';
+const hasBuffer = typeof Buffer === 'function';
+function bytesToBase64(bytes) {
+    if (bytes.length === 0)
+        return '.';
+    if (hasNativeBase64) {
+        return bytes.toBase64?.();
+    }
+    if (hasBuffer) {
+        return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64');
+    }
+    let binary = '';
+    for (let idx = 0; idx < bytes.length; idx++) {
+        binary += String.fromCharCode(bytes[idx]);
+    }
+    return btoa(binary);
+}
+function base64ToBytes(value) {
+    if (value === '.')
+        return new Uint8Array(0);
+    if (hasNativeBase64) {
+        return Uint8Array.fromBase64?.(value);
+    }
+    if (hasBuffer) {
+        return new Uint8Array(Buffer.from(value, 'base64'));
+    }
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let idx = 0; idx < binary.length; idx++) {
+        bytes[idx] = binary.charCodeAt(idx);
+    }
+    return bytes;
+}
+// ---- boot-time captures ----
+/** devalue tags decided by engine class id, sampled at boot. */
+const BRANDED_SAMPLES = `({
+  Number: new Number(0),
+  String: new String(''),
+  Boolean: new Boolean(false),
+  BigInt: Object(0n),
+  Date: new Date(0),
+  RegExp: /x/,
+  Array: [],
+  Set: new Set(),
+  Map: new Map(),
+  ArrayBuffer: new ArrayBuffer(0),
+  DataView: new DataView(new ArrayBuffer(0)),
+  Int8Array: new Int8Array(0),
+  Uint8Array: new Uint8Array(0),
+  Uint8ClampedArray: new Uint8ClampedArray(0),
+  Int16Array: new Int16Array(0),
+  Uint16Array: new Uint16Array(0),
+  Int32Array: new Int32Array(0),
+  Uint32Array: new Uint32Array(0),
+  Float32Array: new Float32Array(0),
+  Float64Array: new Float64Array(0),
+  BigInt64Array: new BigInt64Array(0),
+  BigUint64Array: new BigUint64Array(0),
+})`;
+/**
+ * Intrinsics needed for reading and building, captured from the guest realm
+ * at serde creation (which the runtime does right after evaluating the
+ * bootstrap, before the workflow bundle). Held only on the host: later
+ * patching inside the VM cannot influence serialization.
+ *
+ * Globals installed by the extensions/bootstrap (Headers, Request,
+ * Response, ReadableStream, WritableStream, URL, URLSearchParams,
+ * DOMException, __WorkflowAbortSignal) are captured defensively — absent
+ * ones yield `undefined` and their reducers simply never match, exactly
+ * like the old in-VM reducers' `globalThis.X` probes.
+ */
+const CAPTURE_INTRINSICS = `(() => {
+  const descriptor = (object, key) =>
+    Object.getOwnPropertyDescriptor(object, key);
+  const getter = (object, key) => {
+    const d = descriptor(object, key);
+    return d && d.get;
+  };
+  const TypedArray = Object.getPrototypeOf(Int8Array.prototype);
+  const maybeProto = (Cls) => (Cls ? Cls.prototype : undefined);
+  const g = globalThis;
+
+  return {
+    // --- reading (stringify) ---
+    dateGetTime: Date.prototype.getTime,
+    dateToISOString: Date.prototype.toISOString,
+    regExpSource: getter(RegExp.prototype, 'source'),
+    regExpFlags: getter(RegExp.prototype, 'flags'),
+    numberValueOf: Number.prototype.valueOf,
+    stringValueOf: String.prototype.valueOf,
+    booleanValueOf: Boolean.prototype.valueOf,
+    bigIntValueOf: BigInt.prototype.valueOf,
+    bigIntToString: BigInt.prototype.toString,
+    setForEach: Set.prototype.forEach,
+    mapForEach: Map.prototype.forEach,
+    headersForEach: g.Headers ? g.Headers.prototype.forEach : undefined,
+    urlHref: g.URL ? getter(g.URL.prototype, 'href') : undefined,
+    urlSearchParamsToString: g.URLSearchParams
+      ? g.URLSearchParams.prototype.toString
+      : undefined,
+    urlSearchParamsSize: g.URLSearchParams
+      ? getter(g.URLSearchParams.prototype, 'size')
+      : undefined,
+    viewBuffer: getter(TypedArray, 'buffer'),
+    viewByteOffset: getter(TypedArray, 'byteOffset'),
+    viewByteLength: getter(TypedArray, 'byteLength'),
+    viewLength: getter(TypedArray, 'length'),
+    dataViewBuffer: getter(DataView.prototype, 'buffer'),
+    dataViewByteOffset: getter(DataView.prototype, 'byteOffset'),
+    dataViewByteLength: getter(DataView.prototype, 'byteLength'),
+    arrayBufferByteLength: getter(ArrayBuffer.prototype, 'byteLength'),
+    objectPrototype: Object.prototype,
+    errorPrototype: Error.prototype,
+    domExceptionPrototype: maybeProto(g.DOMException),
+    headersPrototype: maybeProto(g.Headers),
+    requestPrototype: maybeProto(g.Request),
+    responsePrototype: maybeProto(g.Response),
+    readableStreamPrototype: maybeProto(g.ReadableStream),
+    writableStreamPrototype: maybeProto(g.WritableStream),
+    urlPrototype: maybeProto(g.URL),
+    urlSearchParamsPrototype: maybeProto(g.URLSearchParams),
+
+    // --- building (parse) ---
+    Date, RegExp, Set, Map, Array, Object, DataView,
+    Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array,
+    Int32Array, Uint32Array, Float32Array, Float64Array,
+    BigInt64Array, BigUint64Array,
+    Error,
+    AggregateError: g.AggregateError,
+    EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError,
+    DOMException: g.DOMException,
+    Headers: g.Headers,
+    Request: g.Request,
+    Response: g.Response,
+    ReadableStream: g.ReadableStream,
+    WritableStream: g.WritableStream,
+    URL: g.URL,
+    URLSearchParams: g.URLSearchParams,
+    setAdd: Set.prototype.add,
+    mapSet: Map.prototype.set,
+    objectCreate: Object.create,
+    defineProperty: Object.defineProperty,
+    dateNow: Date.now,
+    objectFreeze: Object.freeze,
+    functionBind: Function.prototype.bind,
+    makeSparseArray: (length) => {
+      const array = [];
+      array[4294967294] = undefined;
+      delete array[4294967294];
+      array.length = length;
+      return array;
+    },
+    // Builds the closure-vars thunk a revived step proxy carries. Must be a
+    // guest closure (the proxy stores and later calls it from guest code).
+    makeThunk: (vars) => () => vars,
+  };
+})()`;
+/**
+ * Well-known symbols the reducers/revivers read or stamp, captured as guest
+ * symbol handles so descriptor reads/writes can be keyed on them.
+ */
+const SYMBOL_NAMES = [
+    'WORKFLOW_ABORT_STREAM_NAME',
+    'WORKFLOW_ABORT_HOOK_TOKEN',
+    'BODY_INIT',
+    'WORKFLOW_STREAM_NAME',
+    'WORKFLOW_STREAM_TYPE',
+    'WORKFLOW_STREAM_FRAMING',
+    'WORKFLOW_STREAM_SERVER_RUN_ID',
+    'WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID',
+    'WEBHOOK_RESPONSE_WRITABLE',
+    'WORKFLOW_USE_STEP',
+    'workflow-serialize', // @workflow/serde WORKFLOW_SERIALIZE
+    'workflow-deserialize', // @workflow/serde WORKFLOW_DESERIALIZE
+    'workflow-class-registry',
+    '@workflow/errors//FatalError',
+    '@workflow/errors//HookConflictError',
+    '@workflow/errors//RetryableError',
+    '@workflow/errors//RuntimeDecryptionError',
+];
+/**
+ * The single guest expression that performs EVERY guest-touching part of
+ * serde initialization: the intrinsics capture, the branded samples, and
+ * the well-known symbol lookups, bundled into one container object.
+ *
+ * Bundling matters for the baseline-snapshot path: the container is
+ * created BEFORE the workflow bundle evaluates (capture-before-user-code,
+ * same as the fresh path), its handle's box lives in the snapshot's
+ * linear memory, and every restored VM re-adopts it BY POINTER
+ * (`adoptSerdeRoot`) — so serde initialization executes NO guest code
+ * after user code has run. Anything less lets a module-scope wrapper
+ * around e.g. `Object.getOwnPropertyDescriptor` observe (and be mutated
+ * by) a post-eval capture, diverging fresh and restored replays.
+ */
+const CAPTURE_ROOT = `(() => ({
+  intrinsics: ${CAPTURE_INTRINSICS},
+  samples: ${BRANDED_SAMPLES},
+  symbols: {
+${SYMBOL_NAMES.map((name) => `    ${JSON.stringify(name)}: Symbol.for(${JSON.stringify(name)})`).join(',\n')}
+  },
+}))()`;
+/**
+ * Evaluate the serde capture root in a VM. Must run after the runtime
+ * bootstrap and BEFORE any user code. The returned handle owns the
+ * container; on the baseline-snapshot path its raw box pointer
+ * (`handle.ptr`) is recorded next to the snapshot and re-adopted per
+ * restored VM via {@link adoptSerdeRoot} — do NOT dispose the handle
+ * before the snapshot is taken (the box must stay live in the memory
+ * image).
+ */
+export function captureSerdeRoot(vm) {
+    return vm.evalCode(CAPTURE_ROOT);
+}
+/**
+ * Re-create the capture-root handle in a VM restored from a snapshot
+ * taken while the exported root was alive, via quickjs-wasi's
+ * snapshot-portable handle tokens (`importHandle` duplicates the
+ * underlying value — the returned handle is independently owned and the
+ * serde disposes it per restored VM). No guest code executes.
+ */
+export function adoptSerdeRoot(vm, token) {
+    return vm.importHandle(token);
+}
+/**
+ * Export the capture root as a snapshot-portable token to record next to
+ * the baseline snapshot. The root handle must stay undisposed until the
+ * snapshot is taken (its box — and the reference it holds — must be part
+ * of the memory image).
+ */
+export function exportSerdeRoot(vm, root) {
+    return vm.exportHandle(root);
+}
+/**
+ * Create the host-side serde for a VM. Must be called after the runtime
+ * bootstrap has been evaluated (so bootstrap-installed globals are
+ * capturable) and before the workflow bundle runs.
+ */
+export function createQuickJSSerde(vm, 
+/**
+ * Pre-captured serde root (baseline-snapshot path): the container
+ * `captureSerdeRoot` created BEFORE user code, re-adopted from the
+ * restored memory image via `adoptSerdeRoot`. When omitted, the root
+ * is captured now — callers must guarantee no user code has run yet.
+ * Either way, initialization below performs only plain-data property
+ * reads and C-level classId reads on the container: NO guest code
+ * executes here, so nothing user-patchable can observe or perturb it.
+ */
+capturedRoot) {
+    const disposables = [];
+    const keep = (handle) => {
+        disposables.push(handle);
+        return handle;
+    };
+    const isHandle = (value) => value instanceof JSValueHandle;
+    // --- boot capture ---
+    const root = keep(capturedRoot ?? captureSerdeRoot(vm));
+    const tagByClassId = new Map();
+    {
+        const samples = root.getProp('samples');
+        try {
+            for (const tag of samples.getOwnPropertyNames()) {
+                const sample = samples.getProp(tag);
+                tagByClassId.set(sample.classId, tag);
+                sample.dispose();
+            }
+        }
+        finally {
+            samples.dispose();
+        }
+    }
+    const intrinsics = keep(root.getProp('intrinsics'));
+    const at = (name) => keep(intrinsics.getProp(name));
+    /** Absent captures (extension/bootstrap global not installed). */
+    const optional = (name) => {
+        const handle = at(name);
+        return handle.isUndefined ? undefined : handle;
+    };
+    const i = {
+        dateGetTime: at('dateGetTime'),
+        dateToISOString: at('dateToISOString'),
+        regExpSource: at('regExpSource'),
+        regExpFlags: at('regExpFlags'),
+        numberValueOf: at('numberValueOf'),
+        stringValueOf: at('stringValueOf'),
+        booleanValueOf: at('booleanValueOf'),
+        bigIntValueOf: at('bigIntValueOf'),
+        bigIntToString: at('bigIntToString'),
+        setForEach: at('setForEach'),
+        mapForEach: at('mapForEach'),
+        headersForEach: optional('headersForEach'),
+        urlHref: optional('urlHref'),
+        urlSearchParamsToString: optional('urlSearchParamsToString'),
+        urlSearchParamsSize: optional('urlSearchParamsSize'),
+        viewBuffer: at('viewBuffer'),
+        viewByteOffset: at('viewByteOffset'),
+        viewByteLength: at('viewByteLength'),
+        viewLength: at('viewLength'),
+        dataViewBuffer: at('dataViewBuffer'),
+        dataViewByteOffset: at('dataViewByteOffset'),
+        dataViewByteLength: at('dataViewByteLength'),
+        arrayBufferByteLength: at('arrayBufferByteLength'),
+        objectPrototype: at('objectPrototype'),
+        errorPrototype: at('errorPrototype'),
+        domExceptionPrototype: optional('domExceptionPrototype'),
+        headersPrototype: optional('headersPrototype'),
+        requestPrototype: optional('requestPrototype'),
+        responsePrototype: optional('responsePrototype'),
+        readableStreamPrototype: optional('readableStreamPrototype'),
+        writableStreamPrototype: optional('writableStreamPrototype'),
+        urlPrototype: optional('urlPrototype'),
+        urlSearchParamsPrototype: optional('urlSearchParamsPrototype'),
+        Date: at('Date'),
+        RegExp: at('RegExp'),
+        Set: at('Set'),
+        Map: at('Map'),
+        Array: at('Array'),
+        Object: at('Object'),
+        Error: at('Error'),
+        AggregateError: optional('AggregateError'),
+        DOMException: optional('DOMException'),
+        Headers: optional('Headers'),
+        ReadableStream: optional('ReadableStream'),
+        WritableStream: optional('WritableStream'),
+        URL: optional('URL'),
+        URLSearchParams: optional('URLSearchParams'),
+        setAdd: at('setAdd'),
+        mapSet: at('mapSet'),
+        objectCreate: at('objectCreate'),
+        defineProperty: at('defineProperty'),
+        dateNow: at('dateNow'),
+        objectFreeze: at('objectFreeze'),
+        functionBind: at('functionBind'),
+        makeSparseArray: at('makeSparseArray'),
+        makeThunk: at('makeThunk'),
+    };
+    const errorConstructors = new Map();
+    for (const name of [
+        'EvalError',
+        'RangeError',
+        'ReferenceError',
+        'SyntaxError',
+        'TypeError',
+        'URIError',
+    ]) {
+        errorConstructors.set(name, at(name));
+    }
+    const typedArrayConstructors = new Map();
+    for (const name of [
+        'Int8Array',
+        'Uint8Array',
+        'Uint8ClampedArray',
+        'Int16Array',
+        'Uint16Array',
+        'Int32Array',
+        'Uint32Array',
+        'Float32Array',
+        'Float64Array',
+        'BigInt64Array',
+        'BigUint64Array',
+        'DataView',
+    ]) {
+        typedArrayConstructors.set(name, at(name));
+    }
+    const symbols = new Map();
+    {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const symbolsContainer = __addDisposableResource(env_1, root.getProp('symbols'), false);
+            for (const name of SYMBOL_NAMES) {
+                symbols.set(name, keep(symbolsContainer.getProp(name)));
+            }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    const sym = (name) => {
+        const handle = symbols.get(name);
+        if (!handle)
+            throw new Error(`unknown captured symbol: ${name}`);
+        return handle;
+    };
+    // --- handle helpers ---
+    const call = (fn, thisValue, ...args) => vm.callFunction(fn, thisValue, ...args);
+    const invoke = (fn, ...args) => vm.callFunction(fn, vm.undefined, ...args);
+    /**
+     * Guest own-property check through the handle's introspection method.
+     * MUST NOT be replaced with `Object.hasOwn`, which would interrogate the
+     * host JSValueHandle wrapper object (always false) instead of the guest
+     * value — biome's noPrototypeBuiltins auto-fix does exactly that, which
+     * is why this is centralized here with the suppression.
+     */
+    const guestHasOwn = (handle, key) => 
+    // biome-ignore lint/suspicious/noPrototypeBuiltins: JSValueHandle.hasOwnProperty is quickjs-wasi's guest-side introspection API, not Object.prototype.hasOwnProperty
+    handle.hasOwnProperty(key);
+    /**
+     * Own data-property read. Returns undefined for absent properties AND for
+     * accessor properties — an inherited or own getter is never invoked
+     * (matching the hardened node:vm codec's descriptor-based reads).
+     */
+    const own = (target, key) => {
+        const descriptor = target.getOwnPropertyDescriptor(key);
+        if (!descriptor)
+            return undefined;
+        descriptor.get?.dispose();
+        descriptor.set?.dispose();
+        return descriptor.value;
+    };
+    /**
+     * Data-property read following the prototype chain (the safe analogue of
+     * `value.name` on an Error instance, where `name`/`message` live on the
+     * prototype). Accessors anywhere on the chain are skipped, not invoked.
+     */
+    const chained = (target, key) => {
+        let current;
+        let owned = false; // whether `current` is ours to dispose
+        let cursor = target;
+        for (let depth = 0; depth < 32; depth++) {
+            const found = own(cursor, key);
+            if (found) {
+                if (owned)
+                    cursor.dispose();
+                return found;
+            }
+            const proto = cursor.getPrototypeOf();
+            if (owned)
+                cursor.dispose();
+            if (proto.isNull || proto.isUndefined) {
+                proto.dispose();
+                return undefined;
+            }
+            cursor = proto;
+            owned = true;
+            current = proto;
+        }
+        if (owned && current)
+            current.dispose();
+        return undefined;
+    };
+    /** Host string from a data property (own-or-chain), or undefined. */
+    const chainedString = (target, key) => {
+        const handle = chained(target, key);
+        if (!handle)
+            return undefined;
+        const result = handle.isString ? handle.toString() : undefined;
+        handle.dispose();
+        return result;
+    };
+    const ownString = (target, key) => {
+        const handle = own(target, key);
+        if (!handle)
+            return undefined;
+        const result = handle.isString ? handle.toString() : undefined;
+        handle.dispose();
+        return result;
+    };
+    /**
+     * Whether `handle` has `prototypeHandle` anywhere on its prototype chain —
+     * the trap-free analogue of `instanceof` (which would fire
+     * `Symbol.hasInstance`).
+     */
+    const hasPrototype = (handle, prototypeHandle) => {
+        if (!prototypeHandle)
+            return false;
+        let cursor = handle.getPrototypeOf();
+        for (let depth = 0; depth < 32; depth++) {
+            if (cursor.isNull || cursor.isUndefined) {
+                cursor.dispose();
+                return false;
+            }
+            if (cursor.identity === prototypeHandle.identity) {
+                cursor.dispose();
+                return true;
+            }
+            const next = cursor.getPrototypeOf();
+            cursor.dispose();
+            cursor = next;
+        }
+        cursor.dispose();
+        return false;
+    };
+    /** `Object.defineProperty` write, immune to inherited setters. */
+    const define = (target, key, value) => {
+        const descriptor = vm.newObject();
+        try {
+            descriptor.setProp('value', value);
+            descriptor.setProp('writable', vm.true);
+            descriptor.setProp('enumerable', vm.true);
+            descriptor.setProp('configurable', vm.true);
+            if (typeof key === 'string') {
+                const keyHandle = vm.newString(key);
+                try {
+                    call(i.defineProperty, vm.undefined, target, keyHandle, descriptor).dispose();
+                }
+                finally {
+                    keyHandle.dispose();
+                }
+            }
+            else {
+                call(i.defineProperty, vm.undefined, target, key, descriptor).dispose();
+            }
+        }
+        finally {
+            descriptor.dispose();
+        }
+    };
+    const newGuestString = (value) => vm.newString(value);
+    /** Collect Set values / Map entries via captured forEach. */
+    const collect = (forEach, collection, arity) => {
+        const collected = [];
+        const visitor = vm.newEphemeralFunction((value, key) => {
+            // dup(): the visitor's own arg handles are borrowed (C-owned,
+            // scope-exempt as of quickjs-wasi 3.3.1); the dups are owned
+            // references, scope-tracked and swept at the pass boundary.
+            collected.push(arity === 1 ? value.dup() : [key.dup(), value.dup()]);
+            return vm.undefined;
+        });
+        try {
+            call(forEach, collection, visitor).dispose();
+        }
+        finally {
+            visitor.dispose();
+        }
+        return collected;
+    };
+    /** Copy a typed array / DataView's viewed bytes to the host. */
+    const viewBytes = (handle) => {
+        const isDataView = handle.isDataView;
+        const buffer = call(isDataView ? i.dataViewBuffer : i.viewBuffer, handle);
+        try {
+            const byteOffset = call(isDataView ? i.dataViewByteOffset : i.viewByteOffset, handle).consume((h) => h.toNumber());
+            const byteLength = call(isDataView ? i.dataViewByteLength : i.viewByteLength, handle).consume((h) => h.toNumber());
+            const bytes = new Uint8Array(buffer.toArrayBuffer());
+            return bytes.subarray(byteOffset, byteOffset + byteLength);
+        }
+        finally {
+            buffer.dispose();
+        }
+    };
+    const tagOfHandle = (handle) => {
+        if (handle.isProxy)
+            return 'Object';
+        return tagByClassId.get(handle.classId) ?? 'Object';
+    };
+    // --- identity ---
+    const identities = new Map();
+    const identityOf = (pointer) => {
+        let identity = identities.get(pointer);
+        if (!identity) {
+            identity = { pointer };
+            identities.set(pointer, identity);
+        }
+        return identity;
+    };
+    const primitiveOf = (handle) => {
+        if (handle.isUndefined)
+            return undefined;
+        if (handle.isNull)
+            return null;
+        if (handle.isBool)
+            return handle.toBoolean();
+        if (handle.isNumber)
+            return handle.toNumber();
+        if (handle.isBigInt)
+            return guestBigInt(handle);
+        return handle.toString();
+    };
+    /**
+     * Extract a guest bigint via the captured `BigInt.prototype.toString` —
+     * `handle.toBigInt()` truncates to 64 bits.
+     */
+    const guestBigInt = (handle) => BigInt(call(i.bigIntToString, handle).consume((h) => h.toString()));
+    // --- hybrid stringify operations ---
+    // Handles take the introspection path; host values (reducer outputs)
+    // fall back to devalue's defaults.
+    const d = defaultStringifyOperations;
+    const stringifyOperations = {
+        identify: (value) => {
+            if (!isHandle(value))
+                return d.identify(value);
+            const pointer = value.identity;
+            if (pointer === 0 || value.isString)
+                return primitiveOf(value);
+            return identityOf(pointer);
+        },
+        typeOf: (value) => {
+            if (!isHandle(value))
+                return d.typeOf(value);
+            if (value.isNull)
+                return 'null';
+            return value.typeof;
+        },
+        toPrimitive: (value) => (isHandle(value) ? primitiveOf(value) : value),
+        tagOf: (value) => (isHandle(value) ? tagOfHandle(value) : d.tagOf(value)),
+        isThenable: (value) => isHandle(value) ? value.isPromise : d.isThenable(value),
+        toPromise: async (value) => {
+            if (!isHandle(value))
+                return d.toPromise(value);
+            const settled = await vm.resolvePromise(value);
+            if ('error' in settled)
+                throw settled.error;
+            return settled.value;
+        },
+        unbox: (value) => {
+            if (!isHandle(value))
+                return d.unbox(value);
+            switch (tagOfHandle(value)) {
+                case 'Number':
+                    return call(i.numberValueOf, value);
+                case 'String':
+                    return call(i.stringValueOf, value);
+                case 'Boolean':
+                    return call(i.booleanValueOf, value);
+                default:
+                    return call(i.bigIntValueOf, value);
+            }
+        },
+        toISOString: (value) => {
+            if (!isHandle(value))
+                return d.toISOString(value);
+            if (Number.isNaN(call(i.dateGetTime, value).consume((h) => h.toNumber()))) {
+                return '';
+            }
+            return call(i.dateToISOString, value).consume((h) => h.toString());
+        },
+        toStringValue: (value) => {
+            if (!isHandle(value))
+                return d.toStringValue(value);
+            // URL / URLSearchParams are matched by workflow reducers before
+            // devalue's native handling, and Temporal doesn't exist in the VM, so
+            // this is unreachable in practice. Refuse rather than invoke guest
+            // `toString`.
+            throw new Error(`no captured string conversion for ${tagOfHandle(value)} in the VM`);
+        },
+        regExpInfo: (value) => {
+            if (!isHandle(value))
+                return d.regExpInfo(value);
+            return {
+                source: call(i.regExpSource, value).consume((h) => h.toString()),
+                flags: call(i.regExpFlags, value).consume((h) => h.toString()),
+            };
+        },
+        valuesOf: (value) => isHandle(value) ? collect(i.setForEach, value, 1) : d.valuesOf(value),
+        entriesOf: (value) => isHandle(value)
+            ? collect(i.mapForEach, value, 2)
+            : d.entriesOf(value),
+        viewInfo: (value) => {
+            if (!isHandle(value))
+                return d.viewInfo(value);
+            const isDataView = value.isDataView;
+            const buffer = call(isDataView ? i.dataViewBuffer : i.viewBuffer, value);
+            const info = {
+                buffer,
+                byteOffset: call(isDataView ? i.dataViewByteOffset : i.viewByteOffset, value).consume((h) => h.toNumber()),
+                byteLength: call(isDataView ? i.dataViewByteLength : i.viewByteLength, value).consume((h) => h.toNumber()),
+                bufferByteLength: call(i.arrayBufferByteLength, buffer).consume((h) => h.toNumber()),
+                length: 0,
+            };
+            if (!isDataView) {
+                info.length = call(i.viewLength, value).consume((h) => h.toNumber());
+            }
+            return info;
+        },
+        toArrayBuffer: (value) => isHandle(value) ? value.toArrayBuffer() : d.toArrayBuffer(value),
+        lengthOf: (value) => {
+            if (!isHandle(value))
+                return d.lengthOf(value);
+            const length = own(value, 'length');
+            return length?.consume((h) => h.toNumber()) ?? 0;
+        },
+        hasOwn: (value, key) => isHandle(value) ? guestHasOwn(value, String(key)) : d.hasOwn(value, key),
+        indicesOf: (value) => isHandle(value) ? filterArrayIndices(value.keys()) : d.indicesOf(value),
+        shapeOf: (value) => {
+            if (!isHandle(value))
+                return d.shapeOf(value);
+            if (value.isProxy)
+                return { kind: 'not-plain' };
+            const prototype = value.getPrototypeOf();
+            try {
+                const isPlain = prototype.isNull || prototype.identity === i.objectPrototype.identity;
+                if (!isPlain)
+                    return { kind: 'not-plain' };
+                const keys = [];
+                for (const key of value.getOwnPropertyKeys()) {
+                    if (typeof key !== 'string') {
+                        const enumerable = value.getOwnPropertyDescriptor(key)?.enumerable ?? false;
+                        key.dispose();
+                        if (enumerable)
+                            return { kind: 'symbol-keys' };
+                        continue;
+                    }
+                    if (value.propertyIsEnumerable(key))
+                        keys.push(key);
+                }
+                return {
+                    kind: prototype.isNull ? 'null-proto' : 'plain',
+                    keys,
+                };
+            }
+            finally {
+                prototype.dispose();
+            }
+        },
+        get: (value, key) => {
+            if (!isHandle(value))
+                return d.get(value, key);
+            const descriptor = value.getOwnPropertyDescriptor(String(key));
+            if (!descriptor)
+                return undefined;
+            if (descriptor.get) {
+                // Parity with the hardened node:vm codec: getters are invoked (full
+                // compatibility with values whose shape depends on accessors), the
+                // difference from `[[Get]]` being that this is an explicit, single
+                // invocation of the accessor the descriptor names.
+                const result = call(descriptor.get, value);
+                descriptor.get.dispose();
+                descriptor.set?.dispose();
+                return result;
+            }
+            descriptor.set?.dispose();
+            return descriptor.value;
+        },
+    };
+    // --- workflow reducers (handle space) ---
+    /** Host shape for error-family reduction; leaves may be handles. */
+    const reduceErrorShape = (value) => {
+        const shape = {
+            message: chainedString(value, 'message') ?? '',
+        };
+        const stack = chainedString(value, 'stack');
+        if (stack !== undefined)
+            shape.stack = stack;
+        if (guestHasOwn(value, 'cause')) {
+            shape.cause = own(value, 'cause') ?? undefined;
+        }
+        return shape;
+    };
+    const namedErrorSubclassReducer = (subclassName) => (value) => {
+        if (!isHandle(value) || !value.isError)
+            return false;
+        if (chainedString(value, 'name') !== subclassName)
+            return false;
+        return reduceErrorShape(value);
+    };
+    /** Own symbol-keyed data read returning a host string, or undefined. */
+    const ownSymbolString = (value, name) => {
+        const handle = own(value, sym(name));
+        if (!handle)
+            return undefined;
+        const result = handle.isString ? handle.toString() : undefined;
+        handle.dispose();
+        return result;
+    };
+    const reduceAbort = (value) => {
+        // streamName/hookToken live on the signal (or the controller's signal).
+        const signal = own(value, 'signal');
+        const holder = signal ?? value;
+        const streamName = ownSymbolString(value, 'WORKFLOW_ABORT_STREAM_NAME') ??
+            ownSymbolString(holder, 'WORKFLOW_ABORT_STREAM_NAME');
+        const hookToken = ownSymbolString(value, 'WORKFLOW_ABORT_HOOK_TOKEN') ??
+            ownSymbolString(holder, 'WORKFLOW_ABORT_HOOK_TOKEN');
+        if (!streamName) {
+            signal?.dispose();
+            throw new Error('AbortController/AbortSignal stream name is not set');
+        }
+        const aborted = own(holder, 'aborted')?.consume((h) => h.toBoolean()) ?? false;
+        const reason = aborted ? own(holder, 'reason') : undefined;
+        if (signal && holder !== value)
+            signal.dispose();
+        return {
+            streamName,
+            hookToken,
+            aborted,
+            reason: aborted ? reason : undefined,
+        };
+    };
+    const reducers = {
+        // Order is wire-significant (first match wins) and mirrors
+        // codec-devalue-vm.ts getReducersForMode('workflow') exactly.
+        AbortController: (value) => {
+            if (!isHandle(value) || value.typeof !== 'object' || value.isNull) {
+                return false;
+            }
+            if (!guestHasOwn(value, 'signal'))
+                return false;
+            const hasStamp = ownSymbolString(value, 'WORKFLOW_ABORT_STREAM_NAME') !== undefined ||
+                own(value, 'signal')?.consume((signal) => ownSymbolString(signal, 'WORKFLOW_ABORT_STREAM_NAME') !== undefined);
+            if (!hasStamp)
+                return false;
+            return reduceAbort(value);
+        },
+        AbortSignal: (value) => {
+            if (!isHandle(value) || value.typeof !== 'object' || value.isNull) {
+                return false;
+            }
+            if (ownSymbolString(value, 'WORKFLOW_ABORT_STREAM_NAME') === undefined) {
+                return false;
+            }
+            return reduceAbort(value);
+        },
+        Class: (value) => {
+            if (!isHandle(value) || value.typeof !== 'function')
+                return false;
+            const classId = ownString(value, 'classId');
+            if (classId === undefined)
+                return false;
+            return { classId };
+        },
+        Instance: (value) => {
+            if (!isHandle(value) || value.typeof !== 'object' || value.isNull) {
+                return false;
+            }
+            const cls = chained(value, 'constructor');
+            if (!cls || cls.typeof !== 'function') {
+                cls?.dispose();
+                return false;
+            }
+            try {
+                const serializeMethod = chained(cls, sym('workflow-serialize'));
+                if (!serializeMethod || serializeMethod.typeof !== 'function') {
+                    serializeMethod?.dispose();
+                    return false;
+                }
+                try {
+                    const classId = chainedString(cls, 'classId');
+                    if (classId === undefined) {
+                        const name = chainedString(cls, 'name') ?? '<anonymous>';
+                        throw new Error(`Class "${name}" with Symbol(workflow-serialize) must have a static "classId" property.`);
+                    }
+                    // Guest code by contract: the class's own serializer runs, exactly
+                    // as it did under the in-VM codec.
+                    const data = call(serializeMethod, cls, value);
+                    return { classId, data };
+                }
+                finally {
+                    serializeMethod.dispose();
+                }
+            }
+            finally {
+                cls.dispose();
+            }
+        },
+        StepFunction: (value) => {
+            if (!isHandle(value) || value.typeof !== 'function')
+                return false;
+            const stepId = ownString(value, 'stepId');
+            if (stepId === undefined)
+                return false;
+            const payload = { stepId };
+            const closureVarsFn = own(value, '__closureVarsFn');
+            if (closureVarsFn) {
+                if (closureVarsFn.typeof === 'function') {
+                    // Guest code by contract (same as the in-VM codec).
+                    const closureVars = call(closureVarsFn, vm.undefined);
+                    if (!closureVars.isUndefined)
+                        payload.closureVars = closureVars;
+                    else
+                        closureVars.dispose();
+                }
+                closureVarsFn.dispose();
+            }
+            if (guestHasOwn(value, '__boundThis')) {
+                payload.boundThis = own(value, '__boundThis');
+            }
+            const boundArgs = own(value, '__boundArgs');
+            if (boundArgs) {
+                const length = own(boundArgs, 'length')?.consume((h) => h.toNumber()) ?? 0;
+                if (boundArgs.isArray && length > 0)
+                    payload.boundArgs = boundArgs;
+                else
+                    boundArgs.dispose();
+            }
+            return payload;
+        },
+        ArrayBuffer: (value) => {
+            if (!isHandle(value) || tagOfHandle(value) !== 'ArrayBuffer') {
+                return false;
+            }
+            return bytesToBase64(new Uint8Array(value.toArrayBuffer()));
+        },
+        BigInt: (value) => {
+            if (!isHandle(value) || !value.isBigInt)
+                return false;
+            return guestBigInt(value).toString();
+        },
+        BigInt64Array: (value) => isHandle(value) && tagOfHandle(value) === 'BigInt64Array'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+        BigUint64Array: (value) => isHandle(value) && tagOfHandle(value) === 'BigUint64Array'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+        Date: (value) => {
+            if (!isHandle(value) || tagOfHandle(value) !== 'Date')
+                return false;
+            const time = call(i.dateGetTime, value).consume((h) => h.toNumber());
+            if (Number.isNaN(time))
+                return '.';
+            return call(i.dateToISOString, value).consume((h) => h.toString());
+        },
+        DOMException: (value) => {
+            if (!isHandle(value) || !isHandle(value))
+                return false;
+            if (!i.domExceptionPrototype ||
+                !hasPrototype(value, i.domExceptionPrototype)) {
+                return false;
+            }
+            const shape = reduceErrorShape(value);
+            return {
+                message: shape.message,
+                name: chainedString(value, 'name'),
+                stack: shape.stack,
+                ...(Object.hasOwn(shape, 'cause') ? { cause: shape.cause } : {}),
+            };
+        },
+        AggregateError: (value) => {
+            if (!isHandle(value) || !value.isError)
+                return false;
+            if (chainedString(value, 'name') !== 'AggregateError')
+                return false;
+            const shape = reduceErrorShape(value);
+            return {
+                message: shape.message,
+                stack: shape.stack,
+                errors: own(value, 'errors'),
+                ...(Object.hasOwn(shape, 'cause') ? { cause: shape.cause } : {}),
+            };
+        },
+        EvalError: namedErrorSubclassReducer('EvalError'),
+        FatalError: namedErrorSubclassReducer('FatalError'),
+        HookConflictError: (value) => {
+            if (!isHandle(value) || !value.isError)
+                return false;
+            if (chainedString(value, 'name') !== 'HookConflictError')
+                return false;
+            const shape = reduceErrorShape(value);
+            const reduced = {
+                message: shape.message,
+                stack: shape.stack,
+                token: own(value, 'token'),
+            };
+            const conflictingRunId = own(value, 'conflictingRunId');
+            if (conflictingRunId && !conflictingRunId.isUndefined) {
+                reduced.conflictingRunId = conflictingRunId;
+            }
+            else {
+                conflictingRunId?.dispose();
+            }
+            if (Object.hasOwn(shape, 'cause'))
+                reduced.cause = shape.cause;
+            return reduced;
+        },
+        RangeError: namedErrorSubclassReducer('RangeError'),
+        ReferenceError: namedErrorSubclassReducer('ReferenceError'),
+        RetryableError: (value) => {
+            if (!isHandle(value) || !value.isError)
+                return false;
+            if (chainedString(value, 'name') !== 'RetryableError')
+                return false;
+            const shape = reduceErrorShape(value);
+            // retryAfter is a guest Date (or string/number); normalize to an epoch
+            // timestamp exactly like the in-VM reducer. The absent/invalid
+            // fallback reads the GUEST clock (the deterministic replay clock at
+            // the WASI layer), not the host wall clock: the in-VM reducer's
+            // `Date.now()` was replay-stable by construction, and a host-side
+            // `Date.now()` here would write different bytes on every replay of
+            // the same value.
+            let retryAfter = invoke(i.dateNow).consume((h) => h.toNumber()) + 1000;
+            const raw = own(value, 'retryAfter');
+            if (raw) {
+                if (tagOfHandle(raw) === 'Date') {
+                    const t = call(i.dateGetTime, raw).consume((h) => h.toNumber());
+                    if (!Number.isNaN(t))
+                        retryAfter = t;
+                }
+                else if (raw.isString || raw.isNumber) {
+                    const t = new Date(raw.isString ? raw.toString() : raw.toNumber()).getTime();
+                    if (!Number.isNaN(t))
+                        retryAfter = t;
+                }
+                raw.dispose();
+            }
+            const reduced = {
+                message: shape.message,
+                stack: shape.stack,
+                retryAfter,
+            };
+            if (Object.hasOwn(shape, 'cause'))
+                reduced.cause = shape.cause;
+            return reduced;
+        },
+        RuntimeDecryptionError: (value) => {
+            if (!isHandle(value) || !value.isError)
+                return false;
+            if (chainedString(value, 'name') !== 'RuntimeDecryptionError') {
+                return false;
+            }
+            const shape = reduceErrorShape(value);
+            const reduced = {
+                message: shape.message,
+                stack: shape.stack,
+            };
+            const context = own(value, 'context');
+            if (context && !context.isUndefined)
+                reduced.context = context;
+            else
+                context?.dispose();
+            if (Object.hasOwn(shape, 'cause'))
+                reduced.cause = shape.cause;
+            return reduced;
+        },
+        SyntaxError: namedErrorSubclassReducer('SyntaxError'),
+        TypeError: namedErrorSubclassReducer('TypeError'),
+        URIError: namedErrorSubclassReducer('URIError'),
+        Error: (value) => {
+            if (!isHandle(value) || !value.isError)
+                return false;
+            const shape = reduceErrorShape(value);
+            return {
+                name: chainedString(value, 'name') ?? 'Error',
+                message: shape.message,
+                stack: shape.stack,
+                ...(Object.hasOwn(shape, 'cause') ? { cause: shape.cause } : {}),
+            };
+        },
+        Float32Array: (value) => isHandle(value) && tagOfHandle(value) === 'Float32Array'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+        Float64Array: (value) => isHandle(value) && tagOfHandle(value) === 'Float64Array'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+        Int8Array: (value) => isHandle(value) && tagOfHandle(value) === 'Int8Array'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+        Int16Array: (value) => isHandle(value) && tagOfHandle(value) === 'Int16Array'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+        Int32Array: (value) => isHandle(value) && tagOfHandle(value) === 'Int32Array'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+        Map: (value) => isHandle(value) && tagOfHandle(value) === 'Map'
+            ? collect(i.mapForEach, value, 2)
+            : false,
+        RegExp: (value) => {
+            if (!isHandle(value) || tagOfHandle(value) !== 'RegExp')
+                return false;
+            return {
+                source: call(i.regExpSource, value).consume((h) => h.toString()),
+                flags: call(i.regExpFlags, value).consume((h) => h.toString()),
+            };
+        },
+        Headers: (value) => {
+            if (!isHandle(value) ||
+                !i.headersPrototype ||
+                !hasPrototype(value, i.headersPrototype) ||
+                !i.headersForEach) {
+                return false;
+            }
+            // Headers.forEach yields (value, key); normalize to [key, value]
+            // pairs of host strings, matching Array.from(headers).
+            const entries = [];
+            const visitor = vm.newEphemeralFunction((headerValue, headerKey) => {
+                entries.push([headerKey.toString(), headerValue.toString()]);
+                return vm.undefined;
+            });
+            try {
+                call(i.headersForEach, value, visitor).dispose();
+            }
+            finally {
+                visitor.dispose();
+            }
+            return entries;
+        },
+        Request: (value) => {
+            if (!isHandle(value) || value.typeof !== 'object' || value.isNull) {
+                return false;
+            }
+            const isRequest = (i.requestPrototype && hasPrototype(value, i.requestPrototype)) ||
+                own(value, 'json')?.consume((h) => h.typeof === 'function');
+            if (!isRequest)
+                return false;
+            const method = own(value, 'method');
+            if (!method || !method.isString) {
+                method?.dispose();
+                return false;
+            }
+            const data = {
+                method,
+                url: own(value, 'url'),
+                headers: own(value, 'headers'),
+                body: own(value, 'body'),
+                duplex: own(value, 'duplex'),
+            };
+            const responseWritable = own(value, sym('WEBHOOK_RESPONSE_WRITABLE'));
+            if (responseWritable && !responseWritable.isUndefined) {
+                data.responseWritable = responseWritable;
+            }
+            else {
+                responseWritable?.dispose();
+            }
+            return data;
+        },
+        Response: (value) => {
+            if (!isHandle(value) || value.typeof !== 'object' || value.isNull) {
+                return false;
+            }
+            const isResponse = (i.responsePrototype && hasPrototype(value, i.responsePrototype)) ||
+                chained(value, 'clone')?.consume((h) => h.typeof === 'function');
+            if (!isResponse)
+                return false;
+            const status = own(value, 'status');
+            if (!status || !status.isNumber) {
+                status?.dispose();
+                return false;
+            }
+            return {
+                type: own(value, 'type'),
+                url: own(value, 'url'),
+                status,
+                statusText: own(value, 'statusText'),
+                headers: own(value, 'headers'),
+                body: own(value, 'body'),
+                redirected: own(value, 'redirected'),
+            };
+        },
+        ReadableStream: (value) => {
+            if (!isHandle(value) ||
+                value.typeof !== 'object' ||
+                value.isNull ||
+                !i.readableStreamPrototype ||
+                !hasPrototype(value, i.readableStreamPrototype)) {
+                return false;
+            }
+            const bodyInit = own(value, sym('BODY_INIT'));
+            if (bodyInit && !bodyInit.isUndefined) {
+                return { bodyInit };
+            }
+            bodyInit?.dispose();
+            const name = ownSymbolString(value, 'WORKFLOW_STREAM_NAME');
+            if (name) {
+                const s = { name };
+                const type = ownSymbolString(value, 'WORKFLOW_STREAM_TYPE');
+                if (type)
+                    s.type = type;
+                const framing = ownSymbolString(value, 'WORKFLOW_STREAM_FRAMING');
+                if (framing)
+                    s.framing = framing;
+                return s;
+            }
+            return { name: '__empty' };
+        },
+        WritableStream: (value) => {
+            if (!isHandle(value) ||
+                value.typeof !== 'object' ||
+                value.isNull ||
+                !i.writableStreamPrototype ||
+                !hasPrototype(value, i.writableStreamPrototype)) {
+                return false;
+            }
+            const s = {
+                name: ownSymbolString(value, 'WORKFLOW_STREAM_NAME') || '__empty',
+            };
+            const runId = ownSymbolString(value, 'WORKFLOW_STREAM_SERVER_RUN_ID');
+            if (runId)
+                s.runId = runId;
+            const deploymentId = ownSymbolString(value, 'WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID');
+            if (deploymentId)
+                s.deploymentId = deploymentId;
+            return s;
+        },
+        Set: (value) => isHandle(value) && tagOfHandle(value) === 'Set'
+            ? collect(i.setForEach, value, 1)
+            : false,
+        URL: (value) => {
+            if (!isHandle(value) ||
+                !i.urlPrototype ||
+                !hasPrototype(value, i.urlPrototype) ||
+                !i.urlHref) {
+                return false;
+            }
+            return call(i.urlHref, value).consume((h) => h.toString());
+        },
+        WorkflowFunction: (value) => {
+            if (!isHandle(value) || value.typeof !== 'function')
+                return false;
+            const workflowId = ownString(value, 'workflowId');
+            if (workflowId === undefined)
+                return false;
+            return { workflowId };
+        },
+        URLSearchParams: (value) => {
+            if (!isHandle(value) ||
+                !i.urlSearchParamsPrototype ||
+                !hasPrototype(value, i.urlSearchParamsPrototype) ||
+                !i.urlSearchParamsToString) {
+                return false;
+            }
+            const size = i.urlSearchParamsSize
+                ? call(i.urlSearchParamsSize, value).consume((h) => h.toNumber())
+                : Number.NaN;
+            if (size === 0)
+                return '.';
+            return call(i.urlSearchParamsToString, value).consume((h) => h.toString());
+        },
+        Uint8Array: (value) => isHandle(value) && tagOfHandle(value) === 'Uint8Array'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+        Uint8ClampedArray: (value) => isHandle(value) && tagOfHandle(value) === 'Uint8ClampedArray'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+        Uint16Array: (value) => isHandle(value) && tagOfHandle(value) === 'Uint16Array'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+        Uint32Array: (value) => isHandle(value) && tagOfHandle(value) === 'Uint32Array'
+            ? bytesToBase64(viewBytes(value))
+            : false,
+    };
+    // --- parse operations (handle-only: everything is built in the VM) ---
+    const parseOperations = {
+        fromPrimitive: (value) => typeof value === 'bigint' ? vm.newBigInt(value) : vm.hostToHandle(value),
+        fromISOString: (iso) => {
+            const argument = iso === '' ? vm.newNumber(Number.NaN) : vm.newString(iso);
+            try {
+                return vm.construct(i.Date, argument);
+            }
+            finally {
+                argument.dispose();
+            }
+        },
+        fromStringValue: (tag, _string) => {
+            throw new Error(`${tag} cannot be revived in the VM`);
+        },
+        fromArrayBuffer: (buffer) => vm.newArrayBuffer(buffer),
+        fromRegExpInfo: (source, flags) => {
+            const sourceHandle = vm.newString(source);
+            try {
+                if (!flags)
+                    return vm.construct(i.RegExp, sourceHandle);
+                const flagsHandle = vm.newString(flags);
+                try {
+                    return vm.construct(i.RegExp, sourceHandle, flagsHandle);
+                }
+                finally {
+                    flagsHandle.dispose();
+                }
+            }
+            finally {
+                sourceHandle.dispose();
+            }
+        },
+        fromViewInfo: (tag, buffer, byteOffset, length) => {
+            const Constructor = typedArrayConstructors.get(tag);
+            if (!Constructor)
+                throw new Error(`${tag} is not available in the VM`);
+            if (byteOffset === undefined) {
+                return vm.construct(Constructor, buffer);
+            }
+            const offsetHandle = vm.newNumber(byteOffset);
+            const lengthHandle = vm.newNumber(length ?? 0);
+            try {
+                return vm.construct(Constructor, buffer, offsetHandle, lengthHandle);
+            }
+            finally {
+                offsetHandle.dispose();
+                lengthHandle.dispose();
+            }
+        },
+        box: (value) => vm.construct(i.Object, value),
+        createArray: (length) => {
+            const lengthHandle = vm.newNumber(length);
+            try {
+                return vm.construct(i.Array, lengthHandle);
+            }
+            finally {
+                lengthHandle.dispose();
+            }
+        },
+        createSparseArray: (length) => {
+            const lengthHandle = vm.newNumber(length);
+            try {
+                return invoke(i.makeSparseArray, lengthHandle);
+            }
+            finally {
+                lengthHandle.dispose();
+            }
+        },
+        createObject: () => vm.newObject(),
+        createNullPrototypeObject: () => call(i.objectCreate, vm.undefined, vm.null),
+        createSet: () => vm.construct(i.Set),
+        createMap: () => vm.construct(i.Map),
+        set: (target, key, value) => define(target, String(key), value),
+        addValue: (set, value) => {
+            call(i.setAdd, set, value).dispose();
+        },
+        addEntry: (map, key, value) => {
+            call(i.mapSet, map, key, value).dispose();
+        },
+    };
+    // --- workflow revivers (handle space) ---
+    /** Guest lookup of a registered error class on globalThis, by symbol. */
+    const registeredErrorClass = (name) => {
+        const cls = own(vm.global, sym(name));
+        if (!cls || cls.typeof !== 'function') {
+            cls?.dispose();
+            return undefined;
+        }
+        return cls;
+    };
+    /** Construct a guest Error via `ctor(message)` + define stack/cause. */
+    const buildError = (ctor, value, opts = {}) => {
+        const message = own(value, 'message') ?? vm.undefined;
+        const error = vm.construct(ctor, message, ...(opts.extraCtorArgs ?? []));
+        if (message !== vm.undefined)
+            message.dispose();
+        if (opts.name !== undefined) {
+            const nameHandle = newGuestString(opts.name);
+            define(error, 'name', nameHandle);
+            nameHandle.dispose();
+        }
+        const stack = own(value, 'stack');
+        if (stack && !stack.isUndefined)
+            define(error, 'stack', stack);
+        stack?.dispose();
+        if (guestHasOwn(value, 'cause')) {
+            const cause = own(value, 'cause') ?? vm.undefined;
+            define(error, 'cause', cause);
+            if (cause !== vm.undefined)
+                cause.dispose();
+        }
+        return error;
+    };
+    const namedErrorSubclassReviver = (subclassName) => (value) => {
+        const ctor = errorConstructors.get(subclassName);
+        if (ctor)
+            return buildError(ctor, value);
+        return buildError(i.Error, value, { name: subclassName });
+    };
+    const reviveAbortSignal = (value) => {
+        const cls = own(vm.global, '__WorkflowAbortSignal');
+        if (!cls || cls.typeof !== 'function') {
+            cls?.dispose();
+            throw new Error('WorkflowAbortSignal is not registered in the VM (bootstrap not evaluated)');
+        }
+        try {
+            const streamName = own(value, 'streamName') ?? vm.undefined;
+            const hookToken = own(value, 'hookToken') ?? vm.undefined;
+            const signal = vm.construct(cls, streamName, hookToken);
+            if (streamName !== vm.undefined)
+                streamName.dispose();
+            if (hookToken !== vm.undefined)
+                hookToken.dispose();
+            const aborted = own(value, 'aborted');
+            if (aborted?.toBoolean()) {
+                const setAborted = chained(signal, '_setAborted');
+                if (setAborted) {
+                    const reason = own(value, 'reason') ?? vm.undefined;
+                    call(setAborted, signal, reason).dispose();
+                    if (reason !== vm.undefined)
+                        reason.dispose();
+                    setAborted.dispose();
+                }
+            }
+            aborted?.dispose();
+            return signal;
+        }
+        finally {
+            cls.dispose();
+        }
+    };
+    const revivers = {
+        AbortController: (value) => {
+            const controller = vm.newObject();
+            const streamName = own(value, 'streamName') ?? vm.undefined;
+            define(controller, sym('WORKFLOW_ABORT_STREAM_NAME'), streamName);
+            if (streamName !== vm.undefined)
+                streamName.dispose();
+            const hookToken = own(value, 'hookToken') ?? vm.undefined;
+            define(controller, sym('WORKFLOW_ABORT_HOOK_TOKEN'), hookToken);
+            if (hookToken !== vm.undefined)
+                hookToken.dispose();
+            const signal = reviveAbortSignal(value);
+            define(controller, 'signal', signal);
+            signal.dispose();
+            const noop = vm.evalCode('(function(){})');
+            define(controller, 'abort', noop);
+            noop.dispose();
+            return controller;
+        },
+        AbortSignal: (value) => reviveAbortSignal(value),
+        Class: (value) => {
+            const classId = ownString(value, 'classId');
+            const cls = lookupRegisteredClass(classId);
+            if (!cls) {
+                throw new Error(`Class "${classId}" not found. Make sure the class is registered with registerSerializationClass.`);
+            }
+            return cls;
+        },
+        Instance: (value) => {
+            const classId = ownString(value, 'classId');
+            const cls = lookupRegisteredClass(classId);
+            if (!cls) {
+                throw new Error(`Class "${classId}" not found. Make sure the class is registered with registerSerializationClass.`);
+            }
+            try {
+                const deserializeMethod = chained(cls, sym('workflow-deserialize'));
+                if (!deserializeMethod || deserializeMethod.typeof !== 'function') {
+                    deserializeMethod?.dispose();
+                    throw new Error(`Class "${classId}" does not have a static Symbol(workflow-deserialize) method.`);
+                }
+                try {
+                    const data = own(value, 'data') ?? vm.undefined;
+                    const result = call(deserializeMethod, cls, data);
+                    if (data !== vm.undefined)
+                        data.dispose();
+                    return result;
+                }
+                finally {
+                    deserializeMethod.dispose();
+                }
+            }
+            finally {
+                cls.dispose();
+            }
+        },
+        StepFunction: (value) => {
+            const useStep = own(vm.global, sym('WORKFLOW_USE_STEP'));
+            if (!useStep || useStep.typeof !== 'function') {
+                useStep?.dispose();
+                throw new Error('WORKFLOW_USE_STEP not found on global object. Step functions cannot be deserialized outside workflow context.');
+            }
+            try {
+                const stepId = own(value, 'stepId') ?? vm.undefined;
+                const closureVars = own(value, 'closureVars');
+                let proxy;
+                if (closureVars && !closureVars.isUndefined) {
+                    const thunk = invoke(i.makeThunk, closureVars);
+                    proxy = invoke(useStep, stepId, thunk);
+                    thunk.dispose();
+                }
+                else {
+                    proxy = invoke(useStep, stepId);
+                }
+                closureVars?.dispose();
+                if (stepId !== vm.undefined)
+                    stepId.dispose();
+                if (guestHasOwn(value, 'boundThis')) {
+                    // Re-bind through the proxy's own (overridden) `.bind`, which is
+                    // an own data property stamped by WORKFLOW_USE_STEP.
+                    const bind = own(proxy, 'bind') ?? chained(proxy, 'bind');
+                    const boundThis = own(value, 'boundThis') ?? vm.undefined;
+                    const boundArgs = own(value, 'boundArgs');
+                    const args = [boundThis];
+                    const argHandles = [];
+                    if (boundArgs && boundArgs.isArray) {
+                        const length = own(boundArgs, 'length')?.consume((h) => h.toNumber()) ?? 0;
+                        for (let index = 0; index < length; index++) {
+                            const element = own(boundArgs, String(index)) ?? vm.undefined;
+                            args.push(element);
+                            if (element !== vm.undefined)
+                                argHandles.push(element);
+                        }
+                    }
+                    boundArgs?.dispose();
+                    if (bind) {
+                        const bound = call(bind, proxy, ...args);
+                        bind.dispose();
+                        proxy.dispose();
+                        proxy = bound;
+                    }
+                    if (boundThis !== vm.undefined)
+                        boundThis.dispose();
+                    for (const handle of argHandles)
+                        handle.dispose();
+                }
+                return proxy;
+            }
+            finally {
+                useStep.dispose();
+            }
+        },
+        ArrayBuffer: (value) => vm.newArrayBuffer(base64ToBytes(isHandle(value) ? value.toString() : value)
+            .buffer),
+        BigInt: (value) => vm.newBigInt(BigInt(isHandle(value) ? value.toString() : value)),
+        BigInt64Array: (value) => buildTypedArray('BigInt64Array', value),
+        BigUint64Array: (value) => buildTypedArray('BigUint64Array', value),
+        Date: (value) => {
+            // The reducer emits '.' for invalid dates and an ISO string otherwise.
+            const iso = isHandle(value) ? value.toString() : value;
+            const argument = iso === '.' ? vm.newNumber(Number.NaN) : vm.newString(iso);
+            try {
+                return vm.construct(i.Date, argument);
+            }
+            finally {
+                argument.dispose();
+                if (isHandle(value))
+                    value.dispose();
+            }
+        },
+        DOMException: (value) => {
+            if (i.DOMException) {
+                const message = own(value, 'message') ?? vm.undefined;
+                const name = own(value, 'name') ?? vm.undefined;
+                const error = vm.construct(i.DOMException, message, name);
+                if (message !== vm.undefined)
+                    message.dispose();
+                if (name !== vm.undefined)
+                    name.dispose();
+                const stack = own(value, 'stack');
+                if (stack && !stack.isUndefined)
+                    define(error, 'stack', stack);
+                stack?.dispose();
+                if (guestHasOwn(value, 'cause')) {
+                    const cause = own(value, 'cause') ?? vm.undefined;
+                    define(error, 'cause', cause);
+                    if (cause !== vm.undefined)
+                        cause.dispose();
+                }
+                return error;
+            }
+            return buildError(i.Error, value, {
+                name: ownString(value, 'name') ?? 'DOMException',
+            });
+        },
+        AggregateError: (value) => {
+            const errors = own(value, 'errors');
+            const errorsArg = errors && !errors.isUndefined ? errors : vm.evalCode('([])');
+            const message = own(value, 'message') ?? vm.undefined;
+            const ctor = i.AggregateError ?? i.Error;
+            const error = ctor === i.AggregateError
+                ? vm.construct(ctor, errorsArg, message)
+                : buildError(i.Error, value, { name: 'AggregateError' });
+            if (ctor === i.AggregateError) {
+                const stack = own(value, 'stack');
+                if (stack && !stack.isUndefined)
+                    define(error, 'stack', stack);
+                stack?.dispose();
+                if (guestHasOwn(value, 'cause')) {
+                    const cause = own(value, 'cause') ?? vm.undefined;
+                    define(error, 'cause', cause);
+                    if (cause !== vm.undefined)
+                        cause.dispose();
+                }
+            }
+            if (message !== vm.undefined)
+                message.dispose();
+            errorsArg.dispose();
+            return error;
+        },
+        EvalError: namedErrorSubclassReviver('EvalError'),
+        FatalError: (value) => {
+            const cls = registeredErrorClass('@workflow/errors//FatalError');
+            const error = cls
+                ? buildError(cls, value)
+                : buildError(i.Error, value, { name: 'FatalError' });
+            cls?.dispose();
+            return error;
+        },
+        HookConflictError: (value) => {
+            const cls = registeredErrorClass('@workflow/errors//HookConflictError');
+            let error;
+            if (cls) {
+                // Constructor takes (token, conflictingRunId).
+                const token = own(value, 'token') ?? vm.undefined;
+                const conflictingRunId = own(value, 'conflictingRunId') ?? vm.undefined;
+                error = vm.construct(cls, token, conflictingRunId);
+                if (token !== vm.undefined)
+                    token.dispose();
+                if (conflictingRunId !== vm.undefined)
+                    conflictingRunId.dispose();
+                const stack = own(value, 'stack');
+                if (stack && !stack.isUndefined)
+                    define(error, 'stack', stack);
+                stack?.dispose();
+                if (guestHasOwn(value, 'cause')) {
+                    const cause = own(value, 'cause') ?? vm.undefined;
+                    define(error, 'cause', cause);
+                    if (cause !== vm.undefined)
+                        cause.dispose();
+                }
+                cls.dispose();
+            }
+            else {
+                error = buildError(i.Error, value, { name: 'HookConflictError' });
+                const token = own(value, 'token');
+                if (token) {
+                    define(error, 'token', token);
+                    token.dispose();
+                }
+                const conflictingRunId = own(value, 'conflictingRunId');
+                if (conflictingRunId && !conflictingRunId.isUndefined) {
+                    define(error, 'conflictingRunId', conflictingRunId);
+                }
+                conflictingRunId?.dispose();
+            }
+            return error;
+        },
+        RangeError: namedErrorSubclassReviver('RangeError'),
+        ReferenceError: namedErrorSubclassReviver('ReferenceError'),
+        RetryableError: (value) => {
+            const retryAfterMs = own(value, 'retryAfter')?.consume((h) => h.isNumber ? h.toNumber() : Number.NaN) ?? Number.NaN;
+            const timeHandle = vm.newNumber(retryAfterMs);
+            const retryAfterDate = vm.construct(i.Date, timeHandle);
+            timeHandle.dispose();
+            const cls = registeredErrorClass('@workflow/errors//RetryableError');
+            let error;
+            if (cls) {
+                // Constructor takes (message, { retryAfter }).
+                const options = vm.newObject();
+                options.setProp('retryAfter', retryAfterDate);
+                const message = own(value, 'message') ?? vm.undefined;
+                error = vm.construct(cls, message, options);
+                if (message !== vm.undefined)
+                    message.dispose();
+                options.dispose();
+                const stack = own(value, 'stack');
+                if (stack && !stack.isUndefined)
+                    define(error, 'stack', stack);
+                stack?.dispose();
+                if (guestHasOwn(value, 'cause')) {
+                    const cause = own(value, 'cause') ?? vm.undefined;
+                    define(error, 'cause', cause);
+                    if (cause !== vm.undefined)
+                        cause.dispose();
+                }
+                cls.dispose();
+            }
+            else {
+                error = buildError(i.Error, value, { name: 'RetryableError' });
+                define(error, 'retryAfter', retryAfterDate);
+            }
+            retryAfterDate.dispose();
+            return error;
+        },
+        RuntimeDecryptionError: (value) => {
+            const cls = registeredErrorClass('@workflow/errors//RuntimeDecryptionError');
+            let error;
+            if (cls) {
+                // Constructor takes (message, { cause, context }).
+                const options = vm.newObject();
+                const context = own(value, 'context');
+                if (context && !context.isUndefined) {
+                    options.setProp('context', context);
+                }
+                context?.dispose();
+                if (guestHasOwn(value, 'cause')) {
+                    const cause = own(value, 'cause') ?? vm.undefined;
+                    options.setProp('cause', cause);
+                    if (cause !== vm.undefined)
+                        cause.dispose();
+                }
+                const message = own(value, 'message') ?? vm.undefined;
+                error = vm.construct(cls, message, options);
+                if (message !== vm.undefined)
+                    message.dispose();
+                options.dispose();
+                const stack = own(value, 'stack');
+                if (stack && !stack.isUndefined)
+                    define(error, 'stack', stack);
+                stack?.dispose();
+                cls.dispose();
+            }
+            else {
+                error = buildError(i.Error, value, { name: 'RuntimeDecryptionError' });
+                const context = own(value, 'context');
+                if (context && !context.isUndefined) {
+                    define(error, 'context', context);
+                }
+                context?.dispose();
+            }
+            return error;
+        },
+        SyntaxError: namedErrorSubclassReviver('SyntaxError'),
+        TypeError: namedErrorSubclassReviver('TypeError'),
+        URIError: namedErrorSubclassReviver('URIError'),
+        Error: (value) => buildError(i.Error, value, {
+            name: ownString(value, 'name') ?? 'Error',
+        }),
+        Float32Array: (value) => buildTypedArray('Float32Array', value),
+        Float64Array: (value) => buildTypedArray('Float64Array', value),
+        Int8Array: (value) => buildTypedArray('Int8Array', value),
+        Int16Array: (value) => buildTypedArray('Int16Array', value),
+        Int32Array: (value) => buildTypedArray('Int32Array', value),
+        Map: (value) => {
+            // value is a guest array of [k, v] arrays.
+            const map = vm.construct(i.Map);
+            const length = own(value, 'length')?.consume((h) => h.toNumber()) ?? 0;
+            for (let index = 0; index < length; index++) {
+                const entry = own(value, String(index));
+                if (!entry)
+                    continue;
+                const key = own(entry, '0') ?? vm.undefined;
+                const entryValue = own(entry, '1') ?? vm.undefined;
+                call(i.mapSet, map, key, entryValue).dispose();
+                if (key !== vm.undefined)
+                    key.dispose();
+                if (entryValue !== vm.undefined)
+                    entryValue.dispose();
+                entry.dispose();
+            }
+            return map;
+        },
+        RegExp: (value) => {
+            const source = own(value, 'source') ?? vm.undefined;
+            const flags = own(value, 'flags') ?? vm.undefined;
+            const regexp = vm.construct(i.RegExp, source, flags);
+            if (source !== vm.undefined)
+                source.dispose();
+            if (flags !== vm.undefined)
+                flags.dispose();
+            return regexp;
+        },
+        Set: (value) => {
+            const set = vm.construct(i.Set);
+            const length = own(value, 'length')?.consume((h) => h.toNumber()) ?? 0;
+            for (let index = 0; index < length; index++) {
+                const element = own(value, String(index)) ?? vm.undefined;
+                call(i.setAdd, set, element).dispose();
+                if (element !== vm.undefined)
+                    element.dispose();
+            }
+            return set;
+        },
+        URL: (value) => {
+            if (!i.URL)
+                throw new Error('URL is not available in the VM');
+            const href = isHandle(value) ? value : vm.newString(value);
+            try {
+                return vm.construct(i.URL, href);
+            }
+            finally {
+                if (!isHandle(value))
+                    href.dispose();
+            }
+        },
+        WorkflowFunction: (value) => {
+            const workflowId = own(value, 'workflowId') ?? vm.undefined;
+            const throwerFactory = vm.evalCode(`(function(workflowId) {
+          var f = function() {
+            throw new Error('Workflow functions cannot be called directly. Use start() to invoke them.');
+          };
+          f.workflowId = workflowId;
+          return f;
+        })`);
+            try {
+                return invoke(throwerFactory, workflowId);
+            }
+            finally {
+                throwerFactory.dispose();
+                if (workflowId !== vm.undefined)
+                    workflowId.dispose();
+            }
+        },
+        URLSearchParams: (value) => {
+            if (!i.URLSearchParams) {
+                throw new Error('URLSearchParams is not available in the VM');
+            }
+            const raw = isHandle(value) ? value.toString() : value;
+            const init = vm.newString(raw === '.' ? '' : raw);
+            try {
+                return vm.construct(i.URLSearchParams, init);
+            }
+            finally {
+                init.dispose();
+                if (isHandle(value))
+                    value.dispose();
+            }
+        },
+        Uint8Array: (value) => buildTypedArray('Uint8Array', value),
+        Uint8ClampedArray: (value) => buildTypedArray('Uint8ClampedArray', value),
+        Uint16Array: (value) => buildTypedArray('Uint16Array', value),
+        Uint32Array: (value) => buildTypedArray('Uint32Array', value),
+        Headers: (value) => {
+            if (!i.Headers)
+                throw new Error('Headers is not available in the VM');
+            return vm.construct(i.Headers, value);
+        },
+        Request: (value) => {
+            // Mirror the in-VM reviver: mutate the parsed object into a
+            // Request-alike by attaching the prototype methods directly.
+            if (i.requestPrototype) {
+                for (const method of ['json', 'text', 'arrayBuffer']) {
+                    const fn = own(i.requestPrototype, method);
+                    if (fn && fn.typeof === 'function')
+                        define(value, method, fn);
+                    fn?.dispose();
+                }
+            }
+            const responseWritable = own(value, 'responseWritable');
+            if (responseWritable && !responseWritable.isUndefined) {
+                define(value, sym('WEBHOOK_RESPONSE_WRITABLE'), responseWritable);
+            }
+            responseWritable?.dispose();
+            return value.dup();
+        },
+        Response: (value) => {
+            if (i.responsePrototype) {
+                for (const method of [
+                    'json',
+                    'text',
+                    'arrayBuffer',
+                    'bytes',
+                    'clone',
+                ]) {
+                    const fn = own(i.responsePrototype, method);
+                    if (fn && fn.typeof === 'function')
+                        define(value, method, fn);
+                    fn?.dispose();
+                }
+            }
+            const body = own(value, 'body') ?? vm.undefined;
+            define(value, '_body', body);
+            if (body !== vm.undefined)
+                body.dispose();
+            const status = own(value, 'status')?.consume((h) => h.toNumber()) ?? 0;
+            const ok = status >= 200 && status < 300 ? vm.true : vm.false;
+            define(value, 'ok', ok);
+            define(value, 'bodyUsed', vm.false);
+            return value.dup();
+        },
+        ReadableStream: (value) => {
+            const prototype = i.readableStreamPrototype ?? vm.null;
+            const stream = call(i.objectCreate, vm.undefined, prototype);
+            const bodyInit = own(value, 'bodyInit');
+            if (bodyInit && !bodyInit.isUndefined) {
+                define(stream, sym('BODY_INIT'), bodyInit);
+                bodyInit.dispose();
+                return stream;
+            }
+            bodyInit?.dispose();
+            const name = own(value, 'name');
+            if (name && !name.isUndefined) {
+                define(stream, sym('WORKFLOW_STREAM_NAME'), name);
+                const type = own(value, 'type');
+                if (type && !type.isUndefined) {
+                    define(stream, sym('WORKFLOW_STREAM_TYPE'), type);
+                }
+                type?.dispose();
+                const framing = own(value, 'framing');
+                if (framing && !framing.isUndefined) {
+                    define(stream, sym('WORKFLOW_STREAM_FRAMING'), framing);
+                }
+                framing?.dispose();
+            }
+            name?.dispose();
+            return stream;
+        },
+        WritableStream: (value) => {
+            const prototype = i.writableStreamPrototype ?? vm.null;
+            const stream = call(i.objectCreate, vm.undefined, prototype);
+            const name = own(value, 'name');
+            if (name && !name.isUndefined) {
+                define(stream, sym('WORKFLOW_STREAM_NAME'), name);
+            }
+            name?.dispose();
+            const runId = own(value, 'runId');
+            if (runId?.isString) {
+                define(stream, sym('WORKFLOW_STREAM_SERVER_RUN_ID'), runId);
+            }
+            runId?.dispose();
+            const deploymentId = own(value, 'deploymentId');
+            if (deploymentId?.isString) {
+                define(stream, sym('WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID'), deploymentId);
+            }
+            deploymentId?.dispose();
+            return stream;
+        },
+    };
+    function buildTypedArray(tag, base64) {
+        const Constructor = typedArrayConstructors.get(tag);
+        if (!Constructor)
+            throw new Error(`${tag} is not available in the VM`);
+        // Parse operations build guest values, so a reduced base64 payload
+        // arrives as a guest string handle.
+        const raw = isHandle(base64) ? base64.toString() : base64;
+        const bytes = base64ToBytes(raw);
+        const buffer = vm.newArrayBuffer(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+        try {
+            return vm.construct(Constructor, buffer);
+        }
+        finally {
+            buffer.dispose();
+        }
+    }
+    function lookupRegisteredClass(classId) {
+        if (classId === undefined)
+            return undefined;
+        const registry = own(vm.global, sym('workflow-class-registry'));
+        if (!registry || registry.isUndefined) {
+            registry?.dispose();
+            return undefined;
+        }
+        try {
+            const getMethod = chained(registry, 'get');
+            if (!getMethod)
+                return undefined;
+            try {
+                const key = vm.newString(classId);
+                const cls = call(getMethod, registry, key);
+                key.dispose();
+                if (cls.isUndefined || cls.typeof !== 'function') {
+                    cls.dispose();
+                    return undefined;
+                }
+                return cls;
+            }
+            finally {
+                getMethod.dispose();
+            }
+        }
+        finally {
+            registry.dispose();
+        }
+    }
+    // --- public API ---
+    return {
+        reducerKeys: Object.keys(reducers),
+        reviverKeys: Object.keys(revivers),
+        installProcessEnv(env) {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const plain = {};
+                for (const [key, value] of Object.entries(env)) {
+                    if (typeof value === 'string')
+                        plain[key] = value;
+                }
+                const envHandle = __addDisposableResource(env_2, vm.hostToHandle(plain), false);
+                call(i.objectFreeze, vm.undefined, envHandle).dispose();
+                const processHandle = __addDisposableResource(env_2, vm.newObject(), false);
+                define(processHandle, 'env', envHandle);
+                vm.setProp(vm.global, 'process', processHandle);
+            }
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
+            finally {
+                __disposeResources(env_2);
+            }
+        },
+        serialize(value) {
+            // Handle scope: reducers and the hybrid operations mint one handle
+            // per visited value node (descriptor reads, dup()s, intrinsic call
+            // results) and nothing disposes them individually — without the
+            // scope each serialize leaks ~one handle per node for the VM's
+            // lifetime, which compounds across an inline-loop session's whole
+            // batch. Requires quickjs-wasi >= 3.3.1: earlier versions also
+            // scope-tracked the handles the host-callback trampoline wraps
+            // around C-owned argv pointers, and disposing those (Map/Set/
+            // Headers forEach visitors run mid-pass) corrupted the guest heap;
+            // 3.3.1 marks them borrowed and scope-exempt. The input handle is
+            // caller-owned (created before the scope) and the output is host
+            // bytes, so nothing escapes.
+            //
+            // `identities` must be cleared per pass ONCE handles are bulk-freed:
+            // it keys object identity on the raw guest pointer, and freeing
+            // handles lets QuickJS reuse pointers — a stale entry from an
+            // earlier pass could then alias a different object and corrupt the
+            // dedup/cycle detection. Identity only needs stability within one
+            // stringify pass.
+            try {
+                const payload = vm.withScope(() => encoder.encode(stringify(value, reducers, { operations: stringifyOperations })));
+                const prefix = encoder.encode(SerializationFormat.DEVALUE_V1);
+                const result = new Uint8Array(prefix.length + payload.length);
+                result.set(prefix, 0);
+                result.set(payload, prefix.length);
+                return result;
+            }
+            finally {
+                identities.clear();
+            }
+        },
+        deserialize(data) {
+            if (data.length < FORMAT_PREFIX_LENGTH) {
+                throw new Error('Data too short to contain format prefix');
+            }
+            const prefix = decoder.decode(data.subarray(0, FORMAT_PREFIX_LENGTH));
+            if (prefix !== SerializationFormat.DEVALUE_V1) {
+                throw new Error(`Unsupported serialization format: ${prefix}`);
+            }
+            const payload = decoder.decode(data.subarray(FORMAT_PREFIX_LENGTH));
+            // Handle scope, mirroring serialize(): revivers mint intermediate
+            // handles (children already attached to their parents, intrinsic
+            // call results) that are safe to free once the graph is built —
+            // guest values are refcounted, so parents keep their children
+            // alive. Only the root escapes to the caller.
+            return vm.withScope((scope) => scope.escape(parse(payload, revivers, {
+                operations: parseOperations,
+            })));
+        },
+        dispose() {
+            for (const handle of disposables.reverse())
+                handle.dispose();
+            disposables.length = 0;
+            identities.clear();
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quickjs-serde.js","sourceRoot":"","sources":["../../src/runtime/quickjs-serde.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Host-side serialization for the QuickJS engine.\n *\n * Implements the workflow wire codec (format-prefixed devalue, identical to\n * `codec-devalue-vm.ts` / the node:vm engine's workflow-mode codec) as\n * host code operating on `JSValueHandle`s, using devalue 5.9's pluggable\n * operations (quickjs-wasi's host-side introspection primitives underneath).\n * The serde bundle previously evaluated inside the VM is gone: guest values\n * are read and built through handles, so no serializer code lives in — or\n * can be tampered with from — the guest realm.\n *\n * Side-effect discipline mirrors the node:vm engine's hardened codec\n * (serialization/hardened.ts):\n *\n * - classification is by engine brand (`classId` against boot-captured\n *   samples, `isError`, `isProxy`), never `instanceof` or\n *   `Symbol.toStringTag`;\n * - extraction goes through intrinsics captured at boot (before any user\n *   code runs) invoked with explicit receivers, or through own-property\n *   descriptor reads — patched prototypes and inherited accessors never\n *   run;\n * - the only guest code serialization can execute is the same code the\n *   previous in-VM codec executed by contract: a class's static\n *   `WORKFLOW_SERIALIZE` method, a step proxy's `__closureVarsFn`, and\n *   `WORKFLOW_USE_STEP` / `WORKFLOW_DESERIALIZE` on revival.\n *\n * Wire-format parity with the previous in-VM codec is REQUIRED and covered\n * by tests: event logs written by either codec must be readable by the\n * other (steps serialized by the node runtime feed VM revival and vice\n * versa).\n *\n * Hybrid value space: reducers return host shapes (plain objects, strings,\n * numbers) whose leaves may be guest handles — exactly how the node:vm\n * codec mixes host shapes with sandbox-realm leaves. Every stringify\n * operation therefore dispatches on `JSValueHandle` and falls back to\n * devalue's default host operations for host values. Parse operations\n * always build guest values, so the parse side is handle-only.\n */\n\nimport {\n  defaultStringifyOperations,\n  filterArrayIndices,\n  type ParseOperations,\n  parse,\n  type StringifyOperations,\n  stringify,\n} from 'devalue';\nimport { JSValueHandle, type QuickJS } from 'quickjs-wasi';\nimport { SerializationFormat } from '../serialization/types.js';\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\nconst FORMAT_PREFIX_LENGTH = 4;\n\n// ---- base64 (host-side; wire-compatible with the old in-VM btoa path) ----\n//\n// Feature-detected so the codec carries no unconditional Node dependency\n// (the QuickJS engine targets WASM-capable non-Node hosts too): the\n// ES-proposal Uint8Array base64 methods when present, Node's Buffer when\n// present, and a btoa/atob loop otherwise (universally available on web\n// runtimes).\n\ntype Base64Uint8ArrayCtor = Uint8ArrayConstructor & {\n  fromBase64?: (value: string) => Uint8Array;\n};\ntype Base64Uint8Array = Uint8Array & { toBase64?: () => string };\n\nconst hasNativeBase64 =\n  typeof (Uint8Array as Base64Uint8ArrayCtor).fromBase64 === 'function' &&\n  typeof (Uint8Array.prototype as Base64Uint8Array).toBase64 === 'function';\nconst hasBuffer = typeof Buffer === 'function';\n\nfunction bytesToBase64(bytes: Uint8Array): string {\n  if (bytes.length === 0) return '.';\n  if (hasNativeBase64) {\n    return (bytes as Base64Uint8Array).toBase64?.() as string;\n  }\n  if (hasBuffer) {\n    return Buffer.from(\n      bytes.buffer,\n      bytes.byteOffset,\n      bytes.byteLength\n    ).toString('base64');\n  }\n  let binary = '';\n  for (let idx = 0; idx < bytes.length; idx++) {\n    binary += String.fromCharCode(bytes[idx]);\n  }\n  return btoa(binary);\n}\n\nfunction base64ToBytes(value: string): Uint8Array {\n  if (value === '.') return new Uint8Array(0);\n  if (hasNativeBase64) {\n    return (Uint8Array as Base64Uint8ArrayCtor).fromBase64?.(\n      value\n    ) as Uint8Array;\n  }\n  if (hasBuffer) {\n    return new Uint8Array(Buffer.from(value, 'base64'));\n  }\n  const binary = atob(value);\n  const bytes = new Uint8Array(binary.length);\n  for (let idx = 0; idx < binary.length; idx++) {\n    bytes[idx] = binary.charCodeAt(idx);\n  }\n  return bytes;\n}\n\n// ---- boot-time captures ----\n\n/** devalue tags decided by engine class id, sampled at boot. */\nconst BRANDED_SAMPLES = `({\n  Number: new Number(0),\n  String: new String(''),\n  Boolean: new Boolean(false),\n  BigInt: Object(0n),\n  Date: new Date(0),\n  RegExp: /x/,\n  Array: [],\n  Set: new Set(),\n  Map: new Map(),\n  ArrayBuffer: new ArrayBuffer(0),\n  DataView: new DataView(new ArrayBuffer(0)),\n  Int8Array: new Int8Array(0),\n  Uint8Array: new Uint8Array(0),\n  Uint8ClampedArray: new Uint8ClampedArray(0),\n  Int16Array: new Int16Array(0),\n  Uint16Array: new Uint16Array(0),\n  Int32Array: new Int32Array(0),\n  Uint32Array: new Uint32Array(0),\n  Float32Array: new Float32Array(0),\n  Float64Array: new Float64Array(0),\n  BigInt64Array: new BigInt64Array(0),\n  BigUint64Array: new BigUint64Array(0),\n})`;\n\n/**\n * Intrinsics needed for reading and building, captured from the guest realm\n * at serde creation (which the runtime does right after evaluating the\n * bootstrap, before the workflow bundle). Held only on the host: later\n * patching inside the VM cannot influence serialization.\n *\n * Globals installed by the extensions/bootstrap (Headers, Request,\n * Response, ReadableStream, WritableStream, URL, URLSearchParams,\n * DOMException, __WorkflowAbortSignal) are captured defensively — absent\n * ones yield `undefined` and their reducers simply never match, exactly\n * like the old in-VM reducers' `globalThis.X` probes.\n */\nconst CAPTURE_INTRINSICS = `(() => {\n  const descriptor = (object, key) =>\n    Object.getOwnPropertyDescriptor(object, key);\n  const getter = (object, key) => {\n    const d = descriptor(object, key);\n    return d && d.get;\n  };\n  const TypedArray = Object.getPrototypeOf(Int8Array.prototype);\n  const maybeProto = (Cls) => (Cls ? Cls.prototype : undefined);\n  const g = globalThis;\n\n  return {\n    // --- reading (stringify) ---\n    dateGetTime: Date.prototype.getTime,\n    dateToISOString: Date.prototype.toISOString,\n    regExpSource: getter(RegExp.prototype, 'source'),\n    regExpFlags: getter(RegExp.prototype, 'flags'),\n    numberValueOf: Number.prototype.valueOf,\n    stringValueOf: String.prototype.valueOf,\n    booleanValueOf: Boolean.prototype.valueOf,\n    bigIntValueOf: BigInt.prototype.valueOf,\n    bigIntToString: BigInt.prototype.toString,\n    setForEach: Set.prototype.forEach,\n    mapForEach: Map.prototype.forEach,\n    headersForEach: g.Headers ? g.Headers.prototype.forEach : undefined,\n    urlHref: g.URL ? getter(g.URL.prototype, 'href') : undefined,\n    urlSearchParamsToString: g.URLSearchParams\n      ? g.URLSearchParams.prototype.toString\n      : undefined,\n    urlSearchParamsSize: g.URLSearchParams\n      ? getter(g.URLSearchParams.prototype, 'size')\n      : undefined,\n    viewBuffer: getter(TypedArray, 'buffer'),\n    viewByteOffset: getter(TypedArray, 'byteOffset'),\n    viewByteLength: getter(TypedArray, 'byteLength'),\n    viewLength: getter(TypedArray, 'length'),\n    dataViewBuffer: getter(DataView.prototype, 'buffer'),\n    dataViewByteOffset: getter(DataView.prototype, 'byteOffset'),\n    dataViewByteLength: getter(DataView.prototype, 'byteLength'),\n    arrayBufferByteLength: getter(ArrayBuffer.prototype, 'byteLength'),\n    objectPrototype: Object.prototype,\n    errorPrototype: Error.prototype,\n    domExceptionPrototype: maybeProto(g.DOMException),\n    headersPrototype: maybeProto(g.Headers),\n    requestPrototype: maybeProto(g.Request),\n    responsePrototype: maybeProto(g.Response),\n    readableStreamPrototype: maybeProto(g.ReadableStream),\n    writableStreamPrototype: maybeProto(g.WritableStream),\n    urlPrototype: maybeProto(g.URL),\n    urlSearchParamsPrototype: maybeProto(g.URLSearchParams),\n\n    // --- building (parse) ---\n    Date, RegExp, Set, Map, Array, Object, DataView,\n    Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array,\n    Int32Array, Uint32Array, Float32Array, Float64Array,\n    BigInt64Array, BigUint64Array,\n    Error,\n    AggregateError: g.AggregateError,\n    EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError,\n    DOMException: g.DOMException,\n    Headers: g.Headers,\n    Request: g.Request,\n    Response: g.Response,\n    ReadableStream: g.ReadableStream,\n    WritableStream: g.WritableStream,\n    URL: g.URL,\n    URLSearchParams: g.URLSearchParams,\n    setAdd: Set.prototype.add,\n    mapSet: Map.prototype.set,\n    objectCreate: Object.create,\n    defineProperty: Object.defineProperty,\n    dateNow: Date.now,\n    objectFreeze: Object.freeze,\n    functionBind: Function.prototype.bind,\n    makeSparseArray: (length) => {\n      const array = [];\n      array[4294967294] = undefined;\n      delete array[4294967294];\n      array.length = length;\n      return array;\n    },\n    // Builds the closure-vars thunk a revived step proxy carries. Must be a\n    // guest closure (the proxy stores and later calls it from guest code).\n    makeThunk: (vars) => () => vars,\n  };\n})()`;\n\n/**\n * Well-known symbols the reducers/revivers read or stamp, captured as guest\n * symbol handles so descriptor reads/writes can be keyed on them.\n */\nconst SYMBOL_NAMES = [\n  'WORKFLOW_ABORT_STREAM_NAME',\n  'WORKFLOW_ABORT_HOOK_TOKEN',\n  'BODY_INIT',\n  'WORKFLOW_STREAM_NAME',\n  'WORKFLOW_STREAM_TYPE',\n  'WORKFLOW_STREAM_FRAMING',\n  'WORKFLOW_STREAM_SERVER_RUN_ID',\n  'WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID',\n  'WEBHOOK_RESPONSE_WRITABLE',\n  'WORKFLOW_USE_STEP',\n  'workflow-serialize', // @workflow/serde WORKFLOW_SERIALIZE\n  'workflow-deserialize', // @workflow/serde WORKFLOW_DESERIALIZE\n  'workflow-class-registry',\n  '@workflow/errors//FatalError',\n  '@workflow/errors//HookConflictError',\n  '@workflow/errors//RetryableError',\n  '@workflow/errors//RuntimeDecryptionError',\n] as const;\ntype SymbolName = (typeof SYMBOL_NAMES)[number];\n\n/**\n * The single guest expression that performs EVERY guest-touching part of\n * serde initialization: the intrinsics capture, the branded samples, and\n * the well-known symbol lookups, bundled into one container object.\n *\n * Bundling matters for the baseline-snapshot path: the container is\n * created BEFORE the workflow bundle evaluates (capture-before-user-code,\n * same as the fresh path), its handle's box lives in the snapshot's\n * linear memory, and every restored VM re-adopts it BY POINTER\n * (`adoptSerdeRoot`) — so serde initialization executes NO guest code\n * after user code has run. Anything less lets a module-scope wrapper\n * around e.g. `Object.getOwnPropertyDescriptor` observe (and be mutated\n * by) a post-eval capture, diverging fresh and restored replays.\n */\nconst CAPTURE_ROOT = `(() => ({\n  intrinsics: ${CAPTURE_INTRINSICS},\n  samples: ${BRANDED_SAMPLES},\n  symbols: {\n${SYMBOL_NAMES.map(\n  (name) => `    ${JSON.stringify(name)}: Symbol.for(${JSON.stringify(name)})`\n).join(',\\n')}\n  },\n}))()`;\n\n/**\n * Evaluate the serde capture root in a VM. Must run after the runtime\n * bootstrap and BEFORE any user code. The returned handle owns the\n * container; on the baseline-snapshot path its raw box pointer\n * (`handle.ptr`) is recorded next to the snapshot and re-adopted per\n * restored VM via {@link adoptSerdeRoot} — do NOT dispose the handle\n * before the snapshot is taken (the box must stay live in the memory\n * image).\n */\nexport function captureSerdeRoot(vm: QuickJS): JSValueHandle {\n  return vm.evalCode(CAPTURE_ROOT);\n}\n\n/**\n * Re-create the capture-root handle in a VM restored from a snapshot\n * taken while the exported root was alive, via quickjs-wasi's\n * snapshot-portable handle tokens (`importHandle` duplicates the\n * underlying value — the returned handle is independently owned and the\n * serde disposes it per restored VM). No guest code executes.\n */\nexport function adoptSerdeRoot(vm: QuickJS, token: number): JSValueHandle {\n  return vm.importHandle(token);\n}\n\n/**\n * Export the capture root as a snapshot-portable token to record next to\n * the baseline snapshot. The root handle must stay undisposed until the\n * snapshot is taken (its box — and the reference it holds — must be part\n * of the memory image).\n */\nexport function exportSerdeRoot(vm: QuickJS, root: JSValueHandle): number {\n  return vm.exportHandle(root);\n}\n\nexport interface QuickJSSerde {\n  /** Serialize a guest value handle to format-prefixed wire bytes. */\n  serialize(value: JSValueHandle): Uint8Array;\n  /** Build a guest value in the VM from format-prefixed wire bytes. */\n  deserialize(data: Uint8Array): JSValueHandle;\n  /**\n   * The reducer names this codec applies, in registration order. Exposed\n   * so tests can assert exhaustiveness against the shared value-space\n   * codec (codec-devalue-vm) — a reducer added there but not here would\n   * otherwise silently round-trip values as plain objects.\n   */\n  reducerKeys: readonly string[];\n  /** Reviver names, for the same exhaustiveness check. */\n  reviverKeys: readonly string[];\n  /**\n   * Install `globalThis.process = { env: Object.freeze({...}) }` in the\n   * VM through handles and boot-captured intrinsics only — no guest\n   * source is evaluated, so a module-scope wrapper around JSON.parse /\n   * Object.freeze cannot observe the injection. This matters on the\n   * baseline-snapshot path, where env injection happens after user code\n   * ran; evaluating guest source there would let patched globals see\n   * (and perturb) it, diverging from the fresh path.\n   */\n  installProcessEnv(env: Record<string, string | undefined>): void;\n  dispose(): void;\n}\n\n/**\n * Create the host-side serde for a VM. Must be called after the runtime\n * bootstrap has been evaluated (so bootstrap-installed globals are\n * capturable) and before the workflow bundle runs.\n */\nexport function createQuickJSSerde(\n  vm: QuickJS,\n  /**\n   * Pre-captured serde root (baseline-snapshot path): the container\n   * `captureSerdeRoot` created BEFORE user code, re-adopted from the\n   * restored memory image via `adoptSerdeRoot`. When omitted, the root\n   * is captured now — callers must guarantee no user code has run yet.\n   * Either way, initialization below performs only plain-data property\n   * reads and C-level classId reads on the container: NO guest code\n   * executes here, so nothing user-patchable can observe or perturb it.\n   */\n  capturedRoot?: JSValueHandle\n): QuickJSSerde {\n  const disposables: JSValueHandle[] = [];\n  const keep = (handle: JSValueHandle): JSValueHandle => {\n    disposables.push(handle);\n    return handle;\n  };\n  const isHandle = (value: unknown): value is JSValueHandle =>\n    value instanceof JSValueHandle;\n\n  // --- boot capture ---\n\n  const root = keep(capturedRoot ?? captureSerdeRoot(vm));\n\n  const tagByClassId = new Map<number, string>();\n  {\n    const samples = root.getProp('samples');\n    try {\n      for (const tag of samples.getOwnPropertyNames()) {\n        const sample = samples.getProp(tag);\n        tagByClassId.set(sample.classId, tag);\n        sample.dispose();\n      }\n    } finally {\n      samples.dispose();\n    }\n  }\n\n  const intrinsics = keep(root.getProp('intrinsics'));\n  const at = (name: string): JSValueHandle => keep(intrinsics.getProp(name));\n  /** Absent captures (extension/bootstrap global not installed). */\n  const optional = (name: string): JSValueHandle | undefined => {\n    const handle = at(name);\n    return handle.isUndefined ? undefined : handle;\n  };\n\n  const i = {\n    dateGetTime: at('dateGetTime'),\n    dateToISOString: at('dateToISOString'),\n    regExpSource: at('regExpSource'),\n    regExpFlags: at('regExpFlags'),\n    numberValueOf: at('numberValueOf'),\n    stringValueOf: at('stringValueOf'),\n    booleanValueOf: at('booleanValueOf'),\n    bigIntValueOf: at('bigIntValueOf'),\n    bigIntToString: at('bigIntToString'),\n    setForEach: at('setForEach'),\n    mapForEach: at('mapForEach'),\n    headersForEach: optional('headersForEach'),\n    urlHref: optional('urlHref'),\n    urlSearchParamsToString: optional('urlSearchParamsToString'),\n    urlSearchParamsSize: optional('urlSearchParamsSize'),\n    viewBuffer: at('viewBuffer'),\n    viewByteOffset: at('viewByteOffset'),\n    viewByteLength: at('viewByteLength'),\n    viewLength: at('viewLength'),\n    dataViewBuffer: at('dataViewBuffer'),\n    dataViewByteOffset: at('dataViewByteOffset'),\n    dataViewByteLength: at('dataViewByteLength'),\n    arrayBufferByteLength: at('arrayBufferByteLength'),\n    objectPrototype: at('objectPrototype'),\n    errorPrototype: at('errorPrototype'),\n    domExceptionPrototype: optional('domExceptionPrototype'),\n    headersPrototype: optional('headersPrototype'),\n    requestPrototype: optional('requestPrototype'),\n    responsePrototype: optional('responsePrototype'),\n    readableStreamPrototype: optional('readableStreamPrototype'),\n    writableStreamPrototype: optional('writableStreamPrototype'),\n    urlPrototype: optional('urlPrototype'),\n    urlSearchParamsPrototype: optional('urlSearchParamsPrototype'),\n    Date: at('Date'),\n    RegExp: at('RegExp'),\n    Set: at('Set'),\n    Map: at('Map'),\n    Array: at('Array'),\n    Object: at('Object'),\n    Error: at('Error'),\n    AggregateError: optional('AggregateError'),\n    DOMException: optional('DOMException'),\n    Headers: optional('Headers'),\n    ReadableStream: optional('ReadableStream'),\n    WritableStream: optional('WritableStream'),\n    URL: optional('URL'),\n    URLSearchParams: optional('URLSearchParams'),\n    setAdd: at('setAdd'),\n    mapSet: at('mapSet'),\n    objectCreate: at('objectCreate'),\n    defineProperty: at('defineProperty'),\n    dateNow: at('dateNow'),\n    objectFreeze: at('objectFreeze'),\n    functionBind: at('functionBind'),\n    makeSparseArray: at('makeSparseArray'),\n    makeThunk: at('makeThunk'),\n  };\n\n  const errorConstructors = new Map<string, JSValueHandle>();\n  for (const name of [\n    'EvalError',\n    'RangeError',\n    'ReferenceError',\n    'SyntaxError',\n    'TypeError',\n    'URIError',\n  ]) {\n    errorConstructors.set(name, at(name));\n  }\n\n  const typedArrayConstructors = new Map<string, JSValueHandle>();\n  for (const name of [\n    'Int8Array',\n    'Uint8Array',\n    'Uint8ClampedArray',\n    'Int16Array',\n    'Uint16Array',\n    'Int32Array',\n    'Uint32Array',\n    'Float32Array',\n    'Float64Array',\n    'BigInt64Array',\n    'BigUint64Array',\n    'DataView',\n  ]) {\n    typedArrayConstructors.set(name, at(name));\n  }\n\n  const symbols = new Map<SymbolName, JSValueHandle>();\n  {\n    using symbolsContainer = root.getProp('symbols');\n    for (const name of SYMBOL_NAMES) {\n      symbols.set(name, keep(symbolsContainer.getProp(name)));\n    }\n  }\n  const sym = (name: SymbolName): JSValueHandle => {\n    const handle = symbols.get(name);\n    if (!handle) throw new Error(`unknown captured symbol: ${name}`);\n    return handle;\n  };\n\n  // --- handle helpers ---\n\n  const call = (\n    fn: JSValueHandle,\n    thisValue: JSValueHandle,\n    ...args: JSValueHandle[]\n  ): JSValueHandle => vm.callFunction(fn, thisValue, ...args);\n\n  const invoke = (fn: JSValueHandle, ...args: JSValueHandle[]): JSValueHandle =>\n    vm.callFunction(fn, vm.undefined, ...args);\n\n  /**\n   * Guest own-property check through the handle's introspection method.\n   * MUST NOT be replaced with `Object.hasOwn`, which would interrogate the\n   * host JSValueHandle wrapper object (always false) instead of the guest\n   * value — biome's noPrototypeBuiltins auto-fix does exactly that, which\n   * is why this is centralized here with the suppression.\n   */\n  const guestHasOwn = (handle: JSValueHandle, key: string): boolean =>\n    // biome-ignore lint/suspicious/noPrototypeBuiltins: JSValueHandle.hasOwnProperty is quickjs-wasi's guest-side introspection API, not Object.prototype.hasOwnProperty\n    handle.hasOwnProperty(key);\n\n  /**\n   * Own data-property read. Returns undefined for absent properties AND for\n   * accessor properties — an inherited or own getter is never invoked\n   * (matching the hardened node:vm codec's descriptor-based reads).\n   */\n  const own = (\n    target: JSValueHandle,\n    key: string | JSValueHandle\n  ): JSValueHandle | undefined => {\n    const descriptor = target.getOwnPropertyDescriptor(key as string);\n    if (!descriptor) return undefined;\n    descriptor.get?.dispose();\n    descriptor.set?.dispose();\n    return descriptor.value;\n  };\n\n  /**\n   * Data-property read following the prototype chain (the safe analogue of\n   * `value.name` on an Error instance, where `name`/`message` live on the\n   * prototype). Accessors anywhere on the chain are skipped, not invoked.\n   */\n  const chained = (\n    target: JSValueHandle,\n    key: string | JSValueHandle\n  ): JSValueHandle | undefined => {\n    let current: JSValueHandle | undefined;\n    let owned = false; // whether `current` is ours to dispose\n    let cursor = target;\n    for (let depth = 0; depth < 32; depth++) {\n      const found = own(cursor, key);\n      if (found) {\n        if (owned) (cursor as JSValueHandle).dispose();\n        return found;\n      }\n      const proto = cursor.getPrototypeOf();\n      if (owned) (cursor as JSValueHandle).dispose();\n      if (proto.isNull || proto.isUndefined) {\n        proto.dispose();\n        return undefined;\n      }\n      cursor = proto;\n      owned = true;\n      current = proto;\n    }\n    if (owned && current) current.dispose();\n    return undefined;\n  };\n\n  /** Host string from a data property (own-or-chain), or undefined. */\n  const chainedString = (\n    target: JSValueHandle,\n    key: string | JSValueHandle\n  ): string | undefined => {\n    const handle = chained(target, key);\n    if (!handle) return undefined;\n    const result = handle.isString ? handle.toString() : undefined;\n    handle.dispose();\n    return result;\n  };\n\n  const ownString = (\n    target: JSValueHandle,\n    key: string | JSValueHandle\n  ): string | undefined => {\n    const handle = own(target, key);\n    if (!handle) return undefined;\n    const result = handle.isString ? handle.toString() : undefined;\n    handle.dispose();\n    return result;\n  };\n\n  /**\n   * Whether `handle` has `prototypeHandle` anywhere on its prototype chain —\n   * the trap-free analogue of `instanceof` (which would fire\n   * `Symbol.hasInstance`).\n   */\n  const hasPrototype = (\n    handle: JSValueHandle,\n    prototypeHandle: JSValueHandle | undefined\n  ): boolean => {\n    if (!prototypeHandle) return false;\n    let cursor = handle.getPrototypeOf();\n    for (let depth = 0; depth < 32; depth++) {\n      if (cursor.isNull || cursor.isUndefined) {\n        cursor.dispose();\n        return false;\n      }\n      if (cursor.identity === prototypeHandle.identity) {\n        cursor.dispose();\n        return true;\n      }\n      const next = cursor.getPrototypeOf();\n      cursor.dispose();\n      cursor = next;\n    }\n    cursor.dispose();\n    return false;\n  };\n\n  /** `Object.defineProperty` write, immune to inherited setters. */\n  const define = (\n    target: JSValueHandle,\n    key: string | JSValueHandle,\n    value: JSValueHandle\n  ): void => {\n    const descriptor = vm.newObject();\n    try {\n      descriptor.setProp('value', value);\n      descriptor.setProp('writable', vm.true);\n      descriptor.setProp('enumerable', vm.true);\n      descriptor.setProp('configurable', vm.true);\n      if (typeof key === 'string') {\n        const keyHandle = vm.newString(key);\n        try {\n          call(\n            i.defineProperty,\n            vm.undefined,\n            target,\n            keyHandle,\n            descriptor\n          ).dispose();\n        } finally {\n          keyHandle.dispose();\n        }\n      } else {\n        call(i.defineProperty, vm.undefined, target, key, descriptor).dispose();\n      }\n    } finally {\n      descriptor.dispose();\n    }\n  };\n\n  const newGuestString = (value: string): JSValueHandle => vm.newString(value);\n\n  /** Collect Set values / Map entries via captured forEach. */\n  const collect = (\n    forEach: JSValueHandle,\n    collection: JSValueHandle,\n    arity: 1 | 2\n  ): unknown[] => {\n    const collected: unknown[] = [];\n    const visitor = vm.newEphemeralFunction(\n      (value: JSValueHandle, key: JSValueHandle) => {\n        // dup(): the visitor's own arg handles are borrowed (C-owned,\n        // scope-exempt as of quickjs-wasi 3.3.1); the dups are owned\n        // references, scope-tracked and swept at the pass boundary.\n        collected.push(arity === 1 ? value.dup() : [key.dup(), value.dup()]);\n        return vm.undefined;\n      }\n    );\n    try {\n      call(forEach, collection, visitor).dispose();\n    } finally {\n      visitor.dispose();\n    }\n    return collected;\n  };\n\n  /** Copy a typed array / DataView's viewed bytes to the host. */\n  const viewBytes = (handle: JSValueHandle): Uint8Array => {\n    const isDataView = handle.isDataView;\n    const buffer = call(isDataView ? i.dataViewBuffer : i.viewBuffer, handle);\n    try {\n      const byteOffset = call(\n        isDataView ? i.dataViewByteOffset : i.viewByteOffset,\n        handle\n      ).consume((h) => h.toNumber());\n      const byteLength = call(\n        isDataView ? i.dataViewByteLength : i.viewByteLength,\n        handle\n      ).consume((h) => h.toNumber());\n      const bytes = new Uint8Array(buffer.toArrayBuffer());\n      return bytes.subarray(byteOffset, byteOffset + byteLength);\n    } finally {\n      buffer.dispose();\n    }\n  };\n\n  const tagOfHandle = (handle: JSValueHandle): string => {\n    if (handle.isProxy) return 'Object';\n    return tagByClassId.get(handle.classId) ?? 'Object';\n  };\n\n  // --- identity ---\n\n  const identities = new Map<number, object>();\n  const identityOf = (pointer: number): object => {\n    let identity = identities.get(pointer);\n    if (!identity) {\n      identity = { pointer };\n      identities.set(pointer, identity);\n    }\n    return identity;\n  };\n\n  const primitiveOf = (handle: JSValueHandle): unknown => {\n    if (handle.isUndefined) return undefined;\n    if (handle.isNull) return null;\n    if (handle.isBool) return handle.toBoolean();\n    if (handle.isNumber) return handle.toNumber();\n    if (handle.isBigInt) return guestBigInt(handle);\n    return handle.toString();\n  };\n\n  /**\n   * Extract a guest bigint via the captured `BigInt.prototype.toString` —\n   * `handle.toBigInt()` truncates to 64 bits.\n   */\n  const guestBigInt = (handle: JSValueHandle): bigint =>\n    BigInt(call(i.bigIntToString, handle).consume((h) => h.toString()));\n\n  // --- hybrid stringify operations ---\n  // Handles take the introspection path; host values (reducer outputs)\n  // fall back to devalue's defaults.\n\n  const d = defaultStringifyOperations;\n\n  const stringifyOperations: StringifyOperations = {\n    identify: (value) => {\n      if (!isHandle(value)) return d.identify(value);\n      const pointer = value.identity;\n      if (pointer === 0 || value.isString) return primitiveOf(value);\n      return identityOf(pointer);\n    },\n    typeOf: (value) => {\n      if (!isHandle(value)) return d.typeOf(value);\n      if (value.isNull) return 'null';\n      return value.typeof as ReturnType<StringifyOperations['typeOf']>;\n    },\n    toPrimitive: (value) => (isHandle(value) ? primitiveOf(value) : value),\n    tagOf: (value) => (isHandle(value) ? tagOfHandle(value) : d.tagOf(value)),\n    isThenable: (value) =>\n      isHandle(value) ? value.isPromise : d.isThenable(value),\n    toPromise: async (value) => {\n      if (!isHandle(value)) return d.toPromise(value);\n      const settled = await vm.resolvePromise(value);\n      if ('error' in settled) throw settled.error;\n      return settled.value;\n    },\n    unbox: (value) => {\n      if (!isHandle(value)) return d.unbox(value);\n      switch (tagOfHandle(value)) {\n        case 'Number':\n          return call(i.numberValueOf, value);\n        case 'String':\n          return call(i.stringValueOf, value);\n        case 'Boolean':\n          return call(i.booleanValueOf, value);\n        default:\n          return call(i.bigIntValueOf, value);\n      }\n    },\n    toISOString: (value) => {\n      if (!isHandle(value)) return d.toISOString(value);\n      if (\n        Number.isNaN(call(i.dateGetTime, value).consume((h) => h.toNumber()))\n      ) {\n        return '';\n      }\n      return call(i.dateToISOString, value).consume((h) => h.toString());\n    },\n    toStringValue: (value) => {\n      if (!isHandle(value)) return d.toStringValue(value);\n      // URL / URLSearchParams are matched by workflow reducers before\n      // devalue's native handling, and Temporal doesn't exist in the VM, so\n      // this is unreachable in practice. Refuse rather than invoke guest\n      // `toString`.\n      throw new Error(\n        `no captured string conversion for ${tagOfHandle(value)} in the VM`\n      );\n    },\n    regExpInfo: (value) => {\n      if (!isHandle(value)) return d.regExpInfo(value);\n      return {\n        source: call(i.regExpSource, value).consume((h) => h.toString()),\n        flags: call(i.regExpFlags, value).consume((h) => h.toString()),\n      };\n    },\n    valuesOf: (value) =>\n      isHandle(value) ? collect(i.setForEach, value, 1) : d.valuesOf(value),\n    entriesOf: (value) =>\n      isHandle(value)\n        ? (collect(i.mapForEach, value, 2) as Iterable<[unknown, unknown]>)\n        : d.entriesOf(value),\n    viewInfo: (value) => {\n      if (!isHandle(value)) return d.viewInfo(value);\n      const isDataView = value.isDataView;\n      const buffer = call(isDataView ? i.dataViewBuffer : i.viewBuffer, value);\n      const info = {\n        buffer,\n        byteOffset: call(\n          isDataView ? i.dataViewByteOffset : i.viewByteOffset,\n          value\n        ).consume((h) => h.toNumber()),\n        byteLength: call(\n          isDataView ? i.dataViewByteLength : i.viewByteLength,\n          value\n        ).consume((h) => h.toNumber()),\n        bufferByteLength: call(i.arrayBufferByteLength, buffer).consume((h) =>\n          h.toNumber()\n        ),\n        length: 0,\n      };\n      if (!isDataView) {\n        info.length = call(i.viewLength, value).consume((h) => h.toNumber());\n      }\n      return info;\n    },\n    toArrayBuffer: (value) =>\n      isHandle(value) ? value.toArrayBuffer() : d.toArrayBuffer(value),\n    lengthOf: (value) => {\n      if (!isHandle(value)) return d.lengthOf(value);\n      const length = own(value, 'length');\n      return length?.consume((h) => h.toNumber()) ?? 0;\n    },\n    hasOwn: (value, key) =>\n      isHandle(value) ? guestHasOwn(value, String(key)) : d.hasOwn(value, key),\n    indicesOf: (value) =>\n      isHandle(value) ? filterArrayIndices(value.keys()) : d.indicesOf(value),\n    shapeOf: (value) => {\n      if (!isHandle(value)) return d.shapeOf(value);\n      if (value.isProxy) return { kind: 'not-plain' as const };\n      const prototype = value.getPrototypeOf();\n      try {\n        const isPlain =\n          prototype.isNull || prototype.identity === i.objectPrototype.identity;\n        if (!isPlain) return { kind: 'not-plain' as const };\n        const keys: string[] = [];\n        for (const key of value.getOwnPropertyKeys()) {\n          if (typeof key !== 'string') {\n            const enumerable =\n              value.getOwnPropertyDescriptor(key)?.enumerable ?? false;\n            key.dispose();\n            if (enumerable) return { kind: 'symbol-keys' as const };\n            continue;\n          }\n          if (value.propertyIsEnumerable(key)) keys.push(key);\n        }\n        return {\n          kind: prototype.isNull ? ('null-proto' as const) : ('plain' as const),\n          keys,\n        };\n      } finally {\n        prototype.dispose();\n      }\n    },\n    get: (value, key) => {\n      if (!isHandle(value)) return d.get(value, key);\n      const descriptor = value.getOwnPropertyDescriptor(String(key));\n      if (!descriptor) return undefined;\n      if (descriptor.get) {\n        // Parity with the hardened node:vm codec: getters are invoked (full\n        // compatibility with values whose shape depends on accessors), the\n        // difference from `[[Get]]` being that this is an explicit, single\n        // invocation of the accessor the descriptor names.\n        const result = call(descriptor.get, value);\n        descriptor.get.dispose();\n        descriptor.set?.dispose();\n        return result;\n      }\n      descriptor.set?.dispose();\n      return descriptor.value;\n    },\n  };\n\n  // --- workflow reducers (handle space) ---\n\n  /** Host shape for error-family reduction; leaves may be handles. */\n  const reduceErrorShape = (\n    value: JSValueHandle\n  ): { message: string; stack?: string; cause?: unknown } => {\n    const shape: { message: string; stack?: string; cause?: unknown } = {\n      message: chainedString(value, 'message') ?? '',\n    };\n    const stack = chainedString(value, 'stack');\n    if (stack !== undefined) shape.stack = stack;\n    if (guestHasOwn(value, 'cause')) {\n      shape.cause = own(value, 'cause') ?? undefined;\n    }\n    return shape;\n  };\n\n  const namedErrorSubclassReducer =\n    (subclassName: string) => (value: unknown) => {\n      if (!isHandle(value) || !value.isError) return false;\n      if (chainedString(value, 'name') !== subclassName) return false;\n      return reduceErrorShape(value);\n    };\n\n  /** Own symbol-keyed data read returning a host string, or undefined. */\n  const ownSymbolString = (\n    value: JSValueHandle,\n    name: SymbolName\n  ): string | undefined => {\n    const handle = own(value, sym(name));\n    if (!handle) return undefined;\n    const result = handle.isString ? handle.toString() : undefined;\n    handle.dispose();\n    return result;\n  };\n\n  const reduceAbort = (value: JSValueHandle): unknown => {\n    // streamName/hookToken live on the signal (or the controller's signal).\n    const signal = own(value, 'signal');\n    const holder = signal ?? value;\n    const streamName =\n      ownSymbolString(value, 'WORKFLOW_ABORT_STREAM_NAME') ??\n      ownSymbolString(holder, 'WORKFLOW_ABORT_STREAM_NAME');\n    const hookToken =\n      ownSymbolString(value, 'WORKFLOW_ABORT_HOOK_TOKEN') ??\n      ownSymbolString(holder, 'WORKFLOW_ABORT_HOOK_TOKEN');\n    if (!streamName) {\n      signal?.dispose();\n      throw new Error('AbortController/AbortSignal stream name is not set');\n    }\n    const aborted =\n      own(holder, 'aborted')?.consume((h) => h.toBoolean()) ?? false;\n    const reason = aborted ? own(holder, 'reason') : undefined;\n    if (signal && holder !== value) signal.dispose();\n    return {\n      streamName,\n      hookToken,\n      aborted,\n      reason: aborted ? reason : undefined,\n    };\n  };\n\n  const reducers: Record<string, (value: any) => any> = {\n    // Order is wire-significant (first match wins) and mirrors\n    // codec-devalue-vm.ts getReducersForMode('workflow') exactly.\n    AbortController: (value) => {\n      if (!isHandle(value) || value.typeof !== 'object' || value.isNull) {\n        return false;\n      }\n      if (!guestHasOwn(value, 'signal')) return false;\n      const hasStamp =\n        ownSymbolString(value, 'WORKFLOW_ABORT_STREAM_NAME') !== undefined ||\n        own(value, 'signal')?.consume(\n          (signal) =>\n            ownSymbolString(signal, 'WORKFLOW_ABORT_STREAM_NAME') !== undefined\n        );\n      if (!hasStamp) return false;\n      return reduceAbort(value);\n    },\n    AbortSignal: (value) => {\n      if (!isHandle(value) || value.typeof !== 'object' || value.isNull) {\n        return false;\n      }\n      if (ownSymbolString(value, 'WORKFLOW_ABORT_STREAM_NAME') === undefined) {\n        return false;\n      }\n      return reduceAbort(value);\n    },\n    Class: (value) => {\n      if (!isHandle(value) || value.typeof !== 'function') return false;\n      const classId = ownString(value, 'classId');\n      if (classId === undefined) return false;\n      return { classId };\n    },\n    Instance: (value) => {\n      if (!isHandle(value) || value.typeof !== 'object' || value.isNull) {\n        return false;\n      }\n      const cls = chained(value, 'constructor');\n      if (!cls || cls.typeof !== 'function') {\n        cls?.dispose();\n        return false;\n      }\n      try {\n        const serializeMethod = chained(cls, sym('workflow-serialize'));\n        if (!serializeMethod || serializeMethod.typeof !== 'function') {\n          serializeMethod?.dispose();\n          return false;\n        }\n        try {\n          const classId = chainedString(cls, 'classId');\n          if (classId === undefined) {\n            const name = chainedString(cls, 'name') ?? '<anonymous>';\n            throw new Error(\n              `Class \"${name}\" with Symbol(workflow-serialize) must have a static \"classId\" property.`\n            );\n          }\n          // Guest code by contract: the class's own serializer runs, exactly\n          // as it did under the in-VM codec.\n          const data = call(serializeMethod, cls, value);\n          return { classId, data };\n        } finally {\n          serializeMethod.dispose();\n        }\n      } finally {\n        cls.dispose();\n      }\n    },\n    StepFunction: (value) => {\n      if (!isHandle(value) || value.typeof !== 'function') return false;\n      const stepId = ownString(value, 'stepId');\n      if (stepId === undefined) return false;\n      const payload: {\n        stepId: string;\n        closureVars?: unknown;\n        boundThis?: unknown;\n        boundArgs?: unknown;\n      } = { stepId };\n      const closureVarsFn = own(value, '__closureVarsFn');\n      if (closureVarsFn) {\n        if (closureVarsFn.typeof === 'function') {\n          // Guest code by contract (same as the in-VM codec).\n          const closureVars = call(closureVarsFn, vm.undefined);\n          if (!closureVars.isUndefined) payload.closureVars = closureVars;\n          else closureVars.dispose();\n        }\n        closureVarsFn.dispose();\n      }\n      if (guestHasOwn(value, '__boundThis')) {\n        payload.boundThis = own(value, '__boundThis');\n      }\n      const boundArgs = own(value, '__boundArgs');\n      if (boundArgs) {\n        const length =\n          own(boundArgs, 'length')?.consume((h) => h.toNumber()) ?? 0;\n        if (boundArgs.isArray && length > 0) payload.boundArgs = boundArgs;\n        else boundArgs.dispose();\n      }\n      return payload;\n    },\n    ArrayBuffer: (value) => {\n      if (!isHandle(value) || tagOfHandle(value) !== 'ArrayBuffer') {\n        return false;\n      }\n      return bytesToBase64(new Uint8Array(value.toArrayBuffer()));\n    },\n    BigInt: (value) => {\n      if (!isHandle(value) || !value.isBigInt) return false;\n      return guestBigInt(value).toString();\n    },\n    BigInt64Array: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'BigInt64Array'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n    BigUint64Array: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'BigUint64Array'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n    Date: (value) => {\n      if (!isHandle(value) || tagOfHandle(value) !== 'Date') return false;\n      const time = call(i.dateGetTime, value).consume((h) => h.toNumber());\n      if (Number.isNaN(time)) return '.';\n      return call(i.dateToISOString, value).consume((h) => h.toString());\n    },\n    DOMException: (value) => {\n      if (!isHandle(value) || !isHandle(value)) return false;\n      if (\n        !i.domExceptionPrototype ||\n        !hasPrototype(value, i.domExceptionPrototype)\n      ) {\n        return false;\n      }\n      const shape = reduceErrorShape(value) as Record<string, unknown>;\n      return {\n        message: shape.message,\n        name: chainedString(value, 'name'),\n        stack: shape.stack,\n        ...(Object.hasOwn(shape, 'cause') ? { cause: shape.cause } : {}),\n      };\n    },\n    AggregateError: (value) => {\n      if (!isHandle(value) || !value.isError) return false;\n      if (chainedString(value, 'name') !== 'AggregateError') return false;\n      const shape = reduceErrorShape(value) as Record<string, unknown>;\n      return {\n        message: shape.message,\n        stack: shape.stack,\n        errors: own(value, 'errors'),\n        ...(Object.hasOwn(shape, 'cause') ? { cause: shape.cause } : {}),\n      };\n    },\n    EvalError: namedErrorSubclassReducer('EvalError'),\n    FatalError: namedErrorSubclassReducer('FatalError'),\n    HookConflictError: (value) => {\n      if (!isHandle(value) || !value.isError) return false;\n      if (chainedString(value, 'name') !== 'HookConflictError') return false;\n      const shape = reduceErrorShape(value) as Record<string, unknown>;\n      const reduced: Record<string, unknown> = {\n        message: shape.message,\n        stack: shape.stack,\n        token: own(value, 'token'),\n      };\n      const conflictingRunId = own(value, 'conflictingRunId');\n      if (conflictingRunId && !conflictingRunId.isUndefined) {\n        reduced.conflictingRunId = conflictingRunId;\n      } else {\n        conflictingRunId?.dispose();\n      }\n      if (Object.hasOwn(shape, 'cause')) reduced.cause = shape.cause;\n      return reduced;\n    },\n    RangeError: namedErrorSubclassReducer('RangeError'),\n    ReferenceError: namedErrorSubclassReducer('ReferenceError'),\n    RetryableError: (value) => {\n      if (!isHandle(value) || !value.isError) return false;\n      if (chainedString(value, 'name') !== 'RetryableError') return false;\n      const shape = reduceErrorShape(value) as Record<string, unknown>;\n      // retryAfter is a guest Date (or string/number); normalize to an epoch\n      // timestamp exactly like the in-VM reducer. The absent/invalid\n      // fallback reads the GUEST clock (the deterministic replay clock at\n      // the WASI layer), not the host wall clock: the in-VM reducer's\n      // `Date.now()` was replay-stable by construction, and a host-side\n      // `Date.now()` here would write different bytes on every replay of\n      // the same value.\n      let retryAfter = invoke(i.dateNow).consume((h) => h.toNumber()) + 1000;\n      const raw = own(value, 'retryAfter');\n      if (raw) {\n        if (tagOfHandle(raw) === 'Date') {\n          const t = call(i.dateGetTime, raw).consume((h) => h.toNumber());\n          if (!Number.isNaN(t)) retryAfter = t;\n        } else if (raw.isString || raw.isNumber) {\n          const t = new Date(\n            raw.isString ? raw.toString() : raw.toNumber()\n          ).getTime();\n          if (!Number.isNaN(t)) retryAfter = t;\n        }\n        raw.dispose();\n      }\n      const reduced: Record<string, unknown> = {\n        message: shape.message,\n        stack: shape.stack,\n        retryAfter,\n      };\n      if (Object.hasOwn(shape, 'cause')) reduced.cause = shape.cause;\n      return reduced;\n    },\n    RuntimeDecryptionError: (value) => {\n      if (!isHandle(value) || !value.isError) return false;\n      if (chainedString(value, 'name') !== 'RuntimeDecryptionError') {\n        return false;\n      }\n      const shape = reduceErrorShape(value) as Record<string, unknown>;\n      const reduced: Record<string, unknown> = {\n        message: shape.message,\n        stack: shape.stack,\n      };\n      const context = own(value, 'context');\n      if (context && !context.isUndefined) reduced.context = context;\n      else context?.dispose();\n      if (Object.hasOwn(shape, 'cause')) reduced.cause = shape.cause;\n      return reduced;\n    },\n    SyntaxError: namedErrorSubclassReducer('SyntaxError'),\n    TypeError: namedErrorSubclassReducer('TypeError'),\n    URIError: namedErrorSubclassReducer('URIError'),\n    Error: (value) => {\n      if (!isHandle(value) || !value.isError) return false;\n      const shape = reduceErrorShape(value) as Record<string, unknown>;\n      return {\n        name: chainedString(value, 'name') ?? 'Error',\n        message: shape.message,\n        stack: shape.stack,\n        ...(Object.hasOwn(shape, 'cause') ? { cause: shape.cause } : {}),\n      };\n    },\n    Float32Array: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Float32Array'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n    Float64Array: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Float64Array'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n    Int8Array: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Int8Array'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n    Int16Array: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Int16Array'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n    Int32Array: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Int32Array'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n    Map: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Map'\n        ? collect(i.mapForEach, value, 2)\n        : false,\n    RegExp: (value) => {\n      if (!isHandle(value) || tagOfHandle(value) !== 'RegExp') return false;\n      return {\n        source: call(i.regExpSource, value).consume((h) => h.toString()),\n        flags: call(i.regExpFlags, value).consume((h) => h.toString()),\n      };\n    },\n    Headers: (value) => {\n      if (\n        !isHandle(value) ||\n        !i.headersPrototype ||\n        !hasPrototype(value, i.headersPrototype) ||\n        !i.headersForEach\n      ) {\n        return false;\n      }\n      // Headers.forEach yields (value, key); normalize to [key, value]\n      // pairs of host strings, matching Array.from(headers).\n      const entries: [string, string][] = [];\n      const visitor = vm.newEphemeralFunction(\n        (headerValue: JSValueHandle, headerKey: JSValueHandle) => {\n          entries.push([headerKey.toString(), headerValue.toString()]);\n          return vm.undefined;\n        }\n      );\n      try {\n        call(i.headersForEach, value, visitor).dispose();\n      } finally {\n        visitor.dispose();\n      }\n      return entries;\n    },\n    Request: (value) => {\n      if (!isHandle(value) || value.typeof !== 'object' || value.isNull) {\n        return false;\n      }\n      const isRequest =\n        (i.requestPrototype && hasPrototype(value, i.requestPrototype)) ||\n        own(value, 'json')?.consume((h) => h.typeof === 'function');\n      if (!isRequest) return false;\n      const method = own(value, 'method');\n      if (!method || !method.isString) {\n        method?.dispose();\n        return false;\n      }\n      const data: Record<string, unknown> = {\n        method,\n        url: own(value, 'url'),\n        headers: own(value, 'headers'),\n        body: own(value, 'body'),\n        duplex: own(value, 'duplex'),\n      };\n      const responseWritable = own(value, sym('WEBHOOK_RESPONSE_WRITABLE'));\n      if (responseWritable && !responseWritable.isUndefined) {\n        data.responseWritable = responseWritable;\n      } else {\n        responseWritable?.dispose();\n      }\n      return data;\n    },\n    Response: (value) => {\n      if (!isHandle(value) || value.typeof !== 'object' || value.isNull) {\n        return false;\n      }\n      const isResponse =\n        (i.responsePrototype && hasPrototype(value, i.responsePrototype)) ||\n        chained(value, 'clone')?.consume((h) => h.typeof === 'function');\n      if (!isResponse) return false;\n      const status = own(value, 'status');\n      if (!status || !status.isNumber) {\n        status?.dispose();\n        return false;\n      }\n      return {\n        type: own(value, 'type'),\n        url: own(value, 'url'),\n        status,\n        statusText: own(value, 'statusText'),\n        headers: own(value, 'headers'),\n        body: own(value, 'body'),\n        redirected: own(value, 'redirected'),\n      };\n    },\n    ReadableStream: (value) => {\n      if (\n        !isHandle(value) ||\n        value.typeof !== 'object' ||\n        value.isNull ||\n        !i.readableStreamPrototype ||\n        !hasPrototype(value, i.readableStreamPrototype)\n      ) {\n        return false;\n      }\n      const bodyInit = own(value, sym('BODY_INIT'));\n      if (bodyInit && !bodyInit.isUndefined) {\n        return { bodyInit };\n      }\n      bodyInit?.dispose();\n      const name = ownSymbolString(value, 'WORKFLOW_STREAM_NAME');\n      if (name) {\n        const s: Record<string, unknown> = { name };\n        const type = ownSymbolString(value, 'WORKFLOW_STREAM_TYPE');\n        if (type) s.type = type;\n        const framing = ownSymbolString(value, 'WORKFLOW_STREAM_FRAMING');\n        if (framing) s.framing = framing;\n        return s;\n      }\n      return { name: '__empty' };\n    },\n    WritableStream: (value) => {\n      if (\n        !isHandle(value) ||\n        value.typeof !== 'object' ||\n        value.isNull ||\n        !i.writableStreamPrototype ||\n        !hasPrototype(value, i.writableStreamPrototype)\n      ) {\n        return false;\n      }\n      const s: Record<string, unknown> = {\n        name: ownSymbolString(value, 'WORKFLOW_STREAM_NAME') || '__empty',\n      };\n      const runId = ownSymbolString(value, 'WORKFLOW_STREAM_SERVER_RUN_ID');\n      if (runId) s.runId = runId;\n      const deploymentId = ownSymbolString(\n        value,\n        'WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID'\n      );\n      if (deploymentId) s.deploymentId = deploymentId;\n      return s;\n    },\n    Set: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Set'\n        ? collect(i.setForEach, value, 1)\n        : false,\n    URL: (value) => {\n      if (\n        !isHandle(value) ||\n        !i.urlPrototype ||\n        !hasPrototype(value, i.urlPrototype) ||\n        !i.urlHref\n      ) {\n        return false;\n      }\n      return call(i.urlHref, value).consume((h) => h.toString());\n    },\n    WorkflowFunction: (value) => {\n      if (!isHandle(value) || value.typeof !== 'function') return false;\n      const workflowId = ownString(value, 'workflowId');\n      if (workflowId === undefined) return false;\n      return { workflowId };\n    },\n    URLSearchParams: (value) => {\n      if (\n        !isHandle(value) ||\n        !i.urlSearchParamsPrototype ||\n        !hasPrototype(value, i.urlSearchParamsPrototype) ||\n        !i.urlSearchParamsToString\n      ) {\n        return false;\n      }\n      const size = i.urlSearchParamsSize\n        ? call(i.urlSearchParamsSize, value).consume((h) => h.toNumber())\n        : Number.NaN;\n      if (size === 0) return '.';\n      return call(i.urlSearchParamsToString, value).consume((h) =>\n        h.toString()\n      );\n    },\n    Uint8Array: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Uint8Array'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n    Uint8ClampedArray: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Uint8ClampedArray'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n    Uint16Array: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Uint16Array'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n    Uint32Array: (value) =>\n      isHandle(value) && tagOfHandle(value) === 'Uint32Array'\n        ? bytesToBase64(viewBytes(value))\n        : false,\n  };\n\n  // --- parse operations (handle-only: everything is built in the VM) ---\n\n  const parseOperations: ParseOperations = {\n    fromPrimitive: (value) =>\n      typeof value === 'bigint' ? vm.newBigInt(value) : vm.hostToHandle(value),\n    fromISOString: (iso) => {\n      const argument =\n        iso === '' ? vm.newNumber(Number.NaN) : vm.newString(iso);\n      try {\n        return vm.construct(i.Date, argument);\n      } finally {\n        argument.dispose();\n      }\n    },\n    fromStringValue: (tag, _string) => {\n      throw new Error(`${tag} cannot be revived in the VM`);\n    },\n    fromArrayBuffer: (buffer) => vm.newArrayBuffer(buffer),\n    fromRegExpInfo: (source, flags) => {\n      const sourceHandle = vm.newString(source);\n      try {\n        if (!flags) return vm.construct(i.RegExp, sourceHandle);\n        const flagsHandle = vm.newString(flags);\n        try {\n          return vm.construct(i.RegExp, sourceHandle, flagsHandle);\n        } finally {\n          flagsHandle.dispose();\n        }\n      } finally {\n        sourceHandle.dispose();\n      }\n    },\n    fromViewInfo: (tag, buffer, byteOffset, length) => {\n      const Constructor = typedArrayConstructors.get(tag);\n      if (!Constructor) throw new Error(`${tag} is not available in the VM`);\n      if (byteOffset === undefined) {\n        return vm.construct(Constructor, buffer as JSValueHandle);\n      }\n      const offsetHandle = vm.newNumber(byteOffset);\n      const lengthHandle = vm.newNumber(length ?? 0);\n      try {\n        return vm.construct(\n          Constructor,\n          buffer as JSValueHandle,\n          offsetHandle,\n          lengthHandle\n        );\n      } finally {\n        offsetHandle.dispose();\n        lengthHandle.dispose();\n      }\n    },\n    box: (value) => vm.construct(i.Object, value as JSValueHandle),\n    createArray: (length) => {\n      const lengthHandle = vm.newNumber(length);\n      try {\n        return vm.construct(i.Array, lengthHandle);\n      } finally {\n        lengthHandle.dispose();\n      }\n    },\n    createSparseArray: (length) => {\n      const lengthHandle = vm.newNumber(length);\n      try {\n        return invoke(i.makeSparseArray, lengthHandle);\n      } finally {\n        lengthHandle.dispose();\n      }\n    },\n    createObject: () => vm.newObject(),\n    createNullPrototypeObject: () =>\n      call(i.objectCreate, vm.undefined, vm.null),\n    createSet: () => vm.construct(i.Set),\n    createMap: () => vm.construct(i.Map),\n    set: (target, key, value) =>\n      define(target as JSValueHandle, String(key), value as JSValueHandle),\n    addValue: (set, value) => {\n      call(i.setAdd, set as JSValueHandle, value as JSValueHandle).dispose();\n    },\n    addEntry: (map, key, value) => {\n      call(\n        i.mapSet,\n        map as JSValueHandle,\n        key as JSValueHandle,\n        value as JSValueHandle\n      ).dispose();\n    },\n  };\n\n  // --- workflow revivers (handle space) ---\n\n  /** Guest lookup of a registered error class on globalThis, by symbol. */\n  const registeredErrorClass = (\n    name: SymbolName\n  ): JSValueHandle | undefined => {\n    const cls = own(vm.global, sym(name));\n    if (!cls || cls.typeof !== 'function') {\n      cls?.dispose();\n      return undefined;\n    }\n    return cls;\n  };\n\n  /** Construct a guest Error via `ctor(message)` + define stack/cause. */\n  const buildError = (\n    ctor: JSValueHandle,\n    value: JSValueHandle,\n    opts: { name?: string; extraCtorArgs?: JSValueHandle[] } = {}\n  ): JSValueHandle => {\n    const message = own(value, 'message') ?? vm.undefined;\n    const error = vm.construct(ctor, message, ...(opts.extraCtorArgs ?? []));\n    if (message !== vm.undefined) message.dispose();\n    if (opts.name !== undefined) {\n      const nameHandle = newGuestString(opts.name);\n      define(error, 'name', nameHandle);\n      nameHandle.dispose();\n    }\n    const stack = own(value, 'stack');\n    if (stack && !stack.isUndefined) define(error, 'stack', stack);\n    stack?.dispose();\n    if (guestHasOwn(value, 'cause')) {\n      const cause = own(value, 'cause') ?? vm.undefined;\n      define(error, 'cause', cause);\n      if (cause !== vm.undefined) cause.dispose();\n    }\n    return error;\n  };\n\n  const namedErrorSubclassReviver =\n    (subclassName: string) => (value: JSValueHandle) => {\n      const ctor = errorConstructors.get(subclassName);\n      if (ctor) return buildError(ctor, value);\n      return buildError(i.Error, value, { name: subclassName });\n    };\n\n  const reviveAbortSignal = (value: JSValueHandle): JSValueHandle => {\n    const cls = own(vm.global, '__WorkflowAbortSignal');\n    if (!cls || cls.typeof !== 'function') {\n      cls?.dispose();\n      throw new Error(\n        'WorkflowAbortSignal is not registered in the VM (bootstrap not evaluated)'\n      );\n    }\n    try {\n      const streamName = own(value, 'streamName') ?? vm.undefined;\n      const hookToken = own(value, 'hookToken') ?? vm.undefined;\n      const signal = vm.construct(cls, streamName, hookToken);\n      if (streamName !== vm.undefined) streamName.dispose();\n      if (hookToken !== vm.undefined) hookToken.dispose();\n      const aborted = own(value, 'aborted');\n      if (aborted?.toBoolean()) {\n        const setAborted = chained(signal, '_setAborted');\n        if (setAborted) {\n          const reason = own(value, 'reason') ?? vm.undefined;\n          call(setAborted, signal, reason).dispose();\n          if (reason !== vm.undefined) reason.dispose();\n          setAborted.dispose();\n        }\n      }\n      aborted?.dispose();\n      return signal;\n    } finally {\n      cls.dispose();\n    }\n  };\n\n  const revivers: Record<string, (value: any) => any> = {\n    AbortController: (value: JSValueHandle) => {\n      const controller = vm.newObject();\n      const streamName = own(value, 'streamName') ?? vm.undefined;\n      define(controller, sym('WORKFLOW_ABORT_STREAM_NAME'), streamName);\n      if (streamName !== vm.undefined) streamName.dispose();\n      const hookToken = own(value, 'hookToken') ?? vm.undefined;\n      define(controller, sym('WORKFLOW_ABORT_HOOK_TOKEN'), hookToken);\n      if (hookToken !== vm.undefined) hookToken.dispose();\n      const signal = reviveAbortSignal(value);\n      define(controller, 'signal', signal);\n      signal.dispose();\n      const noop = vm.evalCode('(function(){})');\n      define(controller, 'abort', noop);\n      noop.dispose();\n      return controller;\n    },\n    AbortSignal: (value: JSValueHandle) => reviveAbortSignal(value),\n    Class: (value: JSValueHandle) => {\n      const classId = ownString(value, 'classId');\n      const cls = lookupRegisteredClass(classId);\n      if (!cls) {\n        throw new Error(\n          `Class \"${classId}\" not found. Make sure the class is registered with registerSerializationClass.`\n        );\n      }\n      return cls;\n    },\n    Instance: (value: JSValueHandle) => {\n      const classId = ownString(value, 'classId');\n      const cls = lookupRegisteredClass(classId);\n      if (!cls) {\n        throw new Error(\n          `Class \"${classId}\" not found. Make sure the class is registered with registerSerializationClass.`\n        );\n      }\n      try {\n        const deserializeMethod = chained(cls, sym('workflow-deserialize'));\n        if (!deserializeMethod || deserializeMethod.typeof !== 'function') {\n          deserializeMethod?.dispose();\n          throw new Error(\n            `Class \"${classId}\" does not have a static Symbol(workflow-deserialize) method.`\n          );\n        }\n        try {\n          const data = own(value, 'data') ?? vm.undefined;\n          const result = call(deserializeMethod, cls, data);\n          if (data !== vm.undefined) data.dispose();\n          return result;\n        } finally {\n          deserializeMethod.dispose();\n        }\n      } finally {\n        cls.dispose();\n      }\n    },\n    StepFunction: (value: JSValueHandle) => {\n      const useStep = own(vm.global, sym('WORKFLOW_USE_STEP'));\n      if (!useStep || useStep.typeof !== 'function') {\n        useStep?.dispose();\n        throw new Error(\n          'WORKFLOW_USE_STEP not found on global object. Step functions cannot be deserialized outside workflow context.'\n        );\n      }\n      try {\n        const stepId = own(value, 'stepId') ?? vm.undefined;\n        const closureVars = own(value, 'closureVars');\n        let proxy: JSValueHandle;\n        if (closureVars && !closureVars.isUndefined) {\n          const thunk = invoke(i.makeThunk, closureVars);\n          proxy = invoke(useStep, stepId, thunk);\n          thunk.dispose();\n        } else {\n          proxy = invoke(useStep, stepId);\n        }\n        closureVars?.dispose();\n        if (stepId !== vm.undefined) stepId.dispose();\n        if (guestHasOwn(value, 'boundThis')) {\n          // Re-bind through the proxy's own (overridden) `.bind`, which is\n          // an own data property stamped by WORKFLOW_USE_STEP.\n          const bind = own(proxy, 'bind') ?? chained(proxy, 'bind');\n          const boundThis = own(value, 'boundThis') ?? vm.undefined;\n          const boundArgs = own(value, 'boundArgs');\n          const args: JSValueHandle[] = [boundThis];\n          const argHandles: JSValueHandle[] = [];\n          if (boundArgs && boundArgs.isArray) {\n            const length =\n              own(boundArgs, 'length')?.consume((h) => h.toNumber()) ?? 0;\n            for (let index = 0; index < length; index++) {\n              const element = own(boundArgs, String(index)) ?? vm.undefined;\n              args.push(element);\n              if (element !== vm.undefined) argHandles.push(element);\n            }\n          }\n          boundArgs?.dispose();\n          if (bind) {\n            const bound = call(bind, proxy, ...args);\n            bind.dispose();\n            proxy.dispose();\n            proxy = bound;\n          }\n          if (boundThis !== vm.undefined) boundThis.dispose();\n          for (const handle of argHandles) handle.dispose();\n        }\n        return proxy;\n      } finally {\n        useStep.dispose();\n      }\n    },\n    ArrayBuffer: (value: string | JSValueHandle) =>\n      vm.newArrayBuffer(\n        base64ToBytes(isHandle(value) ? value.toString() : value)\n          .buffer as ArrayBuffer\n      ),\n    BigInt: (value: string | JSValueHandle) =>\n      vm.newBigInt(BigInt(isHandle(value) ? value.toString() : value)),\n    BigInt64Array: (value: string | JSValueHandle) =>\n      buildTypedArray('BigInt64Array', value),\n    BigUint64Array: (value: string | JSValueHandle) =>\n      buildTypedArray('BigUint64Array', value),\n    Date: (value: JSValueHandle | string) => {\n      // The reducer emits '.' for invalid dates and an ISO string otherwise.\n      const iso = isHandle(value) ? value.toString() : value;\n      const argument =\n        iso === '.' ? vm.newNumber(Number.NaN) : vm.newString(iso);\n      try {\n        return vm.construct(i.Date, argument);\n      } finally {\n        argument.dispose();\n        if (isHandle(value)) value.dispose();\n      }\n    },\n    DOMException: (value: JSValueHandle) => {\n      if (i.DOMException) {\n        const message = own(value, 'message') ?? vm.undefined;\n        const name = own(value, 'name') ?? vm.undefined;\n        const error = vm.construct(i.DOMException, message, name);\n        if (message !== vm.undefined) message.dispose();\n        if (name !== vm.undefined) name.dispose();\n        const stack = own(value, 'stack');\n        if (stack && !stack.isUndefined) define(error, 'stack', stack);\n        stack?.dispose();\n        if (guestHasOwn(value, 'cause')) {\n          const cause = own(value, 'cause') ?? vm.undefined;\n          define(error, 'cause', cause);\n          if (cause !== vm.undefined) cause.dispose();\n        }\n        return error;\n      }\n      return buildError(i.Error, value, {\n        name: ownString(value, 'name') ?? 'DOMException',\n      });\n    },\n    AggregateError: (value: JSValueHandle) => {\n      const errors = own(value, 'errors');\n      const errorsArg =\n        errors && !errors.isUndefined ? errors : vm.evalCode('([])');\n      const message = own(value, 'message') ?? vm.undefined;\n      const ctor = i.AggregateError ?? i.Error;\n      const error =\n        ctor === i.AggregateError\n          ? vm.construct(ctor, errorsArg, message)\n          : buildError(i.Error, value, { name: 'AggregateError' });\n      if (ctor === i.AggregateError) {\n        const stack = own(value, 'stack');\n        if (stack && !stack.isUndefined) define(error, 'stack', stack);\n        stack?.dispose();\n        if (guestHasOwn(value, 'cause')) {\n          const cause = own(value, 'cause') ?? vm.undefined;\n          define(error, 'cause', cause);\n          if (cause !== vm.undefined) cause.dispose();\n        }\n      }\n      if (message !== vm.undefined) message.dispose();\n      errorsArg.dispose();\n      return error;\n    },\n    EvalError: namedErrorSubclassReviver('EvalError'),\n    FatalError: (value: JSValueHandle) => {\n      const cls = registeredErrorClass('@workflow/errors//FatalError');\n      const error = cls\n        ? buildError(cls, value)\n        : buildError(i.Error, value, { name: 'FatalError' });\n      cls?.dispose();\n      return error;\n    },\n    HookConflictError: (value: JSValueHandle) => {\n      const cls = registeredErrorClass('@workflow/errors//HookConflictError');\n      let error: JSValueHandle;\n      if (cls) {\n        // Constructor takes (token, conflictingRunId).\n        const token = own(value, 'token') ?? vm.undefined;\n        const conflictingRunId = own(value, 'conflictingRunId') ?? vm.undefined;\n        error = vm.construct(cls, token, conflictingRunId);\n        if (token !== vm.undefined) token.dispose();\n        if (conflictingRunId !== vm.undefined) conflictingRunId.dispose();\n        const stack = own(value, 'stack');\n        if (stack && !stack.isUndefined) define(error, 'stack', stack);\n        stack?.dispose();\n        if (guestHasOwn(value, 'cause')) {\n          const cause = own(value, 'cause') ?? vm.undefined;\n          define(error, 'cause', cause);\n          if (cause !== vm.undefined) cause.dispose();\n        }\n        cls.dispose();\n      } else {\n        error = buildError(i.Error, value, { name: 'HookConflictError' });\n        const token = own(value, 'token');\n        if (token) {\n          define(error, 'token', token);\n          token.dispose();\n        }\n        const conflictingRunId = own(value, 'conflictingRunId');\n        if (conflictingRunId && !conflictingRunId.isUndefined) {\n          define(error, 'conflictingRunId', conflictingRunId);\n        }\n        conflictingRunId?.dispose();\n      }\n      return error;\n    },\n    RangeError: namedErrorSubclassReviver('RangeError'),\n    ReferenceError: namedErrorSubclassReviver('ReferenceError'),\n    RetryableError: (value: JSValueHandle) => {\n      const retryAfterMs =\n        own(value, 'retryAfter')?.consume((h) =>\n          h.isNumber ? h.toNumber() : Number.NaN\n        ) ?? Number.NaN;\n      const timeHandle = vm.newNumber(retryAfterMs);\n      const retryAfterDate = vm.construct(i.Date, timeHandle);\n      timeHandle.dispose();\n      const cls = registeredErrorClass('@workflow/errors//RetryableError');\n      let error: JSValueHandle;\n      if (cls) {\n        // Constructor takes (message, { retryAfter }).\n        const options = vm.newObject();\n        options.setProp('retryAfter', retryAfterDate);\n        const message = own(value, 'message') ?? vm.undefined;\n        error = vm.construct(cls, message, options);\n        if (message !== vm.undefined) message.dispose();\n        options.dispose();\n        const stack = own(value, 'stack');\n        if (stack && !stack.isUndefined) define(error, 'stack', stack);\n        stack?.dispose();\n        if (guestHasOwn(value, 'cause')) {\n          const cause = own(value, 'cause') ?? vm.undefined;\n          define(error, 'cause', cause);\n          if (cause !== vm.undefined) cause.dispose();\n        }\n        cls.dispose();\n      } else {\n        error = buildError(i.Error, value, { name: 'RetryableError' });\n        define(error, 'retryAfter', retryAfterDate);\n      }\n      retryAfterDate.dispose();\n      return error;\n    },\n    RuntimeDecryptionError: (value: JSValueHandle) => {\n      const cls = registeredErrorClass(\n        '@workflow/errors//RuntimeDecryptionError'\n      );\n      let error: JSValueHandle;\n      if (cls) {\n        // Constructor takes (message, { cause, context }).\n        const options = vm.newObject();\n        const context = own(value, 'context');\n        if (context && !context.isUndefined) {\n          options.setProp('context', context);\n        }\n        context?.dispose();\n        if (guestHasOwn(value, 'cause')) {\n          const cause = own(value, 'cause') ?? vm.undefined;\n          options.setProp('cause', cause);\n          if (cause !== vm.undefined) cause.dispose();\n        }\n        const message = own(value, 'message') ?? vm.undefined;\n        error = vm.construct(cls, message, options);\n        if (message !== vm.undefined) message.dispose();\n        options.dispose();\n        const stack = own(value, 'stack');\n        if (stack && !stack.isUndefined) define(error, 'stack', stack);\n        stack?.dispose();\n        cls.dispose();\n      } else {\n        error = buildError(i.Error, value, { name: 'RuntimeDecryptionError' });\n        const context = own(value, 'context');\n        if (context && !context.isUndefined) {\n          define(error, 'context', context);\n        }\n        context?.dispose();\n      }\n      return error;\n    },\n    SyntaxError: namedErrorSubclassReviver('SyntaxError'),\n    TypeError: namedErrorSubclassReviver('TypeError'),\n    URIError: namedErrorSubclassReviver('URIError'),\n    Error: (value: JSValueHandle) =>\n      buildError(i.Error, value, {\n        name: ownString(value, 'name') ?? 'Error',\n      }),\n    Float32Array: (value: string | JSValueHandle) =>\n      buildTypedArray('Float32Array', value),\n    Float64Array: (value: string | JSValueHandle) =>\n      buildTypedArray('Float64Array', value),\n    Int8Array: (value: string | JSValueHandle) =>\n      buildTypedArray('Int8Array', value),\n    Int16Array: (value: string | JSValueHandle) =>\n      buildTypedArray('Int16Array', value),\n    Int32Array: (value: string | JSValueHandle) =>\n      buildTypedArray('Int32Array', value),\n    Map: (value: JSValueHandle) => {\n      // value is a guest array of [k, v] arrays.\n      const map = vm.construct(i.Map);\n      const length = own(value, 'length')?.consume((h) => h.toNumber()) ?? 0;\n      for (let index = 0; index < length; index++) {\n        const entry = own(value, String(index));\n        if (!entry) continue;\n        const key = own(entry, '0') ?? vm.undefined;\n        const entryValue = own(entry, '1') ?? vm.undefined;\n        call(i.mapSet, map, key, entryValue).dispose();\n        if (key !== vm.undefined) key.dispose();\n        if (entryValue !== vm.undefined) entryValue.dispose();\n        entry.dispose();\n      }\n      return map;\n    },\n    RegExp: (value: JSValueHandle) => {\n      const source = own(value, 'source') ?? vm.undefined;\n      const flags = own(value, 'flags') ?? vm.undefined;\n      const regexp = vm.construct(i.RegExp, source, flags);\n      if (source !== vm.undefined) source.dispose();\n      if (flags !== vm.undefined) flags.dispose();\n      return regexp;\n    },\n    Set: (value: JSValueHandle) => {\n      const set = vm.construct(i.Set);\n      const length = own(value, 'length')?.consume((h) => h.toNumber()) ?? 0;\n      for (let index = 0; index < length; index++) {\n        const element = own(value, String(index)) ?? vm.undefined;\n        call(i.setAdd, set, element).dispose();\n        if (element !== vm.undefined) element.dispose();\n      }\n      return set;\n    },\n    URL: (value: JSValueHandle | string) => {\n      if (!i.URL) throw new Error('URL is not available in the VM');\n      const href = isHandle(value) ? value : vm.newString(value);\n      try {\n        return vm.construct(i.URL, href);\n      } finally {\n        if (!isHandle(value)) href.dispose();\n      }\n    },\n    WorkflowFunction: (value: JSValueHandle) => {\n      const workflowId = own(value, 'workflowId') ?? vm.undefined;\n      const throwerFactory = vm.evalCode(\n        `(function(workflowId) {\n          var f = function() {\n            throw new Error('Workflow functions cannot be called directly. Use start() to invoke them.');\n          };\n          f.workflowId = workflowId;\n          return f;\n        })`\n      );\n      try {\n        return invoke(throwerFactory, workflowId);\n      } finally {\n        throwerFactory.dispose();\n        if (workflowId !== vm.undefined) workflowId.dispose();\n      }\n    },\n    URLSearchParams: (value: JSValueHandle | string) => {\n      if (!i.URLSearchParams) {\n        throw new Error('URLSearchParams is not available in the VM');\n      }\n      const raw = isHandle(value) ? value.toString() : value;\n      const init = vm.newString(raw === '.' ? '' : raw);\n      try {\n        return vm.construct(i.URLSearchParams, init);\n      } finally {\n        init.dispose();\n        if (isHandle(value)) value.dispose();\n      }\n    },\n    Uint8Array: (value: string | JSValueHandle) =>\n      buildTypedArray('Uint8Array', value),\n    Uint8ClampedArray: (value: string | JSValueHandle) =>\n      buildTypedArray('Uint8ClampedArray', value),\n    Uint16Array: (value: string | JSValueHandle) =>\n      buildTypedArray('Uint16Array', value),\n    Uint32Array: (value: string | JSValueHandle) =>\n      buildTypedArray('Uint32Array', value),\n    Headers: (value: JSValueHandle) => {\n      if (!i.Headers) throw new Error('Headers is not available in the VM');\n      return vm.construct(i.Headers, value);\n    },\n    Request: (value: JSValueHandle) => {\n      // Mirror the in-VM reviver: mutate the parsed object into a\n      // Request-alike by attaching the prototype methods directly.\n      if (i.requestPrototype) {\n        for (const method of ['json', 'text', 'arrayBuffer']) {\n          const fn = own(i.requestPrototype, method);\n          if (fn && fn.typeof === 'function') define(value, method, fn);\n          fn?.dispose();\n        }\n      }\n      const responseWritable = own(value, 'responseWritable');\n      if (responseWritable && !responseWritable.isUndefined) {\n        define(value, sym('WEBHOOK_RESPONSE_WRITABLE'), responseWritable);\n      }\n      responseWritable?.dispose();\n      return value.dup();\n    },\n    Response: (value: JSValueHandle) => {\n      if (i.responsePrototype) {\n        for (const method of [\n          'json',\n          'text',\n          'arrayBuffer',\n          'bytes',\n          'clone',\n        ]) {\n          const fn = own(i.responsePrototype, method);\n          if (fn && fn.typeof === 'function') define(value, method, fn);\n          fn?.dispose();\n        }\n      }\n      const body = own(value, 'body') ?? vm.undefined;\n      define(value, '_body', body);\n      if (body !== vm.undefined) body.dispose();\n      const status = own(value, 'status')?.consume((h) => h.toNumber()) ?? 0;\n      const ok = status >= 200 && status < 300 ? vm.true : vm.false;\n      define(value, 'ok', ok);\n      define(value, 'bodyUsed', vm.false);\n      return value.dup();\n    },\n    ReadableStream: (value: JSValueHandle) => {\n      const prototype = i.readableStreamPrototype ?? vm.null;\n      const stream = call(i.objectCreate, vm.undefined, prototype);\n      const bodyInit = own(value, 'bodyInit');\n      if (bodyInit && !bodyInit.isUndefined) {\n        define(stream, sym('BODY_INIT'), bodyInit);\n        bodyInit.dispose();\n        return stream;\n      }\n      bodyInit?.dispose();\n      const name = own(value, 'name');\n      if (name && !name.isUndefined) {\n        define(stream, sym('WORKFLOW_STREAM_NAME'), name);\n        const type = own(value, 'type');\n        if (type && !type.isUndefined) {\n          define(stream, sym('WORKFLOW_STREAM_TYPE'), type);\n        }\n        type?.dispose();\n        const framing = own(value, 'framing');\n        if (framing && !framing.isUndefined) {\n          define(stream, sym('WORKFLOW_STREAM_FRAMING'), framing);\n        }\n        framing?.dispose();\n      }\n      name?.dispose();\n      return stream;\n    },\n    WritableStream: (value: JSValueHandle) => {\n      const prototype = i.writableStreamPrototype ?? vm.null;\n      const stream = call(i.objectCreate, vm.undefined, prototype);\n      const name = own(value, 'name');\n      if (name && !name.isUndefined) {\n        define(stream, sym('WORKFLOW_STREAM_NAME'), name);\n      }\n      name?.dispose();\n      const runId = own(value, 'runId');\n      if (runId?.isString) {\n        define(stream, sym('WORKFLOW_STREAM_SERVER_RUN_ID'), runId);\n      }\n      runId?.dispose();\n      const deploymentId = own(value, 'deploymentId');\n      if (deploymentId?.isString) {\n        define(\n          stream,\n          sym('WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID'),\n          deploymentId\n        );\n      }\n      deploymentId?.dispose();\n      return stream;\n    },\n  };\n\n  function buildTypedArray(\n    tag: string,\n    base64: string | JSValueHandle\n  ): JSValueHandle {\n    const Constructor = typedArrayConstructors.get(tag);\n    if (!Constructor) throw new Error(`${tag} is not available in the VM`);\n    // Parse operations build guest values, so a reduced base64 payload\n    // arrives as a guest string handle.\n    const raw = isHandle(base64) ? base64.toString() : base64;\n    const bytes = base64ToBytes(raw);\n    const buffer = vm.newArrayBuffer(\n      bytes.buffer.slice(\n        bytes.byteOffset,\n        bytes.byteOffset + bytes.byteLength\n      ) as ArrayBuffer\n    );\n    try {\n      return vm.construct(Constructor, buffer);\n    } finally {\n      buffer.dispose();\n    }\n  }\n\n  function lookupRegisteredClass(\n    classId: string | undefined\n  ): JSValueHandle | undefined {\n    if (classId === undefined) return undefined;\n    const registry = own(vm.global, sym('workflow-class-registry'));\n    if (!registry || registry.isUndefined) {\n      registry?.dispose();\n      return undefined;\n    }\n    try {\n      const getMethod = chained(registry, 'get');\n      if (!getMethod) return undefined;\n      try {\n        const key = vm.newString(classId);\n        const cls = call(getMethod, registry, key);\n        key.dispose();\n        if (cls.isUndefined || cls.typeof !== 'function') {\n          cls.dispose();\n          return undefined;\n        }\n        return cls;\n      } finally {\n        getMethod.dispose();\n      }\n    } finally {\n      registry.dispose();\n    }\n  }\n\n  // --- public API ---\n\n  return {\n    reducerKeys: Object.keys(reducers),\n    reviverKeys: Object.keys(revivers),\n    installProcessEnv(env: Record<string, string | undefined>): void {\n      const plain: Record<string, string> = {};\n      for (const [key, value] of Object.entries(env)) {\n        if (typeof value === 'string') plain[key] = value;\n      }\n      using envHandle = vm.hostToHandle(plain);\n      call(i.objectFreeze, vm.undefined, envHandle).dispose();\n      using processHandle = vm.newObject();\n      define(processHandle, 'env', envHandle);\n      vm.setProp(vm.global, 'process', processHandle);\n    },\n    serialize(value: JSValueHandle): Uint8Array {\n      // Handle scope: reducers and the hybrid operations mint one handle\n      // per visited value node (descriptor reads, dup()s, intrinsic call\n      // results) and nothing disposes them individually — without the\n      // scope each serialize leaks ~one handle per node for the VM's\n      // lifetime, which compounds across an inline-loop session's whole\n      // batch. Requires quickjs-wasi >= 3.3.1: earlier versions also\n      // scope-tracked the handles the host-callback trampoline wraps\n      // around C-owned argv pointers, and disposing those (Map/Set/\n      // Headers forEach visitors run mid-pass) corrupted the guest heap;\n      // 3.3.1 marks them borrowed and scope-exempt. The input handle is\n      // caller-owned (created before the scope) and the output is host\n      // bytes, so nothing escapes.\n      //\n      // `identities` must be cleared per pass ONCE handles are bulk-freed:\n      // it keys object identity on the raw guest pointer, and freeing\n      // handles lets QuickJS reuse pointers — a stale entry from an\n      // earlier pass could then alias a different object and corrupt the\n      // dedup/cycle detection. Identity only needs stability within one\n      // stringify pass.\n      try {\n        const payload = vm.withScope(() =>\n          encoder.encode(\n            stringify(value, reducers, { operations: stringifyOperations })\n          )\n        );\n        const prefix = encoder.encode(SerializationFormat.DEVALUE_V1);\n        const result = new Uint8Array(prefix.length + payload.length);\n        result.set(prefix, 0);\n        result.set(payload, prefix.length);\n        return result;\n      } finally {\n        identities.clear();\n      }\n    },\n    deserialize(data: Uint8Array): JSValueHandle {\n      if (data.length < FORMAT_PREFIX_LENGTH) {\n        throw new Error('Data too short to contain format prefix');\n      }\n      const prefix = decoder.decode(data.subarray(0, FORMAT_PREFIX_LENGTH));\n      if (prefix !== SerializationFormat.DEVALUE_V1) {\n        throw new Error(`Unsupported serialization format: ${prefix}`);\n      }\n      const payload = decoder.decode(data.subarray(FORMAT_PREFIX_LENGTH));\n      // Handle scope, mirroring serialize(): revivers mint intermediate\n      // handles (children already attached to their parents, intrinsic\n      // call results) that are safe to free once the graph is built —\n      // guest values are refcounted, so parents keep their children\n      // alive. Only the root escapes to the caller.\n      return vm.withScope((scope) =>\n        scope.escape(\n          parse(payload, revivers, {\n            operations: parseOperations,\n          }) as JSValueHandle\n        )\n      );\n    },\n    dispose() {\n      for (const handle of disposables.reverse()) handle.dispose();\n      disposables.length = 0;\n      identities.clear();\n    },\n  };\n}\n"]}