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

package/dist/serialization/encryption.js

@@ -1,51 +1,186 @@
 /**
  * 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 { WorkflowRuntimeError } from '@workflow/errors';
-import { decrypt as aesGcmDecrypt, encrypt as aesGcmEncrypt, } from '../encryption.js';
+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' 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.
-    // Uses WorkflowRuntimeError to preserve the error contract from the
-    // legacy maybeDecrypt() implementation that callers may rely on.
-    if (format === SerializationFormat.ENCRYPTED && !key) {
-        throw new WorkflowRuntimeError('Encrypted data encountered but no encryption key is available. ' +
-            'Encryption is not configured or no key was provided for this run.');
+    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);
-    return aesGcmDecrypt(key, payload);
+    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,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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`  | (none)         | 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\n * only 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

@@ -9,6 +9,19 @@
  * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/serialization/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH;;;;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"}
+{"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

@@ -9,8 +9,26 @@
  * 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.
@@ -24,7 +42,7 @@ export function formatSerializationError(context, error) {
     if (error instanceof DevalueError && error.path) {
         message += ` at path "${error.path}"`;
     }
-    // Workflow can serialize a much richer set than the devalue defaults —
+    // 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
@@ -38,4 +56,4 @@ export function formatSerializationError(context, error) {
     }
     return { message, hint };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlcmlhbGl6YXRpb24vZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFFSCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFN0M7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSx3QkFBd0IsQ0FDdEMsT0FBZSxFQUNmLEtBQWM7SUFFZCxxRUFBcUU7SUFDckUsNkRBQTZEO0lBQzdELE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsY0FBYyxDQUFDLENBQUMsQ0FBQyxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDO0lBQ3hFLElBQUksT0FBTyxHQUFHLHVCQUF1QixPQUFPLEVBQUUsQ0FBQztJQUMvQyxJQUFJLEtBQUssWUFBWSxZQUFZLElBQUksS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ2hELE9BQU8sSUFBSSxhQUFhLEtBQUssQ0FBQyxJQUFJLEdBQUcsQ0FBQztJQUN4QyxDQUFDO0lBQ0QsdUVBQXVFO0lBQ3ZFLDJFQUEyRTtJQUMzRSxzRUFBc0U7SUFDdEUsc0VBQXNFO0lBQ3RFLDRDQUE0QztJQUM1QyxNQUFNLElBQUksR0FBRyxpQkFBaUIsSUFBSSxnSkFBZ0osQ0FBQztJQUNuTCxJQUFJLEtBQUssWUFBWSxZQUFZLElBQUksS0FBSyxDQUFDLEtBQUssS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUMvRCxhQUFhLENBQUMsS0FBSyxDQUFDLHNCQUFzQixFQUFFO1lBQzFDLE9BQU87WUFDUCxnQkFBZ0IsRUFBRSxLQUFLLENBQUMsS0FBSztTQUM5QixDQUFDLENBQUM7SUFDTCxDQUFDO0lBQ0QsT0FBTyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUMzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTaGFyZWQgZXJyb3IgZm9ybWF0dGluZyB1dGlsaXR5IGZvciBzZXJpYWxpemF0aW9uIGZhaWx1cmVzLlxuICpcbiAqIFVzZWQgYnkgdGhlIG1vZGUtc3BlY2lmaWMgc2VyaWFsaXplcnMgKHdvcmtmbG93LCBzdGVwLCBjbGllbnQpIHRvXG4gKiBwcm9kdWNlIGNvbnNpc3RlbnQgZXJyb3IgbWVzc2FnZXMgd2l0aCBkZXZhbHVlIHBhdGggaW5mb3JtYXRpb24uXG4gKlxuICogUmV0dXJucyBhIGB7IG1lc3NhZ2UsIGhpbnQgfWAgcGFpciBzbyBjYWxsZXJzIGNhbiB0aHJvdyBhXG4gKiBgU2VyaWFsaXphdGlvbkVycm9yKG1lc3NhZ2UsIHsgaGludCwgY2F1c2UgfSlgIGFuZCBoYXZlIHRoZSBoaW50IGZsb3dcbiAqIHRocm91Z2ggdGhlIHN0YW5kYXJkIGZyaWVuZGx5LWVycm9ycyBmcmFtaW5nIGluc3RlYWQgb2YgYmVpbmcgYmFrZWRcbiAqIGludG8gdGhlIG1lc3NhZ2Ugc3RyaW5nLlxuICovXG5cbmltcG9ydCB7IERldmFsdWVFcnJvciB9IGZyb20gJ2RldmFsdWUnO1xuaW1wb3J0IHsgcnVudGltZUxvZ2dlciB9IGZyb20gJy4uL2xvZ2dlci5qcyc7XG5cbi8qKlxuICogRm9ybWF0IGEgc2VyaWFsaXphdGlvbiBlcnJvciB3aXRoIGNvbnRleHQgYWJvdXQgd2hhdCBmYWlsZWQuXG4gKiBFeHRyYWN0cyBwYXRoLCB2YWx1ZSwgYW5kIHJlYXNvbiBmcm9tIGRldmFsdWUncyBEZXZhbHVlRXJyb3Igd2hlbiBhdmFpbGFibGUuXG4gKiBMb2dzIHRoZSBwcm9ibGVtYXRpYyB2YWx1ZSB0byB0aGUgY29uc29sZSBmb3IgYmV0dGVyIGRlYnVnZ2luZy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGZvcm1hdFNlcmlhbGl6YXRpb25FcnJvcihcbiAgY29udGV4dDogc3RyaW5nLFxuICBlcnJvcjogdW5rbm93blxuKTogeyBtZXNzYWdlOiBzdHJpbmc7IGhpbnQ6IHN0cmluZyB9IHtcbiAgLy8gYHJldHVybmluZ2AgZm9yIG91dHB1dHMsIGBwYXNzaW5nYCBmb3IgZXZlcnl0aGluZyB0aGF0IGNyb3NzZXMgdGhlXG4gIC8vIGJvdW5kYXJ5IHRoZSBvdGhlciB3YXkgKGFyZ3VtZW50cywgc3RyZWFtIG1lc3NhZ2VzLCBldGMuKS5cbiAgY29uc3QgdmVyYiA9IGNvbnRleHQuaW5jbHVkZXMoJ3JldHVybiB2YWx1ZScpID8gJ3JldHVybmluZycgOiAncGFzc2luZyc7XG4gIGxldCBtZXNzYWdlID0gYEZhaWxlZCB0byBzZXJpYWxpemUgJHtjb250ZXh0fWA7XG4gIGlmIChlcnJvciBpbnN0YW5jZW9mIERldmFsdWVFcnJvciAmJiBlcnJvci5wYXRoKSB7XG4gICAgbWVzc2FnZSArPSBgIGF0IHBhdGggXCIke2Vycm9yLnBhdGh9XCJgO1xuICB9XG4gIC8vIFdvcmtmbG93IGNhbiBzZXJpYWxpemUgYSBtdWNoIHJpY2hlciBzZXQgdGhhbiB0aGUgZGV2YWx1ZSBkZWZhdWx0cyDigJRcbiAgLy8gY2xhc3NlcyByZWdpc3RlcmVkIHZpYSBgV09SS0ZMT1dfU0VSSUFMSVpFYCwgRmF0YWxFcnJvciAvIFJldHJ5YWJsZUVycm9yXG4gIC8vIHN1YmNsYXNzZXMsIEFib3J0U2lnbmFsLCBldGMuIFBvaW50aW5nIGF0IHRoZSBmb3VuZGF0aW9ucyBkb2Mga2VlcHNcbiAgLy8gdGhpcyBoaW50IGFjY3VyYXRlIGFzIHRoZSBzdXBwb3J0ZWQgc2V0IGdyb3dzLCBpbnN0ZWFkIG9mIHJlcGVhdGluZ1xuICAvLyBhIGhhcmRjb2RlZCBsaXN0IHRoYXQgZHJpZnRzIG91dCBvZiBzeW5jLlxuICBjb25zdCBoaW50ID0gYEVuc3VyZSB5b3UncmUgJHt2ZXJifSB3b3JrZmxvdyBzZXJpYWxpemFibGUgdHlwZXMuIENoZWNrIHRoZSBzZXJpYWxpemF0aW9uIGRvY3MgdG8gc2VlIHdoYXQncyBzZXJpYWxpemFibGU6IGh0dHBzOi8vd29ya2Zsb3ctc2RrLmRldi9kb2NzL2ZvdW5kYXRpb25zL3NlcmlhbGl6YXRpb25gO1xuICBpZiAoZXJyb3IgaW5zdGFuY2VvZiBEZXZhbHVlRXJyb3IgJiYgZXJyb3IudmFsdWUgIT09IHVuZGVmaW5lZCkge1xuICAgIHJ1bnRpbWVMb2dnZXIuZXJyb3IoJ1NlcmlhbGl6YXRpb24gZmFpbGVkJywge1xuICAgICAgY29udGV4dCxcbiAgICAgIHByb2JsZW1hdGljVmFsdWU6IGVycm9yLnZhbHVlLFxuICAgIH0pO1xuICB9XG4gIHJldHVybiB7IG1lc3NhZ2UsIGhpbnQgfTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/format.d.ts

@@ -4,14 +4,14 @@
  * 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
+ * 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.
+ * 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';
@@ -43,7 +43,7 @@ export declare function isEncrypted(data: Uint8Array | unknown): boolean;
  *
  * 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 —
+ * (`[a-z0-9]{4}`). This is intentional for forward compatibility, so
  * 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

package/dist/serialization/format.js

@@ -4,14 +4,14 @@
  * 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
+ * 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.
+ * 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';
@@ -65,7 +65,7 @@ export function isEncrypted(data) {
  *
  * 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 —
+ * (`[a-z0-9]{4}`). This is intentional for forward compatibility, so
  * 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
@@ -94,4 +94,4 @@ export function decodeFormatPrefix(data) {
     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"]}
+//# 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, so\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"]}

package/dist/serialization/hardened.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Hardened introspection for serializing values that may originate inside a
+ * workflow VM (`node:vm`) sandbox realm.
+ *
+ * Serialization runs on the host, but the values it inspects were
+ * constructed by workflow code, so a naive dynamic operation like
+ * `value.toISOString()`, `Array.from(map)`, or `Object.prototype.toString`
+ * dispatches into the sandbox realm and executes workflow code (patched
+ * prototype methods, getters, proxy traps, `Symbol.toStringTag` accessors).
+ * That is a determinism hazard: serialization happens exactly once per
+ * payload (never again on replay), so any workflow-visible side effect it
+ * triggers exists only on the live execution path and diverges from replay.
+ *
+ * This module makes serialization side-effect free wherever the data allows
+ * it, and *observable* where it does not:
+ *
+ * - **Classification** uses engine-level brand checks (`node:util` `types`,
+ *   internal-slot probes) instead of `instanceof` / `Object.prototype.toString`,
+ *   which makes it immune to `Symbol.hasInstance`, `Symbol.toStringTag`, and
+ *   reassigned globals.
+ * - **Extraction** goes through intrinsics captured at module load (host
+ *   boot, before any workflow code runs). Internal slots are realm-agnostic,
+ *   so host intrinsics read VM-realm objects without touching the sandbox's
+ *   (patchable) prototypes.
+ * - **Property access** reads through descriptors, so plain data never
+ *   invokes anything. Where workflow code *must* run because the data itself
+ *   lives behind it (getters, proxies, custom `[WORKFLOW_SERIALIZE]`
+ *   methods, `toString()` on toStringTag-branded objects such as Temporal
+ *   polyfills), the execution is preserved for compatibility and recorded
+ *   in the active {@link GuestCodeStats} sink, so callers (e.g. a retained-VM
+ *   gate) can react.
+ *
+ * **Recording is not prevention.** For the recorded cases the determinism
+ * hazard is still live: a getter that calls `Math.random()` advances the
+ * run's seeded PRNG during serialization, and because serialization happens
+ * exactly once and is never replayed, every subsequent draw (including the
+ * correlation ids derived from that stream) shifts relative to replay. The
+ * report is the only trace of that; acting on it (warning, demoting a
+ * retained VM to replay) is left to the caller.
+ *
+ * The recorder is ambient module state, set for the duration of a
+ * synchronous `stringify` call via {@link withGuestCodeStats}. devalue's
+ * `stringify` is fully synchronous, so this is safe without async context.
+ */
+import type { StringifyOperations } from 'devalue';
+/**
+ * A single instance of workflow (guest) code executing during serialization.
+ */
+export interface GuestCodeExecution {
+    /**
+     * What forced the execution:
+     * - `getter`: an accessor property was invoked to read data
+     * - `proxy`: a proxy was introspected, firing its traps. Note this also
+     *   implies a **shape change**: brand checks answer "not that type" for a
+     *   proxy, so a proxied `Map` serializes as a plain object rather than as a
+     *   `Map`, and this report is the only evidence of it. (Such values were
+     *   never serializable before, since the internal-slot reads in the previous
+     *   implementation threw on them, so the shape change replaces a crash,
+     *   but it is silent.)
+     * - `method`: a workflow-defined function was invoked (e.g. a custom
+     *   `[WORKFLOW_SERIALIZE]` serializer, `toString()` on a
+     *   `Symbol.toStringTag`-branded object, a duck-typed `getTime()`, or a
+     *   `__closureVarsFn` this package did not generate)
+     */
+    kind: 'getter' | 'proxy' | 'method';
+    /** Best-effort context: the property key, method name, or tag involved. */
+    detail?: string;
+}
+/**
+ * Mutable sink recording workflow-code execution serialization could not
+ * avoid. `executions` contains the first five samples and `totalExecutions`
+ * is the exact count.
+ */
+export interface GuestCodeStats {
+    executions: GuestCodeExecution[];
+    totalExecutions?: number;
+}
+export declare const GUEST_CODE_EXECUTION_SAMPLE_LIMIT = 5;
+/**
+ * Runs `fn` (synchronously) with `stats` as the active guest-code sink.
+ * Nested calls stack correctly; a `null`/`undefined` sink disables
+ * recording without disabling hardening.
+ */
+export declare function withGuestCodeStats<T>(stats: GuestCodeStats | undefined, fn: () => T): T;
+/** Marks a function as having been passed to `useStep`. */
+export declare function markUseStepClosureFn<T extends object>(fn: T): T;
+/** Whether `fn` was marked by {@link markUseStepClosureFn}. */
+export declare function isUseStepClosureFn(fn: unknown): boolean;
+export declare function recordGuestCode(kind: GuestCodeExecution['kind'], detail?: string): void;
+/** `Date.prototype.getDate`, for invalid-date checks. */
+export declare const dateGetDate: (thisArg: unknown) => number;
+/** `Date.prototype.getTime`. */
+export declare const dateGetTime: (thisArg: unknown) => number;
+/** `Date.prototype.toISOString`. */
+export declare const dateToISOString: (thisArg: unknown) => string;
+/** `RegExp.prototype.source` getter. */
+export declare const regExpSource: (value: unknown) => string;
+/** `RegExp.prototype.flags` getter. */
+export declare const regExpFlags: (value: unknown) => string;
+/** `ArrayBuffer.prototype.byteLength` getter (internal slot read). */
+export declare const arrayBufferByteLength: (value: unknown) => number;
+/**
+ * Reads `value[key]` with `[[Get]]` semantics, but through descriptors:
+ * plain data properties never invoke anything; accessor properties are
+ * invoked (the data lives behind them) and recorded; proxies fall back to
+ * a plain read (their traps are the only access path) and are recorded.
+ */
+export declare function readProperty(value: unknown, key: PropertyKey): unknown;
+/**
+ * `key in value` semantics without firing proxy traps for ordinary
+ * objects. Proxies fall back to the `in` operator and are recorded.
+ */
+export declare function hasProperty(value: unknown, key: PropertyKey): boolean;
+/**
+ * `value instanceof C` semantics for a known `C.prototype`, without
+ * consulting `Symbol.hasInstance` (which workflow code can define). Used
+ * for host classes that are injected into the sandbox (Headers, URL,
+ * URLSearchParams, DOMException), where the instances (from any realm the
+ * host handed the class to) carry the host prototype in their chain.
+ *
+ * Proxies are walked rather than rejected: `Reflect.getPrototypeOf` fires
+ * the proxy's `getPrototypeOf` trap, matching `instanceof` semantics, and
+ * real values depend on that: Next.js hands the runtime a proxied
+ * `NextRequest`, and answering "not a Request" for it would silently break
+ * webhooks. The traps are guest-observable, so the proxy is recorded.
+ */
+export declare function isInstanceOfPrototype(value: unknown, prototype: object | undefined): boolean;
+/** `URL.prototype.href` getter. */
+export declare function urlHref(value: URL): string;
+/** `URLSearchParams.prototype.toString`: returns `''` iff empty. */
+export declare function urlSearchParamsToString(value: URLSearchParams): string;
+/**
+ * Iterates a Headers instance through the captured host iterator, so the
+ * iterator object, and its `next`, are host-realm.
+ */
+export declare function headersToEntries(value: Headers): [string, string][];
+/**
+ * Iterates a genuine Map's entries entirely through host intrinsics: the
+ * iterator object is created by the host `Map.prototype.entries`, so its
+ * realm, and therefore its `next`, is the host's, not the sandbox's.
+ */
+export declare function mapToEntries(value: Map<unknown, unknown>): [unknown, unknown][];
+/** See {@link mapToEntries}. */
+export declare function setToValues(value: Set<unknown>): unknown[];
+/**
+ * The bytes of an `ArrayBufferView`, read via internal-slot getters, so
+ * own-property shadowing and prototype patches cannot change which bytes
+ * are serialized.
+ */
+export declare function viewInfo(value: ArrayBufferView): {
+    buffer: ArrayBufferLike;
+    byteOffset: number;
+    byteLength: number;
+};
+export declare const hardenedStringifyOperations: Partial<StringifyOperations>;
+//# sourceMappingURL=hardened.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hardened.d.ts","sourceRoot":"","sources":["../../src/serialization/hardened.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAKnD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;;;OAcG;IACH,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpC,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,iCAAiC,IAAI,CAAC;AAUnD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,cAAc,GAAG,SAAS,EACjC,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CAWH;AAyBD,2DAA2D;AAC3D,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAG/D;AAED,+DAA+D;AAC/D,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAEvD;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,EAChC,MAAM,CAAC,EAAE,MAAM,GACd,IAAI,CAUN;AAwCD,yDAAyD;AACzD,eAAO,MAAM,WAAW,8BAAsC,CAAC;AAC/D,gCAAgC;AAChC,eAAO,MAAM,WAAW,8BAAsC,CAAC;AAC/D,oCAAoC;AACpC,eAAO,MAAM,eAAe,8BAA0C,CAAC;AACvE,wCAAwC;AACxC,eAAO,MAAM,YAAY,UAlBd,OAAO,WAkByD,CAAC;AAC5E,uCAAuC;AACvC,eAAO,MAAM,WAAW,UApBb,OAAO,WAoBuD,CAAC;AAC1E,sEAAsE;AACtE,eAAO,MAAM,qBAAqB,UAtBvB,OAAO,WAyBjB,CAAC;AAiGF;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAiCtE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAsBrE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,OAAO,CAWT;AASD,mCAAmC;AACnC,wBAAgB,OAAO,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAM1C;AAED,oEAAoE;AACpE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAMtE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAMnE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,GAC3B,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAEtB;AAED,gCAAgC;AAChC,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,OAAO,EAAE,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG;IAChD,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAaA;AAyFD,eAAO,MAAM,2BAA2B,EAAE,OAAO,CAAC,mBAAmB,CAgFpE,CAAC"}