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

package/dist/encryption.js

@@ -1,6 +1,10 @@
 import { RuntimeDecryptionError, WorkflowRuntimeError } from '@workflow/errors';
-const NONCE_LENGTH = 12;
-const TAG_LENGTH = 128; // bits
+/** AES-GCM nonce length in bytes. */
+export const NONCE_LENGTH = 12;
+/** AES-GCM authentication tag length in bits. */
+export const TAG_LENGTH = 128;
+/** AES-GCM authentication tag length in bytes. */
+export const TAG_BYTES = TAG_LENGTH / 8;
 const KEY_LENGTH = 32; // bytes (AES-256)
 /**
  * Import a raw AES-256 key as a `CryptoKey` for use with `encrypt()`/`decrypt()`.
@@ -32,13 +36,22 @@ export async function importKey(raw, usages = ['encrypt', 'decrypt']) {
  *
  * @param key - CryptoKey from `importKey()`
  * @param data - Plaintext to encrypt
+ * @param aad - Optional additional authenticated data. Not encrypted, but
+ *   covered by the GCM auth tag: decryption fails unless the exact same
+ *   bytes are supplied. Used by the sealed-box layer to bind ciphertext to
+ *   a `projectId|runId` context. Omit for no AAD (the legacy behavior).
  * @returns `[nonce (12 bytes)][ciphertext + GCM auth tag]`
  */
