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

package/dist/serialization/reducers/common-vm.js

@@ -0,0 +1,579 @@
+/**
+ * VM-compatible common reducers and revivers.
+ *
+ * Identical to common.ts but without Node.js dependencies:
+ * - Uses native `btoa` / `atob` (provided by quickjs-wasi's base64
+ *   extension, see `quickjs-assets.generated.ts`) instead of Buffer
+ *   or pure-JS base64.
+ * - Uses `instanceof Error` instead of `types.isNativeError()`.
+ *
+ * This module is safe to bundle into the QuickJS WASM VM.
+ */
+// ---- Base64 helpers (native btoa/atob from the quickjs-wasi base64 extension) ----
+function arrayBufferToBase64(value, offset, length) {
+    if (length === 0)
+        return '.';
+    // btoa requires a binary string. Build it from the byte view.
+    const uint8 = new Uint8Array(value, offset, length);
+    let binary = '';
+    for (let i = 0; i < uint8.length; i++) {
+        binary += String.fromCharCode(uint8[i]);
+    }
+    return btoa(binary);
+}
+function viewToBase64(value) {
+    return arrayBufferToBase64(value.buffer, value.byteOffset, value.byteLength);
+}
+function reviveArrayBuffer(value) {
+    if (value === '.')
+        return new ArrayBuffer(0);
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+}
+// ---- Error subclass helper ----
+// Creates a reducer for a built-in Error subclass whose serialized shape
+// is exactly { message, stack, cause? }. Matches by `value.name`
+// (instance property) for cross-realm + bundler-output robustness — see
+// the host-side common.ts for full rationale.
+function makeNamedErrorSubclassReducer(subclassName) {
+    return (value) => {
+        if (!(value instanceof Error))
+            return false;
+        if (value.name !== subclassName)
+            return false;
+        const reduced = {
+            message: value.message,
+            stack: value.stack,
+        };
+        if ('cause' in value)
+            reduced.cause = value.cause;
+        return reduced;
+    };
+}
+// Creates a reviver for a built-in Error subclass. Looks up the
+// constructor on globalThis so the resulting object passes
+// `instanceof TypeError` etc. in the consuming realm. Falls back to
+// a base Error with the right `.name` if the constructor is not
+// available (defensive — built-ins always exist).
+function makeNamedErrorSubclassReviver(subclassName) {
+    return (value) => {
+        const Cls = globalThis[subclassName];
+        let error;
+        if (typeof Cls === 'function') {
+            error = new Cls(value.message);
+        }
+        else {
+            error = new Error(value.message);
+            error.name = subclassName;
+        }
+        if (value.stack !== undefined)
+            error.stack = value.stack;
+        if ('cause' in value)
+            error.cause = value.cause;
+        return error;
+    };
+}
+// ---- Reducers ----
+export function getCommonReducers() {
+    return {
+        ArrayBuffer: (value) => value instanceof ArrayBuffer &&
+            arrayBufferToBase64(value, 0, value.byteLength),
+        BigInt: (value) => typeof value === 'bigint' && value.toString(),
+        BigInt64Array: (value) => value instanceof BigInt64Array && viewToBase64(value),
+        BigUint64Array: (value) => value instanceof BigUint64Array && viewToBase64(value),
+        Date: (value) => {
+            if (!(value instanceof Date))
+                return false;
+            const valid = !Number.isNaN(value.getDate());
+            return valid ? value.toISOString() : '.';
+        },
+        // DOMException is checked before Error so that DOMException-specific
+        // shape (name, message, stack, cause) survives the round-trip.
+        DOMException: (value) => {
+            if (!(value instanceof DOMException))
+                return false;
+            const reduced = {
+                message: value.message,
+                name: value.name,
+                stack: value.stack,
+            };
+            if ('cause' in value)
+                reduced.cause = value.cause;
+            return reduced;
+        },
+        // First-class Error subclass reducers. Order matters: each subclass
+        // reducer is checked before the generic `Error` catch-all so that
+        // e.g. a TypeError instance routes through the TypeError reducer
+        // instead of the base Error reducer. Matching is by `value.name`
+        // (the instance property) for cross-realm + bundler robustness;
+        // see common.ts for full rationale.
+        AggregateError: (value) => {
+            if (!(value instanceof Error) || value.name !== 'AggregateError')
+                return false;
+            const reduced = {
+                message: value.message,
+                stack: value.stack,
+                errors: value.errors,
+            };
+            if ('cause' in value)
+                reduced.cause = value.cause;
+            return reduced;
+        },
+        EvalError: makeNamedErrorSubclassReducer('EvalError'),
+        FatalError: makeNamedErrorSubclassReducer('FatalError'),
+        // HookConflictError carries an extra token (+ optional
+        // conflictingRunId); mirror the host-side common.ts reducer.
+        HookConflictError: (value) => {
+            if (!(value instanceof Error) || value.name !== 'HookConflictError')
+                return false;
+            const reduced = {
+                message: value.message,
+                stack: value.stack,
+                token: value.token,
+            };
+            if (value.conflictingRunId !== undefined) {
+                reduced.conflictingRunId = value.conflictingRunId;
+            }
+            if ('cause' in value)
+                reduced.cause = value.cause;
+            return reduced;
+        },
+        RangeError: makeNamedErrorSubclassReducer('RangeError'),
+        ReferenceError: makeNamedErrorSubclassReducer('ReferenceError'),
+        // RetryableError carries an extra retryAfter; serialize as numeric
+        // epoch timestamp for cross-realm safety (see host-side common.ts).
+        RetryableError: (value) => {
+            if (!(value instanceof Error) || value.name !== 'RetryableError')
+                return false;
+            const retryAfterRaw = value.retryAfter;
+            let retryAfter;
+            if (retryAfterRaw &&
+                typeof retryAfterRaw === 'object' &&
+                typeof retryAfterRaw.getTime === 'function') {
+                const t = retryAfterRaw.getTime();
+                retryAfter = Number.isNaN(t) ? Date.now() + 1000 : t;
+            }
+            else if (typeof retryAfterRaw === 'string' ||
+                typeof retryAfterRaw === 'number') {
+                const t = new Date(retryAfterRaw).getTime();
+                retryAfter = Number.isNaN(t) ? Date.now() + 1000 : t;
+            }
+            else {
+                retryAfter = Date.now() + 1000;
+            }
+            const reduced = {
+                message: value.message,
+                stack: value.stack,
+                retryAfter,
+            };
+            if ('cause' in value)
+                reduced.cause = value.cause;
+            return reduced;
+        },
+        // RuntimeDecryptionError carries an extra `context` object (operation,
+        // byteLength, formatPrefix) that the generic Error reducer would drop.
+        RuntimeDecryptionError: (value) => {
+            if (!(value instanceof Error) || value.name !== 'RuntimeDecryptionError')
+                return false;
+            const reduced = {
+                message: value.message,
+                stack: value.stack,
+            };
+            const context = value.context;
+            if (context !== undefined) {
+                reduced.context = context;
+            }
+            if ('cause' in value)
+                reduced.cause = value.cause;
+            return reduced;
+        },
+        SyntaxError: makeNamedErrorSubclassReducer('SyntaxError'),
+        TypeError: makeNamedErrorSubclassReducer('TypeError'),
+        URIError: makeNamedErrorSubclassReducer('URIError'),
+        // Base Error reducer — catch-all. Matched LAST after subclass-specific
+        // reducers above. Preserves `name` so user Error subclasses without
+        // dedicated reducers retain their identity through the round-trip.
+        Error: (value) => {
+            // In the VM, use instanceof Error (no node:util available)
+            if (!(value instanceof Error))
+                return false;
+            const reduced = {
+                name: value.name,
+                message: value.message,
+                stack: value.stack,
+            };
+            if ('cause' in value)
+                reduced.cause = value.cause;
+            return reduced;
+        },
+        Float32Array: (value) => value instanceof Float32Array && viewToBase64(value),
+        Float64Array: (value) => value instanceof Float64Array && viewToBase64(value),
+        Int8Array: (value) => value instanceof Int8Array && viewToBase64(value),
+        Int16Array: (value) => value instanceof Int16Array && viewToBase64(value),
+        Int32Array: (value) => value instanceof Int32Array && viewToBase64(value),
+        Map: (value) => value instanceof Map && Array.from(value),
+        RegExp: (value) => value instanceof RegExp && {
+            source: value.source,
+            flags: value.flags,
+        },
+        // Request/Response/Headers — serialize using the polyfill constructors
+        Headers: (value) => {
+            const H = globalThis.Headers;
+            if (!H || !(value instanceof H))
+                return false;
+            return Array.from(value);
+        },
+        Request: (value) => {
+            const R = globalThis.Request;
+            if (!R)
+                return false;
+            // Use instanceof OR check for the Request-specific .json method
+            // (duck-typing on method/url alone would match plain objects and
+            // cause infinite recursion since the reducer output also has those)
+            if (!(value instanceof R) && typeof value?.json !== 'function')
+                return false;
+            if (typeof value?.method !== 'string')
+                return false;
+            const data = {
+                method: value.method,
+                url: value.url,
+                headers: value.headers,
+                body: value.body,
+                duplex: value.duplex,
+            };
+            // Include the webhook response writable stream if present
+            const responseWritable = value[Symbol.for('WEBHOOK_RESPONSE_WRITABLE')];
+            if (responseWritable) {
+                data.responseWritable = responseWritable;
+            }
+            return data;
+        },
+        Response: (value) => {
+            const R = globalThis.Response;
+            if (!R)
+                return false;
+            // Use instanceof OR check for Response-specific .clone method
+            if (!(value instanceof R) && typeof value?.clone !== 'function')
+                return false;
+            if (typeof value?.status !== 'number')
+                return false;
+            return {
+                type: value.type,
+                url: value.url,
+                status: value.status,
+                statusText: value.statusText,
+                headers: value.headers,
+                body: value.body,
+                redirected: value.redirected,
+            };
+        },
+        ReadableStream: ((value) => {
+            if (value == null)
+                return false;
+            const RS = globalThis.ReadableStream;
+            if (!RS ||
+                !(value instanceof RS || Object.getPrototypeOf(value) === RS.prototype))
+                return false;
+            const bodyInit = value[Symbol.for('BODY_INIT')];
+            if (bodyInit !== undefined) {
+                return { bodyInit };
+            }
+            // Preserve stream name if present (opaque pointer for passing to steps)
+            const name = value[Symbol.for('WORKFLOW_STREAM_NAME')];
+            if (name) {
+                const s = { name };
+                const type = value[Symbol.for('WORKFLOW_STREAM_TYPE')];
+                if (type)
+                    s.type = type;
+                // Preserve wire framing so the step-side reviver can unframe
+                // byte streams (framed-v1) — dropping it turns a framed webhook
+                // body into raw length-prefixed bytes for the consumer.
+                const framing = value[Symbol.for('WORKFLOW_STREAM_FRAMING')];
+                if (framing)
+                    s.framing = framing;
+                return s;
+            }
+            return { name: '__empty' };
+        }),
+        WritableStream: ((value) => {
+            if (value == null)
+                return false;
+            const WS = globalThis.WritableStream;
+            if (!WS ||
+                !(value instanceof WS || Object.getPrototypeOf(value) === WS.prototype))
+                return false;
+            const name = value[Symbol.for('WORKFLOW_STREAM_NAME')];
+            const s = {
+                name: name || '__empty',
+            };
+            // When the handle was forwarded from another run (parent -> child
+            // via start()), preserve the foreign runId/deploymentId so the
+            // step-side reviver opens the writable against the original stream.
+            // Mirrors the node:vm workflow reducer in serialization.ts.
+            const foreignRunId = value[Symbol.for('WORKFLOW_STREAM_SERVER_RUN_ID')];
+            if (typeof foreignRunId === 'string')
+                s.runId = foreignRunId;
+            const foreignDeploymentId = value[Symbol.for('WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID')];
+            if (typeof foreignDeploymentId === 'string') {
+                s.deploymentId = foreignDeploymentId;
+            }
+            return s;
+        }),
+        Set: (value) => value instanceof Set && Array.from(value),
+        URL: (value) => value instanceof URL && value.href,
+        WorkflowFunction: (value) => {
+            // Only match function references with a workflowId property (set by
+            // the SWC compiler on workflow functions). Plain { workflowId } objects
+            // are NOT matched — this prevents infinite recursion since the reduced
+            // form { workflowId } is a plain object, not a function.
+            if (typeof value !== 'function')
+                return false;
+            const workflowId = value.workflowId;
+            if (typeof workflowId !== 'string')
+                return false;
+            return { workflowId };
+        },
+        URLSearchParams: (value) => {
+            if (!(value instanceof URLSearchParams))
+                return false;
+            return value.size === 0 ? '.' : String(value);
+        },
+        Uint8Array: (value) => value instanceof Uint8Array && viewToBase64(value),
+        Uint8ClampedArray: (value) => value instanceof Uint8ClampedArray && viewToBase64(value),
+        Uint16Array: (value) => value instanceof Uint16Array && viewToBase64(value),
+        Uint32Array: (value) => value instanceof Uint32Array && viewToBase64(value),
+    };
+}
+// ---- Revivers ----
+export function getCommonRevivers() {
+    return {
+        ArrayBuffer: (value) => reviveArrayBuffer(value),
+        BigInt: (value) => BigInt(value),
+        BigInt64Array: (value) => new BigInt64Array(reviveArrayBuffer(value)),
+        BigUint64Array: (value) => new BigUint64Array(reviveArrayBuffer(value)),
+        Date: (value) => new Date(value),
+        DOMException: (value) => {
+            const error = new DOMException(value.message, value.name);
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            if ('cause' in value)
+                error.cause = value.cause;
+            return error;
+        },
+        AggregateError: (value) => {
+            const error = new AggregateError(value.errors ?? [], value.message);
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            if ('cause' in value)
+                error.cause = value.cause;
+            return error;
+        },
+        EvalError: makeNamedErrorSubclassReviver('EvalError'),
+        FatalError: (value) => {
+            // Prefer the host-registered FatalError class (registered via
+            // Symbol.for keys by @workflow/errors so `instanceof FatalError`
+            // works across realms). Fall back to a synthesized Error with
+            // the right .name when no registration is present.
+            // FatalError's constructor takes only `message`, so cause is
+            // attached as a property after construction (matching the host
+            // reviver in common.ts).
+            const Cls = globalThis[Symbol.for('@workflow/errors//FatalError')];
+            let error;
+            if (typeof Cls === 'function') {
+                error = new Cls(value.message);
+            }
+            else {
+                error = new Error(value.message);
+                error.name = 'FatalError';
+            }
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            if ('cause' in value)
+                error.cause = value.cause;
+            return error;
+        },
+        HookConflictError: (value) => {
+            // Prefer the registered HookConflictError class (see the FatalError
+            // reviver above). Its constructor takes (token, conflictingRunId).
+            const Cls = globalThis[Symbol.for('@workflow/errors//HookConflictError')];
+            let error;
+            if (typeof Cls === 'function') {
+                error = new Cls(value.token, value.conflictingRunId);
+            }
+            else {
+                error = new Error(value.message);
+                error.name = 'HookConflictError';
+                error.token = value.token;
+                if (value.conflictingRunId !== undefined) {
+                    error.conflictingRunId = value.conflictingRunId;
+                }
+            }
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            if ('cause' in value)
+                error.cause = value.cause;
+            return error;
+        },
+        RangeError: makeNamedErrorSubclassReviver('RangeError'),
+        ReferenceError: makeNamedErrorSubclassReviver('ReferenceError'),
+        RetryableError: (value) => {
+            // RetryableError's constructor accepts (message, { retryAfter }).
+            // Cause is attached after construction (the constructor does not
+            // forward it). retryAfter is stored as a Date in the VM realm.
+            const Cls = globalThis[Symbol.for('@workflow/errors//RetryableError')];
+            const retryAfter = new Date(value.retryAfter);
+            let error;
+            if (typeof Cls === 'function') {
+                error = new Cls(value.message, { retryAfter });
+            }
+            else {
+                error = new Error(value.message);
+                error.name = 'RetryableError';
+                error.retryAfter = retryAfter;
+            }
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            if ('cause' in value)
+                error.cause = value.cause;
+            return error;
+        },
+        RuntimeDecryptionError: (value) => {
+            // Prefer the registered RuntimeDecryptionError class (see the
+            // FatalError reviver above). Its constructor accepts
+            // (message, { cause, context }).
+            const Cls = globalThis[Symbol.for('@workflow/errors//RuntimeDecryptionError')];
+            let error;
+            if (typeof Cls === 'function') {
+                const opts = {};
+                if ('cause' in value)
+                    opts.cause = value.cause;
+                if (value.context !== undefined)
+                    opts.context = value.context;
+                error = new Cls(value.message, opts);
+            }
+            else {
+                error = new Error(value.message);
+                error.name = 'RuntimeDecryptionError';
+                if (value.context !== undefined) {
+                    error.context = value.context;
+                }
+                if ('cause' in value)
+                    error.cause = value.cause;
+            }
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            return error;
+        },
+        SyntaxError: makeNamedErrorSubclassReviver('SyntaxError'),
+        TypeError: makeNamedErrorSubclassReviver('TypeError'),
+        URIError: makeNamedErrorSubclassReviver('URIError'),
+        Error: (value) => {
+            const error = new Error(value.message);
+            error.name = value.name;
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            if ('cause' in value)
+                error.cause = value.cause;
+            return error;
+        },
+        Float32Array: (value) => new Float32Array(reviveArrayBuffer(value)),
+        Float64Array: (value) => new Float64Array(reviveArrayBuffer(value)),
+        Int8Array: (value) => new Int8Array(reviveArrayBuffer(value)),
+        Int16Array: (value) => new Int16Array(reviveArrayBuffer(value)),
+        Int32Array: (value) => new Int32Array(reviveArrayBuffer(value)),
+        Map: (value) => new Map(value),
+        RegExp: (value) => new RegExp(value.source, value.flags),
+        Set: (value) => new Set(value),
+        URL: (value) => new URL(value),
+        WorkflowFunction: (value) => Object.assign(() => {
+            throw new Error('Workflow functions cannot be called directly. Use start() to invoke them.');
+        }, { workflowId: value.workflowId }),
+        URLSearchParams: (value) => new URLSearchParams(value === '.' ? '' : value),
+        Uint8Array: (value) => new Uint8Array(reviveArrayBuffer(value)),
+        Uint8ClampedArray: (value) => new Uint8ClampedArray(reviveArrayBuffer(value)),
+        Uint16Array: (value) => new Uint16Array(reviveArrayBuffer(value)),
+        Uint32Array: (value) => new Uint32Array(reviveArrayBuffer(value)),
+        // Web API types — revived as plain objects in the VM since the real
+        // constructors (Headers, Request, Response) are not available in QuickJS.
+        // The workflow code can access the properties but not call Web API methods.
+        Headers: (value) => {
+            return new globalThis.Headers(value);
+        },
+        Request: (value) => {
+            const Req = globalThis.Request;
+            if (Req) {
+                value.json = Req.prototype.json;
+                value.text = Req.prototype.text;
+                value.arrayBuffer = Req.prototype.arrayBuffer;
+            }
+            // Carry over the webhook response writable stream to the symbol property
+            if (value.responseWritable) {
+                value[Symbol.for('WEBHOOK_RESPONSE_WRITABLE')] = value.responseWritable;
+            }
+            return value;
+        },
+        Response: (value) => {
+            // Don't use Object.setPrototypeOf — devalue continues to set properties
+            // on the object after the reviver runs, and getter-only properties
+            // (like 'ok') on the prototype would cause "no setter" errors.
+            // Instead, copy methods directly onto the object.
+            const Resp = globalThis.Response;
+            if (Resp) {
+                value.json = Resp.prototype.json;
+                value.text = Resp.prototype.text;
+                value.arrayBuffer = Resp.prototype.arrayBuffer;
+                if (Resp.prototype.bytes)
+                    value.bytes = Resp.prototype.bytes;
+                if (Resp.prototype.clone)
+                    value.clone = Resp.prototype.clone;
+            }
+            value._body = value.body;
+            value.ok = value.status >= 200 && value.status < 300;
+            value.bodyUsed = false;
+            return value;
+        },
+        ReadableStream: (value) => {
+            const RS = globalThis.ReadableStream;
+            const stream = Object.create(RS ? RS.prototype : {});
+            if (value && 'bodyInit' in value) {
+                // Body from Response/Request constructor — store the raw data
+                stream[Symbol.for('BODY_INIT')] = value.bodyInit;
+            }
+            else if (value && 'name' in value) {
+                // Named stream reference — preserve the name/type for re-serialization.
+                // Streams are opaque pointers in the VM — they can be passed to steps
+                // but not consumed directly.
+                stream[Symbol.for('WORKFLOW_STREAM_NAME')] = value.name;
+                if (value.type)
+                    stream[Symbol.for('WORKFLOW_STREAM_TYPE')] = value.type;
+                if (value.framing) {
+                    stream[Symbol.for('WORKFLOW_STREAM_FRAMING')] = value.framing;
+                }
+            }
+            return stream;
+        },
+        WritableStream: (value) => {
+            const WS = globalThis.WritableStream;
+            const stream = Object.create(WS ? WS.prototype : {});
+            if (value && 'name' in value) {
+                stream[Symbol.for('WORKFLOW_STREAM_NAME')] = value.name;
+            }
+            // Preserve the foreign runId/deploymentId, if present, so that when
+            // the handle is later passed to a step the workflow reducer can
+            // forward it through to the step reviver (cross-run writable
+            // forwarding via start()).
+            if (value && typeof value.runId === 'string') {
+                stream[Symbol.for('WORKFLOW_STREAM_SERVER_RUN_ID')] = value.runId;
+            }
+            if (value && typeof value.deploymentId === 'string') {
+                stream[Symbol.for('WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID')] = value.deploymentId;
+            }
+            return stream;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-vm.js","sourceRoot":"","sources":["../../../src/serialization/reducers/common-vm.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * VM-compatible common reducers and revivers.\n *\n * Identical to common.ts but without Node.js dependencies:\n * - Uses native `btoa` / `atob` (provided by quickjs-wasi's base64\n *   extension, see `quickjs-assets.generated.ts`) instead of Buffer\n *   or pure-JS base64.\n * - Uses `instanceof Error` instead of `types.isNativeError()`.\n *\n * This module is safe to bundle into the QuickJS WASM VM.\n */\n\nimport type { Reducers, Revivers, SerializableSpecial } from '../types.js';\n\n// ---- Base64 helpers (native btoa/atob from the quickjs-wasi base64 extension) ----\n\nfunction arrayBufferToBase64(\n  value: ArrayBufferLike,\n  offset: number,\n  length: number\n): string {\n  if (length === 0) return '.';\n  // btoa requires a binary string. Build it from the byte view.\n  const uint8 = new Uint8Array(value, offset, length);\n  let binary = '';\n  for (let i = 0; i < uint8.length; i++) {\n    binary += String.fromCharCode(uint8[i]!);\n  }\n  return btoa(binary);\n}\n\nfunction viewToBase64(value: ArrayBufferView): string {\n  return arrayBufferToBase64(value.buffer, value.byteOffset, value.byteLength);\n}\n\nfunction reviveArrayBuffer(value: string): ArrayBuffer {\n  if (value === '.') return new ArrayBuffer(0);\n  const binary = atob(value);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i++) {\n    bytes[i] = binary.charCodeAt(i);\n  }\n  return bytes.buffer as ArrayBuffer;\n}\n\n// ---- Error subclass helper ----\n\n// Creates a reducer for a built-in Error subclass whose serialized shape\n// is exactly { message, stack, cause? }. Matches by `value.name`\n// (instance property) for cross-realm + bundler-output robustness — see\n// the host-side common.ts for full rationale.\nfunction makeNamedErrorSubclassReducer(subclassName: string) {\n  return (\n    value: unknown\n  ): { message: string; stack?: string; cause?: unknown } | false => {\n    if (!(value instanceof Error)) return false;\n    if (value.name !== subclassName) return false;\n    const reduced: { message: string; stack?: string; cause?: unknown } = {\n      message: value.message,\n      stack: value.stack,\n    };\n    if ('cause' in value) reduced.cause = (value as { cause: unknown }).cause;\n    return reduced;\n  };\n}\n\n// Creates a reviver for a built-in Error subclass. Looks up the\n// constructor on globalThis so the resulting object passes\n// `instanceof TypeError` etc. in the consuming realm. Falls back to\n// a base Error with the right `.name` if the constructor is not\n// available (defensive — built-ins always exist).\nfunction makeNamedErrorSubclassReviver(subclassName: string) {\n  return (value: { message: string; stack?: string; cause?: unknown }) => {\n    const Cls = (globalThis as any)[subclassName];\n    let error: Error;\n    if (typeof Cls === 'function') {\n      error = new Cls(value.message);\n    } else {\n      error = new Error(value.message);\n      error.name = subclassName;\n    }\n    if (value.stack !== undefined) error.stack = value.stack;\n    if ('cause' in value) (error as any).cause = (value as any).cause;\n    return error;\n  };\n}\n\n// ---- Reducers ----\n\nexport function getCommonReducers(): Partial<Reducers> {\n  return {\n    ArrayBuffer: (value) =>\n      value instanceof ArrayBuffer &&\n      arrayBufferToBase64(value, 0, value.byteLength),\n    BigInt: (value) => typeof value === 'bigint' && value.toString(),\n    BigInt64Array: (value) =>\n      value instanceof BigInt64Array && viewToBase64(value),\n    BigUint64Array: (value) =>\n      value instanceof BigUint64Array && viewToBase64(value),\n    Date: (value) => {\n      if (!(value instanceof Date)) return false;\n      const valid = !Number.isNaN(value.getDate());\n      return valid ? value.toISOString() : '.';\n    },\n    // DOMException is checked before Error so that DOMException-specific\n    // shape (name, message, stack, cause) survives the round-trip.\n    DOMException: (value) => {\n      if (!(value instanceof DOMException)) return false;\n      const reduced: SerializableSpecial['DOMException'] = {\n        message: value.message,\n        name: value.name,\n        stack: value.stack,\n      };\n      if ('cause' in value) reduced.cause = (value as any).cause;\n      return reduced;\n    },\n    // First-class Error subclass reducers. Order matters: each subclass\n    // reducer is checked before the generic `Error` catch-all so that\n    // e.g. a TypeError instance routes through the TypeError reducer\n    // instead of the base Error reducer. Matching is by `value.name`\n    // (the instance property) for cross-realm + bundler robustness;\n    // see common.ts for full rationale.\n    AggregateError: (value) => {\n      if (!(value instanceof Error) || value.name !== 'AggregateError')\n        return false;\n      const reduced: SerializableSpecial['AggregateError'] = {\n        message: value.message,\n        stack: value.stack,\n        errors: (value as AggregateError).errors,\n      };\n      if ('cause' in value) reduced.cause = (value as any).cause;\n      return reduced;\n    },\n    EvalError: makeNamedErrorSubclassReducer('EvalError'),\n    FatalError: makeNamedErrorSubclassReducer('FatalError'),\n    // HookConflictError carries an extra token (+ optional\n    // conflictingRunId); mirror the host-side common.ts reducer.\n    HookConflictError: (value) => {\n      if (!(value instanceof Error) || value.name !== 'HookConflictError')\n        return false;\n      const reduced: SerializableSpecial['HookConflictError'] = {\n        message: value.message,\n        stack: value.stack,\n        token: (value as any).token,\n      };\n      if ((value as any).conflictingRunId !== undefined) {\n        reduced.conflictingRunId = (value as any).conflictingRunId;\n      }\n      if ('cause' in value) reduced.cause = (value as any).cause;\n      return reduced;\n    },\n    RangeError: makeNamedErrorSubclassReducer('RangeError'),\n    ReferenceError: makeNamedErrorSubclassReducer('ReferenceError'),\n    // RetryableError carries an extra retryAfter; serialize as numeric\n    // epoch timestamp for cross-realm safety (see host-side common.ts).\n    RetryableError: (value) => {\n      if (!(value instanceof Error) || value.name !== 'RetryableError')\n        return false;\n      const retryAfterRaw = (value as any).retryAfter;\n      let retryAfter: number;\n      if (\n        retryAfterRaw &&\n        typeof retryAfterRaw === 'object' &&\n        typeof (retryAfterRaw as { getTime?: unknown }).getTime === 'function'\n      ) {\n        const t = (retryAfterRaw as Date).getTime();\n        retryAfter = Number.isNaN(t) ? Date.now() + 1000 : t;\n      } else if (\n        typeof retryAfterRaw === 'string' ||\n        typeof retryAfterRaw === 'number'\n      ) {\n        const t = new Date(retryAfterRaw).getTime();\n        retryAfter = Number.isNaN(t) ? Date.now() + 1000 : t;\n      } else {\n        retryAfter = Date.now() + 1000;\n      }\n      const reduced: SerializableSpecial['RetryableError'] = {\n        message: value.message,\n        stack: value.stack,\n        retryAfter,\n      };\n      if ('cause' in value) reduced.cause = (value as any).cause;\n      return reduced;\n    },\n    // RuntimeDecryptionError carries an extra `context` object (operation,\n    // byteLength, formatPrefix) that the generic Error reducer would drop.\n    RuntimeDecryptionError: (value) => {\n      if (!(value instanceof Error) || value.name !== 'RuntimeDecryptionError')\n        return false;\n      const reduced: SerializableSpecial['RuntimeDecryptionError'] = {\n        message: value.message,\n        stack: value.stack,\n      };\n      const context = (value as any).context;\n      if (context !== undefined) {\n        reduced.context = context;\n      }\n      if ('cause' in value) reduced.cause = (value as any).cause;\n      return reduced;\n    },\n    SyntaxError: makeNamedErrorSubclassReducer('SyntaxError'),\n    TypeError: makeNamedErrorSubclassReducer('TypeError'),\n    URIError: makeNamedErrorSubclassReducer('URIError'),\n    // Base Error reducer — catch-all. Matched LAST after subclass-specific\n    // reducers above. Preserves `name` so user Error subclasses without\n    // dedicated reducers retain their identity through the round-trip.\n    Error: (value) => {\n      // In the VM, use instanceof Error (no node:util available)\n      if (!(value instanceof Error)) return false;\n      const reduced: SerializableSpecial['Error'] = {\n        name: value.name,\n        message: value.message,\n        stack: value.stack,\n      };\n      if ('cause' in value) reduced.cause = (value as any).cause;\n      return reduced;\n    },\n    Float32Array: (value) =>\n      value instanceof Float32Array && viewToBase64(value),\n    Float64Array: (value) =>\n      value instanceof Float64Array && viewToBase64(value),\n    Int8Array: (value) => value instanceof Int8Array && viewToBase64(value),\n    Int16Array: (value) => value instanceof Int16Array && viewToBase64(value),\n    Int32Array: (value) => value instanceof Int32Array && viewToBase64(value),\n    Map: (value) => value instanceof Map && Array.from(value),\n    RegExp: (value) =>\n      value instanceof RegExp && {\n        source: value.source,\n        flags: value.flags,\n      },\n    // Request/Response/Headers — serialize using the polyfill constructors\n    Headers: (value) => {\n      const H = (globalThis as any).Headers;\n      if (!H || !(value instanceof H)) return false;\n      return Array.from(value as Iterable<[string, string]>);\n    },\n    Request: (value) => {\n      const R = (globalThis as any).Request;\n      if (!R) return false;\n      // Use instanceof OR check for the Request-specific .json method\n      // (duck-typing on method/url alone would match plain objects and\n      // cause infinite recursion since the reducer output also has those)\n      if (!(value instanceof R) && typeof value?.json !== 'function')\n        return false;\n      if (typeof value?.method !== 'string') return false;\n      const data: any = {\n        method: value.method,\n        url: value.url,\n        headers: value.headers,\n        body: value.body,\n        duplex: value.duplex,\n      };\n      // Include the webhook response writable stream if present\n      const responseWritable = value[Symbol.for('WEBHOOK_RESPONSE_WRITABLE')];\n      if (responseWritable) {\n        data.responseWritable = responseWritable;\n      }\n      return data;\n    },\n    Response: (value) => {\n      const R = (globalThis as any).Response;\n      if (!R) return false;\n      // Use instanceof OR check for Response-specific .clone method\n      if (!(value instanceof R) && typeof value?.clone !== 'function')\n        return false;\n      if (typeof value?.status !== 'number') return false;\n      return {\n        type: value.type,\n        url: value.url,\n        status: value.status,\n        statusText: value.statusText,\n        headers: value.headers,\n        body: value.body,\n        redirected: value.redirected,\n      };\n    },\n    ReadableStream: ((value: any) => {\n      if (value == null) return false;\n      const RS = (globalThis as any).ReadableStream;\n      if (\n        !RS ||\n        !(value instanceof RS || Object.getPrototypeOf(value) === RS.prototype)\n      )\n        return false;\n      const bodyInit = value[Symbol.for('BODY_INIT')];\n      if (bodyInit !== undefined) {\n        return { bodyInit };\n      }\n      // Preserve stream name if present (opaque pointer for passing to steps)\n      const name = value[Symbol.for('WORKFLOW_STREAM_NAME')];\n      if (name) {\n        const s: any = { name };\n        const type = value[Symbol.for('WORKFLOW_STREAM_TYPE')];\n        if (type) s.type = type;\n        // Preserve wire framing so the step-side reviver can unframe\n        // byte streams (framed-v1) — dropping it turns a framed webhook\n        // body into raw length-prefixed bytes for the consumer.\n        const framing = value[Symbol.for('WORKFLOW_STREAM_FRAMING')];\n        if (framing) s.framing = framing;\n        return s;\n      }\n      return { name: '__empty' };\n    }) as any,\n    WritableStream: ((value: any) => {\n      if (value == null) return false;\n      const WS = (globalThis as any).WritableStream;\n      if (\n        !WS ||\n        !(value instanceof WS || Object.getPrototypeOf(value) === WS.prototype)\n      )\n        return false;\n      const name = value[Symbol.for('WORKFLOW_STREAM_NAME')];\n      const s: { name: string; runId?: string; deploymentId?: string } = {\n        name: name || '__empty',\n      };\n      // When the handle was forwarded from another run (parent -> child\n      // via start()), preserve the foreign runId/deploymentId so the\n      // step-side reviver opens the writable against the original stream.\n      // Mirrors the node:vm workflow reducer in serialization.ts.\n      const foreignRunId = value[Symbol.for('WORKFLOW_STREAM_SERVER_RUN_ID')];\n      if (typeof foreignRunId === 'string') s.runId = foreignRunId;\n      const foreignDeploymentId =\n        value[Symbol.for('WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID')];\n      if (typeof foreignDeploymentId === 'string') {\n        s.deploymentId = foreignDeploymentId;\n      }\n      return s;\n    }) as any,\n    Set: (value) => value instanceof Set && Array.from(value),\n    URL: (value) => value instanceof URL && value.href,\n    WorkflowFunction: (value) => {\n      // Only match function references with a workflowId property (set by\n      // the SWC compiler on workflow functions). Plain { workflowId } objects\n      // are NOT matched — this prevents infinite recursion since the reduced\n      // form { workflowId } is a plain object, not a function.\n      if (typeof value !== 'function') return false;\n      const workflowId = (value as any).workflowId;\n      if (typeof workflowId !== 'string') return false;\n      return { workflowId };\n    },\n    URLSearchParams: (value) => {\n      if (!(value instanceof URLSearchParams)) return false;\n      return value.size === 0 ? '.' : String(value);\n    },\n    Uint8Array: (value) => value instanceof Uint8Array && viewToBase64(value),\n    Uint8ClampedArray: (value) =>\n      value instanceof Uint8ClampedArray && viewToBase64(value),\n    Uint16Array: (value) => value instanceof Uint16Array && viewToBase64(value),\n    Uint32Array: (value) => value instanceof Uint32Array && viewToBase64(value),\n  };\n}\n\n// ---- Revivers ----\n\nexport function getCommonRevivers(): Partial<Revivers> {\n  return {\n    ArrayBuffer: (value: string) => reviveArrayBuffer(value),\n    BigInt: (value: string) => BigInt(value),\n    BigInt64Array: (value: string) =>\n      new BigInt64Array(reviveArrayBuffer(value)),\n    BigUint64Array: (value: string) =>\n      new BigUint64Array(reviveArrayBuffer(value)),\n    Date: (value) => new Date(value),\n    DOMException: (value) => {\n      const error = new DOMException(value.message, value.name);\n      if (value.stack !== undefined) error.stack = value.stack;\n      if ('cause' in value) (error as any).cause = value.cause;\n      return error;\n    },\n    AggregateError: (value) => {\n      const error = new AggregateError(value.errors ?? [], value.message);\n      if (value.stack !== undefined) error.stack = value.stack;\n      if ('cause' in value) (error as any).cause = value.cause;\n      return error;\n    },\n    EvalError: makeNamedErrorSubclassReviver('EvalError'),\n    FatalError: (value) => {\n      // Prefer the host-registered FatalError class (registered via\n      // Symbol.for keys by @workflow/errors so `instanceof FatalError`\n      // works across realms). Fall back to a synthesized Error with\n      // the right .name when no registration is present.\n      // FatalError's constructor takes only `message`, so cause is\n      // attached as a property after construction (matching the host\n      // reviver in common.ts).\n      const Cls = (globalThis as any)[\n        Symbol.for('@workflow/errors//FatalError')\n      ];\n      let error: Error;\n      if (typeof Cls === 'function') {\n        error = new Cls(value.message);\n      } else {\n        error = new Error(value.message);\n        error.name = 'FatalError';\n      }\n      if (value.stack !== undefined) error.stack = value.stack;\n      if ('cause' in value) (error as any).cause = (value as any).cause;\n      return error;\n    },\n    HookConflictError: (value) => {\n      // Prefer the registered HookConflictError class (see the FatalError\n      // reviver above). Its constructor takes (token, conflictingRunId).\n      const Cls = (globalThis as any)[\n        Symbol.for('@workflow/errors//HookConflictError')\n      ];\n      let error: Error;\n      if (typeof Cls === 'function') {\n        error = new Cls(value.token, value.conflictingRunId);\n      } else {\n        error = new Error(value.message);\n        error.name = 'HookConflictError';\n        (error as any).token = value.token;\n        if (value.conflictingRunId !== undefined) {\n          (error as any).conflictingRunId = value.conflictingRunId;\n        }\n      }\n      if (value.stack !== undefined) error.stack = value.stack;\n      if ('cause' in value) (error as any).cause = (value as any).cause;\n      return error;\n    },\n    RangeError: makeNamedErrorSubclassReviver('RangeError'),\n    ReferenceError: makeNamedErrorSubclassReviver('ReferenceError'),\n    RetryableError: (value) => {\n      // RetryableError's constructor accepts (message, { retryAfter }).\n      // Cause is attached after construction (the constructor does not\n      // forward it). retryAfter is stored as a Date in the VM realm.\n      const Cls = (globalThis as any)[\n        Symbol.for('@workflow/errors//RetryableError')\n      ];\n      const retryAfter = new Date(value.retryAfter);\n      let error: Error;\n      if (typeof Cls === 'function') {\n        error = new Cls(value.message, { retryAfter });\n      } else {\n        error = new Error(value.message);\n        error.name = 'RetryableError';\n        (error as any).retryAfter = retryAfter;\n      }\n      if (value.stack !== undefined) error.stack = value.stack;\n      if ('cause' in value) (error as any).cause = (value as any).cause;\n      return error;\n    },\n    RuntimeDecryptionError: (value) => {\n      // Prefer the registered RuntimeDecryptionError class (see the\n      // FatalError reviver above). Its constructor accepts\n      // (message, { cause, context }).\n      const Cls = (globalThis as any)[\n        Symbol.for('@workflow/errors//RuntimeDecryptionError')\n      ];\n      let error: Error;\n      if (typeof Cls === 'function') {\n        const opts: { cause?: unknown; context?: unknown } = {};\n        if ('cause' in value) opts.cause = (value as any).cause;\n        if (value.context !== undefined) opts.context = value.context;\n        error = new Cls(value.message, opts);\n      } else {\n        error = new Error(value.message);\n        error.name = 'RuntimeDecryptionError';\n        if (value.context !== undefined) {\n          (error as any).context = value.context;\n        }\n        if ('cause' in value) (error as any).cause = (value as any).cause;\n      }\n      if (value.stack !== undefined) error.stack = value.stack;\n      return error;\n    },\n    SyntaxError: makeNamedErrorSubclassReviver('SyntaxError'),\n    TypeError: makeNamedErrorSubclassReviver('TypeError'),\n    URIError: makeNamedErrorSubclassReviver('URIError'),\n    Error: (value) => {\n      const error = new Error(value.message);\n      error.name = value.name;\n      if (value.stack !== undefined) error.stack = value.stack;\n      if ('cause' in value) (error as any).cause = (value as any).cause;\n      return error;\n    },\n    Float32Array: (value: string) => new Float32Array(reviveArrayBuffer(value)),\n    Float64Array: (value: string) => new Float64Array(reviveArrayBuffer(value)),\n    Int8Array: (value: string) => new Int8Array(reviveArrayBuffer(value)),\n    Int16Array: (value: string) => new Int16Array(reviveArrayBuffer(value)),\n    Int32Array: (value: string) => new Int32Array(reviveArrayBuffer(value)),\n    Map: (value) => new Map(value),\n    RegExp: (value) => new RegExp(value.source, value.flags),\n    Set: (value) => new Set(value),\n    URL: (value) => new URL(value),\n    WorkflowFunction: (value) =>\n      Object.assign(\n        () => {\n          throw new Error(\n            'Workflow functions cannot be called directly. Use start() to invoke them.'\n          );\n        },\n        { workflowId: value.workflowId }\n      ),\n    URLSearchParams: (value) => new URLSearchParams(value === '.' ? '' : value),\n    Uint8Array: (value: string) => new Uint8Array(reviveArrayBuffer(value)),\n    Uint8ClampedArray: (value: string) =>\n      new Uint8ClampedArray(reviveArrayBuffer(value)),\n    Uint16Array: (value: string) => new Uint16Array(reviveArrayBuffer(value)),\n    Uint32Array: (value: string) => new Uint32Array(reviveArrayBuffer(value)),\n    // Web API types — revived as plain objects in the VM since the real\n    // constructors (Headers, Request, Response) are not available in QuickJS.\n    // The workflow code can access the properties but not call Web API methods.\n    Headers: (value) => {\n      return new (globalThis as any).Headers(value);\n    },\n    Request: (value: any) => {\n      const Req = (globalThis as any).Request;\n      if (Req) {\n        value.json = Req.prototype.json;\n        value.text = Req.prototype.text;\n        value.arrayBuffer = Req.prototype.arrayBuffer;\n      }\n      // Carry over the webhook response writable stream to the symbol property\n      if (value.responseWritable) {\n        value[Symbol.for('WEBHOOK_RESPONSE_WRITABLE')] = value.responseWritable;\n      }\n      return value;\n    },\n    Response: (value: any) => {\n      // Don't use Object.setPrototypeOf — devalue continues to set properties\n      // on the object after the reviver runs, and getter-only properties\n      // (like 'ok') on the prototype would cause \"no setter\" errors.\n      // Instead, copy methods directly onto the object.\n      const Resp = (globalThis as any).Response;\n      if (Resp) {\n        value.json = Resp.prototype.json;\n        value.text = Resp.prototype.text;\n        value.arrayBuffer = Resp.prototype.arrayBuffer;\n        if (Resp.prototype.bytes) value.bytes = Resp.prototype.bytes;\n        if (Resp.prototype.clone) value.clone = Resp.prototype.clone;\n      }\n      value._body = value.body;\n      value.ok = value.status >= 200 && value.status < 300;\n      value.bodyUsed = false;\n      return value;\n    },\n    ReadableStream: (value) => {\n      const RS = (globalThis as any).ReadableStream;\n      const stream = Object.create(RS ? RS.prototype : {});\n      if (value && 'bodyInit' in value) {\n        // Body from Response/Request constructor — store the raw data\n        stream[Symbol.for('BODY_INIT')] = value.bodyInit;\n      } else if (value && 'name' in value) {\n        // Named stream reference — preserve the name/type for re-serialization.\n        // Streams are opaque pointers in the VM — they can be passed to steps\n        // but not consumed directly.\n        stream[Symbol.for('WORKFLOW_STREAM_NAME')] = value.name;\n        if (value.type) stream[Symbol.for('WORKFLOW_STREAM_TYPE')] = value.type;\n        if (value.framing) {\n          stream[Symbol.for('WORKFLOW_STREAM_FRAMING')] = value.framing;\n        }\n      }\n      return stream;\n    },\n    WritableStream: (value) => {\n      const WS = (globalThis as any).WritableStream;\n      const stream = Object.create(WS ? WS.prototype : {});\n      if (value && 'name' in value) {\n        stream[Symbol.for('WORKFLOW_STREAM_NAME')] = value.name;\n      }\n      // Preserve the foreign runId/deploymentId, if present, so that when\n      // the handle is later passed to a step the workflow reducer can\n      // forward it through to the step reviver (cross-run writable\n      // forwarding via start()).\n      if (value && typeof (value as any).runId === 'string') {\n        stream[Symbol.for('WORKFLOW_STREAM_SERVER_RUN_ID')] = (\n          value as any\n        ).runId;\n      }\n      if (value && typeof (value as any).deploymentId === 'string') {\n        stream[Symbol.for('WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID')] = (\n          value as any\n        ).deploymentId;\n      }\n      return stream;\n    },\n  };\n}\n"]}