@workflow/core 5.0.0-beta.36 → 5.0.0-beta.37

package/dist/serialization/client.d.ts

@@ -5,13 +5,13 @@
  * arguments) and when receiving workflow return values. Supports encryption.
  */
 import type { CodecOptions } from './codec.js';
-import { type CryptoKey } from './encryption.js';
+import { type PayloadKey } 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>;
+export declare function serialize(value: unknown, encryptionKey?: PayloadKey, 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>;
+export declare function deserialize(data: Uint8Array | unknown, encryptionKey?: PayloadKey, options?: CodecOptions): Promise<unknown>;
 //# sourceMappingURL=client.d.ts.map

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

@@ -1 +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;AAG/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,CAmB/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,CAsBlB"}
+{"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;AAG/C,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,UAAU,EAC1B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAmB/B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,aAAa,CAAC,EAAE,UAAU,EAC1B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,OAAO,CAAC,CAsBlB"}

package/dist/serialization/client.js

@@ -45,4 +45,4 @@ export async function deserialize(data, encryptionKey, options) {
     }
     throw new Error(`Unsupported serialization format: ${format}`);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/codec.d.ts

@@ -21,7 +21,7 @@ import type { FormatPrefix } from './types.js';
  *
  * - `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.
+ * - `step`: Runs in the step executor (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.
@@ -51,9 +51,11 @@ export interface CodecOptions {
      */
     extraRevivers?: Record<string, (value: any) => any>;
     /**
-     * Whether to gzip-compress the serialized payload (write side only;
-     * reads always handle both compressed and uncompressed data). Must
-     * only be enabled when the target run supports compressed payloads:
+     * Whether to compress the serialized payload (write side only; zstd is
+     * preferred and gzip is the portable fallback). Reads dispatch compressed
+     * payloads by format prefix; zstd decoding still requires runtime or
+     * registered decoder support. Must only be enabled when the target run
+     * supports compressed payloads:
      * run specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION, and for
      * cross-deployment writes the target deployment's capabilities (see
      * `getRunCapabilities` in capabilities.ts). Defaults to `false`.

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

@@ -1 +1 @@
-{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/serialization/codec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,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;IAEpD;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC;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"}
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/serialization/codec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,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;IAEpD;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC;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

@@ -14,4 +14,4 @@
  *   plain objects). No Date, Map, Set, typed arrays, etc.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/encryption.d.ts

@@ -1,33 +1,134 @@
 /**
  * Composable encryption layer for serialized data.
  *
- * Wraps/unwraps serialized payloads with AES-256-GCM encryption,
- * using the format prefix system to mark encrypted data.
+ * Wraps/unwraps serialized payloads with either symmetric AES-256-GCM
+ * encryption (`encr`) or an asymmetric sealed box (`encp`), using the format
+ * prefix system to mark which. See {@link PayloadKey} for how a caller
+ * declares which capabilities it holds.
  */
 import { type CryptoKey } from '../encryption.js';
-export type { CryptoKey };
+import { type RunKeyPair } from '../sealed-box.js';
+export type { CryptoKey, RunKeyPair };
+/**
+ * Brands distinguishing the structured key variants from a bare `CryptoKey`.
+ *
+ * `Symbol.for` rather than `Symbol()` because these values cross realm
+ * boundaries (host ↔ workflow VM), and the global symbol registry is shared
+ * across realms while unique symbols are not.
+ */
+declare const SEAL_TARGET_BRAND: unique symbol;
+declare const RUN_KEYS_BRAND: unique symbol;
+/**
+ * A write-only capability: seal payloads to a run's X25519 public key.
+ *
+ * This is what a *cross-run* writer holds — a hook resumption targeting
+ * another run, or a child workflow writing into a parent's forwarded stream.
+ * It carries no ability to decrypt anything, and because it is a distinct
+ * nominal type it cannot be mistaken for symmetric key material.
+ *
+ * That last property matters more than it looks: a raw 32-byte X25519 public
+ * key is a *structurally valid* AES-256 key, so handing one to
+ * `importKey(..., 'AES-GCM')` succeeds and silently produces ciphertext that
+ * nobody can ever open. Routing public keys exclusively through
+ * {@link sealTo} makes that mistake unrepresentable rather than merely
+ * discouraged.
+ */
+export interface SealTarget {
+    readonly [SEAL_TARGET_BRAND]: true;
+    /** The recipient run's raw 32-byte X25519 public key. */
+    readonly recipientPublicKey: Uint8Array;
+    /** Additional authenticated data binding the payload to the recipient run. */
+    readonly aad?: Uint8Array;
+}
+/**
+ * The full key capability of a run's *own* runtime (and of o11y tooling
+ * acting on its behalf): the symmetric key for its own payloads, plus the
+ * keypair needed to open sealed payloads that other runs wrote to it.
+ */
+export interface RunPayloadKeys {
+    readonly [RUN_KEYS_BRAND]: true;
+    /** Symmetric AES-256-GCM key — the run's own `encr` payloads. */
+    readonly aes: CryptoKey;
+    /** X25519 keypair — opens `encp` payloads sealed to this run. */
+    readonly keyPair: RunKeyPair;
+    /** Additional authenticated data expected on sealed payloads. */
+    readonly aad?: Uint8Array;
+}
+/**
+ * A resolved key for reading or writing a serialized payload.
+ *
+ * The bare `CryptoKey` variant is the historical shape and remains valid: it
+ * means "symmetric only", which is exactly right for a run that predates
+ * sealed boxes or for any same-run payload. The structured variants are
+ * additive:
+ *
+ * | Variant            | Writes  | Reads          | Held by                  |
+ * | ------------------ | ------- | -------------- | ------------------------ |
+ * | `CryptoKey`        | `encr`  | `encr`         | same-run (legacy shape)  |
+ * | {@link RunPayloadKeys} | `encr`  | `encr`, `encp` | the owning run, o11y     |
+ * | {@link SealTarget} | `encp`  | —              | cross-run writers        |
+ *
+ * A run's own payloads deliberately stay symmetric even when the writer could
+ * seal: sealing costs a fresh ECDH per envelope and 32 extra bytes, and buys
+ * nothing when the writer already holds the decryption key.
+ */
+export type PayloadKey = CryptoKey | SealTarget | RunPayloadKeys;
+/**
+ * The subset of {@link PayloadKey} that can actually *read* a payload.
+ *
+ * Excludes {@link SealTarget}, which is write-only by construction: it holds a
+ * public key, so it can open neither `encp` (needs the private scalar) nor
+ * `encr` (needs the symmetric key). Decrypt-side signatures should take this
+ * rather than `PayloadKey`, so passing a seal target is a compile error instead
+ * of a guaranteed runtime failure.
+ */
+export type DecryptionKey = CryptoKey | RunPayloadKeys;
+/**
+ * Build a write-only seal capability for a recipient run's public key.
+ *
+ * @param recipientPublicKey - The recipient run's raw 32-byte X25519 public key
+ * @param aad - Additional authenticated data, conventionally `runAad(projectId, runId)`
+ */
+export declare function sealTo(recipientPublicKey: Uint8Array, aad?: Uint8Array): SealTarget;
+/**
+ * Bundle a run's symmetric key with the keypair that opens payloads sealed
+ * to it.
+ */
+export declare function runPayloadKeys(aes: CryptoKey, keyPair: RunKeyPair, aad?: Uint8Array): RunPayloadKeys;
+/**
+ * Build the full key capability for a run from its raw 32-byte key material —
+ * the value `World.getEncryptionKeyForRun()` returns.
+ *
+ * Use this anywhere a run reads its own event log: it yields a key that opens
+ * both its own symmetric (`encr`) payloads and sealed (`encp`) payloads other
+ * runs wrote to it. Resolving only `importKey(material)` would leave the
+ * reader unable to open sealed writes.
+ */
+export declare function deriveRunPayloadKeys(runKeyMaterial: Uint8Array): Promise<RunPayloadKeys>;
+export declare function isSealTarget(value: unknown): value is SealTarget;
+export declare function isRunPayloadKeys(value: unknown): value is RunPayloadKeys;
+/**
+ * The symmetric key to use for `encr` operations, or undefined when this key
+ * has no symmetric capability (i.e. it is a seal-only target).
+ */
+export declare function aesKeyOf(key: PayloadKey | undefined): CryptoKey | undefined;
 /**
  * Encryption key parameter type. Accepts a resolved key, undefined (no encryption),
  * a promise, or a resolver that can defer fetching the key until data needs it.
  */
-export type EncryptionKeyParam = CryptoKey | undefined | Promise<CryptoKey | undefined> | (() => Promise<CryptoKey | undefined>);
-export declare function resolveEncryptionKey(key: EncryptionKeyParam): Promise<CryptoKey | undefined>;
+export type EncryptionKeyParam = PayloadKey | undefined | Promise<PayloadKey | undefined> | (() => Promise<PayloadKey | undefined>);
+export declare function resolveEncryptionKey(key: EncryptionKeyParam): Promise<PayloadKey | undefined>;
 /**
  * Encrypt a format-prefixed payload if a key is provided.
- * Wraps the data with the 'encr' format prefix.
+ *
+ * Wraps the data with the `encr` prefix for symmetric keys, or the `encp`
+ * prefix when handed a {@link SealTarget} — a cross-run writer that holds only
+ * the recipient's public key.
  *
  * @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
+ * @returns The encrypted data with its format prefix, or the original data if no key
  */
-export declare function decrypt(data: Uint8Array | unknown, key: CryptoKey | undefined): Promise<Uint8Array | unknown>;
+export declare function encrypt(data: Uint8Array | unknown, key: PayloadKey | undefined): Promise<Uint8Array | unknown>;
+export declare function decrypt(data: Uint8Array | unknown, key: PayloadKey | undefined): Promise<Uint8Array | unknown>;
 //# sourceMappingURL=encryption.d.ts.map

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

@@ -1 +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,GAC9B,CAAC,MAAM,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC;AAE3C,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,kBAAkB,GACtB,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAEhC;AAED;;;;;;;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"}
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../src/serialization/encryption.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAGL,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAGL,KAAK,UAAU,EAEhB,MAAM,kBAAkB,CAAC;AAQ1B,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAEtC;;;;;;GAMG;AACH,QAAA,MAAM,iBAAiB,eAAkD,CAAC;AAC1E,QAAA,MAAM,cAAc,eAA+C,CAAC;AAEpE;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAC;IACnC,yDAAyD;IACzD,QAAQ,CAAC,kBAAkB,EAAE,UAAU,CAAC;IACxC,8EAA8E;IAC9E,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC;IAChC,iEAAiE;IACjE,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC;AAEjE;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,cAAc,CAAC;AAEvD;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,kBAAkB,EAAE,UAAU,EAC9B,GAAG,CAAC,EAAE,UAAU,GACf,UAAU,CAEZ;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,SAAS,EACd,OAAO,EAAE,UAAU,EACnB,GAAG,CAAC,EAAE,UAAU,GACf,cAAc,CAEhB;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,cAAc,EAAE,UAAU,GACzB,OAAO,CAAC,cAAc,CAAC,CAMzB;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAMhE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAMxE;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAK3E;AAED;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAC1B,UAAU,GACV,SAAS,GACT,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,GAC/B,CAAC,MAAM,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC;AAE5C,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,kBAAkB,GACtB,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAEjC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,OAAO,CAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,GAAG,EAAE,UAAU,GAAG,SAAS,GAC1B,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAa/B;AAoDD,wBAAsB,OAAO,CAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,GAAG,EAAE,UAAU,GAAG,SAAS,GAC1B,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CA0C/B"}

package/dist/serialization/encryption.js

@@ -1,45 +1,164 @@
 /**
  * Composable encryption layer for serialized data.
  *
- * Wraps/unwraps serialized payloads with AES-256-GCM encryption,
- * using the format prefix system to mark encrypted data.
+ * Wraps/unwraps serialized payloads with either symmetric AES-256-GCM
+ * encryption (`encr`) or an asymmetric sealed box (`encp`), using the format
+ * prefix system to mark which. See {@link PayloadKey} for how a caller
+ * declares which capabilities it holds.
  */
 import { RuntimeDecryptionError } from '@workflow/errors';
-import { decrypt as aesGcmDecrypt, encrypt as aesGcmEncrypt, } from '../encryption.js';
+import { decrypt as aesGcmDecrypt, encrypt as aesGcmEncrypt, importKey as importAesKey, } from '../encryption.js';
+import { deriveRunKeyPair, open as openSealed, seal as sealToPublicKey, } from '../sealed-box.js';
 import { decodeFormatPrefix, encodeWithFormatPrefix, peekFormatPrefix, } from './format.js';
 import { SerializationFormat } from './types.js';
+/**
+ * Brands distinguishing the structured key variants from a bare `CryptoKey`.
+ *
+ * `Symbol.for` rather than `Symbol()` because these values cross realm
+ * boundaries (host ↔ workflow VM), and the global symbol registry is shared
+ * across realms while unique symbols are not.
+ */
+const SEAL_TARGET_BRAND = Symbol.for('workflow.serialization.sealTarget');
+const RUN_KEYS_BRAND = Symbol.for('workflow.serialization.runKeys');
+/**
+ * Build a write-only seal capability for a recipient run's public key.
+ *
+ * @param recipientPublicKey - The recipient run's raw 32-byte X25519 public key
+ * @param aad - Additional authenticated data, conventionally `runAad(projectId, runId)`
+ */
+export function sealTo(recipientPublicKey, aad) {
+    return { [SEAL_TARGET_BRAND]: true, recipientPublicKey, aad };
+}
+/**
+ * Bundle a run's symmetric key with the keypair that opens payloads sealed
+ * to it.
+ */
+export function runPayloadKeys(aes, keyPair, aad) {
+    return { [RUN_KEYS_BRAND]: true, aes, keyPair, aad };
+}
+/**
+ * Build the full key capability for a run from its raw 32-byte key material —
+ * the value `World.getEncryptionKeyForRun()` returns.
+ *
+ * Use this anywhere a run reads its own event log: it yields a key that opens
+ * both its own symmetric (`encr`) payloads and sealed (`encp`) payloads other
+ * runs wrote to it. Resolving only `importKey(material)` would leave the
+ * reader unable to open sealed writes.
+ */
+export async function deriveRunPayloadKeys(runKeyMaterial) {
+    const [aes, keyPair] = await Promise.all([
+        importAesKey(runKeyMaterial),
+        deriveRunKeyPair(runKeyMaterial),
+    ]);
+    return runPayloadKeys(aes, keyPair);
+}
+export function isSealTarget(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[SEAL_TARGET_BRAND] === true);
+}
+export function isRunPayloadKeys(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[RUN_KEYS_BRAND] === true);
+}
+/**
+ * The symmetric key to use for `encr` operations, or undefined when this key
+ * has no symmetric capability (i.e. it is a seal-only target).
+ */
+export function aesKeyOf(key) {
+    if (!key)
+        return undefined;
+    if (isRunPayloadKeys(key))
+        return key.aes;
+    if (isSealTarget(key))
+        return undefined;
+    return key;
+}
 export async function resolveEncryptionKey(key) {
     return typeof key === 'function' ? key() : key;
 }
 /**
  * Encrypt a format-prefixed payload if a key is provided.
- * Wraps the data with the 'encr' format prefix.
+ *
+ * Wraps the data with the `encr` prefix for symmetric keys, or the `encp`
+ * prefix when handed a {@link SealTarget} — a cross-run writer that holds only
+ * the recipient's public key.
  *
  * @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
+ * @returns The encrypted data with its format 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);
+    if (isSealTarget(key)) {
+        const sealed = await sealToPublicKey(key.recipientPublicKey, data, key.aad);
+        return encodeWithFormatPrefix(SerializationFormat.SEALED, sealed);
+    }
+    // Symmetric path — a run's own payloads, including when the caller holds
+    // the full `RunPayloadKeys` bundle and *could* seal. See `PayloadKey`.
+    const aesKey = isRunPayloadKeys(key) ? key.aes : key;
+    const encrypted = await aesGcmEncrypt(aesKey, 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.
+ * Decrypt a format-prefixed payload if it's encrypted or sealed.
+ *
+ * Strips the `encr`/`encp` format prefix and recovers the inner payload.
+ * Opening a sealed (`encp`) payload requires the run's X25519 keypair, so the
+ * caller must supply {@link RunPayloadKeys} — a bare symmetric key cannot do
+ * it, and neither can a {@link SealTarget} (which is write-only by design).
  *
  * @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
  */
+/**
+ * Open a sealed (`encp`) envelope. Split out from {@link decrypt} to keep
+ * each scheme's error handling readable on its own.
+ */
+async function openSealedEnvelope(data, key) {
+    // Sealed payloads need the private scalar. Anything else — no key, a bare
+    // symmetric key, or a write-only seal target — cannot open them.
+    if (!isRunPayloadKeys(key)) {
+        throw new RuntimeDecryptionError('Sealed data encountered but no run keypair is available. ' +
+            "Opening a sealed payload requires the run's own encryption key " +
+            'material; a symmetric key or a seal-only target cannot decrypt it.', {
+            context: {
+                operation: 'decrypt',
+                byteLength: data.byteLength,
+                formatPrefix: 'encp',
+            },
+        });
+    }
+    const { payload } = decodeFormatPrefix(data);
+    try {
+        return await openSealed(key.keyPair, payload, key.aad);
+    }
+    catch (error) {
+        // The sealed-box layer only sees the stripped payload, so it cannot
+        // record the outer envelope prefix. Enrich it here before rethrowing.
+        if (RuntimeDecryptionError.is(error) && error.context) {
+            error.context.formatPrefix = SerializationFormat.SEALED;
+        }
+        throw error;
+    }
+}
 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) {
+    if (format === SerializationFormat.SEALED) {
+        return openSealedEnvelope(data, key);
+    }
+    // If the data is not encrypted, return it unchanged.
+    if (format !== SerializationFormat.ENCRYPTED)
+        return data;
+    // If the data is encrypted but no symmetric key is available, fail fast.
+    const aesKey = aesKeyOf(key);
+    if (!aesKey) {
         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: {
@@ -49,12 +168,9 @@ export async function decrypt(data, key) {
             },
         });
     }
-    // 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);
+        return await aesGcmDecrypt(aesKey, payload);
     }
     catch (error) {
         // The low-level AES layer only sees the stripped payload, so it cannot
@@ -67,4 +183,4 @@ export async function decrypt(data, key) {
         throw error;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.js","sourceRoot":"","sources":["../../src/serialization/encryption.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Composable encryption layer for serialized data.\n *\n * Wraps/unwraps serialized payloads with either symmetric AES-256-GCM\n * encryption (`encr`) or an asymmetric sealed box (`encp`), using the format\n * prefix system to mark which. See {@link PayloadKey} for how a caller\n * declares which capabilities it holds.\n */\n\nimport { RuntimeDecryptionError } from '@workflow/errors';\nimport {\n  decrypt as aesGcmDecrypt,\n  encrypt as aesGcmEncrypt,\n  type CryptoKey,\n  importKey as importAesKey,\n} from '../encryption.js';\nimport {\n  deriveRunKeyPair,\n  open as openSealed,\n  type RunKeyPair,\n  seal as sealToPublicKey,\n} from '../sealed-box.js';\nimport {\n  decodeFormatPrefix,\n  encodeWithFormatPrefix,\n  peekFormatPrefix,\n} from './format.js';\nimport { SerializationFormat } from './types.js';\n\nexport type { CryptoKey, RunKeyPair };\n\n/**\n * Brands distinguishing the structured key variants from a bare `CryptoKey`.\n *\n * `Symbol.for` rather than `Symbol()` because these values cross realm\n * boundaries (host ↔ workflow VM), and the global symbol registry is shared\n * across realms while unique symbols are not.\n */\nconst SEAL_TARGET_BRAND = Symbol.for('workflow.serialization.sealTarget');\nconst RUN_KEYS_BRAND = Symbol.for('workflow.serialization.runKeys');\n\n/**\n * A write-only capability: seal payloads to a run's X25519 public key.\n *\n * This is what a *cross-run* writer holds — a hook resumption targeting\n * another run, or a child workflow writing into a parent's forwarded stream.\n * It carries no ability to decrypt anything, and because it is a distinct\n * nominal type it cannot be mistaken for symmetric key material.\n *\n * That last property matters more than it looks: a raw 32-byte X25519 public\n * key is a *structurally valid* AES-256 key, so handing one to\n * `importKey(..., 'AES-GCM')` succeeds and silently produces ciphertext that\n * nobody can ever open. Routing public keys exclusively through\n * {@link sealTo} makes that mistake unrepresentable rather than merely\n * discouraged.\n */\nexport interface SealTarget {\n  readonly [SEAL_TARGET_BRAND]: true;\n  /** The recipient run's raw 32-byte X25519 public key. */\n  readonly recipientPublicKey: Uint8Array;\n  /** Additional authenticated data binding the payload to the recipient run. */\n  readonly aad?: Uint8Array;\n}\n\n/**\n * The full key capability of a run's *own* runtime (and of o11y tooling\n * acting on its behalf): the symmetric key for its own payloads, plus the\n * keypair needed to open sealed payloads that other runs wrote to it.\n */\nexport interface RunPayloadKeys {\n  readonly [RUN_KEYS_BRAND]: true;\n  /** Symmetric AES-256-GCM key — the run's own `encr` payloads. */\n  readonly aes: CryptoKey;\n  /** X25519 keypair — opens `encp` payloads sealed to this run. */\n  readonly keyPair: RunKeyPair;\n  /** Additional authenticated data expected on sealed payloads. */\n  readonly aad?: Uint8Array;\n}\n\n/**\n * A resolved key for reading or writing a serialized payload.\n *\n * The bare `CryptoKey` variant is the historical shape and remains valid: it\n * means \"symmetric only\", which is exactly right for a run that predates\n * sealed boxes or for any same-run payload. The structured variants are\n * additive:\n *\n * | Variant            | Writes  | Reads          | Held by                  |\n * | ------------------ | ------- | -------------- | ------------------------ |\n * | `CryptoKey`        | `encr`  | `encr`         | same-run (legacy shape)  |\n * | {@link RunPayloadKeys} | `encr`  | `encr`, `encp` | the owning run, o11y     |\n * | {@link SealTarget} | `encp`  | —              | cross-run writers        |\n *\n * A run's own payloads deliberately stay symmetric even when the writer could\n * seal: sealing costs a fresh ECDH per envelope and 32 extra bytes, and buys\n * nothing when the writer already holds the decryption key.\n */\nexport type PayloadKey = CryptoKey | SealTarget | RunPayloadKeys;\n\n/**\n * The subset of {@link PayloadKey} that can actually *read* a payload.\n *\n * Excludes {@link SealTarget}, which is write-only by construction: it holds a\n * public key, so it can open neither `encp` (needs the private scalar) nor\n * `encr` (needs the symmetric key). Decrypt-side signatures should take this\n * rather than `PayloadKey`, so passing a seal target is a compile error instead\n * of a guaranteed runtime failure.\n */\nexport type DecryptionKey = CryptoKey | RunPayloadKeys;\n\n/**\n * Build a write-only seal capability for a recipient run's public key.\n *\n * @param recipientPublicKey - The recipient run's raw 32-byte X25519 public key\n * @param aad - Additional authenticated data, conventionally `runAad(projectId, runId)`\n */\nexport function sealTo(\n  recipientPublicKey: Uint8Array,\n  aad?: Uint8Array\n): SealTarget {\n  return { [SEAL_TARGET_BRAND]: true, recipientPublicKey, aad };\n}\n\n/**\n * Bundle a run's symmetric key with the keypair that opens payloads sealed\n * to it.\n */\nexport function runPayloadKeys(\n  aes: CryptoKey,\n  keyPair: RunKeyPair,\n  aad?: Uint8Array\n): RunPayloadKeys {\n  return { [RUN_KEYS_BRAND]: true, aes, keyPair, aad };\n}\n\n/**\n * Build the full key capability for a run from its raw 32-byte key material —\n * the value `World.getEncryptionKeyForRun()` returns.\n *\n * Use this anywhere a run reads its own event log: it yields a key that opens\n * both its own symmetric (`encr`) payloads and sealed (`encp`) payloads other\n * runs wrote to it. Resolving only `importKey(material)` would leave the\n * reader unable to open sealed writes.\n */\nexport async function deriveRunPayloadKeys(\n  runKeyMaterial: Uint8Array\n): Promise<RunPayloadKeys> {\n  const [aes, keyPair] = await Promise.all([\n    importAesKey(runKeyMaterial),\n    deriveRunKeyPair(runKeyMaterial),\n  ]);\n  return runPayloadKeys(aes, keyPair);\n}\n\nexport function isSealTarget(value: unknown): value is SealTarget {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as Partial<SealTarget>)[SEAL_TARGET_BRAND] === true\n  );\n}\n\nexport function isRunPayloadKeys(value: unknown): value is RunPayloadKeys {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as Partial<RunPayloadKeys>)[RUN_KEYS_BRAND] === true\n  );\n}\n\n/**\n * The symmetric key to use for `encr` operations, or undefined when this key\n * has no symmetric capability (i.e. it is a seal-only target).\n */\nexport function aesKeyOf(key: PayloadKey | undefined): CryptoKey | undefined {\n  if (!key) return undefined;\n  if (isRunPayloadKeys(key)) return key.aes;\n  if (isSealTarget(key)) return undefined;\n  return key;\n}\n\n/**\n * Encryption key parameter type. Accepts a resolved key, undefined (no encryption),\n * a promise, or a resolver that can defer fetching the key until data needs it.\n */\nexport type EncryptionKeyParam =\n  | PayloadKey\n  | undefined\n  | Promise<PayloadKey | undefined>\n  | (() => Promise<PayloadKey | undefined>);\n\nexport async function resolveEncryptionKey(\n  key: EncryptionKeyParam\n): Promise<PayloadKey | undefined> {\n  return typeof key === 'function' ? key() : key;\n}\n\n/**\n * Encrypt a format-prefixed payload if a key is provided.\n *\n * Wraps the data with the `encr` prefix for symmetric keys, or the `encp`\n * prefix when handed a {@link SealTarget} — a cross-run writer that holds only\n * the recipient's public key.\n *\n * @param data - The format-prefixed serialized data\n * @param key - Encryption key (undefined to skip encryption)\n * @returns The encrypted data with its format prefix, or the original data if no key\n */\nexport async function encrypt(\n  data: Uint8Array | unknown,\n  key: PayloadKey | undefined\n): Promise<Uint8Array | unknown> {\n  if (!key || !(data instanceof Uint8Array)) return data;\n\n  if (isSealTarget(key)) {\n    const sealed = await sealToPublicKey(key.recipientPublicKey, data, key.aad);\n    return encodeWithFormatPrefix(SerializationFormat.SEALED, sealed);\n  }\n\n  // Symmetric path — a run's own payloads, including when the caller holds\n  // the full `RunPayloadKeys` bundle and *could* seal. See `PayloadKey`.\n  const aesKey = isRunPayloadKeys(key) ? key.aes : key;\n  const encrypted = await aesGcmEncrypt(aesKey, data);\n  return encodeWithFormatPrefix(SerializationFormat.ENCRYPTED, encrypted);\n}\n\n/**\n * Decrypt a format-prefixed payload if it's encrypted or sealed.\n *\n * Strips the `encr`/`encp` format prefix and recovers the inner payload.\n * Opening a sealed (`encp`) payload requires the run's X25519 keypair, so the\n * caller must supply {@link RunPayloadKeys} — a bare symmetric key cannot do\n * it, and neither can a {@link SealTarget} (which is write-only by design).\n *\n * @param data - The potentially encrypted data\n * @param key - Encryption key (undefined to skip decryption)\n * @returns The decrypted inner payload, or the original data if not encrypted\n */\n/**\n * Open a sealed (`encp`) envelope. Split out from {@link decrypt} to keep\n * each scheme's error handling readable on its own.\n */\nasync function openSealedEnvelope(\n  data: Uint8Array,\n  key: PayloadKey | undefined\n): Promise<Uint8Array> {\n  // Sealed payloads need the private scalar. Anything else — no key, a bare\n  // symmetric key, or a write-only seal target — cannot open them.\n  if (!isRunPayloadKeys(key)) {\n    throw new RuntimeDecryptionError(\n      'Sealed data encountered but no run keypair is available. ' +\n        \"Opening a sealed payload requires the run's own encryption key \" +\n        'material; a symmetric key or a seal-only target cannot decrypt it.',\n      {\n        context: {\n          operation: 'decrypt',\n          byteLength: data.byteLength,\n          formatPrefix: 'encp',\n        },\n      }\n    );\n  }\n\n  const { payload } = decodeFormatPrefix(data);\n  try {\n    return await openSealed(key.keyPair, payload, key.aad);\n  } catch (error) {\n    // The sealed-box layer only sees the stripped payload, so it cannot\n    // record the outer envelope prefix. Enrich it here before rethrowing.\n    if (RuntimeDecryptionError.is(error) && error.context) {\n      error.context.formatPrefix = SerializationFormat.SEALED;\n    }\n    throw error;\n  }\n}\n\nexport async function decrypt(\n  data: Uint8Array | unknown,\n  key: PayloadKey | undefined\n): Promise<Uint8Array | unknown> {\n  // Non-binary data is returned as-is.\n  if (!(data instanceof Uint8Array)) return data;\n\n  const format = peekFormatPrefix(data);\n\n  if (format === SerializationFormat.SEALED) {\n    return openSealedEnvelope(data, key);\n  }\n\n  // If the data is not encrypted, return it unchanged.\n  if (format !== SerializationFormat.ENCRYPTED) return data;\n\n  // If the data is encrypted but no symmetric key is available, fail fast.\n  const aesKey = aesKeyOf(key);\n  if (!aesKey) {\n    throw new RuntimeDecryptionError(\n      'Encrypted data encountered but no encryption key is available. ' +\n        'Encryption is not configured or no key was provided for this run.',\n      {\n        context: {\n          operation: 'decrypt',\n          byteLength: data.byteLength,\n          formatPrefix: 'encr',\n        },\n      }\n    );\n  }\n\n  const { payload } = decodeFormatPrefix(data);\n  try {\n    return await aesGcmDecrypt(aesKey, payload);\n  } catch (error) {\n    // The low-level AES layer only sees the stripped payload, so it cannot\n    // record the outer envelope prefix. This layer peeked it (`encr`), so\n    // enrich the diagnostic context with the real format prefix before\n    // rethrowing.\n    if (RuntimeDecryptionError.is(error) && error.context) {\n      error.context.formatPrefix = format;\n    }\n    throw error;\n  }\n}\n"]}

package/dist/serialization/step.d.ts

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

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

@@ -1 +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;AAG/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,CAmB/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,CAsBlB"}
+{"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;AAG/C,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,UAAU,EAC1B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAmB/B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,aAAa,CAAC,EAAE,UAAU,EAC1B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,OAAO,CAAC,CAsBlB"}

package/dist/serialization/step.js

@@ -1,7 +1,7 @@
 /**
  * Step mode serialization.
  *
- * Used by the step handler for serializing step return values and
+ * Used by the step executor for serializing step return values and
  * deserializing step arguments. Supports encryption as a composable layer.
  */
 import { SerializationError } from '@workflow/errors';
@@ -45,4 +45,4 @@ export async function deserialize(data, encryptionKey, options) {
     }
     throw new Error(`Unsupported serialization format: ${format}`);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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