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

package/dist/sealed-box.js

@@ -0,0 +1,571 @@
+import { RuntimeDecryptionError, WorkflowRuntimeError } from '@workflow/errors';
+import { decrypt as aesGcmDecrypt, encrypt as aesGcmEncrypt, NONCE_LENGTH, TAG_BYTES, } from './encryption.js';
+/**
+ * Browser-compatible sealed-box (asymmetric) encryption for cross-run writes.
+ *
+ * ## Why this exists
+ *
+ * The symmetric `encr` path requires the writer to hold the recipient run's
+ * key, which also grants decrypt capability. For *cross-run* writes (a hook
+ * resumption targeting another run, or a child workflow writing into a
+ * parent's forwarded `WritableStream`) that is more authority than the writer
+ * needs, and obtaining the symmetric key across a deployment boundary costs a
+ * round trip to the Vercel API.
+ *
+ * A sealed box fixes both: the writer needs only the recipient's **public**
+ * key, which is not secret and therefore travels on the run entity (and in
+ * stream descriptors) at no cost. "Encrypt-only" stops being an honor-system
+ * convention enforced by `importKey(raw, ['encrypt'])` and becomes a
+ * cryptographic guarantee: a writer holding only the public key provably
+ * cannot read anything.
+ *
+ * ## Key hierarchy
+ *
+ * Both keys descend from the same per-run key material `K` that
+ * `World.getEncryptionKeyForRun()` already returns today, so nothing about
+ * key acquisition, the World interface, or the Vercel API changes:
+ *
+ * ```
+ * K  (32 bytes, per-run, = HKDF(VERCEL_DEPLOYMENT_KEY, "projectId|runId"))
+ * ├── AES-256 key = K used directly            → 'encr' envelopes (unchanged)
+ * └── X25519 scalar = HKDF(K, SCALAR_INFO)     → 'encp' envelopes
+ *     └── public key = X25519 basepoint · scalar   (published, not secret)
+ * ```
+ *
+ * `K` is therefore both an AEAD key and a key-derivation key. This is sound:
+ * AES-GCM never exposes its key, and HKDF-SHA256 output is computationally
+ * independent of the AES keystream. A strict reading of NIST SP 800-108
+ * prefers these roles be separated, but `K`'s direct AES use is fixed by
+ * backward compatibility with every `encr` payload already written.
+ *
+ * ## Construction
+ *
+ * An ECIES-style sealed box using the same primitives as HPKE (RFC 9180)
+ * base mode with DHKEM(X25519, HKDF-SHA256) and AES-256-GCM, but without the
+ * full `LabeledExtract`/`LabeledExpand` suite-ID ceremony:
+ *
+ * ```
+ * ephemeral    = X25519 keypair, freshly generated per encryption context
+ * sharedSecret = X25519(ephemeralPrivate, recipientPublic)
+ * contentKey   = HKDF-SHA256(
+ *                  ikm  = sharedSecret,
+ *                  salt = zeros(32),
+ *                  info = CONTENT_KEY_INFO ‖ ephemeralPublic ‖ recipientPublic,
+ *                )
+ * ```
+ *
+ * Binding both public keys into `info` is the security-critical part (it is
+ * HPKE's `kem_context`): it prevents key-substitution/unknown-key-share
+ * attacks in which an adversary replays a ciphertext as though it had been
+ * sealed to a different recipient. Deviating from strict RFC 9180 framing is
+ * a deliberate, documented choice: the envelope is versioned via its format
+ * prefix and the HKDF labels below, so a conformant profile can be added
+ * later as a new version without touching existing payloads.
+ *
+ * Wire format (the `encp` format prefix is attached by the serialization
+ * layer, not by this module):
+ *
+ * ```
+ * [ephemeral public key (32 bytes)][nonce (12 bytes)][ciphertext + GCM tag (16 bytes)]
+ * ```
+ *
+ * ## Nonce discipline
+ *
+ * One-shot {@link seal} generates a fresh ephemeral keypair (and therefore a
+ * fresh content key) for every call, so nonce reuse is impossible.
+ *
+ * Callers that amortize the KEM across many frames via {@link encapsulate}
+ * take on nonce discipline themselves, because the content key then outlives a
+ * single message. Two rules apply:
+ *
+ * 1. Every frame MUST use a fresh random nonce (which `aesGcmEncrypt` does).
+ *    Never a counter: a counter restarts at zero after a stream reconnect or a
+ *    durable replay, reusing `(contentKey, nonce)`, which under AES-GCM leaks
+ *    the plaintext XOR of the two frames and the GCM auth subkey.
+ * 2. A writer must not inherit a previous incarnation's content key, so
+ *    {@link encapsulate} is re-run per writer instance.
+ *
+ * Nothing in this module enforces either rule; it is the streaming caller's
+ * contract.
+ */
+/** Length of an X25519 private scalar and public key, in bytes. */
+const X25519_KEY_LENGTH = 32;
+/** Length of the AES-256 content key derived from the shared secret. */
+const CONTENT_KEY_LENGTH = 32;
+/**
+ * HKDF `info` label for deriving the per-run X25519 scalar from the per-run
+ * key material.
+ *
+ * Versioned and namespaced so that any future derivation from the same `K`
+ * (a second keypair, a MAC key, a different curve) can never collide with
+ * this one.
+ */
+const SCALAR_INFO = 'workflow/encp/x25519/v1';
+/**
+ * HKDF `info` prefix for deriving the AES-256-GCM content key from an X25519
+ * shared secret. The ephemeral and recipient public keys are appended to this
+ * label to form the full `info` (HPKE's `kem_context`).
+ */
+const CONTENT_KEY_INFO = 'workflow/encp/aes256gcm/v1';
+/**
+ * DER prefix for an RFC 8410 `PrivateKeyInfo` wrapping a raw X25519 scalar.
+ *
+ * Web Crypto cannot import a raw X25519 private key (`importKey('raw', ...)`
+ * is only defined for public keys on the Secure Curves algorithms), so a
+ * derived scalar has to be wrapped in PKCS#8 before it can be used. The
+ * structure is fully determined for a 32-byte X25519 key:
+ *
+ * ```
+ * SEQUENCE (46 bytes)                         30 2e
+ *   INTEGER 0                                 02 01 00
+ *   SEQUENCE (5 bytes)                        30 05
+ *     OBJECT IDENTIFIER 1.3.101.110 (X25519)  06 03 2b 65 6e
+ *   OCTET STRING (34 bytes)                   04 22
+ *     OCTET STRING (32 bytes)                 04 20
+ *       <scalar>
+ * ```
+ */
+const PKCS8_X25519_PREFIX = new Uint8Array([
+    0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e, 0x04,
+    0x22, 0x04, 0x20,
+]);
+const infoEncoder = new TextEncoder();
+function assertKeyMaterialLength(runKeyMaterial) {
+    if (runKeyMaterial.byteLength !== CONTENT_KEY_LENGTH) {
+        throw new WorkflowRuntimeError(`Run key material must be exactly ${CONTENT_KEY_LENGTH} bytes, got ${runKeyMaterial.byteLength}`);
+    }
+}
+function assertPublicKeyLength(publicKey, label) {
+    if (publicKey.byteLength !== X25519_KEY_LENGTH) {
+        throw new WorkflowRuntimeError(`${label} must be exactly ${X25519_KEY_LENGTH} bytes, got ${publicKey.byteLength}`);
+    }
+}
+/**
+ * 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 async function deriveRunKeyPair(runKeyMaterial) {
+    assertKeyMaterialLength(runKeyMaterial);
+    const hkdfKey = await globalThis.crypto.subtle.importKey('raw', runKeyMaterial, 'HKDF', false, ['deriveBits']);
+    // Zero salt is acceptable per RFC 5869 §3.1: the IKM here is itself HKDF
+    // output (or a high-entropy BYOK value), so it is already uniform. The
+    // `info` label provides domain separation.
+    const scalarBits = await globalThis.crypto.subtle.deriveBits({
+        name: 'HKDF',
+        hash: 'SHA-256',
+        salt: new Uint8Array(32),
+        info: infoEncoder.encode(SCALAR_INFO),
+    }, hkdfKey, X25519_KEY_LENGTH * 8);
+    const scalar = new Uint8Array(scalarBits);
+    // Any 32-byte string is a valid X25519 scalar (the low/high bits are
+    // clamped during scalar multiplication), so the HKDF output needs no
+    // rejection sampling.
+    const publicKey = await derivePublicKeyFromScalar(scalar);
+    return { scalar, publicKey };
+}
+/**
+ * Recover the raw public key for a scalar.
+ *
+ * Web Crypto exposes no scalar-multiplication primitive, so the scalar is
+ * imported as a PKCS#8 private key and its public half read back out of the
+ * JWK export (`x`), which the Secure Curves spec defines as the base64url
+ * raw public key.
+ */
+async function derivePublicKeyFromScalar(scalar) {
+    const privateKey = await importScalar(scalar, /* extractable */ true);
+    const jwk = await globalThis.crypto.subtle.exportKey('jwk', privateKey);
+    if (!jwk.x) {
+        throw new WorkflowRuntimeError('X25519 JWK export did not include a public key component ("x")');
+    }
+    const publicKey = base64UrlToBytes(jwk.x);
+    // Guard the one step in this module that trusts an external encoding. A
+    // short or malformed value here would otherwise flow onward and fail much
+    // later, inside key agreement, with a far less obvious message.
+    if (publicKey.byteLength !== X25519_KEY_LENGTH) {
+        throw new WorkflowRuntimeError(`X25519 JWK export produced a ${publicKey.byteLength}-byte public key, expected ${X25519_KEY_LENGTH}`);
+    }
+    return publicKey;
+}
+async function importScalar(scalar, extractable) {
+    const pkcs8 = new Uint8Array(PKCS8_X25519_PREFIX.length + scalar.byteLength);
+    pkcs8.set(PKCS8_X25519_PREFIX, 0);
+    pkcs8.set(scalar, PKCS8_X25519_PREFIX.length);
+    return globalThis.crypto.subtle.importKey('pkcs8', pkcs8, { name: 'X25519' }, extractable, ['deriveBits']);
+}
+function importPublicKey(publicKey) {
+    return globalThis.crypto.subtle.importKey('raw', publicKey, { name: 'X25519' }, 
+    /* extractable */ true, 
+    // Public keys carry no usages for X25519: the private key does the
+    // deriving; the public key is only ever an argument to it.
+    []);
+}
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const BASE64URL_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+/**
+ * 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 function bytesToBase64(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length; i += 3) {
+        const b0 = bytes[i];
+        const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+        const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+        out += BASE64_CHARS[(b0 >> 2) & 0x3f];
+        out += BASE64_CHARS[((b0 & 0x03) << 4) | ((b1 >> 4) & 0x0f)];
+        out +=
+            i + 1 < bytes.length
+                ? BASE64_CHARS[((b1 & 0x0f) << 2) | ((b2 >> 6) & 0x03)]
+                : '=';
+        out += i + 2 < bytes.length ? BASE64_CHARS[b2 & 0x3f] : '=';
+    }
+    return out;
+}
+/**
+ * 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 function base64ToBytes(value) {
+    // Strip trailing padding, then require what remains to be padding-free.
+    let end = value.length;
+    while (end > 0 && value[end - 1] === '=')
+        end--;
+    const body = value.slice(0, end);
+    if (body.includes('='))
+        return undefined;
+    // 4 chars -> 3 bytes; 3 -> 2; 2 -> 1. A remainder of 1 encodes no byte.
+    if (body.length % 4 === 1)
+        return undefined;
+    // Padding, when present, must bring the total to a multiple of 4.
+    if (end !== value.length && value.length % 4 !== 0)
+        return undefined;
+    let accumulator = 0;
+    let bitCount = 0;
+    const bytes = [];
+    for (let i = 0; i < body.length; i++) {
+        const index = BASE64_CHARS.indexOf(body[i]);
+        if (index === -1)
+            return undefined;
+        accumulator = (accumulator << 6) | index;
+        bitCount += 6;
+        if (bitCount >= 8) {
+            bitCount -= 8;
+            bytes.push((accumulator >> bitCount) & 0xff);
+        }
+    }
+    // Leftover bits belong to no byte and must be zero in canonical base64.
+    if (bitCount > 0 && (accumulator & ((1 << bitCount) - 1)) !== 0) {
+        return undefined;
+    }
+    return new Uint8Array(bytes);
+}
+/**
+ * Decode a base64url string (JWK encoding) to bytes.
+ *
+ * Hand-rolled rather than using `atob` or `Buffer`: this module also runs
+ * inside the workflow VM, whose global surface is deliberately minimal and
+ * does not include either. The inputs here are fixed-size JWK key components,
+ * so a compact decoder is sufficient: it accepts unpadded base64url only,
+ * which is what RFC 7515 §2 mandates for JWK members.
+ */
+function base64UrlToBytes(value) {
+    let accumulator = 0;
+    let bitCount = 0;
+    const bytes = [];
+    for (let i = 0; i < value.length; i++) {
+        const char = value[i];
+        if (char === '=')
+            break;
+        const index = BASE64URL_CHARS.indexOf(char);
+        if (index === -1) {
+            throw new WorkflowRuntimeError(`Invalid base64url character "${char}" in X25519 JWK key component`);
+        }
+        accumulator = (accumulator << 6) | index;
+        bitCount += 6;
+        if (bitCount >= 8) {
+            bitCount -= 8;
+            bytes.push((accumulator >> bitCount) & 0xff);
+        }
+    }
+    return new Uint8Array(bytes);
+}
+/**
+ * Derive the AES-256-GCM content key from an X25519 shared secret, binding
+ * it to both public keys (HPKE's `kem_context`).
+ */
+async function deriveContentKey(sharedSecret, ephemeralPublicKey, recipientPublicKey, usages) {
+    const label = infoEncoder.encode(CONTENT_KEY_INFO);
+    const info = new Uint8Array(label.length + ephemeralPublicKey.length + recipientPublicKey.length);
+    info.set(label, 0);
+    info.set(ephemeralPublicKey, label.length);
+    info.set(recipientPublicKey, label.length + ephemeralPublicKey.length);
+    const hkdfKey = await globalThis.crypto.subtle.importKey('raw', sharedSecret, 'HKDF', false, ['deriveBits']);
+    const contentKeyBits = await globalThis.crypto.subtle.deriveBits({ name: 'HKDF', hash: 'SHA-256', salt: new Uint8Array(32), info }, hkdfKey, CONTENT_KEY_LENGTH * 8);
+    return globalThis.crypto.subtle.importKey('raw', new Uint8Array(contentKeyBits), 'AES-GCM', false, 
+    // `KeyUsage` is a DOM-lib type that is not in scope under `es2022`; the
+    // parameter type is a strict subset of it, so this cast is sound.
+    usages);
+}
+/**
+ * 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 async function encapsulate(recipientPublicKey) {
+    assertPublicKeyLength(recipientPublicKey, 'Recipient public key');
+    let recipientKey;
+    try {
+        recipientKey = await importPublicKey(recipientPublicKey);
+    }
+    catch (cause) {
+        throw new WorkflowRuntimeError(`Invalid X25519 recipient public key: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    }
+    const ephemeral = (await globalThis.crypto.subtle.generateKey({ name: 'X25519' }, 
+    /* extractable */ true, ['deriveBits']));
+    const ephemeralPublicKey = new Uint8Array(await globalThis.crypto.subtle.exportKey('raw', ephemeral.publicKey));
+    let sharedSecretBits;
+    try {
+        sharedSecretBits = await globalThis.crypto.subtle.deriveBits({ name: 'X25519', public: recipientKey }, ephemeral.privateKey, X25519_KEY_LENGTH * 8);
+    }
+    catch (cause) {
+        // Web Crypto throws OperationError when the shared secret is all-zero,
+        // which happens exactly when the recipient public key is a low-order
+        // point. This is the platform giving us HPKE's contributory-behavior
+        // check for free.
+        throw new WorkflowRuntimeError('X25519 key agreement failed: the recipient public key is not a valid ' +
+            'curve point (low-order point or corrupted key material)', { cause });
+    }
+    const contentKey = await deriveContentKey(new Uint8Array(sharedSecretBits), ephemeralPublicKey, recipientPublicKey, ['encrypt']);
+    return { ephemeralPublicKey, contentKey };
+}
+/**
+ * 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 async function decapsulate(keyPair, ephemeralPublicKey) {
+    if (ephemeralPublicKey.byteLength !== X25519_KEY_LENGTH) {
+        throw new RuntimeDecryptionError(`Sealed payload has a malformed ephemeral public key: expected ${X25519_KEY_LENGTH} bytes, got ${ephemeralPublicKey.byteLength}`, {
+            context: {
+                operation: 'decrypt',
+                byteLength: ephemeralPublicKey.byteLength,
+            },
+        });
+    }
+    let sharedSecretBits;
+    try {
+        const [privateKey, senderKey] = await Promise.all([
+            importScalar(keyPair.scalar, /* extractable */ false),
+            importPublicKey(ephemeralPublicKey),
+        ]);
+        sharedSecretBits = await globalThis.crypto.subtle.deriveBits({ name: 'X25519', public: senderKey }, privateKey, X25519_KEY_LENGTH * 8);
+    }
+    catch (cause) {
+        throw new RuntimeDecryptionError(`X25519 key agreement failed while opening a sealed payload: ${cause instanceof Error ? cause.message : String(cause)}`, {
+            cause,
+            context: {
+                operation: 'decrypt',
+                byteLength: ephemeralPublicKey.byteLength,
+            },
+        });
+    }
+    return deriveContentKey(new Uint8Array(sharedSecretBits), ephemeralPublicKey, keyPair.publicKey, ['decrypt']);
+}
+/**
+ * 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 async function seal(recipientPublicKey, data, aad) {
+    const { ephemeralPublicKey, contentKey } = await encapsulate(recipientPublicKey);
+    const encrypted = await aesGcmEncrypt(contentKey, data, aad);
+    const result = new Uint8Array(ephemeralPublicKey.byteLength + encrypted.byteLength);
+    result.set(ephemeralPublicKey, 0);
+    result.set(encrypted, ephemeralPublicKey.byteLength);
+    return result;
+}
+/**
+ * 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 async function open(keyPair, sealed, aad) {
+    // Ephemeral public key + AES-GCM nonce + AES-GCM tag.
+    const minLength = X25519_KEY_LENGTH + NONCE_LENGTH + TAG_BYTES;
+    if (sealed.byteLength < minLength) {
+        throw new RuntimeDecryptionError(`Sealed payload too short: expected at least ${minLength} bytes, got ${sealed.byteLength}`, { context: { operation: 'decrypt', byteLength: sealed.byteLength } });
+    }
+    const ephemeralPublicKey = sealed.subarray(0, X25519_KEY_LENGTH);
+    const encrypted = sealed.subarray(X25519_KEY_LENGTH);
+    const contentKey = await decapsulate(keyPair, ephemeralPublicKey);
+    return aesGcmDecrypt(contentKey, encrypted, aad);
+}
+/**
+ * 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 function createSealSession(recipientPublicKey, aad) {
+    let encapsulation;
+    return {
+        async seal(data) {
+            // Lazily, so constructing a session for a stream that is never written
+            // to costs nothing.
+            encapsulation ??= encapsulate(recipientPublicKey);
+            const { ephemeralPublicKey, contentKey } = await encapsulation;
+            const encrypted = await aesGcmEncrypt(contentKey, data, aad);
+            const result = new Uint8Array(ephemeralPublicKey.byteLength + encrypted.byteLength);
+            result.set(ephemeralPublicKey, 0);
+            result.set(encrypted, ephemeralPublicKey.byteLength);
+            return result;
+        },
+    };
+}
+/**
+ * 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 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 function createOpenSession(keyPair, aad) {
+    let cachedSender;
+    let cachedKey;
+    return {
+        async open(sealed) {
+            const minLength = X25519_KEY_LENGTH + NONCE_LENGTH + TAG_BYTES;
+            if (sealed.byteLength < minLength) {
+                throw new RuntimeDecryptionError(`Sealed payload too short: expected at least ${minLength} bytes, got ${sealed.byteLength}`, { context: { operation: 'decrypt', byteLength: sealed.byteLength } });
+            }
+            const ephemeralPublicKey = sealed.subarray(0, X25519_KEY_LENGTH);
+            const encrypted = sealed.subarray(X25519_KEY_LENGTH);
+            const sender = keyCacheId(ephemeralPublicKey);
+            if (sender !== cachedSender || !cachedKey) {
+                cachedSender = sender;
+                cachedKey = decapsulate(keyPair, ephemeralPublicKey);
+            }
+            let contentKey;
+            try {
+                contentKey = await cachedKey;
+            }
+            catch (error) {
+                // Do not let one bad frame poison the cache for subsequent frames.
+                cachedSender = undefined;
+                cachedKey = undefined;
+                throw error;
+            }
+            return aesGcmDecrypt(contentKey, encrypted, aad);
+        },
+    };
+}
+/** Stable cache key for a 32-byte public key. */
+function keyCacheId(publicKey) {
+    let id = '';
+    for (let i = 0; i < publicKey.length; i++) {
+        id += publicKey[i].toString(16).padStart(2, '0');
+    }
+    return id;
+}
+/**
+ * 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 function runAad(projectId, runId) {
+    return infoEncoder.encode(`${projectId}|${runId}`);
+}
+/**
+ * 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 function decodeRunPublicKey(value) {
+    if (!value)
+        return undefined;
+    const bytes = base64ToBytes(value);
+    if (!bytes || bytes.byteLength !== X25519_KEY_LENGTH)
+        return undefined;
+    return bytes;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sealed-box.js","sourceRoot":"","sources":["../src/sealed-box.ts"],"names":[],"mappings":"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","sourcesContent":["import { RuntimeDecryptionError, WorkflowRuntimeError } from '@workflow/errors';\nimport {\n  decrypt as aesGcmDecrypt,\n  encrypt as aesGcmEncrypt,\n  type CryptoKey,\n  NONCE_LENGTH,\n  TAG_BYTES,\n} from './encryption.js';\n\n/**\n * Browser-compatible sealed-box (asymmetric) encryption for cross-run writes.\n *\n * ## Why this exists\n *\n * The symmetric `encr` path requires the writer to hold the recipient run's\n * key, which also grants decrypt capability. For *cross-run* writes (a hook\n * resumption targeting another run, or a child workflow writing into a\n * parent's forwarded `WritableStream`) that is more authority than the writer\n * needs, and obtaining the symmetric key across a deployment boundary costs a\n * round trip to the Vercel API.\n *\n * A sealed box fixes both: the writer needs only the recipient's **public**\n * key, which is not secret and therefore travels on the run entity (and in\n * stream descriptors) at no cost. \"Encrypt-only\" stops being an honor-system\n * convention enforced by `importKey(raw, ['encrypt'])` and becomes a\n * cryptographic guarantee: a writer holding only the public key provably\n * cannot read anything.\n *\n * ## Key hierarchy\n *\n * Both keys descend from the same per-run key material `K` that\n * `World.getEncryptionKeyForRun()` already returns today, so nothing about\n * key acquisition, the World interface, or the Vercel API changes:\n *\n * ```\n * K  (32 bytes, per-run, = HKDF(VERCEL_DEPLOYMENT_KEY, \"projectId|runId\"))\n * ├── AES-256 key = K used directly            → 'encr' envelopes (unchanged)\n * └── X25519 scalar = HKDF(K, SCALAR_INFO)     → 'encp' envelopes\n *     └── public key = X25519 basepoint · scalar   (published, not secret)\n * ```\n *\n * `K` is therefore both an AEAD key and a key-derivation key. This is sound:\n * AES-GCM never exposes its key, and HKDF-SHA256 output is computationally\n * independent of the AES keystream. A strict reading of NIST SP 800-108\n * prefers these roles be separated, but `K`'s direct AES use is fixed by\n * backward compatibility with every `encr` payload already written.\n *\n * ## Construction\n *\n * An ECIES-style sealed box using the same primitives as HPKE (RFC 9180)\n * base mode with DHKEM(X25519, HKDF-SHA256) and AES-256-GCM, but without the\n * full `LabeledExtract`/`LabeledExpand` suite-ID ceremony:\n *\n * ```\n * ephemeral    = X25519 keypair, freshly generated per encryption context\n * sharedSecret = X25519(ephemeralPrivate, recipientPublic)\n * contentKey   = HKDF-SHA256(\n *                  ikm  = sharedSecret,\n *                  salt = zeros(32),\n *                  info = CONTENT_KEY_INFO ‖ ephemeralPublic ‖ recipientPublic,\n *                )\n * ```\n *\n * Binding both public keys into `info` is the security-critical part (it is\n * HPKE's `kem_context`): it prevents key-substitution/unknown-key-share\n * attacks in which an adversary replays a ciphertext as though it had been\n * sealed to a different recipient. Deviating from strict RFC 9180 framing is\n * a deliberate, documented choice: the envelope is versioned via its format\n * prefix and the HKDF labels below, so a conformant profile can be added\n * later as a new version without touching existing payloads.\n *\n * Wire format (the `encp` format prefix is attached by the serialization\n * layer, not by this module):\n *\n * ```\n * [ephemeral public key (32 bytes)][nonce (12 bytes)][ciphertext + GCM tag (16 bytes)]\n * ```\n *\n * ## Nonce discipline\n *\n * One-shot {@link seal} generates a fresh ephemeral keypair (and therefore a\n * fresh content key) for every call, so nonce reuse is impossible.\n *\n * Callers that amortize the KEM across many frames via {@link encapsulate}\n * take on nonce discipline themselves, because the content key then outlives a\n * single message. Two rules apply:\n *\n * 1. Every frame MUST use a fresh random nonce (which `aesGcmEncrypt` does).\n *    Never a counter: a counter restarts at zero after a stream reconnect or a\n *    durable replay, reusing `(contentKey, nonce)`, which under AES-GCM leaks\n *    the plaintext XOR of the two frames and the GCM auth subkey.\n * 2. A writer must not inherit a previous incarnation's content key, so\n *    {@link encapsulate} is re-run per writer instance.\n *\n * Nothing in this module enforces either rule; it is the streaming caller's\n * contract.\n */\n\n/** Length of an X25519 private scalar and public key, in bytes. */\nconst X25519_KEY_LENGTH = 32;\n\n/** Length of the AES-256 content key derived from the shared secret. */\nconst CONTENT_KEY_LENGTH = 32;\n\n/**\n * HKDF `info` label for deriving the per-run X25519 scalar from the per-run\n * key material.\n *\n * Versioned and namespaced so that any future derivation from the same `K`\n * (a second keypair, a MAC key, a different curve) can never collide with\n * this one.\n */\nconst SCALAR_INFO = 'workflow/encp/x25519/v1';\n\n/**\n * HKDF `info` prefix for deriving the AES-256-GCM content key from an X25519\n * shared secret. The ephemeral and recipient public keys are appended to this\n * label to form the full `info` (HPKE's `kem_context`).\n */\nconst CONTENT_KEY_INFO = 'workflow/encp/aes256gcm/v1';\n\n/**\n * DER prefix for an RFC 8410 `PrivateKeyInfo` wrapping a raw X25519 scalar.\n *\n * Web Crypto cannot import a raw X25519 private key (`importKey('raw', ...)`\n * is only defined for public keys on the Secure Curves algorithms), so a\n * derived scalar has to be wrapped in PKCS#8 before it can be used. The\n * structure is fully determined for a 32-byte X25519 key:\n *\n * ```\n * SEQUENCE (46 bytes)                         30 2e\n *   INTEGER 0                                 02 01 00\n *   SEQUENCE (5 bytes)                        30 05\n *     OBJECT IDENTIFIER 1.3.101.110 (X25519)  06 03 2b 65 6e\n *   OCTET STRING (34 bytes)                   04 22\n *     OCTET STRING (32 bytes)                 04 20\n *       <scalar>\n * ```\n */\nconst PKCS8_X25519_PREFIX = new Uint8Array([\n  0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e, 0x04,\n  0x22, 0x04, 0x20,\n]);\n\nconst infoEncoder = new TextEncoder();\n\n/**\n * A per-run X25519 keypair, derived from the run's key material.\n *\n * Callers should derive this once per run and memoize it alongside the\n * symmetric key, since derivation costs several Web Crypto round trips.\n */\nexport interface RunKeyPair {\n  /** Raw 32-byte X25519 private scalar. Secret. */\n  readonly scalar: Uint8Array;\n  /** Raw 32-byte X25519 public key. Safe to publish. */\n  readonly publicKey: Uint8Array;\n}\n\nfunction assertKeyMaterialLength(runKeyMaterial: Uint8Array): void {\n  if (runKeyMaterial.byteLength !== CONTENT_KEY_LENGTH) {\n    throw new WorkflowRuntimeError(\n      `Run key material must be exactly ${CONTENT_KEY_LENGTH} bytes, got ${runKeyMaterial.byteLength}`\n    );\n  }\n}\n\nfunction assertPublicKeyLength(publicKey: Uint8Array, label: string): void {\n  if (publicKey.byteLength !== X25519_KEY_LENGTH) {\n    throw new WorkflowRuntimeError(\n      `${label} must be exactly ${X25519_KEY_LENGTH} bytes, got ${publicKey.byteLength}`\n    );\n  }\n}\n\n/**\n * Derive the per-run X25519 keypair from the run's 32-byte key material.\n *\n * Deterministic: the same key material always yields the same keypair, which\n * is what lets the owning deployment re-derive its private scalar on demand\n * (from `VERCEL_DEPLOYMENT_KEY`) instead of storing it anywhere.\n *\n * @param runKeyMaterial - The 32 bytes returned by `World.getEncryptionKeyForRun()`\n * @returns The run's X25519 scalar and public key\n */\nexport async function deriveRunKeyPair(\n  runKeyMaterial: Uint8Array\n): Promise<RunKeyPair> {\n  assertKeyMaterialLength(runKeyMaterial);\n\n  const hkdfKey = await globalThis.crypto.subtle.importKey(\n    'raw',\n    runKeyMaterial,\n    'HKDF',\n    false,\n    ['deriveBits']\n  );\n\n  // Zero salt is acceptable per RFC 5869 §3.1: the IKM here is itself HKDF\n  // output (or a high-entropy BYOK value), so it is already uniform. The\n  // `info` label provides domain separation.\n  const scalarBits = await globalThis.crypto.subtle.deriveBits(\n    {\n      name: 'HKDF',\n      hash: 'SHA-256',\n      salt: new Uint8Array(32),\n      info: infoEncoder.encode(SCALAR_INFO),\n    },\n    hkdfKey,\n    X25519_KEY_LENGTH * 8\n  );\n  const scalar = new Uint8Array(scalarBits);\n\n  // Any 32-byte string is a valid X25519 scalar (the low/high bits are\n  // clamped during scalar multiplication), so the HKDF output needs no\n  // rejection sampling.\n  const publicKey = await derivePublicKeyFromScalar(scalar);\n  return { scalar, publicKey };\n}\n\n/**\n * Recover the raw public key for a scalar.\n *\n * Web Crypto exposes no scalar-multiplication primitive, so the scalar is\n * imported as a PKCS#8 private key and its public half read back out of the\n * JWK export (`x`), which the Secure Curves spec defines as the base64url\n * raw public key.\n */\nasync function derivePublicKeyFromScalar(\n  scalar: Uint8Array\n): Promise<Uint8Array> {\n  const privateKey = await importScalar(scalar, /* extractable */ true);\n  const jwk = await globalThis.crypto.subtle.exportKey('jwk', privateKey);\n  if (!jwk.x) {\n    throw new WorkflowRuntimeError(\n      'X25519 JWK export did not include a public key component (\"x\")'\n    );\n  }\n  const publicKey = base64UrlToBytes(jwk.x);\n  // Guard the one step in this module that trusts an external encoding. A\n  // short or malformed value here would otherwise flow onward and fail much\n  // later, inside key agreement, with a far less obvious message.\n  if (publicKey.byteLength !== X25519_KEY_LENGTH) {\n    throw new WorkflowRuntimeError(\n      `X25519 JWK export produced a ${publicKey.byteLength}-byte public key, expected ${X25519_KEY_LENGTH}`\n    );\n  }\n  return publicKey;\n}\n\nasync function importScalar(\n  scalar: Uint8Array,\n  extractable: boolean\n): Promise<CryptoKey> {\n  const pkcs8 = new Uint8Array(PKCS8_X25519_PREFIX.length + scalar.byteLength);\n  pkcs8.set(PKCS8_X25519_PREFIX, 0);\n  pkcs8.set(scalar, PKCS8_X25519_PREFIX.length);\n  return globalThis.crypto.subtle.importKey(\n    'pkcs8',\n    pkcs8,\n    { name: 'X25519' },\n    extractable,\n    ['deriveBits']\n  );\n}\n\nfunction importPublicKey(publicKey: Uint8Array): Promise<CryptoKey> {\n  return globalThis.crypto.subtle.importKey(\n    'raw',\n    publicKey,\n    { name: 'X25519' },\n    /* extractable */ true,\n    // Public keys carry no usages for X25519: the private key does the\n    // deriving; the public key is only ever an argument to it.\n    []\n  );\n}\n\nconst BASE64_CHARS =\n  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\nconst BASE64URL_CHARS =\n  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';\n\n/**\n * Encode bytes as standard (padded) base64.\n *\n * Hand-rolled for the same reason as {@link base64UrlToBytes}: this module\n * runs in the browser (o11y decryption) and inside the workflow VM, so neither\n * `Buffer` nor `btoa` can be assumed. Used for the wire encoding of run public\n * keys, matching the base64 convention already used for `VERCEL_DEPLOYMENT_KEY`\n * and the `run-key` API response.\n */\nexport function bytesToBase64(bytes: Uint8Array): string {\n  let out = '';\n  for (let i = 0; i < bytes.length; i += 3) {\n    const b0 = bytes[i];\n    const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;\n    const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;\n\n    out += BASE64_CHARS[(b0 >> 2) & 0x3f];\n    out += BASE64_CHARS[((b0 & 0x03) << 4) | ((b1 >> 4) & 0x0f)];\n    out +=\n      i + 1 < bytes.length\n        ? BASE64_CHARS[((b1 & 0x0f) << 2) | ((b2 >> 6) & 0x03)]\n        : '=';\n    out += i + 2 < bytes.length ? BASE64_CHARS[b2 & 0x3f] : '=';\n  }\n  return out;\n}\n\n/**\n * Decode standard base64 (padding optional) to bytes.\n *\n * Returns `undefined` for malformed input rather than throwing: callers decode\n * public keys that arrive from storage or over the wire, where a corrupt value\n * should degrade to \"this run has no usable public key\" (and fall back to the\n * symmetric path) rather than crash a resumption.\n *\n * Validation is strict, because a lenient decoder is worse than a throwing one\n * here: silently returning a short or truncated key makes a corrupt value look\n * *present*, so the caller seals to garbage instead of taking the fallback.\n * Rejected: characters outside the alphabet, a length that cannot describe a\n * whole number of bytes (`length % 4 === 1`), padding anywhere but the end, and\n * a final quantum whose unused low bits are not zero.\n */\nexport function base64ToBytes(value: string): Uint8Array | undefined {\n  // Strip trailing padding, then require what remains to be padding-free.\n  let end = value.length;\n  while (end > 0 && value[end - 1] === '=') end--;\n  const body = value.slice(0, end);\n  if (body.includes('=')) return undefined;\n\n  // 4 chars -> 3 bytes; 3 -> 2; 2 -> 1. A remainder of 1 encodes no byte.\n  if (body.length % 4 === 1) return undefined;\n  // Padding, when present, must bring the total to a multiple of 4.\n  if (end !== value.length && value.length % 4 !== 0) return undefined;\n\n  let accumulator = 0;\n  let bitCount = 0;\n  const bytes: number[] = [];\n\n  for (let i = 0; i < body.length; i++) {\n    const index = BASE64_CHARS.indexOf(body[i]);\n    if (index === -1) return undefined;\n    accumulator = (accumulator << 6) | index;\n    bitCount += 6;\n    if (bitCount >= 8) {\n      bitCount -= 8;\n      bytes.push((accumulator >> bitCount) & 0xff);\n    }\n  }\n\n  // Leftover bits belong to no byte and must be zero in canonical base64.\n  if (bitCount > 0 && (accumulator & ((1 << bitCount) - 1)) !== 0) {\n    return undefined;\n  }\n\n  return new Uint8Array(bytes);\n}\n\n/**\n * Decode a base64url string (JWK encoding) to bytes.\n *\n * Hand-rolled rather than using `atob` or `Buffer`: this module also runs\n * inside the workflow VM, whose global surface is deliberately minimal and\n * does not include either. The inputs here are fixed-size JWK key components,\n * so a compact decoder is sufficient: it accepts unpadded base64url only,\n * which is what RFC 7515 §2 mandates for JWK members.\n */\nfunction base64UrlToBytes(value: string): Uint8Array {\n  let accumulator = 0;\n  let bitCount = 0;\n  const bytes: number[] = [];\n\n  for (let i = 0; i < value.length; i++) {\n    const char = value[i];\n    if (char === '=') break;\n    const index = BASE64URL_CHARS.indexOf(char);\n    if (index === -1) {\n      throw new WorkflowRuntimeError(\n        `Invalid base64url character \"${char}\" in X25519 JWK key component`\n      );\n    }\n    accumulator = (accumulator << 6) | index;\n    bitCount += 6;\n    if (bitCount >= 8) {\n      bitCount -= 8;\n      bytes.push((accumulator >> bitCount) & 0xff);\n    }\n  }\n\n  return new Uint8Array(bytes);\n}\n\n/**\n * Derive the AES-256-GCM content key from an X25519 shared secret, binding\n * it to both public keys (HPKE's `kem_context`).\n */\nasync function deriveContentKey(\n  sharedSecret: Uint8Array,\n  ephemeralPublicKey: Uint8Array,\n  recipientPublicKey: Uint8Array,\n  usages: ReadonlyArray<'encrypt' | 'decrypt'>\n): Promise<CryptoKey> {\n  const label = infoEncoder.encode(CONTENT_KEY_INFO);\n  const info = new Uint8Array(\n    label.length + ephemeralPublicKey.length + recipientPublicKey.length\n  );\n  info.set(label, 0);\n  info.set(ephemeralPublicKey, label.length);\n  info.set(recipientPublicKey, label.length + ephemeralPublicKey.length);\n\n  const hkdfKey = await globalThis.crypto.subtle.importKey(\n    'raw',\n    sharedSecret,\n    'HKDF',\n    false,\n    ['deriveBits']\n  );\n  const contentKeyBits = await globalThis.crypto.subtle.deriveBits(\n    { name: 'HKDF', hash: 'SHA-256', salt: new Uint8Array(32), info },\n    hkdfKey,\n    CONTENT_KEY_LENGTH * 8\n  );\n\n  return globalThis.crypto.subtle.importKey(\n    'raw',\n    new Uint8Array(contentKeyBits),\n    'AES-GCM',\n    false,\n    // `KeyUsage` is a DOM-lib type that is not in scope under `es2022`; the\n    // parameter type is a strict subset of it, so this cast is sound.\n    usages as ('encrypt' | 'decrypt')[]\n  );\n}\n\n/**\n * The writer half of the KEM: generate an ephemeral keypair and derive a\n * content key for a recipient's public key.\n *\n * Use this when many payloads share one KEM operation, i.e. stream frames.\n * The returned `contentKey` can only encrypt, so a stream writer provably\n * cannot read the recipient run's data even by mistake.\n *\n * **Callers own nonce discipline.** Encrypt each frame with a fresh random\n * nonce, and call this function again for every new connection attempt or\n * replay so that a restarted writer never reuses a content key. For one-shot\n * payloads prefer {@link seal}, which handles this automatically.\n *\n * @param recipientPublicKey - The recipient run's raw 32-byte X25519 public key\n * @returns The ephemeral public key to publish alongside the ciphertext, and\n *   the encrypt-only content key\n */\nexport async function encapsulate(recipientPublicKey: Uint8Array): Promise<{\n  ephemeralPublicKey: Uint8Array;\n  contentKey: CryptoKey;\n}> {\n  assertPublicKeyLength(recipientPublicKey, 'Recipient public key');\n\n  let recipientKey: CryptoKey;\n  try {\n    recipientKey = await importPublicKey(recipientPublicKey);\n  } catch (cause) {\n    throw new WorkflowRuntimeError(\n      `Invalid X25519 recipient public key: ${cause instanceof Error ? cause.message : String(cause)}`,\n      { cause }\n    );\n  }\n\n  const ephemeral = (await globalThis.crypto.subtle.generateKey(\n    { name: 'X25519' },\n    /* extractable */ true,\n    ['deriveBits']\n  )) as { privateKey: CryptoKey; publicKey: CryptoKey };\n\n  const ephemeralPublicKey = new Uint8Array(\n    await globalThis.crypto.subtle.exportKey('raw', ephemeral.publicKey)\n  );\n\n  let sharedSecretBits: ArrayBuffer;\n  try {\n    sharedSecretBits = await globalThis.crypto.subtle.deriveBits(\n      { name: 'X25519', public: recipientKey },\n      ephemeral.privateKey,\n      X25519_KEY_LENGTH * 8\n    );\n  } catch (cause) {\n    // Web Crypto throws OperationError when the shared secret is all-zero,\n    // which happens exactly when the recipient public key is a low-order\n    // point. This is the platform giving us HPKE's contributory-behavior\n    // check for free.\n    throw new WorkflowRuntimeError(\n      'X25519 key agreement failed: the recipient public key is not a valid ' +\n        'curve point (low-order point or corrupted key material)',\n      { cause }\n    );\n  }\n\n  const contentKey = await deriveContentKey(\n    new Uint8Array(sharedSecretBits),\n    ephemeralPublicKey,\n    recipientPublicKey,\n    ['encrypt']\n  );\n\n  return { ephemeralPublicKey, contentKey };\n}\n\n/**\n * The recipient half of the KEM: recover the content key for a sealed\n * payload from the run's own keypair and the sender's ephemeral public key.\n *\n * @param keyPair - The recipient run's keypair, from {@link deriveRunKeyPair}\n * @param ephemeralPublicKey - The sender's raw 32-byte X25519 public key,\n *   read from the head of the sealed envelope\n * @returns A decrypt-only content key\n */\nexport async function decapsulate(\n  keyPair: RunKeyPair,\n  ephemeralPublicKey: Uint8Array\n): Promise<CryptoKey> {\n  if (ephemeralPublicKey.byteLength !== X25519_KEY_LENGTH) {\n    throw new RuntimeDecryptionError(\n      `Sealed payload has a malformed ephemeral public key: expected ${X25519_KEY_LENGTH} bytes, got ${ephemeralPublicKey.byteLength}`,\n      {\n        context: {\n          operation: 'decrypt',\n          byteLength: ephemeralPublicKey.byteLength,\n        },\n      }\n    );\n  }\n\n  let sharedSecretBits: ArrayBuffer;\n  try {\n    const [privateKey, senderKey] = await Promise.all([\n      importScalar(keyPair.scalar, /* extractable */ false),\n      importPublicKey(ephemeralPublicKey),\n    ]);\n    sharedSecretBits = await globalThis.crypto.subtle.deriveBits(\n      { name: 'X25519', public: senderKey },\n      privateKey,\n      X25519_KEY_LENGTH * 8\n    );\n  } catch (cause) {\n    throw new RuntimeDecryptionError(\n      `X25519 key agreement failed while opening a sealed payload: ${cause instanceof Error ? cause.message : String(cause)}`,\n      {\n        cause,\n        context: {\n          operation: 'decrypt',\n          byteLength: ephemeralPublicKey.byteLength,\n        },\n      }\n    );\n  }\n\n  return deriveContentKey(\n    new Uint8Array(sharedSecretBits),\n    ephemeralPublicKey,\n    keyPair.publicKey,\n    ['decrypt']\n  );\n}\n\n/**\n * Seal a payload to a run's public key.\n *\n * Each call performs its own KEM operation, so every sealed payload gets an\n * independent content key: nonce reuse across calls is impossible by\n * construction.\n *\n * @param recipientPublicKey - The recipient run's raw 32-byte X25519 public key\n * @param data - Plaintext to seal\n * @param aad - Optional additional authenticated data, covered by the GCM tag\n *   but not encrypted. Callers pass the recipient's `projectId|runId` so a\n *   sealed payload cannot be replayed against a different run.\n * @returns `[ephemeral public key (32)][nonce (12)][ciphertext + tag]`\n */\nexport async function seal(\n  recipientPublicKey: Uint8Array,\n  data: Uint8Array,\n  aad?: Uint8Array\n): Promise<Uint8Array> {\n  const { ephemeralPublicKey, contentKey } =\n    await encapsulate(recipientPublicKey);\n  const encrypted = await aesGcmEncrypt(contentKey, data, aad);\n\n  const result = new Uint8Array(\n    ephemeralPublicKey.byteLength + encrypted.byteLength\n  );\n  result.set(ephemeralPublicKey, 0);\n  result.set(encrypted, ephemeralPublicKey.byteLength);\n  return result;\n}\n\n/**\n * Open a payload sealed to this run's public key.\n *\n * @param keyPair - The recipient run's keypair, from {@link deriveRunKeyPair}\n * @param sealed - `[ephemeral public key (32)][nonce (12)][ciphertext + tag]`\n * @param aad - The exact additional authenticated data passed to {@link seal}\n * @returns The decrypted plaintext\n */\nexport async function open(\n  keyPair: RunKeyPair,\n  sealed: Uint8Array,\n  aad?: Uint8Array\n): Promise<Uint8Array> {\n  // Ephemeral public key + AES-GCM nonce + AES-GCM tag.\n  const minLength = X25519_KEY_LENGTH + NONCE_LENGTH + TAG_BYTES;\n  if (sealed.byteLength < minLength) {\n    throw new RuntimeDecryptionError(\n      `Sealed payload too short: expected at least ${minLength} bytes, got ${sealed.byteLength}`,\n      { context: { operation: 'decrypt', byteLength: sealed.byteLength } }\n    );\n  }\n\n  const ephemeralPublicKey = sealed.subarray(0, X25519_KEY_LENGTH);\n  const encrypted = sealed.subarray(X25519_KEY_LENGTH);\n  const contentKey = await decapsulate(keyPair, ephemeralPublicKey);\n  return aesGcmDecrypt(contentKey, encrypted, aad);\n}\n\n/**\n * A writer-side session that amortizes one KEM operation across many sealed\n * payloads. Use it for streams, where one-shot {@link seal} would perform a\n * fresh keygen + ECDH + HKDF for every frame.\n *\n * Safety rests on two properties:\n *\n * - Every payload still gets a **fresh random nonce** from `aesGcmEncrypt`, so\n *   sharing the content key does not risk `(key, nonce)` reuse. (A counter\n *   would: it restarts at zero whenever a writer restarts.)\n * - The session is bound to one writer instance. A reconnect or a durable\n *   replay constructs a new session, so a restarted writer never inherits a\n *   previous incarnation's content key.\n *\n * The envelope layout is byte-identical to {@link seal}, so a reader cannot\n * tell which was used and needs no matching session.\n */\nexport function createSealSession(\n  recipientPublicKey: Uint8Array,\n  aad?: Uint8Array\n): { seal(data: Uint8Array): Promise<Uint8Array> } {\n  let encapsulation:\n    | Promise<{ ephemeralPublicKey: Uint8Array; contentKey: CryptoKey }>\n    | undefined;\n\n  return {\n    async seal(data: Uint8Array): Promise<Uint8Array> {\n      // Lazily, so constructing a session for a stream that is never written\n      // to costs nothing.\n      encapsulation ??= encapsulate(recipientPublicKey);\n      const { ephemeralPublicKey, contentKey } = await encapsulation;\n      const encrypted = await aesGcmEncrypt(contentKey, data, aad);\n\n      const result = new Uint8Array(\n        ephemeralPublicKey.byteLength + encrypted.byteLength\n      );\n      result.set(ephemeralPublicKey, 0);\n      result.set(encrypted, ephemeralPublicKey.byteLength);\n      return result;\n    },\n  };\n}\n\n/**\n * A reader-side session that caches decapsulation per sender.\n *\n * The mirror of {@link createSealSession}: because every frame from one writer\n * carries the same ephemeral public key, this turns an ECDH per frame into an\n * ECDH per writer. Correctness does not depend on the writer having used a\n * session: a stream of independently sealed payloads misses the cache\n * on each new ephemeral key.\n *\n * The cache is keyed by the ephemeral public key and holds one entry, which is\n * the common case (one writer per stream). A second writer evicts the first\n * rather than growing without bound.\n */\nexport function createOpenSession(\n  keyPair: RunKeyPair,\n  aad?: Uint8Array\n): { open(sealed: Uint8Array): Promise<Uint8Array> } {\n  let cachedSender: string | undefined;\n  let cachedKey: Promise<CryptoKey> | undefined;\n\n  return {\n    async open(sealed: Uint8Array): Promise<Uint8Array> {\n      const minLength = X25519_KEY_LENGTH + NONCE_LENGTH + TAG_BYTES;\n      if (sealed.byteLength < minLength) {\n        throw new RuntimeDecryptionError(\n          `Sealed payload too short: expected at least ${minLength} bytes, got ${sealed.byteLength}`,\n          { context: { operation: 'decrypt', byteLength: sealed.byteLength } }\n        );\n      }\n\n      const ephemeralPublicKey = sealed.subarray(0, X25519_KEY_LENGTH);\n      const encrypted = sealed.subarray(X25519_KEY_LENGTH);\n\n      const sender = keyCacheId(ephemeralPublicKey);\n      if (sender !== cachedSender || !cachedKey) {\n        cachedSender = sender;\n        cachedKey = decapsulate(keyPair, ephemeralPublicKey);\n      }\n\n      let contentKey: CryptoKey;\n      try {\n        contentKey = await cachedKey;\n      } catch (error) {\n        // Do not let one bad frame poison the cache for subsequent frames.\n        cachedSender = undefined;\n        cachedKey = undefined;\n        throw error;\n      }\n\n      return aesGcmDecrypt(contentKey, encrypted, aad);\n    },\n  };\n}\n\n/** Stable cache key for a 32-byte public key. */\nfunction keyCacheId(publicKey: Uint8Array): string {\n  let id = '';\n  for (let i = 0; i < publicKey.length; i++) {\n    id += publicKey[i].toString(16).padStart(2, '0');\n  }\n  return id;\n}\n\n/**\n * Build the additional authenticated data that binds a sealed payload to a\n * specific run.\n *\n * Mirrors the `info` used for symmetric per-run key derivation so the two\n * schemes agree on what \"this run\" means.\n *\n * Note that the sealed-box construction already binds a payload to its\n * recipient without any AAD: the content key is derived over\n * `ephemeralPublicKey ‖ recipientPublicKey`, and a recipient public key is\n * unique per (deployment key × project × run). Replaying a sealed payload at\n * a different run therefore fails at key agreement regardless. AAD is\n * available for callers that want an additional, KDF-independent binding:\n * both sides must supply byte-identical values or the payload will not open.\n */\nexport function runAad(projectId: string, runId: string): Uint8Array {\n  return infoEncoder.encode(`${projectId}|${runId}`);\n}\n\n/**\n * Decode a run's published public key, validating both encoding and length.\n *\n * Returns `undefined` when the value is absent, not valid base64, or not\n * exactly 32 bytes. Callers treat that as \"this run has no usable public key\"\n * and fall back to the symmetric path, so a corrupt or truncated stored value\n * degrades to the pre-existing behavior instead of failing a resumption.\n */\nexport function decodeRunPublicKey(\n  value: string | undefined\n): Uint8Array | undefined {\n  if (!value) return undefined;\n  const bytes = base64ToBytes(value);\n  if (!bytes || bytes.byteLength !== X25519_KEY_LENGTH) return undefined;\n  return bytes;\n}\n"]}