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

package/dist/serialization/reducers/common.js

@@ -0,0 +1,362 @@
+/**
+ * Common reducers and revivers for types shared across all serialization modes.
+ *
+ * Handles: ArrayBuffer, BigInt, typed arrays, Date, Error, Headers, Map, Set,
+ * RegExp, Request, Response, URL, URLSearchParams.
+ *
+ * Note: Uses Node.js Buffer for base64 encoding/decoding. For environments
+ * without Buffer (e.g. QuickJS VM), a polyfill or alternative base64
+ * implementation will be needed.
+ */
+import { types } from 'node:util';
+import { FatalError, RetryableError } from '@workflow/errors';
+// ---- Base64 helpers ----
+function arrayBufferToBase64(value, offset, length) {
+    // Avoid returning falsy value for zero-length buffers
+    if (length === 0)
+        return '.';
+    // Create a proper copy to avoid ArrayBuffer detachment issues
+    const uint8 = new Uint8Array(value, offset, length);
+    return Buffer.from(uint8).toString('base64');
+}
+function viewToBase64(value) {
+    return arrayBufferToBase64(value.buffer, value.byteOffset, value.byteLength);
+}
+function reviveArrayBuffer(value, global) {
+    const base64 = value === '.' ? '' : value;
+    const buffer = Buffer.from(base64, 'base64');
+    const arrayBuffer = new global.ArrayBuffer(buffer.length);
+    const uint8Array = new global.Uint8Array(arrayBuffer);
+    uint8Array.set(buffer);
+    return arrayBuffer;
+}
+function revive(str) {
+    // devalue.stringify() always produces valid JSON: special values
+    // (undefined, NaN, Infinity, -0) are encoded as negative integer
+    // sentinels and the remaining structure is ordinary JSON. Parsing
+    // with JSON.parse yields the flattened form that unflatten() expects.
+    return JSON.parse(str);
+}
+/**
+ * Reduces any native Error instance to the shared `BaseErrorPayload` shape,
+ * preserving `cause` only when present (to distinguish "no cause" from
+ * "cause is undefined"). Used directly by reducers for subclasses that need
+ * to extend the shape with additional fields.
+ *
+ * `types.isNativeError()` is used instead of `instanceof` for cross-VM safety:
+ * errors may originate from a different VM context, and `instanceof` fails
+ * across VM boundaries since each context has its own Error constructor.
+ */
+function reduceErrorBase(value) {
+    if (!types.isNativeError(value))
+        return false;
+    const reduced = {
+        message: value.message,
+        stack: value.stack,
+    };
+    if ('cause' in value)
+        reduced.cause = value.cause;
+    return reduced;
+}
+/**
+ * Reduces a native error to the shared `BaseErrorPayload`, but only when its
+ * `name` instance property matches `subclassName`. Used by:
+ *   - `makeErrorSubclassReducer`, for subclasses whose serialized shape is
+ *     exactly `BaseErrorPayload`.
+ *   - Inline reducers for subclasses that extend the shape with additional
+ *     fields (e.g. `AggregateError.errors`, `RetryableError.retryAfter`).
+ *
+ * Matching by `value.name` (instead of `value.constructor?.name`) is robust
+ * to bundlers that emit the class as an anonymous expression — e.g. Turbopack
+ * compiles `export class FatalError extends Error {…}` to a registration call
+ * like `e.s(["FatalError", 0, class extends Error {…}])`, and the resulting
+ * constructor has `name === ''`. Since every Error subclass we care about
+ * sets `this.name` explicitly in its constructor (built-in subclasses do this
+ * automatically; `FatalError`/`RetryableError` do it in user code), the
+ * instance property is the reliable identity marker across realms and
+ * bundlers.
+ */
+function reduceNamedErrorSubclassBase(subclassName, value) {
+    if (!types.isNativeError(value))
+        return false;
+    if (value.name !== subclassName)
+        return false;
+    return reduceErrorBase(value);
+}
+/**
+ * Creates a reducer for a built-in Error subclass whose serialized shape is
+ * exactly `BaseErrorPayload` (no extra fields). The reducer matches by
+ * constructor name (after the isNativeError gate), since `instanceof` may
+ * fail across VM boundaries.
+ */
+function makeErrorSubclassReducer(subclassName) {
+    return (value) => {
+        const base = reduceNamedErrorSubclassBase(subclassName, value);
+        if (!base)
+            return false;
+        return base;
+    };
+}
+/**
+ * Creates a reviver for a built-in Error subclass. Reconstructs the correct
+ * built-in Error type using the context's constructor. The `cause` option is
+ * only passed when the serialized data includes it, preserving the distinction
+ * between "no cause" and "cause is undefined".
+ */
+function makeErrorSubclassReviver(global, ctorName) {
+    return (value) => {
+        const v = value;
+        const opts = 'cause' in v ? { cause: v.cause } : undefined;
+        const Ctor = global[ctorName];
+        const error = new Ctor(v.message, opts);
+        if (v.stack !== undefined)
+            error.stack = v.stack;
+        return error;
+    };
+}
+// ---- Reducers ----
+export function getCommonReducers(global = globalThis) {
+    return {
+        ArrayBuffer: (value) => value instanceof global.ArrayBuffer &&
+            arrayBufferToBase64(value, 0, value.byteLength),
+        BigInt: (value) => typeof value === 'bigint' && value.toString(),
+        BigInt64Array: (value) => value instanceof global.BigInt64Array && viewToBase64(value),
+        BigUint64Array: (value) => value instanceof global.BigUint64Array && viewToBase64(value),
+        Date: (value) => {
+            if (!(value instanceof global.Date))
+                return false;
+            const valid = !Number.isNaN(value.getDate());
+            return valid ? value.toISOString() : '.';
+        },
+        // DOMException is a special case: it `instanceof Error` is true in Node,
+        // but `types.isNativeError()` returns FALSE for it, so the generic Error
+        // reducer (which gates on isNativeError) won't match. Check it explicitly
+        // by constructor name + Error inheritance so we catch DOMExceptions from
+        // any realm (cross-VM safety: instanceof global.DOMException would fail
+        // for instances minted in another context).
+        DOMException: (value) => {
+            if (value === null || typeof value !== 'object')
+                return false;
+            if (value.constructor?.name !==
+                'DOMException')
+                return false;
+            const e = value;
+            const reduced = {
+                message: e.message,
+                name: e.name,
+                stack: e.stack,
+            };
+            if ('cause' in e)
+                reduced.cause = e.cause;
+            return reduced;
+        },
+        // Error subclass reducers are intentionally placed before the base Error
+        // reducer because devalue uses first-match-wins. Subclass-specific reducers
+        // must be checked first so that e.g. a TypeError is serialized as "TypeError"
+        // rather than falling through to the generic "Error" reducer.
+        // See `makeErrorSubclassReducer` for implementation details.
+        EvalError: makeErrorSubclassReducer('EvalError'),
+        FatalError: makeErrorSubclassReducer('FatalError'),
+        RangeError: makeErrorSubclassReducer('RangeError'),
+        ReferenceError: makeErrorSubclassReducer('ReferenceError'),
+        // RetryableError carries an extra `retryAfter` Date that we serialize as
+        // a numeric epoch timestamp. The Date reducer uses `instanceof global.Date`,
+        // which fails for Dates from a different VM realm; serializing as a
+        // number sidesteps that issue.
+        RetryableError: (value) => {
+            const base = reduceNamedErrorSubclassBase('RetryableError', value);
+            if (!base)
+                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;
+            }
+            return {
+                ...base,
+                retryAfter,
+            };
+        },
+        SyntaxError: makeErrorSubclassReducer('SyntaxError'),
+        TypeError: makeErrorSubclassReducer('TypeError'),
+        URIError: makeErrorSubclassReducer('URIError'),
+        // AggregateError is similar to other subclasses but also preserves the
+        // `errors` array. We extend the base helper's output here.
+        AggregateError: (value) => {
+            const base = reduceNamedErrorSubclassBase('AggregateError', value);
+            if (!base)
+                return false;
+            return {
+                ...base,
+                errors: value.errors,
+            };
+        },
+        // Base Error reducer — catch-all for any Error instance not matched by a
+        // specific subclass reducer above (including user Error subclasses without
+        // WORKFLOW_SERIALIZE). Preserves `name` so the error's identity is retained
+        // even though the exact class cannot be reconstructed.
+        Error: (value) => {
+            if (!types.isNativeError(value))
+                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 global.Float32Array && viewToBase64(value),
+        Float64Array: (value) => value instanceof global.Float64Array && viewToBase64(value),
+        Headers: (value) => value instanceof global.Headers && Array.from(value),
+        Int8Array: (value) => value instanceof global.Int8Array && viewToBase64(value),
+        Int16Array: (value) => value instanceof global.Int16Array && viewToBase64(value),
+        Int32Array: (value) => value instanceof global.Int32Array && viewToBase64(value),
+        Map: (value) => value instanceof global.Map && Array.from(value),
+        RegExp: (value) => value instanceof global.RegExp && {
+            source: value.source,
+            flags: value.flags,
+        },
+        // Request and Response are intentionally NOT in common reducers.
+        // They require mode-specific revivers (stream handling, etc.) and
+        // including them here without matching revivers would cause them
+        // to deserialize as plain objects.
+        Set: (value) => value instanceof global.Set && Array.from(value),
+        URL: (value) => value instanceof global.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 global.URLSearchParams))
+                return false;
+            if (value.size === 0)
+                return '.';
+            return String(value);
+        },
+        Uint8Array: (value) => value instanceof global.Uint8Array && viewToBase64(value),
+        Uint8ClampedArray: (value) => value instanceof global.Uint8ClampedArray && viewToBase64(value),
+        Uint16Array: (value) => value instanceof global.Uint16Array && viewToBase64(value),
+        Uint32Array: (value) => value instanceof global.Uint32Array && viewToBase64(value),
+    };
+}
+// ---- Revivers ----
+export function getCommonRevivers(global = globalThis) {
+    return {
+        ArrayBuffer: (value) => reviveArrayBuffer(value, global),
+        BigInt: (value) => global.BigInt(value),
+        BigInt64Array: (value) => new global.BigInt64Array(reviveArrayBuffer(value, global)),
+        BigUint64Array: (value) => new global.BigUint64Array(reviveArrayBuffer(value, global)),
+        Date: (value) => new global.Date(value),
+        DOMException: (value) => {
+            const error = new global.DOMException(value.message, value.name);
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            // DOMException's constructor doesn't accept a cause option, so
+            // we set it manually when present in the serialized data.
+            if ('cause' in value)
+                error.cause = value.cause;
+            return error;
+        },
+        // Error subclass revivers reconstruct the correct built-in Error type.
+        // See `makeErrorSubclassReviver` for implementation details.
+        EvalError: makeErrorSubclassReviver(global, 'EvalError'),
+        // `FatalError` and `RetryableError` are not built-ins, so we resolve them
+        // from the consumer's `globalThis` via a `Symbol.for(...)` key registered
+        // by `@workflow/errors` on load. This makes `instanceof FatalError` work
+        // in user code that lives in a different realm than this reducer module
+        // (e.g. when the host hydrates a value destined for a workflow VM
+        // context). See the registration block at the bottom of
+        // `packages/errors/src/index.ts` for details. Falls back to the imported
+        // class for environments where no bundled `@workflow/errors` has loaded
+        // in the consumer realm.
+        FatalError: (value) => {
+            const Ctor = global[Symbol.for('@workflow/errors//FatalError')] ?? FatalError;
+            const error = new Ctor(value.message);
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            if ('cause' in value)
+                error.cause = value.cause;
+            return error;
+        },
+        RangeError: makeErrorSubclassReviver(global, 'RangeError'),
+        ReferenceError: makeErrorSubclassReviver(global, 'ReferenceError'),
+        RetryableError: (value) => {
+            // Use the context's `Date` constructor (matching the rest of this
+            // module) so the resulting `retryAfter` Date passes `instanceof
+            // global.Date` checks in the target realm. See the FatalError reviver
+            // above for why we resolve `RetryableError` from the consumer's
+            // globalThis instead of the imported class.
+            const Ctor = global[Symbol.for('@workflow/errors//RetryableError')] ?? RetryableError;
+            const error = new Ctor(value.message, {
+                retryAfter: new global.Date(value.retryAfter),
+            });
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            if ('cause' in value)
+                error.cause = value.cause;
+            return error;
+        },
+        SyntaxError: makeErrorSubclassReviver(global, 'SyntaxError'),
+        TypeError: makeErrorSubclassReviver(global, 'TypeError'),
+        URIError: makeErrorSubclassReviver(global, 'URIError'),
+        AggregateError: (value) => {
+            const opts = 'cause' in value ? { cause: value.cause } : undefined;
+            const error = new global.AggregateError(value.errors, value.message, opts);
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            return error;
+        },
+        // Base Error reviver — used for plain Error instances and unrecognized
+        // Error subclasses. Preserves `name` so the error's identity is retained.
+        Error: (value) => {
+            const opts = 'cause' in value ? { cause: value.cause } : undefined;
+            const error = new global.Error(value.message, opts);
+            error.name = value.name;
+            if (value.stack !== undefined)
+                error.stack = value.stack;
+            return error;
+        },
+        Float32Array: (value) => new global.Float32Array(reviveArrayBuffer(value, global)),
+        Float64Array: (value) => new global.Float64Array(reviveArrayBuffer(value, global)),
+        Headers: (value) => new global.Headers(value),
+        Int8Array: (value) => new global.Int8Array(reviveArrayBuffer(value, global)),
+        Int16Array: (value) => new global.Int16Array(reviveArrayBuffer(value, global)),
+        Int32Array: (value) => new global.Int32Array(reviveArrayBuffer(value, global)),
+        Map: (value) => new global.Map(value),
+        RegExp: (value) => new global.RegExp(value.source, value.flags),
+        Set: (value) => new global.Set(value),
+        URL: (value) => new global.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 global.URLSearchParams(value === '.' ? '' : value),
+        Uint8Array: (value) => new global.Uint8Array(reviveArrayBuffer(value, global)),
+        Uint8ClampedArray: (value) => new global.Uint8ClampedArray(reviveArrayBuffer(value, global)),
+        Uint16Array: (value) => new global.Uint16Array(reviveArrayBuffer(value, global)),
+        Uint32Array: (value) => new global.Uint32Array(reviveArrayBuffer(value, global)),
+    };
+}
+// Re-export for use in legacy compat
+export { revive };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../src/serialization/reducers/common.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Common reducers and revivers for types shared across all serialization modes.\n *\n * Handles: ArrayBuffer, BigInt, typed arrays, Date, Error, Headers, Map, Set,\n * RegExp, Request, Response, URL, URLSearchParams.\n *\n * Note: Uses Node.js Buffer for base64 encoding/decoding. For environments\n * without Buffer (e.g. QuickJS VM), a polyfill or alternative base64\n * implementation will be needed.\n */\n\nimport { types } from 'node:util';\nimport { FatalError, RetryableError } from '@workflow/errors';\nimport type { Reducers, Revivers, SerializableSpecial } from '../types.js';\n\n// ---- Base64 helpers ----\n\nfunction arrayBufferToBase64(\n  value: ArrayBufferLike,\n  offset: number,\n  length: number\n): string {\n  // Avoid returning falsy value for zero-length buffers\n  if (length === 0) return '.';\n  // Create a proper copy to avoid ArrayBuffer detachment issues\n  const uint8 = new Uint8Array(value, offset, length);\n  return Buffer.from(uint8).toString('base64');\n}\n\nfunction viewToBase64(value: ArrayBufferView): string {\n  return arrayBufferToBase64(value.buffer, value.byteOffset, value.byteLength);\n}\n\nfunction reviveArrayBuffer(\n  value: string,\n  global: Record<string, any>\n): ArrayBuffer {\n  const base64 = value === '.' ? '' : value;\n  const buffer = Buffer.from(base64, 'base64');\n  const arrayBuffer = new global.ArrayBuffer(buffer.length);\n  const uint8Array = new global.Uint8Array(arrayBuffer);\n  uint8Array.set(buffer);\n  return arrayBuffer;\n}\n\nfunction revive(str: string) {\n  // devalue.stringify() always produces valid JSON: special values\n  // (undefined, NaN, Infinity, -0) are encoded as negative integer\n  // sentinels and the remaining structure is ordinary JSON. Parsing\n  // with JSON.parse yields the flattened form that unflatten() expects.\n  return JSON.parse(str);\n}\n\n// ---- Error subclass helpers ----\n\n/**\n * The shared shape that every Error-subclass reducer in this module\n * produces. Some subclasses (e.g. `AggregateError`, `RetryableError`) extend\n * this with additional fields by spreading the base payload.\n */\ntype BaseErrorPayload = {\n  message: string;\n  stack?: string;\n  cause?: unknown;\n};\n\n/**\n * Subset of `SerializableSpecial` keys whose payload shape is exactly the\n * `BaseErrorPayload`. `makeErrorSubclassReducer` is constrained to only\n * these keys so its return type is sound — subclasses that need extra\n * fields (like `AggregateError.errors` or `RetryableError.retryAfter`) use\n * `reduceErrorBase` directly and extend the result.\n */\ntype SimpleErrorSubclassKey = {\n  [K in keyof SerializableSpecial]: SerializableSpecial[K] extends BaseErrorPayload\n    ? BaseErrorPayload extends SerializableSpecial[K]\n      ? K\n      : never\n    : never;\n}[keyof SerializableSpecial];\n\n/**\n * Reduces any native Error instance to the shared `BaseErrorPayload` shape,\n * preserving `cause` only when present (to distinguish \"no cause\" from\n * \"cause is undefined\"). Used directly by reducers for subclasses that need\n * to extend the shape with additional fields.\n *\n * `types.isNativeError()` is used instead of `instanceof` for cross-VM safety:\n * errors may originate from a different VM context, and `instanceof` fails\n * across VM boundaries since each context has its own Error constructor.\n */\nfunction reduceErrorBase(value: unknown): BaseErrorPayload | false {\n  if (!types.isNativeError(value)) return false;\n  const reduced: BaseErrorPayload = {\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 * Reduces a native error to the shared `BaseErrorPayload`, but only when its\n * `name` instance property matches `subclassName`. Used by:\n *   - `makeErrorSubclassReducer`, for subclasses whose serialized shape is\n *     exactly `BaseErrorPayload`.\n *   - Inline reducers for subclasses that extend the shape with additional\n *     fields (e.g. `AggregateError.errors`, `RetryableError.retryAfter`).\n *\n * Matching by `value.name` (instead of `value.constructor?.name`) is robust\n * to bundlers that emit the class as an anonymous expression — e.g. Turbopack\n * compiles `export class FatalError extends Error {…}` to a registration call\n * like `e.s([\"FatalError\", 0, class extends Error {…}])`, and the resulting\n * constructor has `name === ''`. Since every Error subclass we care about\n * sets `this.name` explicitly in its constructor (built-in subclasses do this\n * automatically; `FatalError`/`RetryableError` do it in user code), the\n * instance property is the reliable identity marker across realms and\n * bundlers.\n */\nfunction reduceNamedErrorSubclassBase(\n  subclassName: string,\n  value: unknown\n): BaseErrorPayload | false {\n  if (!types.isNativeError(value)) return false;\n  if (value.name !== subclassName) return false;\n  return reduceErrorBase(value);\n}\n\n/**\n * Creates a reducer for a built-in Error subclass whose serialized shape is\n * exactly `BaseErrorPayload` (no extra fields). The reducer matches by\n * constructor name (after the isNativeError gate), since `instanceof` may\n * fail across VM boundaries.\n */\nfunction makeErrorSubclassReducer<K extends SimpleErrorSubclassKey>(\n  subclassName: K\n) {\n  return (value: unknown): SerializableSpecial[K] | false => {\n    const base = reduceNamedErrorSubclassBase(subclassName, value);\n    if (!base) return false;\n    return base as SerializableSpecial[K];\n  };\n}\n\n/**\n * Creates a reviver for a built-in Error subclass. Reconstructs the correct\n * built-in Error type using the context's constructor. The `cause` option is\n * only passed when the serialized data includes it, preserving the distinction\n * between \"no cause\" and \"cause is undefined\".\n */\nfunction makeErrorSubclassReviver<K extends keyof SerializableSpecial>(\n  global: Record<string, any>,\n  ctorName: string\n) {\n  return (value: SerializableSpecial[K]) => {\n    const v = value as BaseErrorPayload;\n    const opts = 'cause' in v ? { cause: v.cause } : undefined;\n    const Ctor = global[ctorName];\n    const error: Error = new Ctor(v.message, opts);\n    if (v.stack !== undefined) error.stack = v.stack;\n    return error;\n  };\n}\n\n// ---- Reducers ----\n\nexport function getCommonReducers(\n  global: Record<string, any> = globalThis\n): Partial<Reducers> {\n  return {\n    ArrayBuffer: (value) =>\n      value instanceof global.ArrayBuffer &&\n      arrayBufferToBase64(value, 0, value.byteLength),\n    BigInt: (value) => typeof value === 'bigint' && value.toString(),\n    BigInt64Array: (value) =>\n      value instanceof global.BigInt64Array && viewToBase64(value),\n    BigUint64Array: (value) =>\n      value instanceof global.BigUint64Array && viewToBase64(value),\n    Date: (value) => {\n      if (!(value instanceof global.Date)) return false;\n      const valid = !Number.isNaN(value.getDate());\n      return valid ? value.toISOString() : '.';\n    },\n    // DOMException is a special case: it `instanceof Error` is true in Node,\n    // but `types.isNativeError()` returns FALSE for it, so the generic Error\n    // reducer (which gates on isNativeError) won't match. Check it explicitly\n    // by constructor name + Error inheritance so we catch DOMExceptions from\n    // any realm (cross-VM safety: instanceof global.DOMException would fail\n    // for instances minted in another context).\n    DOMException: (value) => {\n      if (value === null || typeof value !== 'object') return false;\n      if (\n        (value as { constructor?: { name?: string } }).constructor?.name !==\n        'DOMException'\n      )\n        return false;\n      const e = value as Error & { cause?: unknown };\n      const reduced: SerializableSpecial['DOMException'] = {\n        message: e.message,\n        name: e.name,\n        stack: e.stack,\n      };\n      if ('cause' in e) reduced.cause = e.cause;\n      return reduced;\n    },\n    // Error subclass reducers are intentionally placed before the base Error\n    // reducer because devalue uses first-match-wins. Subclass-specific reducers\n    // must be checked first so that e.g. a TypeError is serialized as \"TypeError\"\n    // rather than falling through to the generic \"Error\" reducer.\n    // See `makeErrorSubclassReducer` for implementation details.\n    EvalError: makeErrorSubclassReducer('EvalError'),\n    FatalError: makeErrorSubclassReducer('FatalError'),\n    RangeError: makeErrorSubclassReducer('RangeError'),\n    ReferenceError: makeErrorSubclassReducer('ReferenceError'),\n    // RetryableError carries an extra `retryAfter` Date that we serialize as\n    // a numeric epoch timestamp. The Date reducer uses `instanceof global.Date`,\n    // which fails for Dates from a different VM realm; serializing as a\n    // number sidesteps that issue.\n    RetryableError: (value) => {\n      const base = reduceNamedErrorSubclassBase('RetryableError', value);\n      if (!base) return false;\n      const retryAfterRaw = (value as RetryableError).retryAfter as unknown;\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      return {\n        ...base,\n        retryAfter,\n      } satisfies SerializableSpecial['RetryableError'];\n    },\n    SyntaxError: makeErrorSubclassReducer('SyntaxError'),\n    TypeError: makeErrorSubclassReducer('TypeError'),\n    URIError: makeErrorSubclassReducer('URIError'),\n    // AggregateError is similar to other subclasses but also preserves the\n    // `errors` array. We extend the base helper's output here.\n    AggregateError: (value) => {\n      const base = reduceNamedErrorSubclassBase('AggregateError', value);\n      if (!base) return false;\n      return {\n        ...base,\n        errors: (value as AggregateError).errors,\n      } satisfies SerializableSpecial['AggregateError'];\n    },\n    // Base Error reducer — catch-all for any Error instance not matched by a\n    // specific subclass reducer above (including user Error subclasses without\n    // WORKFLOW_SERIALIZE). Preserves `name` so the error's identity is retained\n    // even though the exact class cannot be reconstructed.\n    Error: (value) => {\n      if (!types.isNativeError(value)) 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.cause;\n      return reduced;\n    },\n    Float32Array: (value) =>\n      value instanceof global.Float32Array && viewToBase64(value),\n    Float64Array: (value) =>\n      value instanceof global.Float64Array && viewToBase64(value),\n    Headers: (value) => value instanceof global.Headers && Array.from(value),\n    Int8Array: (value) =>\n      value instanceof global.Int8Array && viewToBase64(value),\n    Int16Array: (value) =>\n      value instanceof global.Int16Array && viewToBase64(value),\n    Int32Array: (value) =>\n      value instanceof global.Int32Array && viewToBase64(value),\n    Map: (value) => value instanceof global.Map && Array.from(value),\n    RegExp: (value) =>\n      value instanceof global.RegExp && {\n        source: value.source,\n        flags: value.flags,\n      },\n    // Request and Response are intentionally NOT in common reducers.\n    // They require mode-specific revivers (stream handling, etc.) and\n    // including them here without matching revivers would cause them\n    // to deserialize as plain objects.\n    Set: (value) => value instanceof global.Set && Array.from(value),\n    URL: (value) => value instanceof global.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 global.URLSearchParams)) return false;\n      if (value.size === 0) return '.';\n      return String(value);\n    },\n    Uint8Array: (value) =>\n      value instanceof global.Uint8Array && viewToBase64(value),\n    Uint8ClampedArray: (value) =>\n      value instanceof global.Uint8ClampedArray && viewToBase64(value),\n    Uint16Array: (value) =>\n      value instanceof global.Uint16Array && viewToBase64(value),\n    Uint32Array: (value) =>\n      value instanceof global.Uint32Array && viewToBase64(value),\n  };\n}\n\n// ---- Revivers ----\n\nexport function getCommonRevivers(\n  global: Record<string, any> = globalThis\n): Partial<Revivers> {\n  return {\n    ArrayBuffer: (value: string) => reviveArrayBuffer(value, global),\n    BigInt: (value: string) => global.BigInt(value),\n    BigInt64Array: (value: string) =>\n      new global.BigInt64Array(reviveArrayBuffer(value, global)),\n    BigUint64Array: (value: string) =>\n      new global.BigUint64Array(reviveArrayBuffer(value, global)),\n    Date: (value) => new global.Date(value),\n    DOMException: (value) => {\n      const error = new global.DOMException(value.message, value.name);\n      if (value.stack !== undefined) error.stack = value.stack;\n      // DOMException's constructor doesn't accept a cause option, so\n      // we set it manually when present in the serialized data.\n      if ('cause' in value) error.cause = value.cause;\n      return error;\n    },\n    // Error subclass revivers reconstruct the correct built-in Error type.\n    // See `makeErrorSubclassReviver` for implementation details.\n    EvalError: makeErrorSubclassReviver(global, 'EvalError'),\n    // `FatalError` and `RetryableError` are not built-ins, so we resolve them\n    // from the consumer's `globalThis` via a `Symbol.for(...)` key registered\n    // by `@workflow/errors` on load. This makes `instanceof FatalError` work\n    // in user code that lives in a different realm than this reducer module\n    // (e.g. when the host hydrates a value destined for a workflow VM\n    // context). See the registration block at the bottom of\n    // `packages/errors/src/index.ts` for details. Falls back to the imported\n    // class for environments where no bundled `@workflow/errors` has loaded\n    // in the consumer realm.\n    FatalError: (value) => {\n      const Ctor =\n        ((global as Record<symbol, unknown>)[\n          Symbol.for('@workflow/errors//FatalError')\n        ] as typeof FatalError | undefined) ?? FatalError;\n      const error = new Ctor(value.message);\n      if (value.stack !== undefined) error.stack = value.stack;\n      if ('cause' in value) error.cause = value.cause;\n      return error;\n    },\n    RangeError: makeErrorSubclassReviver(global, 'RangeError'),\n    ReferenceError: makeErrorSubclassReviver(global, 'ReferenceError'),\n    RetryableError: (value) => {\n      // Use the context's `Date` constructor (matching the rest of this\n      // module) so the resulting `retryAfter` Date passes `instanceof\n      // global.Date` checks in the target realm. See the FatalError reviver\n      // above for why we resolve `RetryableError` from the consumer's\n      // globalThis instead of the imported class.\n      const Ctor =\n        ((global as Record<symbol, unknown>)[\n          Symbol.for('@workflow/errors//RetryableError')\n        ] as typeof RetryableError | undefined) ?? RetryableError;\n      const error = new Ctor(value.message, {\n        retryAfter: new global.Date(value.retryAfter),\n      });\n      if (value.stack !== undefined) error.stack = value.stack;\n      if ('cause' in value) error.cause = value.cause;\n      return error;\n    },\n    SyntaxError: makeErrorSubclassReviver(global, 'SyntaxError'),\n    TypeError: makeErrorSubclassReviver(global, 'TypeError'),\n    URIError: makeErrorSubclassReviver(global, 'URIError'),\n    AggregateError: (value) => {\n      const opts = 'cause' in value ? { cause: value.cause } : undefined;\n      const error = new global.AggregateError(\n        value.errors,\n        value.message,\n        opts\n      );\n      if (value.stack !== undefined) error.stack = value.stack;\n      return error;\n    },\n    // Base Error reviver — used for plain Error instances and unrecognized\n    // Error subclasses. Preserves `name` so the error's identity is retained.\n    Error: (value) => {\n      const opts = 'cause' in value ? { cause: value.cause } : undefined;\n      const error = new global.Error(value.message, opts);\n      error.name = value.name;\n      if (value.stack !== undefined) error.stack = value.stack;\n      return error;\n    },\n    Float32Array: (value: string) =>\n      new global.Float32Array(reviveArrayBuffer(value, global)),\n    Float64Array: (value: string) =>\n      new global.Float64Array(reviveArrayBuffer(value, global)),\n    Headers: (value) => new global.Headers(value),\n    Int8Array: (value: string) =>\n      new global.Int8Array(reviveArrayBuffer(value, global)),\n    Int16Array: (value: string) =>\n      new global.Int16Array(reviveArrayBuffer(value, global)),\n    Int32Array: (value: string) =>\n      new global.Int32Array(reviveArrayBuffer(value, global)),\n    Map: (value) => new global.Map(value),\n    RegExp: (value) => new global.RegExp(value.source, value.flags),\n    Set: (value) => new global.Set(value),\n    URL: (value) => new global.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) =>\n      new global.URLSearchParams(value === '.' ? '' : value),\n    Uint8Array: (value: string) =>\n      new global.Uint8Array(reviveArrayBuffer(value, global)),\n    Uint8ClampedArray: (value: string) =>\n      new global.Uint8ClampedArray(reviveArrayBuffer(value, global)),\n    Uint16Array: (value: string) =>\n      new global.Uint16Array(reviveArrayBuffer(value, global)),\n    Uint32Array: (value: string) =>\n      new global.Uint32Array(reviveArrayBuffer(value, global)),\n  };\n}\n\n// Re-export for use in legacy compat\nexport { revive };\n"]}

