@workflow/core 5.0.0-beta.4 → 5.0.0-beta.41

package/dist/serialization/encryption.js

@@ -0,0 +1,186 @@
+/**
+ * Composable encryption layer for serialized 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, 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` 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 its format prefix, or the original data if no key
+ */
+export async function encrypt(data, key) {
+    if (!key || !(data instanceof Uint8Array))
+        return 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 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 (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: {
+                operation: 'decrypt',
+                byteLength: data.byteLength,
+                formatPrefix: 'encr',
+            },
+        });
+    }
+    const { payload } = decodeFormatPrefix(data);
+    try {
+        return await aesGcmDecrypt(aesKey, 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,{"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/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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

package/dist/serialization/format.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Format prefix system for serialized payloads.
+ *
+ * All serialized payloads are prefixed with a 4-byte format identifier that
+ * allows the deserializer to determine how to decode the payload. This enables:
+ *
+ * 1. Self-describing payloads — the World layer is agnostic to serialization format
+ * 2. Gradual migration — old runs keep working, new runs can use new formats
+ * 3. Composability — encryption can wrap any format ("encr" wrapping "devl")
+ * 4. Debugging — raw data inspection immediately reveals the format
+ *
+ * Format: [4 bytes: format identifier][payload]
+ *
+ * The format prefix is open-ended — any 4-character [a-z0-9] string is valid.
+ * This allows new codecs to be added without modifying this module.
+ */
+import { type FormatPrefix } from './types.js';
+/**
+ * Encode a payload with a format prefix.
+ *
+ * @param format - The format identifier (4 chars, [a-z0-9])
+ * @param payload - The serialized payload bytes
+ * @returns A new Uint8Array with format prefix prepended
+ */
+export declare function encodeWithFormatPrefix(format: FormatPrefix, payload: Uint8Array | unknown): Uint8Array | unknown;
+/**
+ * Peek at the format prefix without consuming it.
+ *
+ * Returns the prefix if it's a valid format prefix ([a-z0-9]{4}),
+ * or null if the data is legacy/non-binary or doesn't start with a
+ * valid prefix.
+ *
+ * @param data - The format-prefixed data
+ * @returns The format prefix, or null
+ */
+export declare function peekFormatPrefix(data: Uint8Array | unknown): FormatPrefix | null;
+/**
+ * Check if data is encrypted (has 'encr' format prefix).
+ */
+export declare function isEncrypted(data: Uint8Array | unknown): boolean;
+/**
+ * Decode a format-prefixed payload.
+ *
+ * Unlike the legacy implementation which only accepted known formats
+ * (`devl`, `encr`), this function accepts any valid format prefix
+ * (`[a-z0-9]{4}`). This is intentional for forward compatibility —
+ * new codecs (e.g. `cbor`) can be added without modifying this module.
+ * Callers are responsible for checking whether they support the returned
+ * format and throwing an appropriate error if not (e.g. "Unsupported
+ * serialization format").
+ *
+ * @param data - The format-prefixed data
+ * @returns An object with the format prefix and payload
+ * @throws Error if the data is too short or has an invalid prefix
+ */
+export declare function decodeFormatPrefix(data: Uint8Array | unknown): {
+    format: FormatPrefix;
+    payload: Uint8Array;
+};
+//# sourceMappingURL=format.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/serialization/format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,YAAY,CAAC;AAQpB;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,UAAU,GAAG,OAAO,GAC5B,UAAU,GAAG,OAAO,CAUtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,UAAU,GAAG,OAAO,GACzB,YAAY,GAAG,IAAI,CAOrB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAE/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG;IAC9D,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,UAAU,CAAC;CACrB,CA0BA"}

package/dist/serialization/format.js

@@ -0,0 +1,97 @@
+/**
+ * Format prefix system for serialized payloads.
+ *
+ * All serialized payloads are prefixed with a 4-byte format identifier that
+ * allows the deserializer to determine how to decode the payload. This enables:
+ *
+ * 1. Self-describing payloads — the World layer is agnostic to serialization format
+ * 2. Gradual migration — old runs keep working, new runs can use new formats
+ * 3. Composability — encryption can wrap any format ("encr" wrapping "devl")
+ * 4. Debugging — raw data inspection immediately reveals the format
+ *
+ * Format: [4 bytes: format identifier][payload]
+ *
+ * The format prefix is open-ended — any 4-character [a-z0-9] string is valid.
+ * This allows new codecs to be added without modifying this module.
+ */
+import { isFormatPrefix, SerializationFormat, } from './types.js';
+/** Length of the format prefix in bytes */
+const FORMAT_PREFIX_LENGTH = 4;
+const formatEncoder = new TextEncoder();
+const formatDecoder = new TextDecoder();
+/**
+ * Encode a payload with a format prefix.
+ *
+ * @param format - The format identifier (4 chars, [a-z0-9])
+ * @param payload - The serialized payload bytes
+ * @returns A new Uint8Array with format prefix prepended
+ */
+export function encodeWithFormatPrefix(format, payload) {
+    if (!(payload instanceof Uint8Array)) {
+        return payload;
+    }
+    const prefixBytes = formatEncoder.encode(format);
+    const result = new Uint8Array(FORMAT_PREFIX_LENGTH + payload.length);
+    result.set(prefixBytes, 0);
+    result.set(payload, FORMAT_PREFIX_LENGTH);
+    return result;
+}
+/**
+ * Peek at the format prefix without consuming it.
+ *
+ * Returns the prefix if it's a valid format prefix ([a-z0-9]{4}),
+ * or null if the data is legacy/non-binary or doesn't start with a
+ * valid prefix.
+ *
+ * @param data - The format-prefixed data
+ * @returns The format prefix, or null
+ */
+export function peekFormatPrefix(data) {
+    if (!(data instanceof Uint8Array) || data.length < FORMAT_PREFIX_LENGTH) {
+        return null;
+    }
+    const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);
+    const str = formatDecoder.decode(prefixBytes);
+    return isFormatPrefix(str) ? str : null;
+}
+/**
+ * Check if data is encrypted (has 'encr' format prefix).
+ */
+export function isEncrypted(data) {
+    return peekFormatPrefix(data) === SerializationFormat.ENCRYPTED;
+}
+/**
+ * Decode a format-prefixed payload.
+ *
+ * Unlike the legacy implementation which only accepted known formats
+ * (`devl`, `encr`), this function accepts any valid format prefix
+ * (`[a-z0-9]{4}`). This is intentional for forward compatibility —
+ * new codecs (e.g. `cbor`) can be added without modifying this module.
+ * Callers are responsible for checking whether they support the returned
+ * format and throwing an appropriate error if not (e.g. "Unsupported
+ * serialization format").
+ *
+ * @param data - The format-prefixed data
+ * @returns An object with the format prefix and payload
+ * @throws Error if the data is too short or has an invalid prefix
+ */
+export function decodeFormatPrefix(data) {
+    // Compat for legacy specVersion 1 runs that don't have a format prefix
+    if (!(data instanceof Uint8Array)) {
+        return {
+            format: SerializationFormat.DEVALUE_V1,
+            payload: new TextEncoder().encode(JSON.stringify(data)),
+        };
+    }
+    if (data.length < FORMAT_PREFIX_LENGTH) {
+        throw new Error(`Data too short to contain format prefix: expected at least ${FORMAT_PREFIX_LENGTH} bytes, got ${data.length}`);
+    }
+    const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);
+    const str = formatDecoder.decode(prefixBytes);
+    if (!isFormatPrefix(str)) {
+        throw new Error(`Invalid format prefix: "${str}". Must be 4 characters of [a-z0-9].`);
+    }
+    const payload = data.subarray(FORMAT_PREFIX_LENGTH);
+    return { format: str, payload };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format.js","sourceRoot":"","sources":["../../src/serialization/format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAEL,cAAc,EACd,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAEpB,2CAA2C;AAC3C,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAE/B,MAAM,aAAa,GAAG,IAAI,WAAW,EAAE,CAAC;AACxC,MAAM,aAAa,GAAG,IAAI,WAAW,EAAE,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CACpC,MAAoB,EACpB,OAA6B;IAE7B,IAAI,CAAC,CAAC,OAAO,YAAY,UAAU,CAAC,EAAE,CAAC;QACrC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,MAAM,WAAW,GAAG,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACjD,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrE,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IAC3B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAC;IAC1C,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAA0B;IAE1B,IAAI,CAAC,CAAC,IAAI,YAAY,UAAU,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,oBAAoB,EAAE,CAAC;QACxE,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC;IAC3D,MAAM,GAAG,GAAG,aAAa,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAC9C,OAAO,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;AAC1C,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,IAA0B;IACpD,OAAO,gBAAgB,CAAC,IAAI,CAAC,KAAK,mBAAmB,CAAC,SAAS,CAAC;AAClE,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAA0B;IAI3D,uEAAuE;IACvE,IAAI,CAAC,CAAC,IAAI,YAAY,UAAU,CAAC,EAAE,CAAC;QAClC,OAAO;YACL,MAAM,EAAE,mBAAmB,CAAC,UAAU;YACtC,OAAO,EAAE,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;SACxD,CAAC;IACJ,CAAC;IAED,IAAI,IAAI,CAAC,MAAM,GAAG,oBAAoB,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CACb,8DAA8D,oBAAoB,eAAe,IAAI,CAAC,MAAM,EAAE,CAC/G,CAAC;IACJ,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC;IAC3D,MAAM,GAAG,GAAG,aAAa,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAE9C,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACb,2BAA2B,GAAG,sCAAsC,CACrE,CAAC;IACJ,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC;IACpD,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC;AAClC,CAAC","sourcesContent":["/**\n * Format prefix system for serialized payloads.\n *\n * All serialized payloads are prefixed with a 4-byte format identifier that\n * allows the deserializer to determine how to decode the payload. This enables:\n *\n * 1. Self-describing payloads — the World layer is agnostic to serialization format\n * 2. Gradual migration — old runs keep working, new runs can use new formats\n * 3. Composability — encryption can wrap any format (\"encr\" wrapping \"devl\")\n * 4. Debugging — raw data inspection immediately reveals the format\n *\n * Format: [4 bytes: format identifier][payload]\n *\n * The format prefix is open-ended — any 4-character [a-z0-9] string is valid.\n * This allows new codecs to be added without modifying this module.\n */\n\nimport {\n  type FormatPrefix,\n  isFormatPrefix,\n  SerializationFormat,\n} from './types.js';\n\n/** Length of the format prefix in bytes */\nconst FORMAT_PREFIX_LENGTH = 4;\n\nconst formatEncoder = new TextEncoder();\nconst formatDecoder = new TextDecoder();\n\n/**\n * Encode a payload with a format prefix.\n *\n * @param format - The format identifier (4 chars, [a-z0-9])\n * @param payload - The serialized payload bytes\n * @returns A new Uint8Array with format prefix prepended\n */\nexport function encodeWithFormatPrefix(\n  format: FormatPrefix,\n  payload: Uint8Array | unknown\n): Uint8Array | unknown {\n  if (!(payload instanceof Uint8Array)) {\n    return payload;\n  }\n\n  const prefixBytes = formatEncoder.encode(format);\n  const result = new Uint8Array(FORMAT_PREFIX_LENGTH + payload.length);\n  result.set(prefixBytes, 0);\n  result.set(payload, FORMAT_PREFIX_LENGTH);\n  return result;\n}\n\n/**\n * Peek at the format prefix without consuming it.\n *\n * Returns the prefix if it's a valid format prefix ([a-z0-9]{4}),\n * or null if the data is legacy/non-binary or doesn't start with a\n * valid prefix.\n *\n * @param data - The format-prefixed data\n * @returns The format prefix, or null\n */\nexport function peekFormatPrefix(\n  data: Uint8Array | unknown\n): FormatPrefix | null {\n  if (!(data instanceof Uint8Array) || data.length < FORMAT_PREFIX_LENGTH) {\n    return null;\n  }\n  const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);\n  const str = formatDecoder.decode(prefixBytes);\n  return isFormatPrefix(str) ? str : null;\n}\n\n/**\n * Check if data is encrypted (has 'encr' format prefix).\n */\nexport function isEncrypted(data: Uint8Array | unknown): boolean {\n  return peekFormatPrefix(data) === SerializationFormat.ENCRYPTED;\n}\n\n/**\n * Decode a format-prefixed payload.\n *\n * Unlike the legacy implementation which only accepted known formats\n * (`devl`, `encr`), this function accepts any valid format prefix\n * (`[a-z0-9]{4}`). This is intentional for forward compatibility —\n * new codecs (e.g. `cbor`) can be added without modifying this module.\n * Callers are responsible for checking whether they support the returned\n * format and throwing an appropriate error if not (e.g. \"Unsupported\n * serialization format\").\n *\n * @param data - The format-prefixed data\n * @returns An object with the format prefix and payload\n * @throws Error if the data is too short or has an invalid prefix\n */\nexport function decodeFormatPrefix(data: Uint8Array | unknown): {\n  format: FormatPrefix;\n  payload: Uint8Array;\n} {\n  // Compat for legacy specVersion 1 runs that don't have a format prefix\n  if (!(data instanceof Uint8Array)) {\n    return {\n      format: SerializationFormat.DEVALUE_V1,\n      payload: new TextEncoder().encode(JSON.stringify(data)),\n    };\n  }\n\n  if (data.length < FORMAT_PREFIX_LENGTH) {\n    throw new Error(\n      `Data too short to contain format prefix: expected at least ${FORMAT_PREFIX_LENGTH} bytes, got ${data.length}`\n    );\n  }\n\n  const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);\n  const str = formatDecoder.decode(prefixBytes);\n\n  if (!isFormatPrefix(str)) {\n    throw new Error(\n      `Invalid format prefix: \"${str}\". Must be 4 characters of [a-z0-9].`\n    );\n  }\n\n  const payload = data.subarray(FORMAT_PREFIX_LENGTH);\n  return { format: str, payload };\n}\n"]}