@workflow/core 5.0.0-beta.0 → 5.0.0-beta.10

package/dist/schemas.d.ts

@@ -11,5 +11,5 @@
  */
 export type Serializable = string | number | boolean | null | undefined | Serializable[] | {
     [key: string]: Serializable;
-} | ArrayBuffer | bigint | BigInt64Array | BigUint64Array | Date | DOMException | Float32Array | Float64Array | Headers | Int8Array | Int16Array | Int32Array | Map<Serializable, Serializable> | ReadableStream<Uint8Array> | RegExp | Response | Set<Serializable> | URL | URLSearchParams | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | WritableStream<Uint8Array> | ((...args: Serializable[]) => Promise<Serializable>);
+} | ArrayBuffer | bigint | BigInt64Array | BigUint64Array | Date | DOMException | Error | Float32Array | Float64Array | Headers | Int8Array | Int16Array | Int32Array | Map<Serializable, Serializable> | ReadableStream<Uint8Array> | RegExp | Response | Set<Serializable> | URL | URLSearchParams | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | WritableStream<Uint8Array> | AbortController | AbortSignal | ((...args: Serializable[]) => Promise<Serializable>);
 //# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,YAAY,GAEpB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,YAAY,EAAE,GACd;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,GAG/B,WAAW,GACX,MAAM,GACN,aAAa,GACb,cAAc,GACd,IAAI,GACJ,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,OAAO,GACP,SAAS,GACT,UAAU,GACV,UAAU,GACV,GAAG,CAAC,YAAY,EAAE,YAAY,CAAC,GAC/B,cAAc,CAAC,UAAU,CAAC,GAC1B,MAAM,GACN,QAAQ,GACR,GAAG,CAAC,YAAY,CAAC,GACjB,GAAG,GACH,eAAe,GACf,UAAU,GACV,iBAAiB,GACjB,WAAW,GACX,WAAW,GACX,cAAc,CAAC,UAAU,CAAC,GAC1B,CAAC,CAAC,GAAG,IAAI,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,YAAY,GAEpB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,YAAY,EAAE,GACd;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,GAG/B,WAAW,GACX,MAAM,GACN,aAAa,GACb,cAAc,GACd,IAAI,GACJ,YAAY,GACZ,KAAK,GACL,YAAY,GACZ,YAAY,GACZ,OAAO,GACP,SAAS,GACT,UAAU,GACV,UAAU,GACV,GAAG,CAAC,YAAY,EAAE,YAAY,CAAC,GAC/B,cAAc,CAAC,UAAU,CAAC,GAC1B,MAAM,GACN,QAAQ,GACR,GAAG,CAAC,YAAY,CAAC,GACjB,GAAG,GACH,eAAe,GACf,UAAU,GACV,iBAAiB,GACjB,WAAW,GACX,WAAW,GACX,cAAc,CAAC,UAAU,CAAC,GAC1B,eAAe,GACf,WAAW,GACX,CAAC,CAAC,GAAG,IAAI,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC"}