package/dist/serialization/reducers/step-function.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reducer and reviver for step function references.
+ *
+ * In workflow mode, step functions are replaced by the SWC plugin with
+ * proxies created by `globalThis[Symbol.for("WORKFLOW_USE_STEP")]("stepId")`.
+ * These proxies have a `.stepId` property and optionally a `.__closureVarsFn`
+ * for captured closure variables. They may additionally have `.__boundThis`
+ * (and rarely `.__boundArgs`) when the SWC plugin emitted
+ * `useStep(...).bind(this)` for a nested arrow step that lexically
+ * captured `this` (see `packages/swc-plugin-workflow/spec.md` → "Lexical
+ * `this` Capture in Nested Arrow Steps").
+ *
+ * The reducer serializes them as
+ *   `{ stepId, closureVars?, boundThis?, boundArgs? }`.
+ * The reviver reconstructs them by calling WORKFLOW_USE_STEP and, when
+ * `boundThis` (or `boundArgs`) is present, re-binding the resulting
+ * proxy so the caller's captured `this` (and prefilled args) survive the
+ * round trip.
+ */
+import type { Reducers, Revivers } from '../types.js';
+export declare function getStepFunctionReducer(): Partial<Reducers>;
+/**
+ * Create the StepFunction reviver for workflow context.
+ *
+ * The reviver calls WORKFLOW_USE_STEP to create the step proxy,
+ * restoring the ability to call the step from workflow code. If the
+ * serialized payload includes `boundThis` (and optionally `boundArgs`),
+ * the reviver also re-binds the freshly-created proxy so a step proxy
+ * that was constructed with `.bind(this, …)` in the workflow bundle
+ * continues to carry that receiver and any prefilled arguments after
+ * being deserialized in another bundle (e.g. when passed as a step
+ * argument).
+ */
+export declare function getStepFunctionReviver(global?: Record<string, any>): Partial<Revivers>;
+//# sourceMappingURL=step-function.d.ts.map

package/dist/serialization/reducers/step-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-function.d.ts","sourceRoot":"","sources":["../../../src/serialization/reducers/step-function.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAItD,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,QAAQ,CAAC,CAuC1D;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAc,GACvC,OAAO,CAAC,QAAQ,CAAC,CA8BnB"}

package/dist/serialization/reducers/step-function.js

@@ -0,0 +1,88 @@
+/**
+ * Reducer and reviver for step function references.
+ *
+ * In workflow mode, step functions are replaced by the SWC plugin with
+ * proxies created by `globalThis[Symbol.for("WORKFLOW_USE_STEP")]("stepId")`.
+ * These proxies have a `.stepId` property and optionally a `.__closureVarsFn`
+ * for captured closure variables. They may additionally have `.__boundThis`
+ * (and rarely `.__boundArgs`) when the SWC plugin emitted
+ * `useStep(...).bind(this)` for a nested arrow step that lexically
+ * captured `this` (see `packages/swc-plugin-workflow/spec.md` → "Lexical
+ * `this` Capture in Nested Arrow Steps").
+ *
+ * The reducer serializes them as
+ *   `{ stepId, closureVars?, boundThis?, boundArgs? }`.
+ * The reviver reconstructs them by calling WORKFLOW_USE_STEP and, when
+ * `boundThis` (or `boundArgs`) is present, re-binding the resulting
+ * proxy so the caller's captured `this` (and prefilled args) survive the
+ * round trip.
+ */
+// ---- Reducer ----
+export function getStepFunctionReducer() {
+    return {
+        StepFunction: (value) => {
+            if (typeof value !== 'function')
+                return false;
+            const stepId = value.stepId;
+            if (typeof stepId !== 'string')
+                return false;
+            const closureVarsFn = value.__closureVarsFn;
+            const closureVars = closureVarsFn && typeof closureVarsFn === 'function'
+                ? closureVarsFn()
+                : undefined;
+            // `__boundThis` / `__boundArgs` are marker properties added by the
+            // step proxy's overridden `.bind` (see step.ts) to record the
+            // bound receiver and any prefilled arguments. Use `in` for
+            // `__boundThis` so we round-trip even when the bound `this` is
+            // `undefined`/`null`. `__boundArgs` is only set when the user
+            // actually supplied prefilled args, so a missing property means
+            // "no prefilled args".
+            const hasBoundThis = '__boundThis' in value;
+            const boundThis = hasBoundThis ? value.__boundThis : undefined;
+            const boundArgs = value.__boundArgs;
+            const payload = { stepId };
+            if (closureVars !== undefined)
+                payload.closureVars = closureVars;
+            if (hasBoundThis)
+                payload.boundThis = boundThis;
+            if (Array.isArray(boundArgs) && boundArgs.length > 0) {
+                payload.boundArgs = boundArgs;
+            }
+            return payload;
+        },
+    };
+}
+// ---- Reviver ----
+/**
+ * Create the StepFunction reviver for workflow context.
+ *
+ * The reviver calls WORKFLOW_USE_STEP to create the step proxy,
+ * restoring the ability to call the step from workflow code. If the
+ * serialized payload includes `boundThis` (and optionally `boundArgs`),
+ * the reviver also re-binds the freshly-created proxy so a step proxy
+ * that was constructed with `.bind(this, …)` in the workflow bundle
+ * continues to carry that receiver and any prefilled arguments after
+ * being deserialized in another bundle (e.g. when passed as a step
+ * argument).
+ */
+export function getStepFunctionReviver(global = globalThis) {
+    const useStep = global[Symbol.for('WORKFLOW_USE_STEP')];
+    return {
+        StepFunction: (value) => {
+            const stepId = value.stepId;
+            const closureVars = value.closureVars;
+            if (!useStep) {
+                throw new Error('WORKFLOW_USE_STEP not found on global object. Step functions cannot be deserialized outside workflow context.');
+            }
+            const proxy = closureVars
+                ? useStep(stepId, () => closureVars)
+                : useStep(stepId);
+            if ('boundThis' in value) {
+                const boundArgs = Array.isArray(value.boundArgs) ? value.boundArgs : [];
+                return proxy.bind(value.boundThis, ...boundArgs);
+            }
+            return proxy;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-function.js","sourceRoot":"","sources":["../../../src/serialization/reducers/step-function.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,oBAAoB;AAEpB,MAAM,UAAU,sBAAsB;IACpC,OAAO;QACL,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE;YACtB,IAAI,OAAO,KAAK,KAAK,UAAU;gBAAE,OAAO,KAAK,CAAC;YAC9C,MAAM,MAAM,GAAI,KAAa,CAAC,MAAM,CAAC;YACrC,IAAI,OAAO,MAAM,KAAK,QAAQ;gBAAE,OAAO,KAAK,CAAC;YAE7C,MAAM,aAAa,GAAI,KAAa,CAAC,eAAe,CAAC;YACrD,MAAM,WAAW,GACf,aAAa,IAAI,OAAO,aAAa,KAAK,UAAU;gBAClD,CAAC,CAAC,aAAa,EAAE;gBACjB,CAAC,CAAC,SAAS,CAAC;YAEhB,mEAAmE;YACnE,8DAA8D;YAC9D,2DAA2D;YAC3D,+DAA+D;YAC/D,8DAA8D;YAC9D,gEAAgE;YAChE,uBAAuB;YACvB,MAAM,YAAY,GAAG,aAAa,IAAK,KAAa,CAAC;YACrD,MAAM,SAAS,GAAG,YAAY,CAAC,CAAC,CAAE,KAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;YACxE,MAAM,SAAS,GAAI,KAAa,CAAC,WAAoC,CAAC;YAEtE,MAAM,OAAO,GAKT,EAAE,MAAM,EAAE,CAAC;YACf,IAAI,WAAW,KAAK,SAAS;gBAAE,OAAO,CAAC,WAAW,GAAG,WAAW,CAAC;YACjE,IAAI,YAAY;gBAAE,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;YAChD,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrD,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;YAChC,CAAC;YAED,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC;AAED,oBAAoB;AAEpB;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CACpC,SAA8B,UAAU;IAExC,MAAM,OAAO,GAAI,MAAc,CAAC,MAAM,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAKlD,CAAC;IAEd,OAAO;QACL,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE;YACtB,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;YAC5B,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;YAEtC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CACb,+GAA+G,CAChH,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,GAAG,WAAW;gBACvB,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC;gBACpC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAEpB,IAAI,WAAW,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;gBACxE,OAAQ,KAAa,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC,CAAC;YAC5D,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Reducer and reviver for step function references.\n *\n * In workflow mode, step functions are replaced by the SWC plugin with\n * proxies created by `globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"stepId\")`.\n * These proxies have a `.stepId` property and optionally a `.__closureVarsFn`\n * for captured closure variables. They may additionally have `.__boundThis`\n * (and rarely `.__boundArgs`) when the SWC plugin emitted\n * `useStep(...).bind(this)` for a nested arrow step that lexically\n * captured `this` (see `packages/swc-plugin-workflow/spec.md` → \"Lexical\n * `this` Capture in Nested Arrow Steps\").\n *\n * The reducer serializes them as\n *   `{ stepId, closureVars?, boundThis?, boundArgs? }`.\n * The reviver reconstructs them by calling WORKFLOW_USE_STEP and, when\n * `boundThis` (or `boundArgs`) is present, re-binding the resulting\n * proxy so the caller's captured `this` (and prefilled args) survive the\n * round trip.\n */\n\nimport type { Reducers, Revivers } from '../types.js';\n\n// ---- Reducer ----\n\nexport function getStepFunctionReducer(): Partial<Reducers> {\n  return {\n    StepFunction: (value) => {\n      if (typeof value !== 'function') return false;\n      const stepId = (value as any).stepId;\n      if (typeof stepId !== 'string') return false;\n\n      const closureVarsFn = (value as any).__closureVarsFn;\n      const closureVars =\n        closureVarsFn && typeof closureVarsFn === 'function'\n          ? closureVarsFn()\n          : undefined;\n\n      // `__boundThis` / `__boundArgs` are marker properties added by the\n      // step proxy's overridden `.bind` (see step.ts) to record the\n      // bound receiver and any prefilled arguments. Use `in` for\n      // `__boundThis` so we round-trip even when the bound `this` is\n      // `undefined`/`null`. `__boundArgs` is only set when the user\n      // actually supplied prefilled args, so a missing property means\n      // \"no prefilled args\".\n      const hasBoundThis = '__boundThis' in (value as any);\n      const boundThis = hasBoundThis ? (value as any).__boundThis : undefined;\n      const boundArgs = (value as any).__boundArgs as unknown[] | undefined;\n\n      const payload: {\n        stepId: string;\n        closureVars?: Record<string, any>;\n        boundThis?: unknown;\n        boundArgs?: unknown[];\n      } = { stepId };\n      if (closureVars !== undefined) payload.closureVars = closureVars;\n      if (hasBoundThis) payload.boundThis = boundThis;\n      if (Array.isArray(boundArgs) && boundArgs.length > 0) {\n        payload.boundArgs = boundArgs;\n      }\n\n      return payload;\n    },\n  };\n}\n\n// ---- Reviver ----\n\n/**\n * Create the StepFunction reviver for workflow context.\n *\n * The reviver calls WORKFLOW_USE_STEP to create the step proxy,\n * restoring the ability to call the step from workflow code. If the\n * serialized payload includes `boundThis` (and optionally `boundArgs`),\n * the reviver also re-binds the freshly-created proxy so a step proxy\n * that was constructed with `.bind(this, …)` in the workflow bundle\n * continues to carry that receiver and any prefilled arguments after\n * being deserialized in another bundle (e.g. when passed as a step\n * argument).\n */\nexport function getStepFunctionReviver(\n  global: Record<string, any> = globalThis\n): Partial<Revivers> {\n  const useStep = (global as any)[Symbol.for('WORKFLOW_USE_STEP')] as\n    | ((\n        stepId: string,\n        closureVarsFn?: () => Record<string, unknown>\n      ) => (...args: unknown[]) => Promise<unknown>)\n    | undefined;\n\n  return {\n    StepFunction: (value) => {\n      const stepId = value.stepId;\n      const closureVars = value.closureVars;\n\n      if (!useStep) {\n        throw new Error(\n          'WORKFLOW_USE_STEP not found on global object. Step functions cannot be deserialized outside workflow context.'\n        );\n      }\n\n      const proxy = closureVars\n        ? useStep(stepId, () => closureVars)\n        : useStep(stepId);\n\n      if ('boundThis' in value) {\n        const boundArgs = Array.isArray(value.boundArgs) ? value.boundArgs : [];\n        return (proxy as any).bind(value.boundThis, ...boundArgs);\n      }\n      return proxy;\n    },\n  };\n}\n"]}

package/dist/serialization/step.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Step mode serialization.
+ *
+ * Used by the step handler for serializing step return values and
+ * deserializing step arguments. Supports encryption as a composable layer.
+ */
+import type { CodecOptions } from './codec.js';
+import { type CryptoKey } from './encryption.js';
+/**
+ * Serialize a value from the step execution environment.
+ */
+export declare function serialize(value: unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<Uint8Array | unknown>;
+/**
+ * Deserialize a value for the step execution environment.
+ */
+export declare function deserialize(data: Uint8Array | unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<unknown>;
+//# sourceMappingURL=step.d.ts.map

package/dist/serialization/step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/serialization/step.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,EACL,KAAK,SAAS,EAGf,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAY/B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,OAAO,CAAC,CAmBlB"}