@workflow/core 5.0.0-beta.46 → 5.0.0-beta.47

package/dist/capabilities.d.ts

@@ -37,11 +37,12 @@
  *   which a run only carries if the deployment that created it could also
  *   open `encp`. The entry exists so the capability set stays a complete,
  *   auditable description of a run's decoding ability.
- * - Lazy hook resume ("consumer re-ensures `hook_received` from `hookInput`"):
- *   deliberately NOT tracked here. Rather than predict a release cutoff, the
- *   run's creating deployment stamps an explicit `hookResumeInputVersion`
- *   execution-context marker; `resumeHook()` gates the lazy path on that
- *   marker (mirrored onto the hook's resumeContext by the server).
+ * - Hook-resume consumer protocol ("consumer re-ensures `hook_received` from
+ *   `hookInput`"): deliberately NOT tracked here. Rather than predict a
+ *   release cutoff, the run's creating deployment stamps an explicit
+ *   `hookResumeInputVersion` execution-context marker (mirrored onto the
+ *   hook's resumeContext by the server); older producers gate their lazy path
+ *   on that marker.
  */
 import { type SerializationFormatType } from './serialization.js';
 /**

package/dist/capabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAGH,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,gBAAgB,EAAE,WAAW,CAAC,uBAAuB,CAAC,CAAC;IAEvD;;;;;;;OAOG;IACH,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AA8DD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,eAAe,CA4BjB"}
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAGH,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,gBAAgB,EAAE,WAAW,CAAC,uBAAuB,CAAC,CAAC;IAEvD;;;;;;;OAOG;IACH,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AA+DD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,eAAe,CA4BjB"}

package/dist/capabilities.js

@@ -37,11 +37,12 @@
  *   which a run only carries if the deployment that created it could also
  *   open `encp`. The entry exists so the capability set stays a complete,
  *   auditable description of a run's decoding ability.
- * - Lazy hook resume ("consumer re-ensures `hook_received` from `hookInput`"):
- *   deliberately NOT tracked here. Rather than predict a release cutoff, the
- *   run's creating deployment stamps an explicit `hookResumeInputVersion`
- *   execution-context marker; `resumeHook()` gates the lazy path on that
- *   marker (mirrored onto the hook's resumeContext by the server).
+ * - Hook-resume consumer protocol ("consumer re-ensures `hook_received` from
+ *   `hookInput`"): deliberately NOT tracked here. Rather than predict a
+ *   release cutoff, the run's creating deployment stamps an explicit
+ *   `hookResumeInputVersion` execution-context marker (mirrored onto the
+ *   hook's resumeContext by the server); older producers gate their lazy path
+ *   on that marker.
  */
 import semver from 'semver';
 import { SerializationFormat, } from './serialization.js';
@@ -81,12 +82,13 @@ const CAPABILITY_VERSION_TABLE = [
     // consumers that cannot unframe them (silent corruption); too-high merely
     // delays the optimization (safe).
     { capability: 'framedByteStreams', minVersion: '5.0.0-beta.15' },
-    // NOTE: lazy hook resume ("does the consumer re-ensure `hook_received` from
-    // the queue message's `hookInput`?") is intentionally NOT gated here. A
-    // version-compare against a predicted release cutoff is a guess; instead the
-    // run's creating deployment stamps an explicit `hookResumeInputVersion`
-    // marker into its execution context, which the server mirrors onto the hook's
-    // resumeContext. `resumeHook()` gates the lazy path on that marker.
+    // NOTE: the hook-resume consumer protocol ("does the consumer re-ensure
+    // `hook_received` from the queue message's `hookInput`?") is intentionally
+    // NOT gated here. A version-compare against a predicted release cutoff is a
+    // guess; instead the run's creating deployment stamps an explicit
+    // `hookResumeInputVersion` marker into its execution context, which the
+    // server mirrors onto the hook's resumeContext. Older producers gate their
+    // lazy path on that marker.
 ];
 /**
  * The set of formats supported by all specVersion 2 runs, regardless of
@@ -129,4 +131,4 @@ export function getRunCapabilities(workflowCoreVersion) {
     }
     return result;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EACL,mBAAmB,GAEpB,MAAM,oBAAoB,CAAC;AAwB5B;;;;GAIG;AACH,MAAM,oBAAoB,GAGrB;IACH,EAAE,MAAM,EAAE,mBAAmB,CAAC,SAAS,EAAE,UAAU,EAAE,eAAe,EAAE;IACtE,2EAA2E;IAC3E,4EAA4E;IAC5E,oEAAoE;IACpE,yEAAyE;IACzE,yEAAyE;IACzE,mEAAmE;IACnE,EAAE,MAAM,EAAE,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE;IACjE,EAAE,MAAM,EAAE,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE;IACjE,8EAA8E;IAC9E,2EAA2E;IAC3E,0EAA0E;IAC1E,6EAA6E;IAC7E,mEAAmE;IACnE,EAAE,MAAM,EAAE,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE;IACnE,kBAAkB;IAClB,6DAA6D;IAC7D,qEAAqE;CACtE,CAAC;AAEF;;;GAGG;AACH,MAAM,wBAAwB,GAGzB;IACH,+EAA+E;IAC/E,6EAA6E;IAC7E,+EAA+E;IAC/E,0EAA0E;IAC1E,kCAAkC;IAClC,EAAE,UAAU,EAAE,mBAAmB,EAAE,UAAU,EAAE,eAAe,EAAE;IAChE,4EAA4E;IAC5E,wEAAwE;IACxE,6EAA6E;IAC7E,wEAAwE;IACxE,8EAA8E;IAC9E,oEAAoE;CACrE,CAAC;AAEF;;;;GAIG;AACH,MAAM,gBAAgB,GAAyC,IAAI,GAAG,CAAC;IACrE,mBAAmB,CAAC,UAAU;CAC/B,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAChC,mBAAuC;IAEvC,IAAI,CAAC,mBAAmB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE,CAAC;QAC/D,OAAO;YACL,gBAAgB,EAAE,gBAAgB;YAClC,iBAAiB,EAAE,KAAK;SACzB,CAAC;IACJ,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,GAAG,CAA0B,gBAAgB,CAAC,CAAC;IAEnE,KAAK,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,oBAAoB,EAAE,CAAC;QAC1D,IAAI,MAAM,CAAC,GAAG,CAAC,mBAAmB,EAAE,UAAU,CAAC,EAAE,CAAC;YAChD,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAoB;QAC9B,gBAAgB,EAAE,OAAO;QACzB,iBAAiB,EAAE,KAAK;KACzB,CAAC;IAEF,KAAK,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,wBAAwB,EAAE,CAAC;QAClE,IAAI,MAAM,CAAC,GAAG,CAAC,mBAAmB,EAAE,UAAU,CAAC,EAAE,CAAC;YAChD,MAAM,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * Capabilities table for workflow runs based on their `@workflow/core` version.\n *\n * When resuming a hook or webhook, the payload must be encoded in a format\n * that the *target* workflow run's deployment can decode. This module provides\n * a way to look up what serialization formats a given `@workflow/core` version\n * supports, so that newer deployments can avoid encoding payloads in formats\n * that older deployments don't understand (e.g., the `encr` encryption format).\n *\n * ## Adding a new format\n *\n * When a new serialization format is introduced:\n * 1. Add the format constant to `SerializationFormat` in `serialization.ts`\n * 2. Add an entry to `FORMAT_VERSION_TABLE` below with the minimum\n *    `@workflow/core` version that supports it\n * 3. The `getRunCapabilities()` function will automatically include it\n *\n * ## Adding a new non-format capability\n *\n * Some capabilities aren't serialization format prefixes: e.g.\n * byte-stream wire framing is an envelope around chunks rather than\n * a content format. For those, add a boolean field to `RunCapabilities`\n * and an entry in `CAPABILITY_VERSION_TABLE` below.\n *\n * ## History\n *\n * - `encr` (AES-256-GCM encryption): added in `4.2.0-beta.64`\n *   Commit: 7618ac36 \"Wire AES-GCM encryption into serialization layer (#1251)\"\n *   https://github.com/vercel/workflow/commit/7618ac36\n * - `framedByteStreams` (wire-level chunk framing for byte streams): added in `5.0.0-beta.15`\n * - `gzip` (gzip payload compression): added in `5.0.0-beta.18`\n * - `zstd` (zstd payload compression, preferred codec): added in `5.0.0-beta.18`\n *   alongside gzip; they co-ship, so any run that can read one can read both.\n * - `encp` (X25519 sealed-box encryption for cross-run writes): added in\n *   `5.0.0-beta.37`. Note that producers do **not** gate `encp` on this table:\n *   they gate on the presence of `encryptionPublicKey` on the target run,\n *   which a run only carries if the deployment that created it could also\n *   open `encp`. The entry exists so the capability set stays a complete,\n *   auditable description of a run's decoding ability.\n * - Lazy hook resume (\"consumer re-ensures `hook_received` from `hookInput`\"):\n *   deliberately NOT tracked here. Rather than predict a release cutoff, the\n *   run's creating deployment stamps an explicit `hookResumeInputVersion`\n *   execution-context marker; `resumeHook()` gates the lazy path on that\n *   marker (mirrored onto the hook's resumeContext by the server).\n */\n\nimport semver from 'semver';\nimport {\n  SerializationFormat,\n  type SerializationFormatType,\n} from './serialization.js';\n\n/**\n * Capabilities of a workflow run based on its `@workflow/core` version.\n */\nexport interface RunCapabilities {\n  /**\n   * The set of serialization format prefixes that the target run can decode.\n   * Use `supportedFormats.has(SerializationFormat.ENCRYPTED)` to check\n   * if encryption is supported, etc.\n   */\n  supportedFormats: ReadonlySet<SerializationFormatType>;\n\n  /**\n   * Whether the target run can decode wire-framed byte streams. When true,\n   * byte streams (`type: 'bytes'` ReadableStreams passed across boundaries)\n   * are wrapped in a length-prefixed frame envelope on the wire so the\n   * reader can identify chunk boundaries, which enables auto-reconnect\n   * on transient stream errors. When false, byte streams are written as\n   * raw bytes (the legacy format) for compatibility with older runs.\n   */\n  framedByteStreams: boolean;\n}\n\n/**\n * Maps serialization format identifiers to the minimum `@workflow/core`\n * version that introduced support for them. Formats not listed here are\n * assumed to be supported by all specVersion 2 runs (e.g., `devl`).\n */\nconst FORMAT_VERSION_TABLE: ReadonlyArray<{\n  format: SerializationFormatType;\n  minVersion: string;\n}> = [\n  { format: SerializationFormat.ENCRYPTED, minVersion: '4.2.0-beta.64' },\n  // TODO(release): verify this matches the actual version that ships payload\n  // compression. If a \"Version Packages (beta)\" PR merges before this change,\n  // bump to the next beta. A too-low cutoff makes new producers write\n  // compressed payloads to consumers that cannot decompress them; too-high\n  // merely delays the optimization (safe). gzip and zstd ship together, so\n  // they share a min version: a run that can read one can read both.\n  { format: SerializationFormat.GZIP, minVersion: '5.0.0-beta.18' },\n  { format: SerializationFormat.ZSTD, minVersion: '5.0.0-beta.18' },\n  // TODO(release): verify this matches the actual version that ships sealed-box\n  // encryption. If a \"Version Packages (beta)\" PR merges before this change,\n  // bump to the next beta. Unlike the entries above, a wrong cutoff here is\n  // not a correctness hazard: producers gate `encp` on the target run carrying\n  // an `encryptionPublicKey`, not on this table (see History above).\n  { format: SerializationFormat.SEALED, minVersion: '5.0.0-beta.37' },\n  // Future entries:\n  // { format: SerializationFormat.CBOR, minVersion: '5.x.y' },\n  // { format: SerializationFormat.ENCRYPTED_V2, minVersion: '5.x.y' },\n];\n\n/**\n * Maps non-format capability flags (booleans on `RunCapabilities`) to the\n * minimum `@workflow/core` version that introduced support for them.\n */\nconst CAPABILITY_VERSION_TABLE: ReadonlyArray<{\n  capability: keyof Omit<RunCapabilities, 'supportedFormats'>;\n  minVersion: string;\n}> = [\n  // TODO(release): verify this matches the actual version that ships byte-stream\n  // framing. If a \"Version Packages (beta)\" PR merges before this change, bump\n  // to the next beta. A too-low cutoff makes new producers write framed bytes to\n  // consumers that cannot unframe them (silent corruption); too-high merely\n  // delays the optimization (safe).\n  { capability: 'framedByteStreams', minVersion: '5.0.0-beta.15' },\n  // NOTE: lazy hook resume (\"does the consumer re-ensure `hook_received` from\n  // the queue message's `hookInput`?\") is intentionally NOT gated here. A\n  // version-compare against a predicted release cutoff is a guess; instead the\n  // run's creating deployment stamps an explicit `hookResumeInputVersion`\n  // marker into its execution context, which the server mirrors onto the hook's\n  // resumeContext. `resumeHook()` gates the lazy path on that marker.\n];\n\n/**\n * The set of formats supported by all specVersion 2 runs, regardless of\n * `@workflow/core` version. These are the baseline formats that were present\n * from the start of the specVersion 2 protocol.\n */\nconst BASELINE_FORMATS: ReadonlySet<SerializationFormatType> = new Set([\n  SerializationFormat.DEVALUE_V1,\n]);\n\n/**\n * Look up what serialization capabilities a workflow run supports based on\n * its `@workflow/core` version string (from `executionContext.workflowCoreVersion`).\n *\n * When the version is `undefined`, not a string, or not a valid semver string\n * (e.g. older runs that predate the field, or corrupted metadata),\n * we assume the most conservative capabilities (baseline formats only,\n * non-format capabilities all `false`).\n */\nexport function getRunCapabilities(\n  workflowCoreVersion: string | undefined\n): RunCapabilities {\n  if (!workflowCoreVersion || !semver.valid(workflowCoreVersion)) {\n    return {\n      supportedFormats: BASELINE_FORMATS,\n      framedByteStreams: false,\n    };\n  }\n\n  const formats = new Set<SerializationFormatType>(BASELINE_FORMATS);\n\n  for (const { format, minVersion } of FORMAT_VERSION_TABLE) {\n    if (semver.gte(workflowCoreVersion, minVersion)) {\n      formats.add(format);\n    }\n  }\n\n  const result: RunCapabilities = {\n    supportedFormats: formats,\n    framedByteStreams: false,\n  };\n\n  for (const { capability, minVersion } of CAPABILITY_VERSION_TABLE) {\n    if (semver.gte(workflowCoreVersion, minVersion)) {\n      result[capability] = true;\n    }\n  }\n\n  return result;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EACL,mBAAmB,GAEpB,MAAM,oBAAoB,CAAC;AAwB5B;;;;GAIG;AACH,MAAM,oBAAoB,GAGrB;IACH,EAAE,MAAM,EAAE,mBAAmB,CAAC,SAAS,EAAE,UAAU,EAAE,eAAe,EAAE;IACtE,2EAA2E;IAC3E,4EAA4E;IAC5E,oEAAoE;IACpE,yEAAyE;IACzE,yEAAyE;IACzE,mEAAmE;IACnE,EAAE,MAAM,EAAE,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE;IACjE,EAAE,MAAM,EAAE,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE;IACjE,8EAA8E;IAC9E,2EAA2E;IAC3E,0EAA0E;IAC1E,6EAA6E;IAC7E,mEAAmE;IACnE,EAAE,MAAM,EAAE,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE;IACnE,kBAAkB;IAClB,6DAA6D;IAC7D,qEAAqE;CACtE,CAAC;AAEF;;;GAGG;AACH,MAAM,wBAAwB,GAGzB;IACH,+EAA+E;IAC/E,6EAA6E;IAC7E,+EAA+E;IAC/E,0EAA0E;IAC1E,kCAAkC;IAClC,EAAE,UAAU,EAAE,mBAAmB,EAAE,UAAU,EAAE,eAAe,EAAE;IAChE,wEAAwE;IACxE,2EAA2E;IAC3E,4EAA4E;IAC5E,kEAAkE;IAClE,wEAAwE;IACxE,2EAA2E;IAC3E,4BAA4B;CAC7B,CAAC;AAEF;;;;GAIG;AACH,MAAM,gBAAgB,GAAyC,IAAI,GAAG,CAAC;IACrE,mBAAmB,CAAC,UAAU;CAC/B,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAChC,mBAAuC;IAEvC,IAAI,CAAC,mBAAmB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE,CAAC;QAC/D,OAAO;YACL,gBAAgB,EAAE,gBAAgB;YAClC,iBAAiB,EAAE,KAAK;SACzB,CAAC;IACJ,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,GAAG,CAA0B,gBAAgB,CAAC,CAAC;IAEnE,KAAK,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,oBAAoB,EAAE,CAAC;QAC1D,IAAI,MAAM,CAAC,GAAG,CAAC,mBAAmB,EAAE,UAAU,CAAC,EAAE,CAAC;YAChD,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAoB;QAC9B,gBAAgB,EAAE,OAAO;QACzB,iBAAiB,EAAE,KAAK;KACzB,CAAC;IAEF,KAAK,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,wBAAwB,EAAE,CAAC;QAClE,IAAI,MAAM,CAAC,GAAG,CAAC,mBAAmB,EAAE,UAAU,CAAC,EAAE,CAAC;YAChD,MAAM,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * Capabilities table for workflow runs based on their `@workflow/core` version.\n *\n * When resuming a hook or webhook, the payload must be encoded in a format\n * that the *target* workflow run's deployment can decode. This module provides\n * a way to look up what serialization formats a given `@workflow/core` version\n * supports, so that newer deployments can avoid encoding payloads in formats\n * that older deployments don't understand (e.g., the `encr` encryption format).\n *\n * ## Adding a new format\n *\n * When a new serialization format is introduced:\n * 1. Add the format constant to `SerializationFormat` in `serialization.ts`\n * 2. Add an entry to `FORMAT_VERSION_TABLE` below with the minimum\n *    `@workflow/core` version that supports it\n * 3. The `getRunCapabilities()` function will automatically include it\n *\n * ## Adding a new non-format capability\n *\n * Some capabilities aren't serialization format prefixes: e.g.\n * byte-stream wire framing is an envelope around chunks rather than\n * a content format. For those, add a boolean field to `RunCapabilities`\n * and an entry in `CAPABILITY_VERSION_TABLE` below.\n *\n * ## History\n *\n * - `encr` (AES-256-GCM encryption): added in `4.2.0-beta.64`\n *   Commit: 7618ac36 \"Wire AES-GCM encryption into serialization layer (#1251)\"\n *   https://github.com/vercel/workflow/commit/7618ac36\n * - `framedByteStreams` (wire-level chunk framing for byte streams): added in `5.0.0-beta.15`\n * - `gzip` (gzip payload compression): added in `5.0.0-beta.18`\n * - `zstd` (zstd payload compression, preferred codec): added in `5.0.0-beta.18`\n *   alongside gzip; they co-ship, so any run that can read one can read both.\n * - `encp` (X25519 sealed-box encryption for cross-run writes): added in\n *   `5.0.0-beta.37`. Note that producers do **not** gate `encp` on this table:\n *   they gate on the presence of `encryptionPublicKey` on the target run,\n *   which a run only carries if the deployment that created it could also\n *   open `encp`. The entry exists so the capability set stays a complete,\n *   auditable description of a run's decoding ability.\n * - Hook-resume consumer protocol (\"consumer re-ensures `hook_received` from\n *   `hookInput`\"): deliberately NOT tracked here. Rather than predict a\n *   release cutoff, the run's creating deployment stamps an explicit\n *   `hookResumeInputVersion` execution-context marker (mirrored onto the\n *   hook's resumeContext by the server); older producers gate their lazy path\n *   on that marker.\n */\n\nimport semver from 'semver';\nimport {\n  SerializationFormat,\n  type SerializationFormatType,\n} from './serialization.js';\n\n/**\n * Capabilities of a workflow run based on its `@workflow/core` version.\n */\nexport interface RunCapabilities {\n  /**\n   * The set of serialization format prefixes that the target run can decode.\n   * Use `supportedFormats.has(SerializationFormat.ENCRYPTED)` to check\n   * if encryption is supported, etc.\n   */\n  supportedFormats: ReadonlySet<SerializationFormatType>;\n\n  /**\n   * Whether the target run can decode wire-framed byte streams. When true,\n   * byte streams (`type: 'bytes'` ReadableStreams passed across boundaries)\n   * are wrapped in a length-prefixed frame envelope on the wire so the\n   * reader can identify chunk boundaries, which enables auto-reconnect\n   * on transient stream errors. When false, byte streams are written as\n   * raw bytes (the legacy format) for compatibility with older runs.\n   */\n  framedByteStreams: boolean;\n}\n\n/**\n * Maps serialization format identifiers to the minimum `@workflow/core`\n * version that introduced support for them. Formats not listed here are\n * assumed to be supported by all specVersion 2 runs (e.g., `devl`).\n */\nconst FORMAT_VERSION_TABLE: ReadonlyArray<{\n  format: SerializationFormatType;\n  minVersion: string;\n}> = [\n  { format: SerializationFormat.ENCRYPTED, minVersion: '4.2.0-beta.64' },\n  // TODO(release): verify this matches the actual version that ships payload\n  // compression. If a \"Version Packages (beta)\" PR merges before this change,\n  // bump to the next beta. A too-low cutoff makes new producers write\n  // compressed payloads to consumers that cannot decompress them; too-high\n  // merely delays the optimization (safe). gzip and zstd ship together, so\n  // they share a min version: a run that can read one can read both.\n  { format: SerializationFormat.GZIP, minVersion: '5.0.0-beta.18' },\n  { format: SerializationFormat.ZSTD, minVersion: '5.0.0-beta.18' },\n  // TODO(release): verify this matches the actual version that ships sealed-box\n  // encryption. If a \"Version Packages (beta)\" PR merges before this change,\n  // bump to the next beta. Unlike the entries above, a wrong cutoff here is\n  // not a correctness hazard: producers gate `encp` on the target run carrying\n  // an `encryptionPublicKey`, not on this table (see History above).\n  { format: SerializationFormat.SEALED, minVersion: '5.0.0-beta.37' },\n  // Future entries:\n  // { format: SerializationFormat.CBOR, minVersion: '5.x.y' },\n  // { format: SerializationFormat.ENCRYPTED_V2, minVersion: '5.x.y' },\n];\n\n/**\n * Maps non-format capability flags (booleans on `RunCapabilities`) to the\n * minimum `@workflow/core` version that introduced support for them.\n */\nconst CAPABILITY_VERSION_TABLE: ReadonlyArray<{\n  capability: keyof Omit<RunCapabilities, 'supportedFormats'>;\n  minVersion: string;\n}> = [\n  // TODO(release): verify this matches the actual version that ships byte-stream\n  // framing. If a \"Version Packages (beta)\" PR merges before this change, bump\n  // to the next beta. A too-low cutoff makes new producers write framed bytes to\n  // consumers that cannot unframe them (silent corruption); too-high merely\n  // delays the optimization (safe).\n  { capability: 'framedByteStreams', minVersion: '5.0.0-beta.15' },\n  // NOTE: the hook-resume consumer protocol (\"does the consumer re-ensure\n  // `hook_received` from the queue message's `hookInput`?\") is intentionally\n  // NOT gated here. A version-compare against a predicted release cutoff is a\n  // guess; instead the run's creating deployment stamps an explicit\n  // `hookResumeInputVersion` marker into its execution context, which the\n  // server mirrors onto the hook's resumeContext. Older producers gate their\n  // lazy path on that marker.\n];\n\n/**\n * The set of formats supported by all specVersion 2 runs, regardless of\n * `@workflow/core` version. These are the baseline formats that were present\n * from the start of the specVersion 2 protocol.\n */\nconst BASELINE_FORMATS: ReadonlySet<SerializationFormatType> = new Set([\n  SerializationFormat.DEVALUE_V1,\n]);\n\n/**\n * Look up what serialization capabilities a workflow run supports based on\n * its `@workflow/core` version string (from `executionContext.workflowCoreVersion`).\n *\n * When the version is `undefined`, not a string, or not a valid semver string\n * (e.g. older runs that predate the field, or corrupted metadata),\n * we assume the most conservative capabilities (baseline formats only,\n * non-format capabilities all `false`).\n */\nexport function getRunCapabilities(\n  workflowCoreVersion: string | undefined\n): RunCapabilities {\n  if (!workflowCoreVersion || !semver.valid(workflowCoreVersion)) {\n    return {\n      supportedFormats: BASELINE_FORMATS,\n      framedByteStreams: false,\n    };\n  }\n\n  const formats = new Set<SerializationFormatType>(BASELINE_FORMATS);\n\n  for (const { format, minVersion } of FORMAT_VERSION_TABLE) {\n    if (semver.gte(workflowCoreVersion, minVersion)) {\n      formats.add(format);\n    }\n  }\n\n  const result: RunCapabilities = {\n    supportedFormats: formats,\n    framedByteStreams: false,\n  };\n\n  for (const { capability, minVersion } of CAPABILITY_VERSION_TABLE) {\n    if (semver.gte(workflowCoreVersion, minVersion)) {\n      result[capability] = true;\n    }\n  }\n\n  return result;\n}\n"]}

package/dist/events-consumer.d.ts

@@ -165,6 +165,27 @@ export declare class EventsConsumer {
      * afterwards is what keeps the two pointers from interfering.
      */
     private drainParked;
+    /**
+     * Release anything parked whose class a consumption has since recorded for
+     * the same entity, on the same terms as {@link skipDuplicateEvent}.
+     *
+     * The ordered walk decides a straggler at the event, but only for one of the
+     * two orders the copies can arrive in. When neither copy has a consumer yet,
+     * both park — the walk steps over the first and re-enters immediately, so
+     * the second is offered in the same tick, with no class recorded because
+     * nothing has been *consumed*. The drain then claims the first and the
+     * second is left held by a consumer list that will never grow the callback
+     * it needs, which the workflow function returning reports through
+     * {@link strandedEvent} as a replay divergence.
+     *
+     * Run before each offer pass rather than once, because the consumption that
+     * records the class happens inside the drain itself.
+     *
+     * Not specific to `attr_set`: `wait_completed` reaches the same state, and
+     * {@link ONE_SHOT_EVENT_TYPES} only covers it in the order where the
+     * consumption came first.
+     */
+    private dropParkedDuplicates;
     /**
      * Step the ordered walk over an event nobody claimed, holding on to it for a
      * later consumer. Returns false when the event's type makes its position a
@@ -173,12 +194,13 @@ export declare class EventsConsumer {
      */
     private park;
     /**
-     * The key `event`'s class is tracked under, or `undefined` for the event
-     * types that belong to no class (`hook_received`, `hook_conflict`,
-     * `attr_set`, `run_created`) and are therefore never skipped.
+     * The key `event`'s class is tracked under, or `undefined` for the events
+     * that belong to no class and are therefore never skipped: the types with no
+     * entry at all (`hook_received`, `hook_conflict`, `run_created`), and a
+     * classed type carrying no entity to track it under.
      *
-     * Run events carry no correlation id. They are classes of the run itself, so
-     * they all key off the same bucket.
+     * {@link classifyEntityEvent} owns that rule, because the observability UI
+     * decides the same question about the same log and the two must not drift.
      */
     private eventClassKey;
     /**
@@ -261,7 +283,8 @@ export declare class EventsConsumer {
      * recorded while the check was in flight can only have been recorded by a
      * consumption inside {@link consume}, whose next pass re-offers this event
      * and steps over it there, leaving the identity guard above to drop the
-     * in-flight check.
+     * in-flight check. One that parks before any consumption records its class
+     * is released later by {@link dropParkedDuplicates} instead.
      */
     private resolveUnconsumedEvent;
     /**

package/dist/events-consumer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events-consumer.d.ts","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"events-consumer.d.ts","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"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"}