package/dist/schemas.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9zY2hlbWFzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9zY2hlbWFzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgc2VyaWFsaXphYmxlIHZhbHVlOlxuICogQW55IHZhbGlkIEpTT04gb2JqZWN0IGlzIHNlcmlhbGl6YWJsZVxuICpcbiAqIEBleGFtcGxlXG4gKlxuICogYGBgdHNcbiAqIC8vIGFueSB2YWxpZCBKU09OIG9iamVjdCBpcyBzZXJpYWxpemFibGVcbiAqIGNvbnN0IGFueUpzb246IFNlcmlhbGl6YWJsZSA9IHsgZm9vOiBcImJhclwiIH07XG4gKiBgYGBcbiAqL1xuZXhwb3J0IHR5cGUgU2VyaWFsaXphYmxlID1cbiAgLy8gU3RhbmRhcmQgSlNPTiB0eXBlc1xuICB8IHN0cmluZ1xuICB8IG51bWJlclxuICB8IGJvb2xlYW5cbiAgfCBudWxsXG4gIHwgdW5kZWZpbmVkXG4gIHwgU2VyaWFsaXphYmxlW11cbiAgfCB7IFtrZXk6IHN0cmluZ106IFNlcmlhbGl6YWJsZSB9XG4gIC8vIFNwZWNpYWwgdHlwZXMgdGhhdCBuZWVkIHNwZWNpYWwgaGFuZGxpbmcgd2hlblxuICAvLyBzZXJpYWxpemVkL2Rlc2VyaWFsaXplZCAoc2VlIGBzZXJpYWxpemF0aW9uLnRzYClcbiAgfCBBcnJheUJ1ZmZlclxuICB8IGJpZ2ludFxuICB8IEJpZ0ludDY0QXJyYXlcbiAgfCBCaWdVaW50NjRBcnJheVxuICB8IERhdGVcbiAgfCBET01FeGNlcHRpb25cbiAgfCBFcnJvclxuICB8IEZsb2F0MzJBcnJheVxuICB8IEZsb2F0NjRBcnJheVxuICB8IEhlYWRlcnNcbiAgfCBJbnQ4QXJyYXlcbiAgfCBJbnQxNkFycmF5XG4gIHwgSW50MzJBcnJheVxuICB8IE1hcDxTZXJpYWxpemFibGUsIFNlcmlhbGl6YWJsZT5cbiAgfCBSZWFkYWJsZVN0cmVhbTxVaW50OEFycmF5PlxuICB8IFJlZ0V4cFxuICB8IFJlc3BvbnNlXG4gIHwgU2V0PFNlcmlhbGl6YWJsZT5cbiAgfCBVUkxcbiAgfCBVUkxTZWFyY2hQYXJhbXNcbiAgfCBVaW50OEFycmF5XG4gIHwgVWludDhDbGFtcGVkQXJyYXlcbiAgfCBVaW50MTZBcnJheVxuICB8IFVpbnQzMkFycmF5XG4gIHwgV3JpdGFibGVTdHJlYW08VWludDhBcnJheT5cbiAgfCBBYm9ydENvbnRyb2xsZXJcbiAgfCBBYm9ydFNpZ25hbFxuICB8ICgoLi4uYXJnczogU2VyaWFsaXphYmxlW10pID0+IFByb21pc2U8U2VyaWFsaXphYmxlPik7IC8vIFN0ZXAgZnVuY3Rpb25cbiJdfQ==