-export async function encrypt(key, data) {
+export async function encrypt(key, data, aad) {
     const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));
     let ciphertext;
     try {
-        ciphertext = await globalThis.crypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH }, key, data);
+        ciphertext = await globalThis.crypto.subtle.encrypt({
+            name: 'AES-GCM',
+            iv: nonce,
+            tagLength: TAG_LENGTH,
+            ...(aad ? { additionalData: aad } : {}),
+        }, key, data);
     }
     catch (cause) {
         // Re-wrap any Web Crypto failure (DOMException etc.) as a
@@ -77,9 +90,12 @@ export async function encrypt(key, data) {
  *
  * @param key - CryptoKey from `importKey()`
  * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`
+ * @param aad - Optional additional authenticated data. Must match the bytes
+ *   passed to {@link encrypt} exactly, otherwise the GCM tag fails to verify
+ *   and a {@link RuntimeDecryptionError} is thrown.
  * @returns Decrypted plaintext
  */
-export async function decrypt(key, data) {
+export async function decrypt(key, data, aad) {
     const minLength = NONCE_LENGTH + TAG_LENGTH / 8; // nonce + auth tag
     if (data.byteLength < minLength) {
         throw new RuntimeDecryptionError(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`, {
@@ -93,7 +109,12 @@ export async function decrypt(key, data) {
     const ciphertext = data.subarray(NONCE_LENGTH);
     let plaintext;
     try {
-        plaintext = await globalThis.crypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH }, key, ciphertext);
+        plaintext = await globalThis.crypto.subtle.decrypt({
+            name: 'AES-GCM',
+            iv: nonce,
+            tagLength: TAG_LENGTH,
+            ...(aad ? { additionalData: aad } : {}),
+        }, key, ciphertext);
     }
     catch (cause) {
         // The most common shape we see in the wild is a DOMException with
@@ -113,4 +134,4 @@ export async function decrypt(key, data) {
     }
     return new Uint8Array(plaintext);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.js","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"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","sourcesContent":["import { RuntimeDecryptionError, WorkflowRuntimeError } from '@workflow/errors';\n\n/**\n * Browser-compatible AES-256-GCM encryption module.\n *\n * Uses the Web Crypto API (`globalThis.crypto.subtle`) which works in\n * both modern browsers and Node.js 20+. This module is intentionally\n * free of Node.js-specific imports so it can be bundled for the browser.\n *\n * The World interface (`getEncryptionKeyForRun`) returns a raw 32-byte\n * AES-256 key. Callers should use `importKey()` once to convert it to a\n * `CryptoKey`, then pass that to `encrypt()`/`decrypt()` for all\n * operations within the same run. This avoids repeated `importKey()`\n * calls on every encrypt/decrypt invocation.\n *\n * Wire format: `[nonce (12 bytes)][ciphertext + auth tag]`\n * The `encr` format prefix is NOT part of this module — it's added/stripped\n * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.\n */\n\n// CryptoKey is a global type in browsers and Node.js 20+, but TypeScript's\n// `es2022` lib doesn't include it. Re-export it from the node:crypto types\n// so consumers can reference it without adding `dom` lib.\nexport type CryptoKey = import('node:crypto').webcrypto.CryptoKey;\n\nconst NONCE_LENGTH = 12;\nconst TAG_LENGTH = 128; // bits\nconst KEY_LENGTH = 32; // bytes (AES-256)\n\n/**\n * Import a raw AES-256 key as a `CryptoKey` for use with `encrypt()`/`decrypt()`.\n *\n * Callers should call this once per run (after `getEncryptionKeyForRun()`)\n * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.\n *\n * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios\n * where the caller should not be able to perform the inverse operation\n * with the key — for example a child workflow writing into a parent\n * run's forwarded WritableStream only needs to encrypt, never decrypt.\n *\n * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)\n * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.\n * @returns CryptoKey ready for AES-GCM operations\n */\nexport async function importKey(\n  raw: Uint8Array,\n  usages: ReadonlyArray<'encrypt' | 'decrypt'> = ['encrypt', 'decrypt']\n) {\n  if (raw.byteLength !== KEY_LENGTH) {\n    throw new WorkflowRuntimeError(\n      `Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`\n    );\n  }\n  return globalThis.crypto.subtle.importKey(\n    'raw',\n    raw,\n    'AES-GCM',\n    false,\n    // `KeyUsage` is a DOM-lib type that's not in scope under `es2022`.\n    // The `ReadonlyArray<'encrypt' | 'decrypt'>` parameter type matches\n    // a strict subset of `KeyUsage[]`, so this cast is sound.\n    usages as ('encrypt' | 'decrypt')[]\n  );\n}\n\n/**\n * Encrypt data using AES-256-GCM.\n *\n * @param key - CryptoKey from `importKey()`\n * @param data - Plaintext to encrypt\n * @returns `[nonce (12 bytes)][ciphertext + GCM auth tag]`\n */\nexport async function encrypt(\n  key: CryptoKey,\n  data: Uint8Array\n): Promise<Uint8Array> {\n  const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));\n  let ciphertext: ArrayBuffer;\n  try {\n    ciphertext = await globalThis.crypto.subtle.encrypt(\n      { name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH },\n      key,\n      data\n    );\n  } catch (cause) {\n    // Re-wrap any Web Crypto failure (DOMException etc.) as a\n    // RuntimeDecryptionError. Failures here are rare — they happen e.g.\n    // when a CryptoKey was imported with `usages: ['decrypt']` only.\n    throw new RuntimeDecryptionError(\n      `AES-256-GCM encryption failed: ${cause instanceof Error ? cause.message : String(cause)}`,\n      {\n        cause,\n        context: {\n          operation: 'encrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  const result = new Uint8Array(NONCE_LENGTH + ciphertext.byteLength);\n  result.set(nonce, 0);\n  result.set(new Uint8Array(ciphertext), NONCE_LENGTH);\n  return result;\n}\n\n/**\n * Decrypt data using AES-256-GCM.\n *\n * Any failure inside the Web Crypto layer — most commonly an\n * `OperationError: The operation failed for an operation-specific reason`\n * raised by `AESCipherJob.onDone` when the GCM authentication tag does\n * not verify — is rewrapped as {@link RuntimeDecryptionError}. The\n * wrapped error carries the original DOMException as `cause`, plus a\n * small diagnostic context (`operation`, input `byteLength`) to help\n * disambiguate ciphertext corruption from key mismatch from truncated\n * transport reads.\n *\n * Note: `data` is the raw AES payload (`[nonce][ciphertext + tag]`), not a\n * format-prefixed envelope — callers strip the `encr` marker via\n * `decodeFormatPrefix()` before reaching this function. The outer\n * envelope's format prefix is therefore attached by the serialization\n * layer (`serialization/encryption.ts`), which is the layer that has it.\n *\n * @param key - CryptoKey from `importKey()`\n * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`\n * @returns Decrypted plaintext\n */\nexport async function decrypt(\n  key: CryptoKey,\n  data: Uint8Array\n): Promise<Uint8Array> {\n  const minLength = NONCE_LENGTH + TAG_LENGTH / 8; // nonce + auth tag\n  if (data.byteLength < minLength) {\n    throw new RuntimeDecryptionError(\n      `Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`,\n      {\n        context: {\n          operation: 'decrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  const nonce = data.subarray(0, NONCE_LENGTH);\n  const ciphertext = data.subarray(NONCE_LENGTH);\n  let plaintext: ArrayBuffer;\n  try {\n    plaintext = await globalThis.crypto.subtle.decrypt(\n      { name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH },\n      key,\n      ciphertext\n    );\n  } catch (cause) {\n    // The most common shape we see in the wild is a DOMException with\n    // `name: 'OperationError'` and message \"The operation failed for\n    // an operation-specific reason\" — this is what Web Crypto throws\n    // when the GCM auth tag does not verify. Re-throw as\n    // RuntimeDecryptionError, attaching diagnostic context (byte length)\n    // that the bare DOMException lacks.\n    const causeMsg = cause instanceof Error ? cause.message : String(cause);\n    throw new RuntimeDecryptionError(\n      `AES-256-GCM decryption failed: ${causeMsg}`,\n      {\n        cause,\n        context: {\n          operation: 'decrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  return new Uint8Array(plaintext);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.js","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAyBhF,qCAAqC;AACrC,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,CAAC;AAC/B,iDAAiD;AACjD,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAC;AAC9B,kDAAkD;AAClD,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,GAAG,CAAC,CAAC;AACxC,MAAM,UAAU,GAAG,EAAE,CAAC,CAAC,kBAAkB;AAEzC;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,GAAe,EACf,SAA+C,CAAC,SAAS,EAAE,SAAS,CAAC;IAErE,IAAI,GAAG,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;QAClC,MAAM,IAAI,oBAAoB,CAC5B,kCAAkC,UAAU,eAAe,GAAG,CAAC,UAAU,EAAE,CAC5E,CAAC;IACJ,CAAC;IACD,OAAO,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CACvC,KAAK,EACL,GAAG,EACH,SAAS,EACT,KAAK;IACL,mEAAmE;IACnE,oEAAoE;IACpE,0DAA0D;IAC1D,MAAmC,CACpC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,GAAc,EACd,IAAgB,EAChB,GAAgB;IAEhB,MAAM,KAAK,GAAG,UAAU,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC;IAC9E,IAAI,UAAuB,CAAC;IAC5B,IAAI,CAAC;QACH,UAAU,GAAG,MAAM,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CACjD;YACE,IAAI,EAAE,SAAS;YACf,EAAE,EAAE,KAAK;YACT,SAAS,EAAE,UAAU;YACrB,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACxC,EACD,GAAG,EACH,IAAI,CACL,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,0DAA0D;QAC1D,oEAAoE;QACpE,iEAAiE;QACjE,MAAM,IAAI,sBAAsB,CAC9B,kCAAkC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAC1F;YACE,KAAK;YACL,OAAO,EAAE;gBACP,SAAS,EAAE,SAAS;gBACpB,UAAU,EAAE,IAAI,CAAC,UAAU;aAC5B;SACF,CACF,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,YAAY,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;IACpE,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACrB,MAAM,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,CAAC;IACrD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,GAAc,EACd,IAAgB,EAChB,GAAgB;IAEhB,MAAM,SAAS,GAAG,YAAY,GAAG,UAAU,GAAG,CAAC,CAAC,CAAC,mBAAmB;IACpE,IAAI,IAAI,CAAC,UAAU,GAAG,SAAS,EAAE,CAAC;QAChC,MAAM,IAAI,sBAAsB,CAC9B,+CAA+C,SAAS,eAAe,IAAI,CAAC,UAAU,EAAE,EACxF;YACE,OAAO,EAAE;gBACP,SAAS,EAAE,SAAS;gBACpB,UAAU,EAAE,IAAI,CAAC,UAAU;aAC5B;SACF,CACF,CAAC;IACJ,CAAC;IACD,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;IAC7C,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC/C,IAAI,SAAsB,CAAC;IAC3B,IAAI,CAAC;QACH,SAAS,GAAG,MAAM,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAChD;YACE,IAAI,EAAE,SAAS;YACf,EAAE,EAAE,KAAK;YACT,SAAS,EAAE,UAAU;YACrB,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACxC,EACD,GAAG,EACH,UAAU,CACX,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,kEAAkE;QAClE,iEAAiE;QACjE,iEAAiE;QACjE,qDAAqD;QACrD,qEAAqE;QACrE,oCAAoC;QACpC,MAAM,QAAQ,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACxE,MAAM,IAAI,sBAAsB,CAC9B,kCAAkC,QAAQ,EAAE,EAC5C;YACE,KAAK;YACL,OAAO,EAAE;gBACP,SAAS,EAAE,SAAS;gBACpB,UAAU,EAAE,IAAI,CAAC,UAAU;aAC5B;SACF,CACF,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,UAAU,CAAC,SAAS,CAAC,CAAC;AACnC,CAAC","sourcesContent":["import { RuntimeDecryptionError, WorkflowRuntimeError } from '@workflow/errors';\n\n/**\n * Browser-compatible AES-256-GCM encryption module.\n *\n * Uses the Web Crypto API (`globalThis.crypto.subtle`) which works in\n * both modern browsers and Node.js 20+. This module is intentionally\n * free of Node.js-specific imports so it can be bundled for the browser.\n *\n * The World interface (`getEncryptionKeyForRun`) returns a raw 32-byte\n * AES-256 key. Callers should use `importKey()` once to convert it to a\n * `CryptoKey`, then pass that to `encrypt()`/`decrypt()` for all\n * operations within the same run. This avoids repeated `importKey()`\n * calls on every encrypt/decrypt invocation.\n *\n * Wire format: `[nonce (12 bytes)][ciphertext + auth tag]`\n * The `encr` format prefix is NOT part of this module — it's added/stripped\n * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.\n */\n\n// CryptoKey is a global type in browsers and Node.js 20+, but TypeScript's\n// `es2022` lib doesn't include it. Re-export it from the node:crypto types\n// so consumers can reference it without adding `dom` lib.\nexport type CryptoKey = import('node:crypto').webcrypto.CryptoKey;\n\n/** AES-GCM nonce length in bytes. */\nexport const NONCE_LENGTH = 12;\n/** AES-GCM authentication tag length in bits. */\nexport const TAG_LENGTH = 128;\n/** AES-GCM authentication tag length in bytes. */\nexport const TAG_BYTES = TAG_LENGTH / 8;\nconst KEY_LENGTH = 32; // bytes (AES-256)\n\n/**\n * Import a raw AES-256 key as a `CryptoKey` for use with `encrypt()`/`decrypt()`.\n *\n * Callers should call this once per run (after `getEncryptionKeyForRun()`)\n * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.\n *\n * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios\n * where the caller should not be able to perform the inverse operation\n * with the key — for example a child workflow writing into a parent\n * run's forwarded WritableStream only needs to encrypt, never decrypt.\n *\n * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)\n * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.\n * @returns CryptoKey ready for AES-GCM operations\n */\nexport async function importKey(\n  raw: Uint8Array,\n  usages: ReadonlyArray<'encrypt' | 'decrypt'> = ['encrypt', 'decrypt']\n) {\n  if (raw.byteLength !== KEY_LENGTH) {\n    throw new WorkflowRuntimeError(\n      `Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`\n    );\n  }\n  return globalThis.crypto.subtle.importKey(\n    'raw',\n    raw,\n    'AES-GCM',\n    false,\n    // `KeyUsage` is a DOM-lib type that's not in scope under `es2022`.\n    // The `ReadonlyArray<'encrypt' | 'decrypt'>` parameter type matches\n    // a strict subset of `KeyUsage[]`, so this cast is sound.\n    usages as ('encrypt' | 'decrypt')[]\n  );\n}\n\n/**\n * Encrypt data using AES-256-GCM.\n *\n * @param key - CryptoKey from `importKey()`\n * @param data - Plaintext to encrypt\n * @param aad - Optional additional authenticated data. Not encrypted, but\n *   covered by the GCM auth tag: decryption fails unless the exact same\n *   bytes are supplied. Used by the sealed-box layer to bind ciphertext to\n *   a `projectId|runId` context. Omit for no AAD (the legacy behavior).\n * @returns `[nonce (12 bytes)][ciphertext + GCM auth tag]`\n */\nexport async function encrypt(\n  key: CryptoKey,\n  data: Uint8Array,\n  aad?: Uint8Array\n): Promise<Uint8Array> {\n  const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));\n  let ciphertext: ArrayBuffer;\n  try {\n    ciphertext = await globalThis.crypto.subtle.encrypt(\n      {\n        name: 'AES-GCM',\n        iv: nonce,\n        tagLength: TAG_LENGTH,\n        ...(aad ? { additionalData: aad } : {}),\n      },\n      key,\n      data\n    );\n  } catch (cause) {\n    // Re-wrap any Web Crypto failure (DOMException etc.) as a\n    // RuntimeDecryptionError. Failures here are rare — they happen e.g.\n    // when a CryptoKey was imported with `usages: ['decrypt']` only.\n    throw new RuntimeDecryptionError(\n      `AES-256-GCM encryption failed: ${cause instanceof Error ? cause.message : String(cause)}`,\n      {\n        cause,\n        context: {\n          operation: 'encrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  const result = new Uint8Array(NONCE_LENGTH + ciphertext.byteLength);\n  result.set(nonce, 0);\n  result.set(new Uint8Array(ciphertext), NONCE_LENGTH);\n  return result;\n}\n\n/**\n * Decrypt data using AES-256-GCM.\n *\n * Any failure inside the Web Crypto layer — most commonly an\n * `OperationError: The operation failed for an operation-specific reason`\n * raised by `AESCipherJob.onDone` when the GCM authentication tag does\n * not verify — is rewrapped as {@link RuntimeDecryptionError}. The\n * wrapped error carries the original DOMException as `cause`, plus a\n * small diagnostic context (`operation`, input `byteLength`) to help\n * disambiguate ciphertext corruption from key mismatch from truncated\n * transport reads.\n *\n * Note: `data` is the raw AES payload (`[nonce][ciphertext + tag]`), not a\n * format-prefixed envelope — callers strip the `encr` marker via\n * `decodeFormatPrefix()` before reaching this function. The outer\n * envelope's format prefix is therefore attached by the serialization\n * layer (`serialization/encryption.ts`), which is the layer that has it.\n *\n * @param key - CryptoKey from `importKey()`\n * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`\n * @param aad - Optional additional authenticated data. Must match the bytes\n *   passed to {@link encrypt} exactly, otherwise the GCM tag fails to verify\n *   and a {@link RuntimeDecryptionError} is thrown.\n * @returns Decrypted plaintext\n */\nexport async function decrypt(\n  key: CryptoKey,\n  data: Uint8Array,\n  aad?: Uint8Array\n): Promise<Uint8Array> {\n  const minLength = NONCE_LENGTH + TAG_LENGTH / 8; // nonce + auth tag\n  if (data.byteLength < minLength) {\n    throw new RuntimeDecryptionError(\n      `Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`,\n      {\n        context: {\n          operation: 'decrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  const nonce = data.subarray(0, NONCE_LENGTH);\n  const ciphertext = data.subarray(NONCE_LENGTH);\n  let plaintext: ArrayBuffer;\n  try {\n    plaintext = await globalThis.crypto.subtle.decrypt(\n      {\n        name: 'AES-GCM',\n        iv: nonce,\n        tagLength: TAG_LENGTH,\n        ...(aad ? { additionalData: aad } : {}),\n      },\n      key,\n      ciphertext\n    );\n  } catch (cause) {\n    // The most common shape we see in the wild is a DOMException with\n    // `name: 'OperationError'` and message \"The operation failed for\n    // an operation-specific reason\" — this is what Web Crypto throws\n    // when the GCM auth tag does not verify. Re-throw as\n    // RuntimeDecryptionError, attaching diagnostic context (byte length)\n    // that the bare DOMException lacks.\n    const causeMsg = cause instanceof Error ? cause.message : String(cause);\n    throw new RuntimeDecryptionError(\n      `AES-256-GCM decryption failed: ${causeMsg}`,\n      {\n        cause,\n        context: {\n          operation: 'decrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  return new Uint8Array(plaintext);\n}\n"]}

package/dist/flushable-stream.d.ts

@@ -1,4 +1,51 @@
 import { type PromiseWithResolvers } from '@workflow/utils';
+/**
+ * A durability barrier a sink may expose under {@link STREAM_DRAIN_SYMBOL}:
+ * resolves once every chunk the sink has accepted is durably written, rejects
+ * if any server write failed. See `WorkflowServerWritableStream`.
+ */
+type DrainBarrier = () => Promise<void>;
+/**
+ * Flow-control knob: upper bound on chunks read-but-not-yet-durably-written
+ * while coalescing. Once this many chunks are outstanding the producer stops
+ * reading until the consumer drains a batch, so a fast producer paired with a
+ * slow server can't grow the in-memory queue without bound. Override:
+ * `WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS`.
+ *
+ * This is deliberately distinct from the per-request batch caps below: this
+ * bounds how much is *buffered*, those bound how much goes out in one
+ * `writeMulti`. Raising this must never let a single request exceed a wire
+ * limit — batch sizing enforces that independently.
+ */
+export declare const MAX_INFLIGHT_CHUNKS = 1000;
+export declare const getMaxInflightChunks: () => number;
+/**
+ * Wire limit: maximum number of chunks in a single coalesced `writeMulti`.
+ * The server enforces a per-multi-write chunk cap (1,000 today); a batch is
+ * split at this bound so it can never be rejected wholesale, independently of
+ * the backpressure knob above. Override: `WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH`.
+ */
+export declare const MAX_CHUNKS_PER_BATCH = 1000;
+export declare const getMaxChunksPerBatch: () => number;
+/**
+ * Wire limit: maximum cumulative bytes in a single coalesced `writeMulti`.
+ * Chunk *count* alone is not enough — 1,000 small chunks are ~100KB but 1,000
+ * file-sized chunks can be hundreds of MB, which platform request-body limits
+ * reject long before the count cap matters. A batch is split once adding the
+ * next chunk would exceed this (a single chunk larger than the cap still goes
+ * out alone). Default 1 MiB. Override: `WORKFLOW_STREAM_MAX_BYTES_PER_BATCH`.
+ */
+export declare const MAX_BYTES_PER_BATCH: number;
+export declare const getMaxBytesPerBatch: () => number;
+/**
+ * Buffer bound (bytes) for the server writable's group-commit buffer — the
+ * byte-denominated counterpart of {@link MAX_INFLIGHT_CHUNKS}. `write()`
+ * blocks once this much data is buffered-but-not-durable, so a fast producer
+ * of large chunks can't grow client memory without bound. Default 8 MiB
+ * (eight request-sized groups). Override: `WORKFLOW_STREAM_MAX_BUFFERED_BYTES`.
+ */
+export declare const MAX_BUFFERED_BYTES: number;
+export declare const getMaxBufferedBytes: () => number;
 /**
  * Polling interval (in ms) for lock release detection.
  *
@@ -43,6 +90,13 @@ export interface FlushableStreamState extends PromiseWithResolvers<void> {
     writablePollingInterval?: ReturnType<typeof setInterval>;
     /** Interval ID for readable lock polling (if active) */
     readablePollingInterval?: ReturnType<typeof setInterval>;
+    /**
+     * Durability barrier of the pipe's sink, when it acks writes on buffer
+     * entry (see {@link STREAM_DRAIN_SYMBOL}). Lock-release completion awaits
+     * this before resolving so `pendingOps === 0` (fast, buffered acks) can't
+     * complete a step while data is still client-side.
+     */
+    drainBarrier?: DrainBarrier;
 }
 export declare function createFlushableState(): FlushableStreamState;
 /**
@@ -79,4 +133,5 @@ export declare function pollReadableLock(readable: ReadableStream, state: Flusha
  * @returns Promise that resolves when stream ends (not when done promise resolves)
  */
 export declare function flushablePipe(source: ReadableStream, sink: WritableStream, state: FlushableStreamState): Promise<void>;
+export {};
 //# sourceMappingURL=flushable-stream.d.ts.map

package/dist/flushable-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flushable-stream.d.ts","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,iBAAiB,CAAC;AAG3E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AASxC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB,CAAC,IAAI,CAAC;IACtE,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;CAC1D;AAED,wBAAgB,oBAAoB,IAAI,oBAAoB,CAa3D;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAoEf"}
+{"version":3,"file":"flushable-stream.d.ts","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,iBAAiB,CAAC;AAI3E;;;;GAIG;AACH,KAAK,YAAY,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAExC,eAAO,MAAM,oBAAoB,QAAO,MAIpC,CAAC;AAEL;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAEzC,eAAO,MAAM,oBAAoB,QAAO,MAIpC,CAAC;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,QAAc,CAAC;AAE/C,eAAO,MAAM,mBAAmB,QAAO,MAInC,CAAC;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAAkB,CAAC;AAElD,eAAO,MAAM,mBAAmB,QAAO,MAInC,CAAC;AAEL;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AASxC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB,CAAC,IAAI,CAAC;IACtE,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD;;;;;OAKG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,wBAAgB,oBAAoB,IAAI,oBAAoB,CAa3D;AAgFD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/dist/flushable-stream.js

@@ -1,6 +1,60 @@
 import { WorkflowRuntimeError } from '@workflow/errors';
 import { withResolvers } from '@workflow/utils';
 import { envNumber } from '@workflow/world';
+import { STREAM_DRAIN_SYMBOL } from './symbols.js';
+/**
+ * Flow-control knob: upper bound on chunks read-but-not-yet-durably-written
+ * while coalescing. Once this many chunks are outstanding the producer stops
+ * reading until the consumer drains a batch, so a fast producer paired with a
+ * slow server can't grow the in-memory queue without bound. Override:
+ * `WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS`.
+ *
+ * This is deliberately distinct from the per-request batch caps below: this
+ * bounds how much is *buffered*, those bound how much goes out in one
+ * `writeMulti`. Raising this must never let a single request exceed a wire
+ * limit — batch sizing enforces that independently.
+ */
+export const MAX_INFLIGHT_CHUNKS = 1000;
+export const getMaxInflightChunks = () => envNumber('WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS', MAX_INFLIGHT_CHUNKS, {
+    integer: true,
+    min: 1,
+});
+/**
+ * Wire limit: maximum number of chunks in a single coalesced `writeMulti`.
+ * The server enforces a per-multi-write chunk cap (1,000 today); a batch is
+ * split at this bound so it can never be rejected wholesale, independently of
+ * the backpressure knob above. Override: `WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH`.
+ */
+export const MAX_CHUNKS_PER_BATCH = 1000;
+export const getMaxChunksPerBatch = () => envNumber('WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH', MAX_CHUNKS_PER_BATCH, {
+    integer: true,
+    min: 1,
+});
+/**
+ * Wire limit: maximum cumulative bytes in a single coalesced `writeMulti`.
+ * Chunk *count* alone is not enough — 1,000 small chunks are ~100KB but 1,000
+ * file-sized chunks can be hundreds of MB, which platform request-body limits
+ * reject long before the count cap matters. A batch is split once adding the
+ * next chunk would exceed this (a single chunk larger than the cap still goes
+ * out alone). Default 1 MiB. Override: `WORKFLOW_STREAM_MAX_BYTES_PER_BATCH`.
+ */
+export const MAX_BYTES_PER_BATCH = 1024 * 1024;
+export const getMaxBytesPerBatch = () => envNumber('WORKFLOW_STREAM_MAX_BYTES_PER_BATCH', MAX_BYTES_PER_BATCH, {
+    integer: true,
+    min: 1,
+});
+/**
+ * Buffer bound (bytes) for the server writable's group-commit buffer — the
+ * byte-denominated counterpart of {@link MAX_INFLIGHT_CHUNKS}. `write()`
+ * blocks once this much data is buffered-but-not-durable, so a fast producer
+ * of large chunks can't grow client memory without bound. Default 8 MiB
+ * (eight request-sized groups). Override: `WORKFLOW_STREAM_MAX_BUFFERED_BYTES`.
+ */
+export const MAX_BUFFERED_BYTES = 8 * 1024 * 1024;
+export const getMaxBufferedBytes = () => envNumber('WORKFLOW_STREAM_MAX_BUFFERED_BYTES', MAX_BUFFERED_BYTES, {
+    integer: true,
+    min: 1,
+});
 /**
  * Polling interval (in ms) for lock release detection.
  *
@@ -92,6 +146,23 @@ function isReadableUnlockedNotClosed(readable) {
     }
     return true;
 }
+/**
+ * Settle the flushable completion after the sink's durability barrier.
+ *
+ * Lock release means the producer is done *writing*; with a group-commit
+ * sink, accepted chunks may still be client-buffered or in a request that is
+ * in flight. Awaiting the barrier here keeps the completion's meaning —
+ * "everything written so far is durable" — identical to the pre-batching
+ * behavior where each write() was individually durable.
+ */
+function resolveAfterDrain(state) {
+    const barrier = state.drainBarrier;
+    if (!barrier) {
+        state.resolve();
+        return;
+    }
+    barrier().then(() => state.resolve(), (err) => state.reject(err));
+}
 /**
  * Polls a WritableStream to check if the user has released their lock.
  * Resolves the done promise when lock is released and no pending ops remain.
@@ -117,9 +188,9 @@ export function pollWritableLock(writable, state) {
         // Check if lock is released (not closed) and no pending ops
         if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {
             state.doneResolved = true;
-            state.resolve();
             clearInterval(intervalId);
             state.writablePollingInterval = undefined;
+            resolveAfterDrain(state);
         }
     }, getLockPollIntervalMs());
     state.writablePollingInterval = intervalId;
@@ -149,9 +220,9 @@ export function pollReadableLock(readable, state) {
         // Check if lock is released (not closed) and no pending ops
         if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {
             state.doneResolved = true;
-            state.resolve();
             clearInterval(intervalId);
             state.readablePollingInterval = undefined;
+            resolveAfterDrain(state);
         }
     }, getLockPollIntervalMs());
     state.readablePollingInterval = intervalId;
@@ -167,7 +238,29 @@ export function pollReadableLock(readable, state) {
  * @param state - The flushable state tracker
  * @returns Promise that resolves when stream ends (not when done promise resolves)
  */
-export async function flushablePipe(source, sink, state) {
+export function flushablePipe(source, sink, state) {
+    // Batching lives in the sink (`WorkflowServerWritableStream` group-commits
+    // its buffer), so this pipe is a plain per-chunk pump regardless of path —
+    // its only responsibilities are lock-release completion and durability
+    // tracking. Group-commit sinks ack write() on buffer entry; adopt their
+    // durability barrier so the lock-release completion still means
+    // "everything written is durable" (see resolveAfterDrain).
+    const drain = sink[STREAM_DRAIN_SYMBOL];
+    if (typeof drain === 'function') {
+        state.drainBarrier = drain;
+    }
+    return flushablePipePerChunk(source, sink, state);
+}
+/**
+ * The pump behind {@link flushablePipe}: awaits each `writer.write()` before
+ * reading the next chunk. Against a group-commit sink, write() acks on buffer
+ * entry, so this loop feeds the sink as fast as the producer emits (bounded
+ * by the sink's buffer bound) and batching happens inside the sink; against a
+ * plain sink each write is individually durable, as before. The source-done
+ * path closes the sink, which drains it, so completion always implies
+ * durability.
+ */
+async function flushablePipePerChunk(source, sink, state) {
     const reader = source.getReader();
     const writer = sink.getWriter();
     let cancelReason;
@@ -213,6 +306,15 @@ export async function flushablePipe(source, sink, state) {
     catch (err) {
         state.streamEnded = true;
         cancelReason = err;
+        // Against an early-ack sink, chunks can still be buffered or in flight
+        // when the pipe fails (pendingOps only counts un-acked writes). Deliver
+        // that accepted prefix before settling the failure: once the state
+        // rejects, the step may persist its failure and the invocation finish,
+        // and anything still client-side would be lost. The original pipe error
+        // stays primary — a drain failure is already sticky on the sink.
+        if (state.drainBarrier) {
+            await state.drainBarrier().catch(() => { });
+        }
         if (!state.doneResolved) {
             state.doneResolved = true;
             state.reject(err);
@@ -234,4 +336,4 @@ export async function flushablePipe(source, sink, state) {
         writer.releaseLock();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flushable-stream.js","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { type PromiseWithResolvers, withResolvers } from '@workflow/utils';\nimport { envNumber } from '@workflow/world';\n\n/**\n * Polling interval (in ms) for lock release detection.\n *\n * The Web Streams API does not expose an event for \"lock released but stream\n * still open\"; we can only distinguish that state by periodically attempting\n * to acquire a reader/writer. For that reason we use polling instead of a\n * fully event-driven approach here.\n *\n * 10ms is chosen so the polling tick almost never sits on the critical path:\n * the V2 step-executor's `opsSettled` race waits for this state to resolve\n * after each step body returns, so a coarser interval (the previous 100ms)\n * adds visible per-step latency to streaming workflows. With a uniformly\n * distributed offset between step return and the next tick, the expected\n * wait is half the interval — so 10ms means ~5ms average wait per step\n * instead of ~50ms. The per-tick work is `writable.locked` plus a\n * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more\n * ticks during a stream's lifetime is not measurable in practice.\n */\nexport const LOCK_POLL_INTERVAL_MS = 10;\n\n/** Effective lock-poll interval. Override: `WORKFLOW_LOCK_POLL_INTERVAL_MS`. */\nconst getLockPollIntervalMs = (): number =>\n  envNumber('WORKFLOW_LOCK_POLL_INTERVAL_MS', LOCK_POLL_INTERVAL_MS, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * State tracker for flushable stream operations.\n * Resolves when either:\n * 1. Stream completes (close/error), OR\n * 2. Lock is released AND all pending operations are flushed\n *\n * Note: `doneResolved` and `streamEnded` are separate:\n * - `doneResolved`: The `done` promise has been resolved (step can complete)\n * - `streamEnded`: The underlying stream has actually closed/errored\n *\n * Once `doneResolved` is set to true, the `done` promise will not resolve\n * again. Re-acquiring locks after release is not supported as a way to\n * trigger additional completion signaling.\n */\nexport interface FlushableStreamState extends PromiseWithResolvers<void> {\n  /** Number of write operations currently in flight to the server */\n  pendingOps: number;\n  /** Whether the `done` promise has been resolved */\n  doneResolved: boolean;\n  /** Whether the underlying stream has actually closed/errored */\n  streamEnded: boolean;\n  /** Interval ID for writable lock polling (if active) */\n  writablePollingInterval?: ReturnType<typeof setInterval>;\n  /** Interval ID for readable lock polling (if active) */\n  readablePollingInterval?: ReturnType<typeof setInterval>;\n}\n\nexport function createFlushableState(): FlushableStreamState {\n  const state: FlushableStreamState = {\n    ...withResolvers<void>(),\n    pendingOps: 0,\n    doneResolved: false,\n    streamEnded: false,\n  };\n\n  // The runtime awaits this promise after user code returns. Observe early\n  // stream failures now so they do not become unhandled rejections first.\n  state.promise.catch(() => {});\n\n  return state;\n}\n\n/**\n * Checks if a WritableStream is unlocked (user released lock) vs closed.\n * When a stream is closed, .locked is false but getWriter() throws.\n * We only want to resolve via polling when the stream is unlocked, not closed.\n * If closed, the pump will handle resolution via the stream ending naturally.\n */\nfunction isWritableUnlockedNotClosed(writable: WritableStream): boolean {\n  if (writable.locked) return false;\n\n  let writer: WritableStreamDefaultWriter | undefined;\n  try {\n    // Try to acquire writer - if successful, stream is unlocked (not closed)\n    writer = writable.getWriter();\n  } catch {\n    // getWriter() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    writer.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Checks if a ReadableStream is unlocked (user released lock) vs closed.\n */\nfunction isReadableUnlockedNotClosed(readable: ReadableStream): boolean {\n  if (readable.locked) return false;\n\n  let reader: ReadableStreamDefaultReader | undefined;\n  try {\n    // Try to acquire reader - if successful, stream is unlocked (not closed)\n    reader = readable.getReader();\n  } catch {\n    // getReader() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    reader.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Polls a WritableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollWritableLock(\n  writable: WritableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.writablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      state.resolve();\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n    }\n  }, getLockPollIntervalMs());\n\n  state.writablePollingInterval = intervalId;\n}\n\n/**\n * Polls a ReadableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollReadableLock(\n  readable: ReadableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.readablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      state.resolve();\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n    }\n  }, getLockPollIntervalMs());\n\n  state.readablePollingInterval = intervalId;\n}\n\n/**\n * Creates a flushable pipe from a ReadableStream to a WritableStream.\n * Unlike pipeTo(), this resolves when:\n * 1. The source stream completes (close/error), OR\n * 2. The user releases their lock on userStream AND all pending writes are flushed\n *\n * @param source - The readable stream to read from (e.g., transform's readable)\n * @param sink - The writable stream to write to (e.g., server writable)\n * @param state - The flushable state tracker\n * @returns Promise that resolves when stream ends (not when done promise resolves)\n */\nexport async function flushablePipe(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  const reader = source.getReader();\n  const writer = sink.getWriter();\n  let cancelReason: unknown;\n\n  try {\n    while (true) {\n      // Check if stream has ended\n      if (state.streamEnded) {\n        return;\n      }\n\n      // Read from source - don't count as pending op since we're just waiting for data\n      // The important ops are writes to the sink (server)\n      const readResult = await Promise.race([\n        reader.read(),\n        writer.closed.then(() => {\n          throw new WorkflowRuntimeError('Writable stream closed prematurely');\n        }),\n      ]);\n\n      // Check if stream has ended (e.g., due to error in another path) before processing\n      if (state.streamEnded) {\n        return;\n      }\n\n      if (readResult.done) {\n        // Source stream completed - close sink and resolve\n        state.streamEnded = true;\n        await writer.close();\n        // Resolve done promise if not already resolved\n        if (!state.doneResolved) {\n          state.doneResolved = true;\n          state.resolve();\n        }\n        return;\n      }\n\n      // Count write as a pending op - this is what we need to flush\n      state.pendingOps++;\n      try {\n        await writer.write(readResult.value);\n      } finally {\n        state.pendingOps--;\n      }\n    }\n  } catch (err) {\n    state.streamEnded = true;\n    cancelReason = err;\n    if (!state.doneResolved) {\n      state.doneResolved = true;\n      state.reject(err);\n    }\n    // Propagate error through flushablePipe's own promise as well.\n    // Callers that rely on the FlushableStreamState should use `state.promise`,\n    // while other callers may depend on this rejection. Some known callers\n    // explicitly ignore this rejection (`.catch(() => {})`) and rely solely\n    // on `state.reject(err)` for error handling.\n    throw err;\n  } finally {\n    // Cancel the upstream reader so the source knows to stop generating data.\n    // Uses cancelReason (set in the catch block) so the source receives context\n    // about why it was cancelled. On normal completion cancelReason is undefined,\n    // which is a harmless no-op on an already-done reader.\n    reader.cancel(cancelReason).catch(() => {});\n    reader.releaseLock();\n    writer.releaseLock();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flushable-stream.js","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { type PromiseWithResolvers, withResolvers } from '@workflow/utils';\nimport { envNumber } from '@workflow/world';\nimport { STREAM_DRAIN_SYMBOL } from './symbols.js';\n\n/**\n * A durability barrier a sink may expose under {@link STREAM_DRAIN_SYMBOL}:\n * resolves once every chunk the sink has accepted is durably written, rejects\n * if any server write failed. See `WorkflowServerWritableStream`.\n */\ntype DrainBarrier = () => Promise<void>;\n\n/**\n * Flow-control knob: upper bound on chunks read-but-not-yet-durably-written\n * while coalescing. Once this many chunks are outstanding the producer stops\n * reading until the consumer drains a batch, so a fast producer paired with a\n * slow server can't grow the in-memory queue without bound. Override:\n * `WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS`.\n *\n * This is deliberately distinct from the per-request batch caps below: this\n * bounds how much is *buffered*, those bound how much goes out in one\n * `writeMulti`. Raising this must never let a single request exceed a wire\n * limit — batch sizing enforces that independently.\n */\nexport const MAX_INFLIGHT_CHUNKS = 1000;\n\nexport const getMaxInflightChunks = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS', MAX_INFLIGHT_CHUNKS, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Wire limit: maximum number of chunks in a single coalesced `writeMulti`.\n * The server enforces a per-multi-write chunk cap (1,000 today); a batch is\n * split at this bound so it can never be rejected wholesale, independently of\n * the backpressure knob above. Override: `WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH`.\n */\nexport const MAX_CHUNKS_PER_BATCH = 1000;\n\nexport const getMaxChunksPerBatch = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH', MAX_CHUNKS_PER_BATCH, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Wire limit: maximum cumulative bytes in a single coalesced `writeMulti`.\n * Chunk *count* alone is not enough — 1,000 small chunks are ~100KB but 1,000\n * file-sized chunks can be hundreds of MB, which platform request-body limits\n * reject long before the count cap matters. A batch is split once adding the\n * next chunk would exceed this (a single chunk larger than the cap still goes\n * out alone). Default 1 MiB. Override: `WORKFLOW_STREAM_MAX_BYTES_PER_BATCH`.\n */\nexport const MAX_BYTES_PER_BATCH = 1024 * 1024;\n\nexport const getMaxBytesPerBatch = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_BYTES_PER_BATCH', MAX_BYTES_PER_BATCH, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Buffer bound (bytes) for the server writable's group-commit buffer — the\n * byte-denominated counterpart of {@link MAX_INFLIGHT_CHUNKS}. `write()`\n * blocks once this much data is buffered-but-not-durable, so a fast producer\n * of large chunks can't grow client memory without bound. Default 8 MiB\n * (eight request-sized groups). Override: `WORKFLOW_STREAM_MAX_BUFFERED_BYTES`.\n */\nexport const MAX_BUFFERED_BYTES = 8 * 1024 * 1024;\n\nexport const getMaxBufferedBytes = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_BUFFERED_BYTES', MAX_BUFFERED_BYTES, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Polling interval (in ms) for lock release detection.\n *\n * The Web Streams API does not expose an event for \"lock released but stream\n * still open\"; we can only distinguish that state by periodically attempting\n * to acquire a reader/writer. For that reason we use polling instead of a\n * fully event-driven approach here.\n *\n * 10ms is chosen so the polling tick almost never sits on the critical path:\n * the V2 step-executor's `opsSettled` race waits for this state to resolve\n * after each step body returns, so a coarser interval (the previous 100ms)\n * adds visible per-step latency to streaming workflows. With a uniformly\n * distributed offset between step return and the next tick, the expected\n * wait is half the interval — so 10ms means ~5ms average wait per step\n * instead of ~50ms. The per-tick work is `writable.locked` plus a\n * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more\n * ticks during a stream's lifetime is not measurable in practice.\n */\nexport const LOCK_POLL_INTERVAL_MS = 10;\n\n/** Effective lock-poll interval. Override: `WORKFLOW_LOCK_POLL_INTERVAL_MS`. */\nconst getLockPollIntervalMs = (): number =>\n  envNumber('WORKFLOW_LOCK_POLL_INTERVAL_MS', LOCK_POLL_INTERVAL_MS, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * State tracker for flushable stream operations.\n * Resolves when either:\n * 1. Stream completes (close/error), OR\n * 2. Lock is released AND all pending operations are flushed\n *\n * Note: `doneResolved` and `streamEnded` are separate:\n * - `doneResolved`: The `done` promise has been resolved (step can complete)\n * - `streamEnded`: The underlying stream has actually closed/errored\n *\n * Once `doneResolved` is set to true, the `done` promise will not resolve\n * again. Re-acquiring locks after release is not supported as a way to\n * trigger additional completion signaling.\n */\nexport interface FlushableStreamState extends PromiseWithResolvers<void> {\n  /** Number of write operations currently in flight to the server */\n  pendingOps: number;\n  /** Whether the `done` promise has been resolved */\n  doneResolved: boolean;\n  /** Whether the underlying stream has actually closed/errored */\n  streamEnded: boolean;\n  /** Interval ID for writable lock polling (if active) */\n  writablePollingInterval?: ReturnType<typeof setInterval>;\n  /** Interval ID for readable lock polling (if active) */\n  readablePollingInterval?: ReturnType<typeof setInterval>;\n  /**\n   * Durability barrier of the pipe's sink, when it acks writes on buffer\n   * entry (see {@link STREAM_DRAIN_SYMBOL}). Lock-release completion awaits\n   * this before resolving so `pendingOps === 0` (fast, buffered acks) can't\n   * complete a step while data is still client-side.\n   */\n  drainBarrier?: DrainBarrier;\n}\n\nexport function createFlushableState(): FlushableStreamState {\n  const state: FlushableStreamState = {\n    ...withResolvers<void>(),\n    pendingOps: 0,\n    doneResolved: false,\n    streamEnded: false,\n  };\n\n  // The runtime awaits this promise after user code returns. Observe early\n  // stream failures now so they do not become unhandled rejections first.\n  state.promise.catch(() => {});\n\n  return state;\n}\n\n/**\n * Checks if a WritableStream is unlocked (user released lock) vs closed.\n * When a stream is closed, .locked is false but getWriter() throws.\n * We only want to resolve via polling when the stream is unlocked, not closed.\n * If closed, the pump will handle resolution via the stream ending naturally.\n */\nfunction isWritableUnlockedNotClosed(writable: WritableStream): boolean {\n  if (writable.locked) return false;\n\n  let writer: WritableStreamDefaultWriter | undefined;\n  try {\n    // Try to acquire writer - if successful, stream is unlocked (not closed)\n    writer = writable.getWriter();\n  } catch {\n    // getWriter() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    writer.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Checks if a ReadableStream is unlocked (user released lock) vs closed.\n */\nfunction isReadableUnlockedNotClosed(readable: ReadableStream): boolean {\n  if (readable.locked) return false;\n\n  let reader: ReadableStreamDefaultReader | undefined;\n  try {\n    // Try to acquire reader - if successful, stream is unlocked (not closed)\n    reader = readable.getReader();\n  } catch {\n    // getReader() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    reader.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Settle the flushable completion after the sink's durability barrier.\n *\n * Lock release means the producer is done *writing*; with a group-commit\n * sink, accepted chunks may still be client-buffered or in a request that is\n * in flight. Awaiting the barrier here keeps the completion's meaning —\n * \"everything written so far is durable\" — identical to the pre-batching\n * behavior where each write() was individually durable.\n */\nfunction resolveAfterDrain(state: FlushableStreamState): void {\n  const barrier = state.drainBarrier;\n  if (!barrier) {\n    state.resolve();\n    return;\n  }\n  barrier().then(\n    () => state.resolve(),\n    (err) => state.reject(err)\n  );\n}\n\n/**\n * Polls a WritableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollWritableLock(\n  writable: WritableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.writablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      resolveAfterDrain(state);\n    }\n  }, getLockPollIntervalMs());\n\n  state.writablePollingInterval = intervalId;\n}\n\n/**\n * Polls a ReadableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollReadableLock(\n  readable: ReadableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.readablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      resolveAfterDrain(state);\n    }\n  }, getLockPollIntervalMs());\n\n  state.readablePollingInterval = intervalId;\n}\n\n/**\n * Creates a flushable pipe from a ReadableStream to a WritableStream.\n * Unlike pipeTo(), this resolves when:\n * 1. The source stream completes (close/error), OR\n * 2. The user releases their lock on userStream AND all pending writes are flushed\n *\n * @param source - The readable stream to read from (e.g., transform's readable)\n * @param sink - The writable stream to write to (e.g., server writable)\n * @param state - The flushable state tracker\n * @returns Promise that resolves when stream ends (not when done promise resolves)\n */\nexport function flushablePipe(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  // Batching lives in the sink (`WorkflowServerWritableStream` group-commits\n  // its buffer), so this pipe is a plain per-chunk pump regardless of path —\n  // its only responsibilities are lock-release completion and durability\n  // tracking. Group-commit sinks ack write() on buffer entry; adopt their\n  // durability barrier so the lock-release completion still means\n  // \"everything written is durable\" (see resolveAfterDrain).\n  const drain = (sink as { [STREAM_DRAIN_SYMBOL]?: DrainBarrier })[\n    STREAM_DRAIN_SYMBOL\n  ];\n  if (typeof drain === 'function') {\n    state.drainBarrier = drain;\n  }\n  return flushablePipePerChunk(source, sink, state);\n}\n\n/**\n * The pump behind {@link flushablePipe}: awaits each `writer.write()` before\n * reading the next chunk. Against a group-commit sink, write() acks on buffer\n * entry, so this loop feeds the sink as fast as the producer emits (bounded\n * by the sink's buffer bound) and batching happens inside the sink; against a\n * plain sink each write is individually durable, as before. The source-done\n * path closes the sink, which drains it, so completion always implies\n * durability.\n */\nasync function flushablePipePerChunk(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  const reader = source.getReader();\n  const writer = sink.getWriter();\n  let cancelReason: unknown;\n\n  try {\n    while (true) {\n      // Check if stream has ended\n      if (state.streamEnded) {\n        return;\n      }\n\n      // Read from source - don't count as pending op since we're just waiting for data\n      // The important ops are writes to the sink (server)\n      const readResult = await Promise.race([\n        reader.read(),\n        writer.closed.then(() => {\n          throw new WorkflowRuntimeError('Writable stream closed prematurely');\n        }),\n      ]);\n\n      // Check if stream has ended (e.g., due to error in another path) before processing\n      if (state.streamEnded) {\n        return;\n      }\n\n      if (readResult.done) {\n        // Source stream completed - close sink and resolve\n        state.streamEnded = true;\n        await writer.close();\n        // Resolve done promise if not already resolved\n        if (!state.doneResolved) {\n          state.doneResolved = true;\n          state.resolve();\n        }\n        return;\n      }\n\n      // Count write as a pending op - this is what we need to flush\n      state.pendingOps++;\n      try {\n        await writer.write(readResult.value);\n      } finally {\n        state.pendingOps--;\n      }\n    }\n  } catch (err) {\n    state.streamEnded = true;\n    cancelReason = err;\n    // Against an early-ack sink, chunks can still be buffered or in flight\n    // when the pipe fails (pendingOps only counts un-acked writes). Deliver\n    // that accepted prefix before settling the failure: once the state\n    // rejects, the step may persist its failure and the invocation finish,\n    // and anything still client-side would be lost. The original pipe error\n    // stays primary — a drain failure is already sticky on the sink.\n    if (state.drainBarrier) {\n      await state.drainBarrier().catch(() => {});\n    }\n    if (!state.doneResolved) {\n      state.doneResolved = true;\n      state.reject(err);\n    }\n    // Propagate error through flushablePipe's own promise as well.\n    // Callers that rely on the FlushableStreamState should use `state.promise`,\n    // while other callers may depend on this rejection. Some known callers\n    // explicitly ignore this rejection (`.catch(() => {})`) and rely solely\n    // on `state.reject(err)` for error handling.\n    throw err;\n  } finally {\n    // Cancel the upstream reader so the source knows to stop generating data.\n    // Uses cancelReason (set in the catch block) so the source receives context\n    // about why it was cancelled. On normal completion cancelReason is undefined,\n    // which is a harmless no-op on an already-done reader.\n    reader.cancel(cancelReason).catch(() => {});\n    reader.releaseLock();\n    writer.releaseLock();\n  }\n}\n"]}

package/dist/global.d.ts

@@ -33,6 +33,8 @@ export interface HookInvocationQueueItem {
     type: 'hook';
     correlationId: string;
     token: string;
+    /** Earliest time the token can be reused after the run ends. */
+    tokenRetentionUntil?: Date;
     metadata?: Serializable;
     hasCreatedEvent?: boolean;
     /** Whether the workflow is awaiting `hook.getConflict()` for this hook */

package/dist/global.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,0EAA0E;IAC1E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,IAAI,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,WAAW,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,uBAAuB,CAAC,EAAE,IAAI,CAAC;CAChC;AAED,MAAM,MAAM,SAAS,GACjB,uBAAuB,GACvB,uBAAuB,GACvB,uBAAuB,GACvB,4BAA4B,CAAC;AAEjC;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;gBAEP,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,UAAU;IAuFzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB;CAGvD;AAED,wBAAgB,OAAO,IAAI,KAAK,CAI/B"}
+{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,mBAAmB,CAAC,EAAE,IAAI,CAAC;IAC3B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,0EAA0E;IAC1E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,IAAI,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,WAAW,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,uBAAuB,CAAC,EAAE,IAAI,CAAC;CAChC;AAED,MAAM,MAAM,SAAS,GACjB,uBAAuB,GACvB,uBAAuB,GACvB,uBAAuB,GACvB,4BAA4B,CAAC;AAEjC;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;gBAEP,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,UAAU;IAuFzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB;CAGvD;AAED,wBAAgB,OAAO,IAAI,KAAK,CAI/B"}

package/dist/global.js

@@ -110,4 +110,4 @@ export class WorkflowSuspension extends Error {
 export function ENOTSUP() {
     throw new WorkflowRuntimeError('This API is not available inside a workflow function. Workflow functions run in a deterministic VM; move the call to a step function for full Node.js access.');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global.js","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { pluralize } from '@workflow/utils';\nimport type { AttributeChange } from '@workflow/world';\nimport type { Serializable } from './schemas.js';\n\nexport interface StepInvocationQueueItem {\n  type: 'step';\n  correlationId: string;\n  stepName: string;\n  args: Serializable[];\n  closureVars?: Record<string, Serializable>;\n  thisVal?: Serializable;\n  hasCreatedEvent?: boolean;\n  /**\n   * Inline step ownership, derived from the step's LATEST `step_started`\n   * during replay: the queue message ID stamped by the invocation running\n   * the step inline, or undefined when the latest start was unstamped (a\n   * retry attempt driven by a queued step message, or an older runtime).\n   * Latest start wins — an unstamped bare start clears a previous stamp; an\n   * owner-recovery re-stamped start restores it.\n   */\n  ownerMessageId?: string;\n  /**\n   * `createdAt` (ms) of the step's latest observed `step_started`. Anchors\n   * the ownership lease: `leaseRemaining = lastStartedAt + lease − now`.\n   */\n  lastStartedAt?: number;\n  /**\n   * Whether a `step_retrying` was observed for this step. From that point\n   * the step is queue-owned (the delayed retry handoff or replay requeue),\n   * so inline ownership is permanently lapsed for this correlation ID.\n   */\n  sawRetrying?: boolean;\n}\n\nexport interface HookInvocationQueueItem {\n  type: 'hook';\n  correlationId: string;\n  token: string;\n  metadata?: Serializable;\n  hasCreatedEvent?: boolean;\n  /** Whether the workflow is awaiting `hook.getConflict()` for this hook */\n  hasConflictAwaiter?: boolean;\n  disposed?: boolean;\n  isWebhook?: boolean;\n  isSystem?: boolean;\n  abortRequested?: boolean;\n  abortReason?: unknown;\n}\n\nexport interface WaitInvocationQueueItem {\n  type: 'wait';\n  correlationId: string;\n  resumeAt: Date;\n  hasCreatedEvent?: boolean;\n}\n\nexport interface AttributeInvocationQueueItem {\n  type: 'attribute';\n  correlationId: string;\n  changes: AttributeChange[];\n  allowReservedAttributes?: true;\n}\n\nexport type QueueItem =\n  | StepInvocationQueueItem\n  | HookInvocationQueueItem\n  | WaitInvocationQueueItem\n  | AttributeInvocationQueueItem;\n\n/**\n * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do\n * not yet have corresponding entries in the event log. The workflow\n * dispatcher will catch this error and push the operations\n * onto the queue.\n */\nexport class WorkflowSuspension extends Error {\n  steps: QueueItem[];\n  globalThis: typeof globalThis;\n  stepCount: number;\n  hookCount: number;\n  waitCount: number;\n  attributeCount: number;\n  hookDisposedCount: number;\n  abortCount: number;\n\n  constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis) {\n    // Convert Map to array for iteration and storage\n    const steps = [...stepsInput.values()];\n\n    // Single-pass counting for efficiency\n    let stepCount = 0;\n    let hookCount = 0;\n    let waitCount = 0;\n    let attributeCount = 0;\n    let hookDisposedCount = 0;\n    let abortCount = 0;\n    for (const item of steps) {\n      if (item.type === 'step') stepCount++;\n      else if (item.type === 'hook') {\n        if (item.disposed) hookDisposedCount++;\n        else if (item.abortRequested) abortCount++;\n        else hookCount++;\n      } else if (item.type === 'wait') waitCount++;\n      else if (item.type === 'attribute') attributeCount++;\n    }\n\n    // Build description parts\n    const parts: string[] = [];\n    if (stepCount > 0) {\n      parts.push(`${stepCount} ${pluralize('step', 'steps', stepCount)}`);\n    }\n    if (hookCount > 0) {\n      parts.push(`${hookCount} ${pluralize('hook', 'hooks', hookCount)}`);\n    }\n    if (waitCount > 0) {\n      parts.push(`${waitCount} ${pluralize('wait', 'waits', waitCount)}`);\n    }\n    if (attributeCount > 0) {\n      parts.push(\n        `${attributeCount} ${pluralize('attribute write', 'attribute writes', attributeCount)}`\n      );\n    }\n    if (hookDisposedCount > 0) {\n      parts.push(\n        `${hookDisposedCount} hook ${pluralize('disposal', 'disposals', hookDisposedCount)}`\n      );\n    }\n\n    // Determine verb (has/have) and action (run/created/received)\n    const totalCount =\n      stepCount + hookCount + waitCount + attributeCount + hookDisposedCount;\n    const hasOrHave = pluralize('has', 'have', totalCount);\n    // Pick action verb: use \"processed\" when mixed types are present\n    const typeCount =\n      (stepCount > 0 ? 1 : 0) +\n      (hookCount > 0 ? 1 : 0) +\n      (waitCount > 0 ? 1 : 0) +\n      (attributeCount > 0 ? 1 : 0) +\n      (hookDisposedCount > 0 ? 1 : 0);\n    let action: string;\n    if (typeCount > 1) {\n      action = 'processed';\n    } else if (stepCount > 0) {\n      action = 'run';\n    } else if (hookCount > 0) {\n      action = 'created';\n    } else if (waitCount > 0) {\n      action = 'created';\n    } else if (attributeCount > 0) {\n      action = 'written';\n    } else if (hookDisposedCount > 0) {\n      action = 'processed';\n    } else {\n      action = 'received';\n    }\n\n    const description =\n      parts.length > 0\n        ? `${parts.join(' and ')} ${hasOrHave} not been ${action} yet`\n        : '0 steps have not been run yet'; // Default case for empty array\n    super(description);\n    this.name = 'WorkflowSuspension';\n    this.steps = steps;\n    this.globalThis = global;\n    this.stepCount = stepCount;\n    this.hookCount = hookCount;\n    this.waitCount = waitCount;\n    this.attributeCount = attributeCount;\n    this.hookDisposedCount = hookDisposedCount;\n    this.abortCount = abortCount;\n  }\n\n  static is(value: unknown): value is WorkflowSuspension {\n    return value instanceof WorkflowSuspension;\n  }\n}\n\nexport function ENOTSUP(): never {\n  throw new WorkflowRuntimeError(\n    'This API is not available inside a workflow function. Workflow functions run in a deterministic VM; move the call to a step function for full Node.js access.'\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global.js","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { pluralize } from '@workflow/utils';\nimport type { AttributeChange } from '@workflow/world';\nimport type { Serializable } from './schemas.js';\n\nexport interface StepInvocationQueueItem {\n  type: 'step';\n  correlationId: string;\n  stepName: string;\n  args: Serializable[];\n  closureVars?: Record<string, Serializable>;\n  thisVal?: Serializable;\n  hasCreatedEvent?: boolean;\n  /**\n   * Inline step ownership, derived from the step's LATEST `step_started`\n   * during replay: the queue message ID stamped by the invocation running\n   * the step inline, or undefined when the latest start was unstamped (a\n   * retry attempt driven by a queued step message, or an older runtime).\n   * Latest start wins — an unstamped bare start clears a previous stamp; an\n   * owner-recovery re-stamped start restores it.\n   */\n  ownerMessageId?: string;\n  /**\n   * `createdAt` (ms) of the step's latest observed `step_started`. Anchors\n   * the ownership lease: `leaseRemaining = lastStartedAt + lease − now`.\n   */\n  lastStartedAt?: number;\n  /**\n   * Whether a `step_retrying` was observed for this step. From that point\n   * the step is queue-owned (the delayed retry handoff or replay requeue),\n   * so inline ownership is permanently lapsed for this correlation ID.\n   */\n  sawRetrying?: boolean;\n}\n\nexport interface HookInvocationQueueItem {\n  type: 'hook';\n  correlationId: string;\n  token: string;\n  /** Earliest time the token can be reused after the run ends. */\n  tokenRetentionUntil?: Date;\n  metadata?: Serializable;\n  hasCreatedEvent?: boolean;\n  /** Whether the workflow is awaiting `hook.getConflict()` for this hook */\n  hasConflictAwaiter?: boolean;\n  disposed?: boolean;\n  isWebhook?: boolean;\n  isSystem?: boolean;\n  abortRequested?: boolean;\n  abortReason?: unknown;\n}\n\nexport interface WaitInvocationQueueItem {\n  type: 'wait';\n  correlationId: string;\n  resumeAt: Date;\n  hasCreatedEvent?: boolean;\n}\n\nexport interface AttributeInvocationQueueItem {\n  type: 'attribute';\n  correlationId: string;\n  changes: AttributeChange[];\n  allowReservedAttributes?: true;\n}\n\nexport type QueueItem =\n  | StepInvocationQueueItem\n  | HookInvocationQueueItem\n  | WaitInvocationQueueItem\n  | AttributeInvocationQueueItem;\n\n/**\n * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do\n * not yet have corresponding entries in the event log. The workflow\n * dispatcher will catch this error and push the operations\n * onto the queue.\n */\nexport class WorkflowSuspension extends Error {\n  steps: QueueItem[];\n  globalThis: typeof globalThis;\n  stepCount: number;\n  hookCount: number;\n  waitCount: number;\n  attributeCount: number;\n  hookDisposedCount: number;\n  abortCount: number;\n\n  constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis) {\n    // Convert Map to array for iteration and storage\n    const steps = [...stepsInput.values()];\n\n    // Single-pass counting for efficiency\n    let stepCount = 0;\n    let hookCount = 0;\n    let waitCount = 0;\n    let attributeCount = 0;\n    let hookDisposedCount = 0;\n    let abortCount = 0;\n    for (const item of steps) {\n      if (item.type === 'step') stepCount++;\n      else if (item.type === 'hook') {\n        if (item.disposed) hookDisposedCount++;\n        else if (item.abortRequested) abortCount++;\n        else hookCount++;\n      } else if (item.type === 'wait') waitCount++;\n      else if (item.type === 'attribute') attributeCount++;\n    }\n\n    // Build description parts\n    const parts: string[] = [];\n    if (stepCount > 0) {\n      parts.push(`${stepCount} ${pluralize('step', 'steps', stepCount)}`);\n    }\n    if (hookCount > 0) {\n      parts.push(`${hookCount} ${pluralize('hook', 'hooks', hookCount)}`);\n    }\n    if (waitCount > 0) {\n      parts.push(`${waitCount} ${pluralize('wait', 'waits', waitCount)}`);\n    }\n    if (attributeCount > 0) {\n      parts.push(\n        `${attributeCount} ${pluralize('attribute write', 'attribute writes', attributeCount)}`\n      );\n    }\n    if (hookDisposedCount > 0) {\n      parts.push(\n        `${hookDisposedCount} hook ${pluralize('disposal', 'disposals', hookDisposedCount)}`\n      );\n    }\n\n    // Determine verb (has/have) and action (run/created/received)\n    const totalCount =\n      stepCount + hookCount + waitCount + attributeCount + hookDisposedCount;\n    const hasOrHave = pluralize('has', 'have', totalCount);\n    // Pick action verb: use \"processed\" when mixed types are present\n    const typeCount =\n      (stepCount > 0 ? 1 : 0) +\n      (hookCount > 0 ? 1 : 0) +\n      (waitCount > 0 ? 1 : 0) +\n      (attributeCount > 0 ? 1 : 0) +\n      (hookDisposedCount > 0 ? 1 : 0);\n    let action: string;\n    if (typeCount > 1) {\n      action = 'processed';\n    } else if (stepCount > 0) {\n      action = 'run';\n    } else if (hookCount > 0) {\n      action = 'created';\n    } else if (waitCount > 0) {\n      action = 'created';\n    } else if (attributeCount > 0) {\n      action = 'written';\n    } else if (hookDisposedCount > 0) {\n      action = 'processed';\n    } else {\n      action = 'received';\n    }\n\n    const description =\n      parts.length > 0\n        ? `${parts.join(' and ')} ${hasOrHave} not been ${action} yet`\n        : '0 steps have not been run yet'; // Default case for empty array\n    super(description);\n    this.name = 'WorkflowSuspension';\n    this.steps = steps;\n    this.globalThis = global;\n    this.stepCount = stepCount;\n    this.hookCount = hookCount;\n    this.waitCount = waitCount;\n    this.attributeCount = attributeCount;\n    this.hookDisposedCount = hookDisposedCount;\n    this.abortCount = abortCount;\n  }\n\n  static is(value: unknown): value is WorkflowSuspension {\n    return value instanceof WorkflowSuspension;\n  }\n}\n\nexport function ENOTSUP(): never {\n  throw new WorkflowRuntimeError(\n    'This API is not available inside a workflow function. Workflow functions run in a deterministic VM; move the call to a step function for full Node.js access.'\n  );\n}\n"]}

package/dist/index.d.ts

@@ -12,7 +12,7 @@
 export { FatalError, RetryableError, type RetryableErrorOptions, } from '@workflow/errors';
 export { createHook, createWebhook, type Hook, type HookOptions, type RequestWithResponse, type Webhook, type WebhookOptions, } from './create-hook.js';
 export { defineHook, type TypedHook } from './define-hook.js';
-export { experimental_setAttributes, type SetAttributesOptions, setAttributes, } from './set-attributes.js';
+export { type SetAttributesOptions, setAttributes, } from './set-attributes.js';
 export { sleep } from './sleep.js';
 export { getStepMetadata, type StepMetadata, } from './step/get-step-metadata.js';
 export { getWorkflowMetadata, type WorkflowMetadata, } from './step/get-workflow-metadata.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,UAAU,EACV,aAAa,EACb,KAAK,IAAI,EACT,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,OAAO,EACZ,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EACL,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EACL,eAAe,EACf,KAAK,YAAY,GAClB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,WAAW,EACX,KAAK,6BAA6B,GACnC,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,UAAU,EACV,aAAa,EACb,KAAK,IAAI,EACT,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,OAAO,EACZ,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EACL,KAAK,oBAAoB,EACzB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EACL,eAAe,EACf,KAAK,YAAY,GAClB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,WAAW,EACX,KAAK,6BAA6B,GACnC,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -12,9 +12,9 @@
 export { FatalError, RetryableError, } from '@workflow/errors';
 export { createHook, createWebhook, } from './create-hook.js';
 export { defineHook } from './define-hook.js';
-export { experimental_setAttributes, setAttributes, } from './set-attributes.js';
+export { setAttributes, } from './set-attributes.js';
 export { sleep } from './sleep.js';
 export { getStepMetadata, } from './step/get-step-metadata.js';
 export { getWorkflowMetadata, } from './step/get-workflow-metadata.js';
 export { getWritable, } from './step/writable-stream.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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