eve 0.27.11 → 0.27.13

package/dist/src/compiled/@workflow/core/sealed-box.d.ts

@@ -0,0 +1,167 @@
+import { type CryptoKey } from './encryption.js';
+/**
+ * A per-run X25519 keypair, derived from the run's key material.
+ *
+ * Callers should derive this once per run and memoize it alongside the
+ * symmetric key — derivation costs several Web Crypto round trips.
+ */
+export interface RunKeyPair {
+    /** Raw 32-byte X25519 private scalar. Secret. */
+    readonly scalar: Uint8Array;
+    /** Raw 32-byte X25519 public key. Safe to publish. */
+    readonly publicKey: Uint8Array;
+}
+/**
+ * Derive the per-run X25519 keypair from the run's 32-byte key material.
+ *
+ * Deterministic: the same key material always yields the same keypair, which
+ * is what lets the owning deployment re-derive its private scalar on demand
+ * (from `VERCEL_DEPLOYMENT_KEY`) instead of storing it anywhere.
+ *
+ * @param runKeyMaterial - The 32 bytes returned by `World.getEncryptionKeyForRun()`
+ * @returns The run's X25519 scalar and public key
+ */
+export declare function deriveRunKeyPair(runKeyMaterial: Uint8Array): Promise<RunKeyPair>;
+/**
+ * Encode bytes as standard (padded) base64.
+ *
+ * Hand-rolled for the same reason as {@link base64UrlToBytes}: this module
+ * runs in the browser (o11y decryption) and inside the workflow VM, so neither
+ * `Buffer` nor `btoa` can be assumed. Used for the wire encoding of run public
+ * keys, matching the base64 convention already used for `VERCEL_DEPLOYMENT_KEY`
+ * and the `run-key` API response.
+ */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/**
+ * Decode standard base64 (padding optional) to bytes.
+ *
+ * Returns `undefined` for malformed input rather than throwing: callers decode
+ * public keys that arrive from storage or over the wire, where a corrupt value
+ * should degrade to "this run has no usable public key" (and fall back to the
+ * symmetric path) rather than crash a resumption.
+ *
+ * Validation is strict, because a lenient decoder is worse than a throwing one
+ * here — silently returning a short or truncated key makes a corrupt value look
+ * *present*, so the caller seals to garbage instead of taking the fallback.
+ * Rejected: characters outside the alphabet, a length that cannot describe a
+ * whole number of bytes (`length % 4 === 1`), padding anywhere but the end, and
+ * a final quantum whose unused low bits are not zero.
+ */
+export declare function base64ToBytes(value: string): Uint8Array | undefined;
+/**
+ * The writer half of the KEM: generate an ephemeral keypair and derive a
+ * content key for a recipient's public key.
+ *
+ * Use this when many payloads share one KEM operation — i.e. stream frames.
+ * The returned `contentKey` can only encrypt, so a stream writer provably
+ * cannot read the recipient run's data even by mistake.
+ *
+ * **Callers own nonce discipline.** Encrypt each frame with a fresh random
+ * nonce, and call this function again for every new connection attempt or
+ * replay so that a restarted writer never reuses a content key. For one-shot
+ * payloads prefer {@link seal}, which handles this automatically.
+ *
+ * @param recipientPublicKey - The recipient run's raw 32-byte X25519 public key
+ * @returns The ephemeral public key to publish alongside the ciphertext, and
+ *   the encrypt-only content key
+ */
+export declare function encapsulate(recipientPublicKey: Uint8Array): Promise<{
+    ephemeralPublicKey: Uint8Array;
+    contentKey: CryptoKey;
+}>;
+/**
+ * The recipient half of the KEM: recover the content key for a sealed
+ * payload from the run's own keypair and the sender's ephemeral public key.
+ *
+ * @param keyPair - The recipient run's keypair, from {@link deriveRunKeyPair}
+ * @param ephemeralPublicKey - The sender's raw 32-byte X25519 public key,
+ *   read from the head of the sealed envelope
+ * @returns A decrypt-only content key
+ */
+export declare function decapsulate(keyPair: RunKeyPair, ephemeralPublicKey: Uint8Array): Promise<CryptoKey>;
+/**
+ * Seal a payload to a run's public key.
+ *
+ * Each call performs its own KEM operation, so every sealed payload gets an
+ * independent content key — nonce reuse across calls is impossible by
+ * construction.
+ *
+ * @param recipientPublicKey - The recipient run's raw 32-byte X25519 public key
+ * @param data - Plaintext to seal
+ * @param aad - Optional additional authenticated data, covered by the GCM tag
+ *   but not encrypted. Callers pass the recipient's `projectId|runId` so a
+ *   sealed payload cannot be replayed against a different run.
+ * @returns `[ephemeral public key (32)][nonce (12)][ciphertext + tag]`
+ */
+export declare function seal(recipientPublicKey: Uint8Array, data: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
+/**
+ * Open a payload sealed to this run's public key.
+ *
+ * @param keyPair - The recipient run's keypair, from {@link deriveRunKeyPair}
+ * @param sealed - `[ephemeral public key (32)][nonce (12)][ciphertext + tag]`
+ * @param aad - The exact additional authenticated data passed to {@link seal}
+ * @returns The decrypted plaintext
+ */
+export declare function open(keyPair: RunKeyPair, sealed: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
+/**
+ * A writer-side session that amortizes one KEM operation across many sealed
+ * payloads — use it for streams, where one-shot {@link seal} would perform a
+ * fresh keygen + ECDH + HKDF for every frame.
+ *
+ * Safety rests on two properties:
+ *
+ * - Every payload still gets a **fresh random nonce** from `aesGcmEncrypt`, so
+ *   sharing the content key does not risk `(key, nonce)` reuse. (A counter
+ *   would: it restarts at zero whenever a writer restarts.)
+ * - The session is bound to one writer instance. A reconnect or a durable
+ *   replay constructs a new session, so a restarted writer never inherits a
+ *   previous incarnation's content key.
+ *
+ * The envelope layout is byte-identical to {@link seal}, so a reader cannot
+ * tell which was used and needs no matching session.
+ */
+export declare function createSealSession(recipientPublicKey: Uint8Array, aad?: Uint8Array): {
+    seal(data: Uint8Array): Promise<Uint8Array>;
+};
+/**
+ * A reader-side session that caches decapsulation per sender.
+ *
+ * The mirror of {@link createSealSession}: because every frame from one writer
+ * carries the same ephemeral public key, this turns an ECDH per frame into an
+ * ECDH per writer. Correctness does not depend on the writer having used a
+ * session — a stream of independently sealed payloads simply misses the cache
+ * on each new ephemeral key.
+ *
+ * The cache is keyed by the ephemeral public key and holds one entry, which is
+ * the common case (one writer per stream). A second writer evicts the first
+ * rather than growing without bound.
+ */
+export declare function createOpenSession(keyPair: RunKeyPair, aad?: Uint8Array): {
+    open(sealed: Uint8Array): Promise<Uint8Array>;
+};
+/**
+ * Build the additional authenticated data that binds a sealed payload to a
+ * specific run.
+ *
+ * Mirrors the `info` used for symmetric per-run key derivation so the two
+ * schemes agree on what "this run" means.
+ *
+ * Note that the sealed-box construction already binds a payload to its
+ * recipient without any AAD: the content key is derived over
+ * `ephemeralPublicKey ‖ recipientPublicKey`, and a recipient public key is
+ * unique per (deployment key × project × run). Replaying a sealed payload at
+ * a different run therefore fails at key agreement regardless. AAD is
+ * available for callers that want an additional, KDF-independent binding —
+ * both sides must supply byte-identical values or the payload will not open.
+ */
+export declare function runAad(projectId: string, runId: string): Uint8Array;
+/**
+ * Decode a run's published public key, validating both encoding and length.
+ *
+ * Returns `undefined` when the value is absent, not valid base64, or not
+ * exactly 32 bytes. Callers treat that as "this run has no usable public key"
+ * and fall back to the symmetric path, so a corrupt or truncated stored value
+ * degrades to the pre-existing behavior instead of failing a resumption.
+ */
+export declare function decodeRunPublicKey(value: string | undefined): Uint8Array | undefined;
+//# sourceMappingURL=sealed-box.d.ts.map

package/dist/src/compiled/@workflow/core/serialization/client.d.ts

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

package/dist/src/compiled/@workflow/core/serialization/codec.d.ts

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

package/dist/src/compiled/@workflow/core/serialization/encryption.d.ts

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

package/dist/src/compiled/@workflow/core/serialization/step.d.ts

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

package/dist/src/compiled/@workflow/core/serialization/types.d.ts

@@ -26,6 +26,16 @@ export declare const SerializationFormat: {
     readonly DEVALUE_V1: FormatPrefix;
     /** Encrypted payload (inner payload has its own format prefix) */
     readonly ENCRYPTED: FormatPrefix;
+    /**
+     * Sealed payload — asymmetrically encrypted to a run's X25519 public key
+     * (inner payload has its own format prefix).
+     *
+     * Used for *cross-run* writes (hook payloads, forwarded stream frames),
+     * where the writer holds only the recipient run's public key and therefore
+     * cannot decrypt. A run's own payloads continue to use {@link ENCRYPTED}.
+     * See `sealed-box.ts` for the construction.
+     */
+    readonly SEALED: FormatPrefix;
     /** Gzip-compressed payload (inner payload has its own format prefix) */
     readonly GZIP: FormatPrefix;
     /** Zstandard-compressed payload (inner payload has its own format prefix) */
@@ -230,6 +240,16 @@ export interface SerializableSpecial {
          * the parent's key without fetching the parent run first.
          */
         deploymentId?: string;
+        /**
+         * The owning run's X25519 public key (base64), when it has one.
+         *
+         * Lets the receiving run seal frames to the stream's owner with no
+         * lookup at all — neither a run fetch nor a key-API round trip. The
+         * owner derives this locally when it creates the stream, so including
+         * it here is free. Absent for runs created by older SDKs, in which
+         * case the receiver falls back to resolving the owner's symmetric key.
+         */
+        encryptionPublicKey?: string;
     };
     AbortController: {
         streamName: string;

package/dist/src/compiled/@workflow/core/serialization-format.d.ts

@@ -5,11 +5,32 @@
  * dispatch, and shared types/classes used by all environments (runtime, web
  * o11y, CLI o11y). It has NO Node.js dependencies.
  */
+/**
+ * Re-exported from the envelope layer so browser consumers (web dashboard,
+ * web-shared) can resolve key material without importing
+ * `@workflow/core/serialization`, whose module graph reaches Node built-ins
+ * (`node:util`, `node:async_hooks`) and cannot be bundled for the browser.
+ *
+ * Everything below is Web Crypto only: `serialization/encryption.ts`,
+ * `encryption.ts` and `sealed-box.ts` are all free of Node dependencies.
+ */
+export { type DecryptionKey, decrypt as decryptEnvelope, deriveRunPayloadKeys, encrypt as encryptEnvelope, isRunPayloadKeys, isSealTarget, type PayloadKey, type RunPayloadKeys, runPayloadKeys, type SealTarget, sealTo, } from './serialization/encryption.js';
 export declare const SerializationFormat: {
     /** devalue stringify/parse with TextEncoder/TextDecoder */
     readonly DEVALUE_V1: "devl";
     /** Encrypted payload (inner payload has its own format prefix after decryption) */
     readonly ENCRYPTED: "encr";
+    /**
+     * Sealed payload — asymmetrically encrypted to a run's X25519 public key
+     * (inner payload has its own format prefix after opening).
+     *
+     * Written by cross-run writers that hold only the recipient run's public
+     * key. Opening it requires the run's private scalar rather than the
+     * symmetric per-run key, so o11y display treats it as ciphertext via
+     * {@link isEncryptedData} but {@link hydrateDataWithKey} does not attempt
+     * an AES-GCM decrypt on it.
+     */
+    readonly SEALED: "encp";
     /** Gzip-compressed payload (inner payload has its own format prefix after decompression) */
     readonly GZIP: "gzip";
     /** Zstandard-compressed payload (inner payload has its own format prefix after decompression) */
@@ -42,10 +63,25 @@ export declare const ENCRYPTED_PLACEHOLDER = "\uD83D\uDD12 Encrypted";
  */
 export declare function isExpiredStub(data: unknown): boolean;
 /**
- * Check if a binary value has the 'encr' format prefix indicating encryption.
+ * Check if a binary value is ciphertext — either a symmetrically encrypted
+ * payload ('encr') or a sealed cross-run payload ('encp').
+ *
+ * This is the predicate display layers want: both schemes are opaque bytes
+ * that must not be fed to the devalue parser, and both render as the same
+ * "Encrypted" affordance in the CLI and web UI. Use {@link isSealedData} when
+ * the *scheme* matters — notably when choosing a decryption path, since a
+ * sealed payload needs the run's private scalar rather than its symmetric key.
+ *
  * Browser-safe — does not depend on the full serialization module.
  */
 export declare function isEncryptedData(data: unknown): boolean;
+/**
+ * Check if a binary value has the 'encp' format prefix, indicating a sealed
+ * (asymmetrically encrypted) cross-run payload.
+ *
+ * Browser-safe — does not depend on the full serialization module.
+ */
+export declare function isSealedData(data: unknown): boolean;
 /**
  * Check if a binary value has a compression format prefix ('gzip' or 'zstd').
  * Browser-safe — does not depend on the full serialization module.
@@ -85,11 +121,15 @@ export declare function hydrateData(value: unknown, revivers: Revivers): unknown
  * decryption. Used by o11y tooling (web UI, CLI) when the user requests
  * decryption.
  *
- * @param value - The value to hydrate (may be encrypted)
+ * @param value - The value to hydrate (may be encrypted or sealed)
  * @param revivers - Devalue revivers for deserialization
- * @param key - AES-256 encryption key (if provided, encrypted data will be decrypted)
+ * @param key - The run's key material. Pass `RunPayloadKeys` (from
+ *   `deriveRunPayloadKeys`) to open both symmetric (`encr`) and sealed
+ *   (`encp`) payloads; a bare `CryptoKey` opens only the symmetric ones.
+ *   Typed as a read capability so a write-only seal target — which could open
+ *   neither scheme — is rejected at compile time rather than failing here.
  */
-export declare function hydrateDataWithKey(value: unknown, revivers: Revivers, key: import('./encryption.js').CryptoKey | undefined): Promise<unknown>;
+export declare function hydrateDataWithKey(value: unknown, revivers: Revivers, key: import('./serialization/encryption.js').DecryptionKey | undefined): Promise<unknown>;
 /** Marker for stream reference objects rendered as links in the UI */
 export declare const STREAM_REF_TYPE = "__workflow_stream_ref__";
 /** A stream reference for UI display */

package/dist/src/compiled/@workflow/core/serialization.d.ts

@@ -1,9 +1,8 @@
-import { type CryptoKey } from './encryption.js';
 import { compress, decompress } from './serialization/compression.js';
-import { decrypt, type EncryptionKeyParam, encrypt } from './serialization/encryption.js';
+import { aesKeyOf, decrypt, deriveRunPayloadKeys, type EncryptionKeyParam, encrypt, isRunPayloadKeys, isSealTarget, type PayloadKey, type RunPayloadKeys, runPayloadKeys, type SealTarget, sealTo } from './serialization/encryption.js';
 import { decodeFormatPrefix, encodeWithFormatPrefix, isEncrypted, peekFormatPrefix } from './serialization/format.js';
 import { type FormatPrefix, isFormatPrefix, SerializationFormat } from './serialization/types.js';
-export { SerializationFormat, type FormatPrefix, isFormatPrefix, encodeWithFormatPrefix, decodeFormatPrefix, peekFormatPrefix, isEncrypted, encrypt, decrypt, compress, decompress, type EncryptionKeyParam, };
+export { SerializationFormat, type FormatPrefix, isFormatPrefix, encodeWithFormatPrefix, decodeFormatPrefix, peekFormatPrefix, isEncrypted, encrypt, decrypt, compress, decompress, type EncryptionKeyParam, type PayloadKey, type RunPayloadKeys, type SealTarget, sealTo, runPayloadKeys, deriveRunPayloadKeys, isSealTarget, isRunPayloadKeys, aesKeyOf, };
 export type SerializationFormatType = (typeof SerializationFormat)[keyof typeof SerializationFormat];
 /**
  * Detect if a readable stream is a byte stream.
@@ -285,6 +284,7 @@ export declare function getCommonRevivers(global?: Record<string, any>): {
         name: string;
         runId?: string;
         deploymentId?: string;
+        encryptionPublicKey?: string;
     }) => any) | undefined;
     AbortController?: ((value: {
         streamName: string;
@@ -323,13 +323,13 @@ export declare function getWorkflowRevivers(global?: Record<string, any>): Parti
  *
  * @deprecated Use `encrypt` from `./serialization/encryption.js` instead.
  */
-export declare function maybeEncrypt(data: Uint8Array, key: CryptoKey | undefined): Promise<Uint8Array>;
+export declare function maybeEncrypt(data: Uint8Array, key: PayloadKey | undefined): Promise<Uint8Array>;
 /**
  * Decrypt data if it has the 'encr' prefix.
  *
  * @deprecated Use `decrypt` from `./serialization/encryption.js` instead.
  */
-export declare function maybeDecrypt(data: Uint8Array | unknown, key: CryptoKey | undefined): Promise<Uint8Array | unknown>;
+export declare function maybeDecrypt(data: Uint8Array | unknown, key: PayloadKey | undefined): Promise<Uint8Array | unknown>;
 /**
  * Replay hydration has two stages:
  *
@@ -350,7 +350,7 @@ export interface PreparedReplayPayload {
  * both direct and promised results lets a future synchronous Node decryptor use
  * the same cache contract as today's asynchronous Web Crypto implementation.
  */
-export type ReplayPayloadPreparer = (value: unknown, key: CryptoKey | undefined) => PreparedReplayPayload | Promise<PreparedReplayPayload>;
+export type ReplayPayloadPreparer = (value: unknown, key: PayloadKey | undefined) => PreparedReplayPayload | Promise<PreparedReplayPayload>;
 /**
  * Decrypt and decompress persisted data without parsing it into JavaScript.
  * Legacy non-binary values pass through unchanged for their consumer to revive.
@@ -384,34 +384,34 @@ export declare function deserializePreparedStepError(prepared: PreparedReplayPay
  *   backwards compatibility with older runs.
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateWorkflowArguments(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateWorkflowArguments(value: unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
 /**
  * Called from workflow execution environment to hydrate the workflow
  * arguments from the database at the start of workflow execution. A prepared
  * payload skips host-side decrypt/decompress but always performs VM revival.
  */
-export declare function hydrateWorkflowArguments(value: Uint8Array | unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, prepared?: PreparedReplayPayload): Promise<any>;
+export declare function hydrateWorkflowArguments(value: Uint8Array | unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, prepared?: PreparedReplayPayload): Promise<any>;
 /**
  * Dehydrate workflow return value for storage.
  */
-export declare function dehydrateWorkflowReturnValue(value: unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateWorkflowReturnValue(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
 /**
  * Called from the client side to hydrate the workflow return value
  * of a completed workflow run.
  */
-export declare function hydrateWorkflowReturnValue(value: Uint8Array | unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>): Promise<any>;
+export declare function hydrateWorkflowReturnValue(value: Uint8Array | unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>): Promise<any>;
 /**
  * Called from the workflow handler when a step is being created.
  * Dehydrates values from within the workflow execution environment.
  */
-export declare function dehydrateStepArguments(value: unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateStepArguments(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
 /**
- * Called from the step handler to hydrate the arguments of a step
+ * Called from the step executor to hydrate the arguments of a step
  * from the database at the start of the step execution.
  */
-export declare function hydrateStepArguments(value: Uint8Array | unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, deploymentId?: string): Promise<any>;
+export declare function hydrateStepArguments(value: Uint8Array | unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, deploymentId?: string): Promise<any>;
 /**
- * Called from the step handler when a step has completed.
+ * Called from the step executor when a step has completed.
  * Dehydrates values from within the step execution environment
  * into a format that can be saved to the database.
  *
@@ -427,9 +427,9 @@ export declare function hydrateStepArguments(value: Uint8Array | unknown, runId:
  *   backwards compatibility with older runs.
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateStepReturnValue(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean, runReadyBarrier?: Promise<unknown>): Promise<Uint8Array | unknown>;
+export declare function dehydrateStepReturnValue(value: unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean, runReadyBarrier?: Promise<unknown>): Promise<Uint8Array | unknown>;
 /**
- * Called from the step handler when a step throws. Dehydrates the thrown
+ * Called from the step executor when a step throws. Dehydrates the thrown
  * value from within the step execution environment into a format that can
  * be saved to the database in a `step_failed` or `step_retrying` event.
  *
@@ -444,7 +444,7 @@ export declare function dehydrateStepReturnValue(value: unknown, runId: string,
  * @param global - Global object for serialization context
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateStepError(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, compression?: boolean): Promise<Uint8Array>;
+export declare function dehydrateStepError(value: unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, compression?: boolean): Promise<Uint8Array>;
 /**
  * Called from the workflow handler when replaying the event log of a
  * `step_failed` or `step_retrying` event. Hydrates the thrown value from
@@ -458,7 +458,7 @@ export declare function dehydrateStepError(value: unknown, runId: string, key: C
  * @param prepared - Optional cached decrypt/decompress result
  * @returns The hydrated thrown value, ready to reject the step promise
  */
-export declare function hydrateStepError(value: Uint8Array | unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, prepared?: PreparedReplayPayload): Promise<unknown>;
+export declare function hydrateStepError(value: Uint8Array | unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, prepared?: PreparedReplayPayload): Promise<unknown>;
 /**
  * Called from the workflow handler when the workflow itself throws.
  * Dehydrates the thrown value from within the workflow execution environment
@@ -470,7 +470,7 @@ export declare function hydrateStepError(value: Uint8Array | unknown, _runId: st
  * @param global - Global object for serialization context
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateRunError(value: unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, compression?: boolean): Promise<Uint8Array>;
+export declare function dehydrateRunError(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, compression?: boolean): Promise<Uint8Array>;
 /**
  * Called from the client side (or observability tools) to hydrate the run
  * error value of a failed workflow run.
@@ -483,7 +483,7 @@ export declare function dehydrateRunError(value: unknown, _runId: string, key: C
  * @param extraRevivers - Additional revivers for custom types
  * @returns The hydrated thrown value, ready to be consumed by the client
  */
-export declare function hydrateRunError(value: Uint8Array | unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>): Promise<unknown>;
+export declare function hydrateRunError(value: Uint8Array | unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>): Promise<unknown>;
 /**
  * Called from the workflow handler when replaying the event log of a `step_completed` event.
  * Hydrates the return value of a step from the database.
@@ -497,5 +497,5 @@ export declare function hydrateRunError(value: Uint8Array | unknown, runId: stri
  * Called from the workflow handler when replaying the event log
  * of a `step_completed` event.
  */
-export declare function hydrateStepReturnValue(value: Uint8Array | unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, prepared?: PreparedReplayPayload): Promise<any>;
+export declare function hydrateStepReturnValue(value: Uint8Array | unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, prepared?: PreparedReplayPayload): Promise<any>;
 //# sourceMappingURL=serialization.d.ts.map