package/dist/serialization/client.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Client (external) mode serialization.
+ *
+ * Used when starting workflows from the client side (serializing workflow
+ * arguments) and when receiving workflow return values. Supports encryption.
+ */
+import type { CodecOptions } from './codec.js';
+import { type CryptoKey } from './encryption.js';
+/**
+ * Serialize a value from the client environment (e.g. workflow arguments).
+ */
+export declare function serialize(value: unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<Uint8Array | unknown>;
+/**
+ * Deserialize a value for the client environment (e.g. workflow return value).
+ */
+export declare function deserialize(data: Uint8Array | unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<unknown>;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/serialization/client.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,CAa/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"}

package/dist/serialization/client.js

@@ -0,0 +1,45 @@
+/**
+ * Client (external) mode serialization.
+ *
+ * Used when starting workflows from the client side (serializing workflow
+ * arguments) and when receiving workflow return values. Supports encryption.
+ */
+import { SerializationError } from '@workflow/errors';
+import { devalueCodec } from './codec-devalue.js';
+import { decrypt as decryptData, encrypt as encryptData, } from './encryption.js';
+import { formatSerializationError, rethrowIfRuntimeError } from './errors.js';
+import { decodeFormatPrefix, encodeWithFormatPrefix } from './format.js';
+import { SerializationFormat } from './types.js';
+/**
+ * Serialize a value from the client environment (e.g. workflow arguments).
+ */
+export async function serialize(value, encryptionKey, options) {
+    try {
+        const payload = devalueCodec.serialize(value, 'client', options);
+        const prefixed = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
+        return encryptData(prefixed, encryptionKey);
+    }
+    catch (error) {
+        rethrowIfRuntimeError(error);
+        const { message, hint } = formatSerializationError('client value', error);
+        throw new SerializationError(message, { hint, cause: error });
+    }
+}
+/**
+ * Deserialize a value for the client environment (e.g. workflow return value).
+ */
+export async function deserialize(data, encryptionKey, options) {
+    const decrypted = await decryptData(data, encryptionKey);
+    if (!(decrypted instanceof Uint8Array)) {
+        if (devalueCodec.deserializeLegacy) {
+            return devalueCodec.deserializeLegacy(decrypted, 'client', options);
+        }
+        throw new Error('Cannot deserialize non-binary data without legacy support');
+    }
+    const { format, payload } = decodeFormatPrefix(decrypted);
+    if (format === SerializationFormat.DEVALUE_V1) {
+        return devalueCodec.deserialize(payload, 'client', options);
+    }
+    throw new Error(`Unsupported serialization format: ${format}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/codec-devalue.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Devalue codec implementation.
+ *
+ * Uses the `devalue` library for serialization. Handles custom types via
+ * reducers (serialize) and revivers (deserialize) which are composed
+ * internally based on the serialization mode.
+ *
+ * The reducer/reviver pattern is specific to devalue — other codecs
+ * (CBOR, JSON) would handle types differently (e.g. CBOR supports Date,
+ * typed arrays, Map, Set natively).
+ */
+import type { Codec } from './codec.js';
+export declare const devalueCodec: Codec;
+//# sourceMappingURL=codec-devalue.d.ts.map

package/dist/serialization/codec-devalue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-devalue.d.ts","sourceRoot":"","sources":["../../src/serialization/codec-devalue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAmC,MAAM,YAAY,CAAC;AAwFzE,eAAO,MAAM,YAAY,EAAE,KA2C1B,CAAC"}

package/dist/serialization/codec-devalue.js

@@ -0,0 +1,98 @@
+/**
+ * Devalue codec implementation.
+ *
+ * Uses the `devalue` library for serialization. Handles custom types via
+ * reducers (serialize) and revivers (deserialize) which are composed
+ * internally based on the serialization mode.
+ *
+ * The reducer/reviver pattern is specific to devalue — other codecs
+ * (CBOR, JSON) would handle types differently (e.g. CBOR supports Date,
+ * typed arrays, Map, Set natively).
+ */
+import { parse, stringify, unflatten } from 'devalue';
+import { getClassReducers, getClassRevivers } from './reducers/class.js';
+import { getCommonReducers, getCommonRevivers } from './reducers/common.js';
+import { getStepFunctionReducer, getStepFunctionReviver, } from './reducers/step-function.js';
+import { SerializationFormat } from './types.js';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+// ---- Reducer/Reviver composition per mode ----
+function getReducersForMode(mode, global = globalThis, extraReducers) {
+    let base;
+    switch (mode) {
+        case 'workflow':
+            // Class/Instance MUST come before common (first-match-wins for Error subclasses)
+            base = {
+                ...getClassReducers(),
+                ...getStepFunctionReducer(),
+                ...getCommonReducers(global),
+            };
+            break;
+        case 'step':
+            base = {
+                ...getClassReducers(),
+                ...getCommonReducers(global),
+            };
+            break;
+        case 'client':
+            base = {
+                ...getClassReducers(),
+                ...getCommonReducers(global),
+            };
+            break;
+    }
+    if (extraReducers) {
+        return { ...base, ...extraReducers };
+    }
+    return base;
+}
+function getReviversForMode(mode, global = globalThis, extraRevivers) {
+    let base;
+    switch (mode) {
+        case 'workflow':
+            base = {
+                ...getClassRevivers(global),
+                ...getStepFunctionReviver(global),
+                ...getCommonRevivers(global),
+            };
+            break;
+        case 'step':
+            base = {
+                ...getClassRevivers(global),
+                ...getCommonRevivers(global),
+            };
+            break;
+        case 'client':
+            base = {
+                ...getClassRevivers(global),
+                ...getCommonRevivers(global),
+                StepFunction: () => {
+                    throw new Error('Step functions cannot be deserialized in client context.');
+                },
+            };
+            break;
+    }
+    if (extraRevivers) {
+        return { ...base, ...extraRevivers };
+    }
+    return base;
+}
+// ---- Codec implementation ----
+export const devalueCodec = {
+    formatPrefix: SerializationFormat.DEVALUE_V1,
+    serialize(value, mode, options) {
+        const reducers = getReducersForMode(mode, options?.global, options?.extraReducers);
+        const str = stringify(value, reducers);
+        return encoder.encode(str);
+    },
+    deserialize(data, mode, options) {
+        const revivers = getReviversForMode(mode, options?.global, options?.extraRevivers);
+        const str = decoder.decode(data);
+        return parse(str, revivers);
+    },
+    deserializeLegacy(data, mode, options) {
+        const revivers = getReviversForMode(mode, options?.global, options?.extraRevivers);
+        return unflatten(data, revivers);
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codec-devalue.js","sourceRoot":"","sources":["../../src/serialization/codec-devalue.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Devalue codec implementation.\n *\n * Uses the `devalue` library for serialization. Handles custom types via\n * reducers (serialize) and revivers (deserialize) which are composed\n * internally based on the serialization mode.\n *\n * The reducer/reviver pattern is specific to devalue — other codecs\n * (CBOR, JSON) would handle types differently (e.g. CBOR supports Date,\n * typed arrays, Map, Set natively).\n */\n\nimport { parse, stringify, unflatten } from 'devalue';\nimport type { Codec, CodecOptions, SerializationMode } from './codec.js';\nimport { getClassReducers, getClassRevivers } from './reducers/class.js';\nimport { getCommonReducers, getCommonRevivers } from './reducers/common.js';\nimport {\n  getStepFunctionReducer,\n  getStepFunctionReviver,\n} from './reducers/step-function.js';\nimport { type Reducers, type Revivers, SerializationFormat } from './types.js';\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\n// ---- Reducer/Reviver composition per mode ----\n\nfunction getReducersForMode(\n  mode: SerializationMode,\n  global: Record<string, any> = globalThis,\n  extraReducers?: Record<string, (value: any) => any>\n): Record<string, (value: any) => any> {\n  let base: Partial<Reducers>;\n  switch (mode) {\n    case 'workflow':\n      // Class/Instance MUST come before common (first-match-wins for Error subclasses)\n      base = {\n        ...getClassReducers(),\n        ...getStepFunctionReducer(),\n        ...getCommonReducers(global),\n      };\n      break;\n    case 'step':\n      base = {\n        ...getClassReducers(),\n        ...getCommonReducers(global),\n      };\n      break;\n    case 'client':\n      base = {\n        ...getClassReducers(),\n        ...getCommonReducers(global),\n      };\n      break;\n  }\n  if (extraReducers) {\n    return { ...base, ...extraReducers } as Record<string, (value: any) => any>;\n  }\n  return base as Record<string, (value: any) => any>;\n}\n\nfunction getReviversForMode(\n  mode: SerializationMode,\n  global: Record<string, any> = globalThis,\n  extraRevivers?: Record<string, (value: any) => any>\n): Record<string, (value: any) => any> {\n  let base: Partial<Revivers>;\n  switch (mode) {\n    case 'workflow':\n      base = {\n        ...getClassRevivers(global),\n        ...getStepFunctionReviver(global),\n        ...getCommonRevivers(global),\n      };\n      break;\n    case 'step':\n      base = {\n        ...getClassRevivers(global),\n        ...getCommonRevivers(global),\n      };\n      break;\n    case 'client':\n      base = {\n        ...getClassRevivers(global),\n        ...getCommonRevivers(global),\n        StepFunction: () => {\n          throw new Error(\n            'Step functions cannot be deserialized in client context.'\n          );\n        },\n      };\n      break;\n  }\n  if (extraRevivers) {\n    return { ...base, ...extraRevivers } as Record<string, (value: any) => any>;\n  }\n  return base as Record<string, (value: any) => any>;\n}\n\n// ---- Codec implementation ----\n\nexport const devalueCodec: Codec = {\n  formatPrefix: SerializationFormat.DEVALUE_V1,\n\n  serialize(\n    value: unknown,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): Uint8Array {\n    const reducers = getReducersForMode(\n      mode,\n      options?.global,\n      options?.extraReducers\n    );\n    const str = stringify(value, reducers);\n    return encoder.encode(str);\n  },\n\n  deserialize(\n    data: Uint8Array,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): unknown {\n    const revivers = getReviversForMode(\n      mode,\n      options?.global,\n      options?.extraRevivers\n    );\n    const str = decoder.decode(data);\n    return parse(str, revivers);\n  },\n\n  deserializeLegacy(\n    data: unknown,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): unknown {\n    const revivers = getReviversForMode(\n      mode,\n      options?.global,\n      options?.extraRevivers\n    );\n    return unflatten(data as any[], revivers);\n  },\n};\n"]}

package/dist/serialization/codec.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Codec interface for serialization formats.
+ *
+ * A codec handles the core serialize/deserialize logic for a specific
+ * wire format (devalue, CBOR, JSON, etc.). Each codec is responsible
+ * for handling all supported data types internally — the caller only
+ * specifies which serialization mode to use.
+ *
+ * - **devalue**: Uses custom reducers/revivers for Date, Error, Map, Set,
+ *   typed arrays, class instances, etc.
+ * - **cbor**: Would handle Date, typed arrays, Map, Set natively via the
+ *   CBOR type system. Class instances would still need custom handling.
+ * - **json**: Would only support standard JSON types (primitives, arrays,
+ *   plain objects). No Date, Map, Set, typed arrays, etc.
+ */
+import type { FormatPrefix } from './types.js';
+/**
+ * The serialization mode determines which types are supported and how
+ * they're handled. Different modes compose different sets of type handlers.
+ *
+ * - `workflow`: Runs inside the workflow VM. Includes class serialization,
+ *   step function serialization. No stream handling.
+ * - `step`: Runs in the step handler (Node.js). Includes class serialization.
+ *   No step function serialization. Stream handling at call sites.
+ * - `client`: Runs on the client side. Includes class serialization.
+ *   No step function serialization. Stream handling at call sites.
+ */
+export type SerializationMode = 'workflow' | 'step' | 'client';
+/**
+ * Options passed to codec serialize/deserialize to support VM-context
+ * serialization and mode-specific type handling.
+ */
+export interface CodecOptions {
+    /**
+     * The global object to use for `instanceof` checks and constructors.
+     * Defaults to `globalThis`. Must be set to the VM's global when
+     * serializing/deserializing data that crosses VM boundaries.
+     */
+    global?: Record<string, any>;
+    /**
+     * Additional reducers to merge into the mode's default reducers.
+     * Used by dehydrate/hydrate functions that need stream handling
+     * or other mode-specific type reducers.
+     */
+    extraReducers?: Record<string, (value: any) => any>;
+    /**
+     * Additional revivers to merge into the mode's default revivers.
+     * Used by dehydrate/hydrate functions that need stream handling
+     * or other mode-specific type revivers.
+     */
+    extraRevivers?: Record<string, (value: any) => any>;
+}
+export interface Codec {
+    /** The 4-character format prefix identifier (e.g. "devl", "cbor", "json") */
+    readonly formatPrefix: FormatPrefix;
+    /**
+     * Serialize a value to bytes.
+     *
+     * The codec handles all supported types internally based on the mode.
+     *
+     * @param value - The value to serialize
+     * @param mode - The serialization mode
+     * @param options - Optional global, extra reducers/revivers
+     * @returns The serialized payload (without format prefix)
+     */
+    serialize(value: unknown, mode: SerializationMode, options?: CodecOptions): Uint8Array;
+    /**
+     * Deserialize bytes back to a value.
+     *
+     * The codec handles all supported types internally based on the mode.
+     *
+     * @param data - The serialized payload (without format prefix)
+     * @param mode - The serialization mode
+     * @param options - Optional global, extra revivers
+     * @returns The deserialized value
+     */
+    deserialize(data: Uint8Array, mode: SerializationMode, options?: CodecOptions): unknown;
+    /**
+     * Deserialize legacy (pre-format-prefix) data.
+     * Used for backwards compatibility with specVersion 1 runs that stored
+     * data as plain JSON arrays instead of binary.
+     *
+     * @param data - The legacy data
+     * @param mode - The serialization mode
+     * @param options - Optional global, extra revivers
+     * @returns The deserialized value
+     */
+    deserializeLegacy?(data: unknown, mode: SerializationMode, options?: CodecOptions): unknown;
+}
+//# sourceMappingURL=codec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/serialization/codec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE/D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE7B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAEpD;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,KAAK;IACpB,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IAEpC;;;;;;;;;OASG;IACH,SAAS,CACP,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAAC;IAEd;;;;;;;;;OASG;IACH,WAAW,CACT,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;IAEX;;;;;;;;;OASG;IACH,iBAAiB,CAAC,CAChB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;CACZ"}

package/dist/serialization/codec.js

@@ -0,0 +1,17 @@
+/**
+ * Codec interface for serialization formats.
+ *
+ * A codec handles the core serialize/deserialize logic for a specific
+ * wire format (devalue, CBOR, JSON, etc.). Each codec is responsible
+ * for handling all supported data types internally — the caller only
+ * specifies which serialization mode to use.
+ *
+ * - **devalue**: Uses custom reducers/revivers for Date, Error, Map, Set,
+ *   typed arrays, class instances, etc.
+ * - **cbor**: Would handle Date, typed arrays, Map, Set natively via the
+ *   CBOR type system. Class instances would still need custom handling.
+ * - **json**: Would only support standard JSON types (primitives, arrays,
+ *   plain objects). No Date, Map, Set, typed arrays, etc.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/encryption.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Composable encryption layer for serialized data.
+ *
+ * Wraps/unwraps serialized payloads with AES-256-GCM encryption,
+ * using the format prefix system to mark encrypted data.
+ */
+import { type CryptoKey } from '../encryption.js';
+export type { CryptoKey };
+/**
+ * Encryption key parameter type. Accepts a resolved key, undefined (no encryption),
+ * or a promise that resolves to either.
+ */
+export type EncryptionKeyParam = CryptoKey | undefined | Promise<CryptoKey | undefined>;
+/**
+ * Encrypt a format-prefixed payload if a key is provided.
+ * Wraps the data with the 'encr' format prefix.
+ *
+ * @param data - The format-prefixed serialized data
+ * @param key - Encryption key (undefined to skip encryption)
+ * @returns The encrypted data with 'encr' prefix, or the original data if no key
+ */
+export declare function encrypt(data: Uint8Array | unknown, key: CryptoKey | undefined): Promise<Uint8Array | unknown>;
+/**
+ * Decrypt a format-prefixed payload if it's encrypted.
+ * Strips the 'encr' format prefix and decrypts the inner payload.
+ *
+ * @param data - The potentially encrypted data
+ * @param key - Encryption key (undefined to skip decryption)
+ * @returns The decrypted inner payload, or the original data if not encrypted
+ */
+export declare function decrypt(data: Uint8Array | unknown, key: CryptoKey | undefined): Promise<Uint8Array | unknown>;
+//# sourceMappingURL=encryption.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../src/serialization/encryption.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAQ1B,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAC1B,SAAS,GACT,SAAS,GACT,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;AAEnC;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,GAAG,EAAE,SAAS,GAAG,SAAS,GACzB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAI/B;AAED;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,GAAG,EAAE,SAAS,GAAG,SAAS,GACzB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAqC/B"}

package/dist/serialization/encryption.js

@@ -0,0 +1,67 @@
+/**
+ * Composable encryption layer for serialized data.
+ *
+ * Wraps/unwraps serialized payloads with AES-256-GCM encryption,
+ * using the format prefix system to mark encrypted data.
+ */
+import { RuntimeDecryptionError } from '@workflow/errors';
+import { decrypt as aesGcmDecrypt, encrypt as aesGcmEncrypt, } from '../encryption.js';
+import { decodeFormatPrefix, encodeWithFormatPrefix, peekFormatPrefix, } from './format.js';
+import { SerializationFormat } from './types.js';
+/**
+ * Encrypt a format-prefixed payload if a key is provided.
+ * Wraps the data with the 'encr' format prefix.
+ *
+ * @param data - The format-prefixed serialized data
+ * @param key - Encryption key (undefined to skip encryption)
+ * @returns The encrypted data with 'encr' prefix, or the original data if no key
+ */
+export async function encrypt(data, key) {
+    if (!key || !(data instanceof Uint8Array))
+        return data;
+    const encrypted = await aesGcmEncrypt(key, data);
+    return encodeWithFormatPrefix(SerializationFormat.ENCRYPTED, encrypted);
+}
+/**
+ * Decrypt a format-prefixed payload if it's encrypted.
+ * Strips the 'encr' format prefix and decrypts the inner payload.
+ *
+ * @param data - The potentially encrypted data
+ * @param key - Encryption key (undefined to skip decryption)
+ * @returns The decrypted inner payload, or the original data if not encrypted
+ */
+export async function decrypt(data, key) {
+    // Non-binary data is returned as-is.
+    if (!(data instanceof Uint8Array))
+        return data;
+    const format = peekFormatPrefix(data);
+    // If the data is encrypted but no key was provided, fail fast.
+    if (format === SerializationFormat.ENCRYPTED && !key) {
+        throw new RuntimeDecryptionError('Encrypted data encountered but no encryption key is available. ' +
+            'Encryption is not configured or no key was provided for this run.', {
+            context: {
+                operation: 'decrypt',
+                byteLength: data.byteLength,
+                formatPrefix: 'encr',
+            },
+        });
+    }
+    // If the data is not encrypted, return it unchanged.
+    if (format !== SerializationFormat.ENCRYPTED)
+        return data;
+    const { payload } = decodeFormatPrefix(data);
+    try {
+        return await aesGcmDecrypt(key, payload);
+    }
+    catch (error) {
+        // The low-level AES layer only sees the stripped payload, so it cannot
+        // record the outer envelope prefix. This layer peeked it (`encr`), so
+        // enrich the diagnostic context with the real format prefix before
+        // rethrowing.
+        if (RuntimeDecryptionError.is(error) && error.context) {
+            error.context.formatPrefix = format;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/errors.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared error formatting utility for serialization failures.
+ *
+ * Used by the mode-specific serializers (workflow, step, client) to
+ * produce consistent error messages with devalue path information.
+ *
+ * Returns a `{ message, hint }` pair so callers can throw a
+ * `SerializationError(message, { hint, cause })` and have the hint flow
+ * through the standard friendly-errors framing instead of being baked
+ * into the message string.
+ */
+/**
+ * Rethrow SDK runtime errors that must not be reframed as
+ * `SerializationError`.
+ *
+ * The serialize/dehydrate wrappers catch every throw and reframe it as a
+ * `SerializationError` (which classifies as `USER_ERROR`). That's correct
+ * for genuine serialization failures, but a `RuntimeDecryptionError` from
+ * the AES-GCM layer is an SDK-internal failure that must keep its identity
+ * so the run-failure classifier routes it to `RUNTIME_ERROR`. Call this at
+ * the top of each serialize catch block to let those errors propagate
+ * unchanged.
+ */
+export declare function rethrowIfRuntimeError(error: unknown): void;
+/**
+ * Format a serialization error with context about what failed.
+ * Extracts path, value, and reason from devalue's DevalueError when available.
+ * Logs the problematic value to the console for better debugging.
+ */
+export declare function formatSerializationError(context: string, error: unknown): {
+    message: string;
+    hint: string;
+};
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/serialization/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAI1D;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,OAAO,GACb;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAqBnC"}

package/dist/serialization/errors.js

@@ -0,0 +1,59 @@
+/**
+ * Shared error formatting utility for serialization failures.
+ *
+ * Used by the mode-specific serializers (workflow, step, client) to
+ * produce consistent error messages with devalue path information.
+ *
+ * Returns a `{ message, hint }` pair so callers can throw a
+ * `SerializationError(message, { hint, cause })` and have the hint flow
+ * through the standard friendly-errors framing instead of being baked
+ * into the message string.
+ */
+import { RuntimeDecryptionError } from '@workflow/errors';
+import { DevalueError } from 'devalue';
+import { runtimeLogger } from '../logger.js';
+/**
+ * Rethrow SDK runtime errors that must not be reframed as
+ * `SerializationError`.
+ *
+ * The serialize/dehydrate wrappers catch every throw and reframe it as a
+ * `SerializationError` (which classifies as `USER_ERROR`). That's correct
+ * for genuine serialization failures, but a `RuntimeDecryptionError` from
+ * the AES-GCM layer is an SDK-internal failure that must keep its identity
+ * so the run-failure classifier routes it to `RUNTIME_ERROR`. Call this at
+ * the top of each serialize catch block to let those errors propagate
+ * unchanged.
+ */
+export function rethrowIfRuntimeError(error) {
+    if (RuntimeDecryptionError.is(error)) {
+        throw error;
+    }
+}
+/**
+ * Format a serialization error with context about what failed.
+ * Extracts path, value, and reason from devalue's DevalueError when available.
+ * Logs the problematic value to the console for better debugging.
+ */
+export function formatSerializationError(context, error) {
+    // `returning` for outputs, `passing` for everything that crosses the
+    // boundary the other way (arguments, stream messages, etc.).
+    const verb = context.includes('return value') ? 'returning' : 'passing';
+    let message = `Failed to serialize ${context}`;
+    if (error instanceof DevalueError && error.path) {
+        message += ` at path "${error.path}"`;
+    }
+    // Workflow can serialize a much richer set than the devalue defaults —
+    // classes registered via `WORKFLOW_SERIALIZE`, FatalError / RetryableError
+    // subclasses, AbortSignal, etc. Pointing at the foundations doc keeps
+    // this hint accurate as the supported set grows, instead of repeating
+    // a hardcoded list that drifts out of sync.
+    const hint = `Ensure you're ${verb} workflow serializable types. Check the serialization docs to see what's serializable: https://workflow-sdk.dev/docs/foundations/serialization`;
+    if (error instanceof DevalueError && error.value !== undefined) {
+        runtimeLogger.error('Serialization failed', {
+            context,
+            problematicValue: error.value,
+        });
+    }
+    return { message, hint };
+}
+//# sourceMappingURL=data:application/json;base64,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