@workflow/core 4.4.0 → 4.6.0

package/dist/capabilities.d.ts

@@ -15,11 +15,22 @@
  *    `@workflow/core` version that supports it
  * 3. The `getRunCapabilities()` function will automatically include it
  *
+ * ## Adding a new non-format capability
+ *
+ * Some capabilities aren't serialization format prefixes — e.g.
+ * byte-stream wire framing is an envelope around chunks rather than
+ * a content format. For those, add a boolean field to `RunCapabilities`
+ * and an entry in `CAPABILITY_VERSION_TABLE` below.
+ *
  * ## History
  *
  * - `encr` (AES-256-GCM encryption): added in `4.2.0-beta.64`
  *   Commit: 7618ac36 "Wire AES-GCM encryption into serialization layer (#1251)"
  *   https://github.com/vercel/workflow/commit/7618ac36
+ * - `framedByteStreams` (wire-level chunk framing for byte streams): added in
+ *   `4.6.0` on the stable line and `5.0.0-beta.15` on the beta line
+ *   Commit: f2ad726 "Add wire-level framing for byte streams (#1853)"
+ *   https://github.com/vercel/workflow/commit/f2ad726
  */
 import { type SerializationFormatType } from './serialization.js';
 /**
@@ -32,6 +43,15 @@ export interface RunCapabilities {
      * if encryption is supported, etc.
      */
     supportedFormats: ReadonlySet<SerializationFormatType>;
+    /**
+     * Whether the target run can decode wire-framed byte streams. When true,
+     * byte streams (`type: 'bytes'` ReadableStreams passed across boundaries)
+     * are wrapped in a length-prefixed frame envelope on the wire so the
+     * reader can identify chunk boundaries — which enables auto-reconnect
+     * on transient stream errors. When false, byte streams are written as
+     * raw bytes (the legacy format) for compatibility with older runs.
+     */
+    framedByteStreams: boolean;
 }
 /**
  * Look up what serialization capabilities a workflow run supports based on
@@ -39,7 +59,8 @@ export interface RunCapabilities {
  *
  * When the version is `undefined`, not a string, or not a valid semver string
  * (e.g. very old runs that predate the field, or corrupted metadata),
- * we assume the most conservative capabilities (baseline formats only).
+ * we assume the most conservative capabilities (baseline formats only,
+ * non-format capabilities all `false`).
  */
 export declare function getRunCapabilities(workflowCoreVersion: string | undefined): RunCapabilities;
 //# sourceMappingURL=capabilities.d.ts.map

package/dist/capabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;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;CACxD;AA0BD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,eAAe,CAcjB"}
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;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;AAsDD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,eAAe,CA8BjB"}

package/dist/capabilities.js

@@ -15,11 +15,22 @@
  *    `@workflow/core` version that supports it
  * 3. The `getRunCapabilities()` function will automatically include it
  *
+ * ## Adding a new non-format capability
+ *
+ * Some capabilities aren't serialization format prefixes — e.g.
+ * byte-stream wire framing is an envelope around chunks rather than
+ * a content format. For those, add a boolean field to `RunCapabilities`
+ * and an entry in `CAPABILITY_VERSION_TABLE` below.
+ *
  * ## History
  *
  * - `encr` (AES-256-GCM encryption): added in `4.2.0-beta.64`
  *   Commit: 7618ac36 "Wire AES-GCM encryption into serialization layer (#1251)"
  *   https://github.com/vercel/workflow/commit/7618ac36
+ * - `framedByteStreams` (wire-level chunk framing for byte streams): added in
+ *   `4.6.0` on the stable line and `5.0.0-beta.15` on the beta line
+ *   Commit: f2ad726 "Add wire-level framing for byte streams (#1853)"
+ *   https://github.com/vercel/workflow/commit/f2ad726
  */
 import semver from 'semver';
 import { SerializationFormat, } from './serialization.js';
@@ -34,6 +45,30 @@ const FORMAT_VERSION_TABLE = [
     // { format: SerializationFormat.CBOR, minVersion: '5.x.y' },
     // { format: SerializationFormat.ENCRYPTED_V2, minVersion: '5.x.y' },
 ];
+/**
+ * Maps non-format capability flags (booleans on `RunCapabilities`) to the
+ * semver range of `@workflow/core` versions that support them.
+ *
+ * These are ranges rather than simple minimum versions because published
+ * release lines interleave: every `5.0.0-beta.x` compares above every
+ * `4.x` version, but betas below `5.0.0-beta.15` predate byte-stream
+ * framing. A plain `>= 4.6.0` check would classify those betas as
+ * framing-capable and write framed bytes to a consumer that cannot
+ * unframe them (silent corruption). Classifying a capable version as
+ * incapable is always safe — it merely falls back to the legacy format.
+ *
+ * Ranges are evaluated with `includePrerelease: true` so that future
+ * prereleases above a cutoff (e.g. `5.1.0-beta.0`) are recognized as
+ * capable.
+ */
+const CAPABILITY_VERSION_TABLE = [
+    {
+        capability: 'framedByteStreams',
+        // Stable line: shipped in 4.6.0. Beta line: shipped in 5.0.0-beta.15;
+        // 5.0.0-beta.0 through 5.0.0-beta.14 must read as raw.
+        range: '>=4.6.0 <5.0.0-0 || >=5.0.0-beta.15',
+    },
+];
 /**
  * The set of formats supported by all specVersion 2 runs, regardless of
  * `@workflow/core` version. These are the baseline formats that were present
@@ -48,11 +83,15 @@ const BASELINE_FORMATS = new Set([
  *
  * When the version is `undefined`, not a string, or not a valid semver string
  * (e.g. very old runs that predate the field, or corrupted metadata),
- * we assume the most conservative capabilities (baseline formats only).
+ * we assume the most conservative capabilities (baseline formats only,
+ * non-format capabilities all `false`).
  */
 export function getRunCapabilities(workflowCoreVersion) {
     if (!workflowCoreVersion || !semver.valid(workflowCoreVersion)) {
-        return { supportedFormats: BASELINE_FORMATS };
+        return {
+            supportedFormats: BASELINE_FORMATS,
+            framedByteStreams: false,
+        };
     }
     const formats = new Set(BASELINE_FORMATS);
     for (const { format, minVersion } of FORMAT_VERSION_TABLE) {
@@ -60,6 +99,15 @@ export function getRunCapabilities(workflowCoreVersion) {
             formats.add(format);
         }
     }
-    return { supportedFormats: formats };
+    const result = {
+        supportedFormats: formats,
+        framedByteStreams: false,
+    };
+    for (const { capability, range } of CAPABILITY_VERSION_TABLE) {
+        if (semver.satisfies(workflowCoreVersion, range, { includePrerelease: true })) {
+            result[capability] = true;
+        }
+    }
+    return result;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;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,kBAAkB;IAClB,6DAA6D;IAC7D,qEAAqE;CACtE,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,wBAAwB,GAGzB;IACH;QACE,UAAU,EAAE,mBAAmB;QAC/B,sEAAsE;QACtE,uDAAuD;QACvD,KAAK,EAAE,qCAAqC;KAC7C;CACF,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,KAAK,EAAE,IAAI,wBAAwB,EAAE,CAAC;QAC7D,IACE,MAAM,CAAC,SAAS,CAAC,mBAAmB,EAAE,KAAK,EAAE,EAAE,iBAAiB,EAAE,IAAI,EAAE,CAAC,EACzE,CAAC;YACD,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\n *   `4.6.0` on the stable line and `5.0.0-beta.15` on the beta line\n *   Commit: f2ad726 \"Add wire-level framing for byte streams (#1853)\"\n *   https://github.com/vercel/workflow/commit/f2ad726\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  // 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 * semver range of `@workflow/core` versions that support them.\n *\n * These are ranges rather than simple minimum versions because published\n * release lines interleave: every `5.0.0-beta.x` compares above every\n * `4.x` version, but betas below `5.0.0-beta.15` predate byte-stream\n * framing. A plain `>= 4.6.0` check would classify those betas as\n * framing-capable and write framed bytes to a consumer that cannot\n * unframe them (silent corruption). Classifying a capable version as\n * incapable is always safe — it merely falls back to the legacy format.\n *\n * Ranges are evaluated with `includePrerelease: true` so that future\n * prereleases above a cutoff (e.g. `5.1.0-beta.0`) are recognized as\n * capable.\n */\nconst CAPABILITY_VERSION_TABLE: ReadonlyArray<{\n  capability: keyof Omit<RunCapabilities, 'supportedFormats'>;\n  range: string;\n}> = [\n  {\n    capability: 'framedByteStreams',\n    // Stable line: shipped in 4.6.0. Beta line: shipped in 5.0.0-beta.15;\n    // 5.0.0-beta.0 through 5.0.0-beta.14 must read as raw.\n    range: '>=4.6.0 <5.0.0-0 || >=5.0.0-beta.15',\n  },\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. very old 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, range } of CAPABILITY_VERSION_TABLE) {\n    if (\n      semver.satisfies(workflowCoreVersion, range, { includePrerelease: true })\n    ) {\n      result[capability] = true;\n    }\n  }\n\n  return result;\n}\n"]}

package/dist/classify-error.d.ts

@@ -16,5 +16,20 @@ import { type RunErrorCode, WorkflowWorldError } from '@workflow/errors';
  * errors as user errors.
  */
 export declare function isWorldContractError(err: unknown): err is WorkflowWorldError;
+/**
+ * True when an error from a world (workflow-server) call is a transient
+ * infrastructure failure that should be retried by redelivering the queue
+ * message, rather than failing the run. A fresh invocation will likely
+ * succeed once the backend (or the firewall in front of it) recovers.
+ *
+ * - `ThrottleError` (429): rate limited / load shed
+ * - `WorkflowWorldError` with `status >= 500`: server-side error
+ * - `WorkflowWorldError` with a retryable transport `code` (`TRANSPORT` /
+ *   `TIMEOUT`): the request never produced a usable response
+ *
+ * Uses `.is()` name-based duck checks (not `instanceof`) for the same
+ * cross-`vm`-realm reason described on `classifyRunError`.
+ */
+export declare function isRetryableWorldError(err: unknown): boolean;
 export declare function classifyRunError(err: unknown): RunErrorCode;
 //# sourceMappingURL=classify-error.d.ts.map

package/dist/classify-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"classify-error.d.ts","sourceRoot":"","sources":["../src/classify-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,YAAY,EAKjB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AA0B1B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAe5E;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAmB3D"}
+{"version":3,"file":"classify-error.d.ts","sourceRoot":"","sources":["../src/classify-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,YAAY,EAMjB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAsC1B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAe5E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAW3D;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CA0B3D"}

package/dist/classify-error.js

@@ -1,9 +1,20 @@
-import { CorruptedEventLogError, ReplayDivergenceError, RUN_ERROR_CODES, RuntimeDecryptionError, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRuntimeError, WorkflowWorldError, } from '@workflow/errors';
+import { CorruptedEventLogError, ReplayDivergenceError, RUN_ERROR_CODES, RuntimeDecryptionError, StepNotRegisteredError, ThrottleError, WorkflowNotRegisteredError, WorkflowRuntimeError, WorkflowWorldError, } from '@workflow/errors';
 const WORLD_CONTRACT_ERROR_CODES = new Set([
     'PARSE_ERROR',
     'SCHEMA_VALIDATION',
     RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,
 ]);
+/**
+ * `WorkflowWorldError.code` values that mark a transient transport failure
+ * (set by world-vercel's HTTP client): `TRANSPORT` covers an exhausted
+ * RetryAgent (`UND_ERR_REQ_RETRY` — e.g. the firewall in front of
+ * workflow-server shedding load with 429/503), a dropped socket, or a
+ * connect/DNS failure; `TIMEOUT` covers a request that exceeded the client
+ * timeout. Both are infrastructure failures a fresh invocation can recover
+ * from. Kept distinct from `WORLD_CONTRACT_ERROR_CODES` so a transport blip is
+ * never misclassified as the server returning a malformed response.
+ */
+const RETRYABLE_WORLD_ERROR_CODES = new Set(['TRANSPORT', 'TIMEOUT']);
 /**
  * Set of error names that should classify as generic `RUNTIME_ERROR`. Each
  * `*.is()` static does a name-based duck check, so subclassing alone is
@@ -50,6 +61,32 @@ export function isWorldContractError(err) {
             'name' in cause &&
             cause.name === 'ZodError'));
 }
+/**
+ * True when an error from a world (workflow-server) call is a transient
+ * infrastructure failure that should be retried by redelivering the queue
+ * message, rather than failing the run. A fresh invocation will likely
+ * succeed once the backend (or the firewall in front of it) recovers.
+ *
+ * - `ThrottleError` (429): rate limited / load shed
+ * - `WorkflowWorldError` with `status >= 500`: server-side error
+ * - `WorkflowWorldError` with a retryable transport `code` (`TRANSPORT` /
+ *   `TIMEOUT`): the request never produced a usable response
+ *
+ * Uses `.is()` name-based duck checks (not `instanceof`) for the same
+ * cross-`vm`-realm reason described on `classifyRunError`.
+ */
+export function isRetryableWorldError(err) {
+    if (ThrottleError.is(err)) {
+        return true;
+    }
+    if (!WorkflowWorldError.is(err)) {
+        return false;
+    }
+    if (err.status !== undefined && err.status >= 500) {
+        return true;
+    }
+    return err.code !== undefined && RETRYABLE_WORLD_ERROR_CODES.has(err.code);
+}
 export function classifyRunError(err) {
     if (ReplayDivergenceError.is(err)) {
         return RUN_ERROR_CODES.REPLAY_DIVERGENCE;
@@ -57,7 +94,14 @@ export function classifyRunError(err) {
     if (CorruptedEventLogError.is(err)) {
         return RUN_ERROR_CODES.CORRUPTED_EVENT_LOG;
     }
-    if (isWorldContractError(err)) {
+    // World-layer faults — both a malformed response (contract violation) and a
+    // transient infrastructure failure (throttle / 5xx / transport / timeout,
+    // e.g. a firewall challenge) — are the backend's fault, not the user's.
+    // Bucket them under WORLD_CONTRACT_ERROR rather than USER_ERROR so dashboards
+    // attribute an outage correctly. Note the retryable variants are normally
+    // redelivered via the queue (see `isRetryableWorldError`) and only reach this
+    // terminal classification if the run ultimately gives up.
+    if (isWorldContractError(err) || isRetryableWorldError(err)) {
         return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;
     }
     for (const isMatch of RUNTIME_ERROR_CHECKS) {
@@ -67,4 +111,4 @@ export function classifyRunError(err) {
     }
     return RUN_ERROR_CODES.USER_ERROR;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classify-error.js","sourceRoot":"","sources":["../src/classify-error.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CorruptedEventLogError,\n  ReplayDivergenceError,\n  RUN_ERROR_CODES,\n  type RunErrorCode,\n  RuntimeDecryptionError,\n  StepNotRegisteredError,\n  ThrottleError,\n  WorkflowNotRegisteredError,\n  WorkflowRuntimeError,\n  WorkflowWorldError,\n} from '@workflow/errors';\n\nconst WORLD_CONTRACT_ERROR_CODES = new Set([\n  'PARSE_ERROR',\n  'SCHEMA_VALIDATION',\n  RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,\n]);\n\n/**\n * `WorkflowWorldError.code` values that mark a transient transport failure\n * (set by world-vercel's HTTP client): `TRANSPORT` covers an exhausted\n * RetryAgent (`UND_ERR_REQ_RETRY` — e.g. the firewall in front of\n * workflow-server shedding load with 429/503), a dropped socket, or a\n * connect/DNS failure; `TIMEOUT` covers a request that exceeded the client\n * timeout. Both are infrastructure failures a fresh invocation can recover\n * from. Kept distinct from `WORLD_CONTRACT_ERROR_CODES` so a transport blip is\n * never misclassified as the server returning a malformed response.\n */\nconst RETRYABLE_WORLD_ERROR_CODES = new Set(['TRANSPORT', 'TIMEOUT']);\n\n/**\n * Set of error names that should classify as generic `RUNTIME_ERROR`. Each\n * `*.is()` static does a name-based duck check, so subclassing alone is\n * not enough — we have to enumerate every concrete subclass we want to\n * recognize. Keep in sync with the `WorkflowRuntimeError` class hierarchy\n * in `@workflow/errors`.\n */\nconst RUNTIME_ERROR_CHECKS = [\n  WorkflowRuntimeError.is,\n  StepNotRegisteredError.is,\n  WorkflowNotRegisteredError.is,\n  // SDK-level encryption failures (most notably AES-GCM auth-tag\n  // mismatches surfacing as a native `OperationError` from\n  // `AESCipherJob.onDone`) are wrapped in `RuntimeDecryptionError` at\n  // the encryption module boundary.\n  RuntimeDecryptionError.is,\n];\n\n/**\n * Classify an error that caused a workflow run to fail.\n *\n * After the structural separation of infrastructure vs user code error\n * handling, the only errors that reach the `run_failed` try/catch are:\n * - User code errors (throws from workflow functions, propagated step failures)\n * - WorkflowRuntimeError and subclasses (missing timestamps, workflow/step\n *   not registered, corrupted event log, etc.)\n *\n * Uses each subclass's `.is()` static (a name-based duck check) instead of\n * a single `instanceof` check because workflows execute in a separate\n * `vm` realm: the VM-context `WorkflowRuntimeError` and the host-context\n * one are distinct classes, so `instanceof` returns `false` for any error\n * thrown inside the workflow VM and we'd misclassify genuine runtime\n * errors as user errors.\n */\nexport function isWorldContractError(err: unknown): err is WorkflowWorldError {\n  if (!WorkflowWorldError.is(err) || err.status !== undefined) {\n    return false;\n  }\n\n  const cause = 'cause' in err ? err.cause : undefined;\n  return (\n    (err.code !== undefined && WORLD_CONTRACT_ERROR_CODES.has(err.code)) ||\n    err.message.startsWith('Failed to parse response body for ') ||\n    err.message.startsWith('Schema validation failed for ') ||\n    (typeof cause === 'object' &&\n      cause !== null &&\n      'name' in cause &&\n      cause.name === 'ZodError')\n  );\n}\n\n/**\n * True when an error from a world (workflow-server) call is a transient\n * infrastructure failure that should be retried by redelivering the queue\n * message, rather than failing the run. A fresh invocation will likely\n * succeed once the backend (or the firewall in front of it) recovers.\n *\n * - `ThrottleError` (429): rate limited / load shed\n * - `WorkflowWorldError` with `status >= 500`: server-side error\n * - `WorkflowWorldError` with a retryable transport `code` (`TRANSPORT` /\n *   `TIMEOUT`): the request never produced a usable response\n *\n * Uses `.is()` name-based duck checks (not `instanceof`) for the same\n * cross-`vm`-realm reason described on `classifyRunError`.\n */\nexport function isRetryableWorldError(err: unknown): boolean {\n  if (ThrottleError.is(err)) {\n    return true;\n  }\n  if (!WorkflowWorldError.is(err)) {\n    return false;\n  }\n  if (err.status !== undefined && err.status >= 500) {\n    return true;\n  }\n  return err.code !== undefined && RETRYABLE_WORLD_ERROR_CODES.has(err.code);\n}\n\nexport function classifyRunError(err: unknown): RunErrorCode {\n  if (ReplayDivergenceError.is(err)) {\n    return RUN_ERROR_CODES.REPLAY_DIVERGENCE;\n  }\n\n  if (CorruptedEventLogError.is(err)) {\n    return RUN_ERROR_CODES.CORRUPTED_EVENT_LOG;\n  }\n\n  // World-layer faults — both a malformed response (contract violation) and a\n  // transient infrastructure failure (throttle / 5xx / transport / timeout,\n  // e.g. a firewall challenge) — are the backend's fault, not the user's.\n  // Bucket them under WORLD_CONTRACT_ERROR rather than USER_ERROR so dashboards\n  // attribute an outage correctly. Note the retryable variants are normally\n  // redelivered via the queue (see `isRetryableWorldError`) and only reach this\n  // terminal classification if the run ultimately gives up.\n  if (isWorldContractError(err) || isRetryableWorldError(err)) {\n    return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;\n  }\n\n  for (const isMatch of RUNTIME_ERROR_CHECKS) {\n    if (isMatch(err)) {\n      return RUN_ERROR_CODES.RUNTIME_ERROR;\n    }\n  }\n  return RUN_ERROR_CODES.USER_ERROR;\n}\n"]}

package/dist/create-hook.d.ts

@@ -24,6 +24,45 @@ export interface Hook<T = any> extends AsyncIterable<T>, Thenable<T> {
      * The token used to identify this hook.
      */
     token: string;
+    /**
+     * Returns a promise that resolves with `{ runId }` identifying the
+     * conflicting run if another active hook already owns this hook's
+     * token, or `null` once the hook has been registered and is ready to
+     * receive payloads.
+     *
+     * Calling `createHook()` alone does not register the hook — registration
+     * only happens when the workflow suspends. Awaiting `getConflict()`
+     * suspends the workflow to commit the hook registration, so it can be
+     * used to claim the token (and detect token conflicts early) without
+     * waiting for payload data.
+     *
+     * When a conflict is detected, the resolved `runId` identifies the run
+     * that currently owns the token. The workflow can decide how to handle
+     * the duplicate in code: return or log `conflict.runId`, or act on the
+     * owner — inspect its status, await its result, or cancel it — by
+     * passing `conflict.runId` to `getRun()` inside a step.
+     *
+     * Note that awaiting the hook's payload (`await hook`) when the token is
+     * already owned by another active hook still rejects with
+     * `HookConflictError`. In the rare case where the conflicting run cannot
+     * be identified (a `hook_conflict` event persisted by an old world that
+     * did not record the owning run's ID), `getConflict()` also rejects with
+     * `HookConflictError` rather than resolving with an incomplete value.
+     *
+     * @example
+     * ```ts
+     * using hook = createHook({ token: `order:${orderId}` });
+     * const conflict = await hook.getConflict();
+     * if (conflict) {
+     *   // another run already owns this token
+     *   return { dedupedTo: conflict.runId };
+     * }
+     * // token is now claimed, without waiting for payload data
+     * ```
+     */
+    getConflict(): Promise<{
+        runId: string;
+    } | null>;
     /**
      * Disposes the hook, releasing its token for reuse by other workflows.
      *

package/dist/create-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-hook.d.ts","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;GAEG;AACH,UAAU,QAAQ,CAAC,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IAClD,WAAW,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;;;;;;;;;;;OAYG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,SAAS,OAAO,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;IACzD;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC;IAChD;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAIlE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,GAAG;IAAE,WAAW,EAAE,QAAQ,CAAA;CAAE,GAClD,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC"}
+{"version":3,"file":"create-hook.d.ts","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;GAEG;AACH,UAAU,QAAQ,CAAC,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IAClD,WAAW,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,WAAW,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IAEjD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;;;;;;;;;;;OAYG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,SAAS,OAAO,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;IACzD;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC;IAChD;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAIlE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,GAAG;IAAE,WAAW,EAAE,QAAQ,CAAA;CAAE,GAClD,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC"}

package/dist/create-hook.js

@@ -29,4 +29,4 @@ export function createWebhook(
 options) {
     throw new Error('`createWebhook()` can only be called inside a workflow function');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-hook.js","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AA2JA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oDAAoD;AACpD,MAAM,UAAU,UAAU,CAAU,OAAqB;IACvD,MAAM,IAAI,KAAK,CACb,8DAA8D,CAC/D,CAAC;AACJ,CAAC;AAaD,MAAM,UAAU,aAAa;AAC3B,oDAAoD;AACpD,OAAwB;IAExB,MAAM,IAAI,KAAK,CACb,iEAAiE,CAClE,CAAC;AACJ,CAAC","sourcesContent":["import type { Serializable } from './schemas.js';\n\n/**\n * An object that can be awaited to receive a value.\n */\ninterface Thenable<T> {\n  then: Promise<T>['then'];\n}\n\n/**\n * A `Request` that can be responded to within a workflow\n * step function by calling the `respondWith()` method.\n */\nexport interface RequestWithResponse extends Request {\n  respondWith: (response: Response) => Promise<void>;\n}\n\n/**\n * A hook that can be awaited and/or iterated over to receive\n * a value within a workflow from an external system.\n *\n * Hooks implement the TC39 Explicit Resource Management proposal,\n * allowing them to be used with the `using` keyword for automatic disposal.\n */\nexport interface Hook<T = any> extends AsyncIterable<T>, Thenable<T> {\n  /**\n   * The token used to identify this hook.\n   */\n  token: string;\n\n  /**\n   * Disposes the hook, releasing its token for reuse by other workflows.\n   *\n   * After calling `dispose()`, the hook will no longer receive any events.\n   * This is useful when you want to explicitly release a hook token before\n   * the workflow completes, allowing another workflow to register a hook\n   * with the same token.\n   *\n   * @example\n   * ```ts\n   * const hook = createHook<{ message: string }>({ token: 'my-token' });\n   *\n   * for await (const payload of hook) {\n   *   if (payload.message === 'done') {\n   *     hook.dispose(); // Release the token early\n   *     break;\n   *   }\n   * }\n   * ```\n   */\n  dispose(): void;\n\n  /**\n   * Implements the TC39 Explicit Resource Management proposal.\n   * Called automatically when using the `using` keyword.\n   *\n   * @example\n   * ```ts\n   * {\n   *   using hook = createHook<{ message: string }>({ token: 'my-token' });\n   *   const payload = await hook;\n   *   // hook is automatically disposed when the block exits\n   * }\n   * ```\n   */\n  [Symbol.dispose](): void;\n}\n\n/**\n * A webhook that can be used to suspend and resume the workflow run\n * upon receiving an HTTP request to the specified URL.\n *\n * @see {@link createWebhook}\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Request\n */\nexport interface Webhook<T extends Request> extends Hook<T> {\n  /**\n   * The URL that external systems can call to send data to the workflow.\n   */\n  url: string;\n}\n\nexport interface HookOptions {\n  /**\n   * Unique token that is used to associate with the hook.\n   *\n   * When specifying an explicit token, the token should be constructed\n   * with information that the dispatching side can reliably reconstruct\n   * the token with the information it has available.\n   *\n   * Deterministic tokens are intended for use with `createHook()` and\n   * server-side `resumeHook()` only. For webhooks (`createWebhook()`),\n   * tokens are always randomly generated to prevent unauthorized access\n   * to the public webhook endpoint.\n   *\n   * If not provided, a randomly generated token will be assigned.\n   *\n   * @example\n   *\n   * ```ts\n   * // Explicit token for a Slack bot (one workflow run per channel)\n   * const hook = createHook<SlackMessage>({\n   *   token: `slack_webhook:${channelId}`,\n   * });\n   * ```\n   */\n  token?: string;\n\n  /**\n   * Additional user-defined data to include with the hook payload.\n   *\n   * @example\n   *\n   * ```ts\n   * const hook = createHook<{ name: string }>({\n   *   metadata: {\n   *     type: \"cat\",\n   *     color: \"orange\",\n   *   },\n   * });\n   * ```\n   */\n  metadata?: Serializable;\n\n  /**\n   * Whether this hook can be resumed via the public webhook endpoint.\n   *\n   * When `true`, the hook can be triggered by sending an HTTP request to the\n   * public `/.well-known/workflow/v1/webhook/{token}` URL. This is automatically\n   * set when using `createWebhook()`.\n   *\n   * When `false` (the default), the hook can only be resumed server-side\n   * via `resumeHook()`.\n   *\n   * @default false\n   */\n  isWebhook?: boolean;\n}\n\nexport interface WebhookOptions\n  extends Omit<HookOptions, 'token' | 'isWebhook'> {\n  /**\n   * If set to a `Response` object, the webhook will automatically\n   * respond with the specified response.\n   *\n   * If set to `\"manual\"`, each individual request will need to\n   * be responded to manually from within the workflow by calling the\n   * `respondWith()` method.\n   *\n   * If not set then the webhook will automatically respond with\n   * a `202 Accepted` response.\n   */\n  respondWith?: Response | 'manual';\n}\n\n/**\n * Creates a {@link Hook} that can be used to suspend and resume the workflow run with a payload.\n *\n * Hooks allow external systems to send arbitrary serializable data into a workflow.\n *\n * @param options - Configuration options for the hook.\n * @returns A `Hook` that can be awaited to receive one or more payloads.\n *\n * @example\n *\n * ```ts\n * export async function workflowWithHook() {\n *   \"use workflow\";\n *\n *   const hook = createHook<{ message: string }>();\n *   console.log('Hook token:', hook.token);\n *\n *   const payload = await hook;\n *   console.log('Received:', payload.message);\n * }\n * ```\n */\n// @ts-expect-error `options` is here for types/docs\nexport function createHook<T = any>(options?: HookOptions): Hook<T> {\n  throw new Error(\n    '`createHook()` can only be called inside a workflow function'\n  );\n}\n\n/**\n * Creates a {@link Webhook} that can be used to suspend and resume the workflow\n * run upon receiving an HTTP request to the specified URL.\n *\n * Webhooks will result in a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request} object\n * that can be interacted with in workflow functions.\n */\nexport function createWebhook(\n  options: WebhookOptions & { respondWith: 'manual' }\n): Webhook<RequestWithResponse>;\nexport function createWebhook(options?: WebhookOptions): Webhook<Request>;\nexport function createWebhook(\n  // @ts-expect-error `options` is here for types/docs\n  options?: WebhookOptions\n): Webhook<Request> | Webhook<RequestWithResponse> {\n  throw new Error(\n    '`createWebhook()` can only be called inside a workflow function'\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-hook.js","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AAiMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oDAAoD;AACpD,MAAM,UAAU,UAAU,CAAU,OAAqB;IACvD,MAAM,IAAI,KAAK,CACb,8DAA8D,CAC/D,CAAC;AACJ,CAAC;AAaD,MAAM,UAAU,aAAa;AAC3B,oDAAoD;AACpD,OAAwB;IAExB,MAAM,IAAI,KAAK,CACb,iEAAiE,CAClE,CAAC;AACJ,CAAC","sourcesContent":["import type { Serializable } from './schemas.js';\n\n/**\n * An object that can be awaited to receive a value.\n */\ninterface Thenable<T> {\n  then: Promise<T>['then'];\n}\n\n/**\n * A `Request` that can be responded to within a workflow\n * step function by calling the `respondWith()` method.\n */\nexport interface RequestWithResponse extends Request {\n  respondWith: (response: Response) => Promise<void>;\n}\n\n/**\n * A hook that can be awaited and/or iterated over to receive\n * a value within a workflow from an external system.\n *\n * Hooks implement the TC39 Explicit Resource Management proposal,\n * allowing them to be used with the `using` keyword for automatic disposal.\n */\nexport interface Hook<T = any> extends AsyncIterable<T>, Thenable<T> {\n  /**\n   * The token used to identify this hook.\n   */\n  token: string;\n\n  /**\n   * Returns a promise that resolves with `{ runId }` identifying the\n   * conflicting run if another active hook already owns this hook's\n   * token, or `null` once the hook has been registered and is ready to\n   * receive payloads.\n   *\n   * Calling `createHook()` alone does not register the hook — registration\n   * only happens when the workflow suspends. Awaiting `getConflict()`\n   * suspends the workflow to commit the hook registration, so it can be\n   * used to claim the token (and detect token conflicts early) without\n   * waiting for payload data.\n   *\n   * When a conflict is detected, the resolved `runId` identifies the run\n   * that currently owns the token. The workflow can decide how to handle\n   * the duplicate in code: return or log `conflict.runId`, or act on the\n   * owner — inspect its status, await its result, or cancel it — by\n   * passing `conflict.runId` to `getRun()` inside a step.\n   *\n   * Note that awaiting the hook's payload (`await hook`) when the token is\n   * already owned by another active hook still rejects with\n   * `HookConflictError`. In the rare case where the conflicting run cannot\n   * be identified (a `hook_conflict` event persisted by an old world that\n   * did not record the owning run's ID), `getConflict()` also rejects with\n   * `HookConflictError` rather than resolving with an incomplete value.\n   *\n   * @example\n   * ```ts\n   * using hook = createHook({ token: `order:${orderId}` });\n   * const conflict = await hook.getConflict();\n   * if (conflict) {\n   *   // another run already owns this token\n   *   return { dedupedTo: conflict.runId };\n   * }\n   * // token is now claimed, without waiting for payload data\n   * ```\n   */\n  getConflict(): Promise<{ runId: string } | null>;\n\n  /**\n   * Disposes the hook, releasing its token for reuse by other workflows.\n   *\n   * After calling `dispose()`, the hook will no longer receive any events.\n   * This is useful when you want to explicitly release a hook token before\n   * the workflow completes, allowing another workflow to register a hook\n   * with the same token.\n   *\n   * @example\n   * ```ts\n   * const hook = createHook<{ message: string }>({ token: 'my-token' });\n   *\n   * for await (const payload of hook) {\n   *   if (payload.message === 'done') {\n   *     hook.dispose(); // Release the token early\n   *     break;\n   *   }\n   * }\n   * ```\n   */\n  dispose(): void;\n\n  /**\n   * Implements the TC39 Explicit Resource Management proposal.\n   * Called automatically when using the `using` keyword.\n   *\n   * @example\n   * ```ts\n   * {\n   *   using hook = createHook<{ message: string }>({ token: 'my-token' });\n   *   const payload = await hook;\n   *   // hook is automatically disposed when the block exits\n   * }\n   * ```\n   */\n  [Symbol.dispose](): void;\n}\n\n/**\n * A webhook that can be used to suspend and resume the workflow run\n * upon receiving an HTTP request to the specified URL.\n *\n * @see {@link createWebhook}\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Request\n */\nexport interface Webhook<T extends Request> extends Hook<T> {\n  /**\n   * The URL that external systems can call to send data to the workflow.\n   */\n  url: string;\n}\n\nexport interface HookOptions {\n  /**\n   * Unique token that is used to associate with the hook.\n   *\n   * When specifying an explicit token, the token should be constructed\n   * with information that the dispatching side can reliably reconstruct\n   * the token with the information it has available.\n   *\n   * Deterministic tokens are intended for use with `createHook()` and\n   * server-side `resumeHook()` only. For webhooks (`createWebhook()`),\n   * tokens are always randomly generated to prevent unauthorized access\n   * to the public webhook endpoint.\n   *\n   * If not provided, a randomly generated token will be assigned.\n   *\n   * @example\n   *\n   * ```ts\n   * // Explicit token for a Slack bot (one workflow run per channel)\n   * const hook = createHook<SlackMessage>({\n   *   token: `slack_webhook:${channelId}`,\n   * });\n   * ```\n   */\n  token?: string;\n\n  /**\n   * Additional user-defined data to include with the hook payload.\n   *\n   * @example\n   *\n   * ```ts\n   * const hook = createHook<{ name: string }>({\n   *   metadata: {\n   *     type: \"cat\",\n   *     color: \"orange\",\n   *   },\n   * });\n   * ```\n   */\n  metadata?: Serializable;\n\n  /**\n   * Whether this hook can be resumed via the public webhook endpoint.\n   *\n   * When `true`, the hook can be triggered by sending an HTTP request to the\n   * public `/.well-known/workflow/v1/webhook/{token}` URL. This is automatically\n   * set when using `createWebhook()`.\n   *\n   * When `false` (the default), the hook can only be resumed server-side\n   * via `resumeHook()`.\n   *\n   * @default false\n   */\n  isWebhook?: boolean;\n}\n\nexport interface WebhookOptions\n  extends Omit<HookOptions, 'token' | 'isWebhook'> {\n  /**\n   * If set to a `Response` object, the webhook will automatically\n   * respond with the specified response.\n   *\n   * If set to `\"manual\"`, each individual request will need to\n   * be responded to manually from within the workflow by calling the\n   * `respondWith()` method.\n   *\n   * If not set then the webhook will automatically respond with\n   * a `202 Accepted` response.\n   */\n  respondWith?: Response | 'manual';\n}\n\n/**\n * Creates a {@link Hook} that can be used to suspend and resume the workflow run with a payload.\n *\n * Hooks allow external systems to send arbitrary serializable data into a workflow.\n *\n * @param options - Configuration options for the hook.\n * @returns A `Hook` that can be awaited to receive one or more payloads.\n *\n * @example\n *\n * ```ts\n * export async function workflowWithHook() {\n *   \"use workflow\";\n *\n *   const hook = createHook<{ message: string }>();\n *   console.log('Hook token:', hook.token);\n *\n *   const payload = await hook;\n *   console.log('Received:', payload.message);\n * }\n * ```\n */\n// @ts-expect-error `options` is here for types/docs\nexport function createHook<T = any>(options?: HookOptions): Hook<T> {\n  throw new Error(\n    '`createHook()` can only be called inside a workflow function'\n  );\n}\n\n/**\n * Creates a {@link Webhook} that can be used to suspend and resume the workflow\n * run upon receiving an HTTP request to the specified URL.\n *\n * Webhooks will result in a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request} object\n * that can be interacted with in workflow functions.\n */\nexport function createWebhook(\n  options: WebhookOptions & { respondWith: 'manual' }\n): Webhook<RequestWithResponse>;\nexport function createWebhook(options?: WebhookOptions): Webhook<Request>;\nexport function createWebhook(\n  // @ts-expect-error `options` is here for types/docs\n  options?: WebhookOptions\n): Webhook<Request> | Webhook<RequestWithResponse> {\n  throw new Error(\n    '`createWebhook()` can only be called inside a workflow function'\n  );\n}\n"]}

package/dist/events-consumer.d.ts

@@ -60,6 +60,15 @@ export declare class EventsConsumer {
     subscribe(fn: EventConsumerCallback): void;
     private notifyConsumedEvent;
     private consume;
+    /**
+     * Offer `currentEvent` to each registered callback in turn. Returns true
+     * when a callback consumed a real (non-null) event and the drain should
+     * advance to the next event in the same synchronous pass; false otherwise
+     * (nothing consumed it, or the consumed event was the end-of-events
+     * sentinel).
+     */
+    private consumeOne;
+    private handleUnconsumed;
 }
 export {};
 //# sourceMappingURL=events-consumer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"events-consumer.d.ts","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAG7C,oBAAY,mBAAmB;IAC7B;;OAEG;IACH,QAAQ,IAAA;IACR;;OAEG;IACH,WAAW,IAAA;IACX;;OAEG;IACH,QAAQ,IAAA;CACT;AAED,KAAK,qBAAqB,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,mBAAmB,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACzC;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,qBAAa,cAAc;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAM;IAC9B,QAAQ,CAAC,SAAS,EAAE,qBAAqB,EAAE,CAAM;IACjD,OAAO,CAAC,eAAe,CAAC,CAAyB;IACjD,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,wBAAwB,CAA8C;IAC9E,OAAO,CAAC,sBAAsB,CAAK;gBAEvB,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,qBAAqB;IAQ3D;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,EAAE,qBAAqB;IAgBnC,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,OAAO,CAkEb;CACH"}
+{"version":3,"file":"events-consumer.d.ts","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAG7C,oBAAY,mBAAmB;IAC7B;;OAEG;IACH,QAAQ,IAAA;IACR;;OAEG;IACH,WAAW,IAAA;IACX;;OAEG;IACH,QAAQ,IAAA;CACT;AAED,KAAK,qBAAqB,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,mBAAmB,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACzC;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,qBAAa,cAAc;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAM;IAC9B,QAAQ,CAAC,SAAS,EAAE,qBAAqB,EAAE,CAAM;IACjD,OAAO,CAAC,eAAe,CAAC,CAAyB;IACjD,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,wBAAwB,CAA8C;IAC9E,OAAO,CAAC,sBAAsB,CAAK;gBAEvB,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,qBAAqB;IAQ3D;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,EAAE,qBAAqB;IAgBnC,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,OAAO,CA0Bb;IAEF;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAgClB,OAAO,CAAC,gBAAgB;CAqCzB"}

package/dist/events-consumer.js

@@ -69,7 +69,40 @@ export class EventsConsumer {
         }
     }
     consume = () => {
-        const currentEvent = this.events[this.eventIndex] ?? null;
+        // Drain consecutively consumable events synchronously within a single
+        // pass instead of paying one `process.nextTick` per consumed event.
+        //
+        // Why this is safe: a callback only consumes an event using a consumer
+        // that is ALREADY registered (e.g. a long-lived step consumer walking
+        // `step_created` → `step_started` → `step_completed`, or the structural
+        // lifecycle consumer). New consumers are only ever registered by workflow
+        // VM body code that runs asynchronously off `ctx.promiseQueue` after a
+        // delivery `resolve()`; none of the callbacks here call `subscribe()`
+        // synchronously. So within one pass `this.callbacks` is mutated only by
+        // this loop (the `Finished` splice), and the next event's consumer is
+        // either already present (advance now) or not yet registered — in which
+        // case no callback consumes the event and we fall through to the
+        // cross-VM-safe deferred unconsumed-event check below, exactly as before.
+        while (true) {
+            const currentEvent = this.events[this.eventIndex] ?? null;
+            if (!this.consumeOne(currentEvent)) {
+                // No callback consumed the current event; handle the terminal case.
+                this.handleUnconsumed(currentEvent);
+                return;
+            }
+            // A real event was consumed — advance to the next in the same pass. A
+            // consumed `null` sentinel never returns true (see consumeOne), so the
+            // synchronous drain can't spin past the end of the log.
+        }
+    };
+    /**
+     * Offer `currentEvent` to each registered callback in turn. Returns true
+     * when a callback consumed a real (non-null) event and the drain should
+     * advance to the next event in the same synchronous pass; false otherwise
+     * (nothing consumed it, or the consumed event was the end-of-events
+     * sentinel).
+     */
+    consumeOne(currentEvent) {
         for (let i = 0; i < this.callbacks.length; i++) {
             const callback = this.callbacks[i];
             let handled = EventConsumerResult.NotConsumed;
@@ -79,23 +112,28 @@ export class EventsConsumer {
             catch (error) {
                 eventsLogger.error('EventConsumer callback threw an error', { error });
             }
-            if (handled === EventConsumerResult.Consumed ||
-                handled === EventConsumerResult.Finished) {
-                if (currentEvent !== null) {
-                    this.notifyConsumedEvent(currentEvent);
-                }
-                // consumer handled this event, so increase the event index
-                this.eventIndex++;
-                // remove the callback if it has finished
-                if (handled === EventConsumerResult.Finished) {
-                    this.callbacks.splice(i, 1);
-                }
-                // continue to the next event
-                process.nextTick(this.consume);
-                return;
+            if (handled !== EventConsumerResult.Consumed &&
+                handled !== EventConsumerResult.Finished) {
+                continue;
+            }
+            if (currentEvent !== null) {
+                this.notifyConsumedEvent(currentEvent);
+            }
+            // consumer handled this event, so increase the event index
+            this.eventIndex++;
+            // remove the callback if it has finished
+            if (handled === EventConsumerResult.Finished) {
+                this.callbacks.splice(i, 1);
             }
+            // Continue draining only for real events. Real consumers return
+            // NotConsumed for the `null` sentinel, but guard against a pathological
+            // callback consuming it so the drain never spins past end-of-log.
+            return currentEvent !== null;
         }
-        // If we reach here, all callbacks returned NotConsumed.
+        return false;
+    }
+    handleUnconsumed(currentEvent) {
+        // All callbacks returned NotConsumed for the current event.
         // If the current event is non-null (a real event, not end-of-events),
         // schedule a deferred check. We chain onto the promiseQueue so that any
         // pending async work (e.g., deserialization/decryption that triggers
@@ -129,6 +167,6 @@ export class EventsConsumer {
                 }, 100);
             });
         }
-    };
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events-consumer.js","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Event } from '@workflow/world';\nimport { eventsLogger } from './logger.js';\n\nexport enum EventConsumerResult {\n  /**\n   * Callback consumed the event, but should not be removed from the callbacks list\n   */\n  Consumed,\n  /**\n   * Callback did not consume the event, so it should be passed to the next callback\n   */\n  NotConsumed,\n  /**\n   * Callback consumed the event, and should be removed from the callbacks list\n   */\n  Finished,\n}\n\ntype EventConsumerCallback = (event: Event | null) => EventConsumerResult;\n\nexport interface EventsConsumerOptions {\n  /**\n   * Callback invoked after an event has been consumed. Consumers such as the\n   * deterministic workflow clock must not observe events that are merely\n   * inspected while waiting for user code to subscribe to the next operation.\n   */\n  onConsumedEvent?: (event: Event) => void;\n  /**\n   * Callback invoked when a non-null event cannot be consumed by any registered\n   * callback, indicating an orphaned or invalid event in the event log. The\n   * check is deferred until after the promise queue has drained, ensuring that\n   * any pending async work (e.g., deserialization/decryption) completes and\n   * downstream subscribe() calls have a chance to cancel the check first.\n   */\n  onUnconsumedEvent: (event: Event) => void;\n  /**\n   * Returns the current promise queue. The unconsumed event check is chained\n   * onto this queue so it only fires after all pending async work (e.g.,\n   * deserialization) has completed. This prevents false positives when async\n   * deserialization delays the resolve() that triggers the next subscribe().\n   */\n  getPromiseQueue: () => Promise<void>;\n}\n\nexport class EventsConsumer {\n  eventIndex: number;\n  readonly events: Event[] = [];\n  readonly callbacks: EventConsumerCallback[] = [];\n  private onConsumedEvent?: (event: Event) => void;\n  private onUnconsumedEvent: (event: Event) => void;\n  private getPromiseQueue: () => Promise<void>;\n  private pendingUnconsumedCheck: Promise<void> | null = null;\n  private pendingUnconsumedTimeout: ReturnType<typeof setTimeout> | null = null;\n  private unconsumedCheckVersion = 0;\n\n  constructor(events: Event[], options: EventsConsumerOptions) {\n    this.events = events;\n    this.eventIndex = 0;\n    this.onConsumedEvent = options.onConsumedEvent;\n    this.onUnconsumedEvent = options.onUnconsumedEvent;\n    this.getPromiseQueue = options.getPromiseQueue;\n  }\n\n  /**\n   * Registers a callback function to be called after an event has been consumed\n   * by a different callback. The callback can return:\n   *  - `EventConsumerResult.Consumed` the event is considered consumed and will not be passed to any other callback, but the callback will remain in the callbacks list\n   *  - `EventConsumerResult.NotConsumed` the event is passed to the next callback\n   *  - `EventConsumerResult.Finished` the event is considered consumed and the callback is removed from the callbacks list\n   *\n   * @param fn - The callback function to register.\n   */\n  subscribe(fn: EventConsumerCallback) {\n    this.callbacks.push(fn);\n    // Cancel any pending unconsumed check since a new callback may consume the event.\n    // Incrementing the version causes any in-flight promise chain check to no-op.\n    // Also clear the pending setTimeout if it hasn't fired yet.\n    if (this.pendingUnconsumedCheck !== null) {\n      this.unconsumedCheckVersion++;\n      this.pendingUnconsumedCheck = null;\n      if (this.pendingUnconsumedTimeout !== null) {\n        clearTimeout(this.pendingUnconsumedTimeout);\n        this.pendingUnconsumedTimeout = null;\n      }\n    }\n    process.nextTick(this.consume);\n  }\n\n  private notifyConsumedEvent(event: Event) {\n    if (!this.onConsumedEvent) {\n      return;\n    }\n    try {\n      this.onConsumedEvent(event);\n    } catch (error) {\n      eventsLogger.error('onConsumedEvent callback threw an error', {\n        error,\n      });\n    }\n  }\n\n  private consume = () => {\n    const currentEvent = this.events[this.eventIndex] ?? null;\n    for (let i = 0; i < this.callbacks.length; i++) {\n      const callback = this.callbacks[i];\n      let handled = EventConsumerResult.NotConsumed;\n      try {\n        handled = callback(currentEvent);\n      } catch (error) {\n        eventsLogger.error('EventConsumer callback threw an error', { error });\n      }\n      if (\n        handled === EventConsumerResult.Consumed ||\n        handled === EventConsumerResult.Finished\n      ) {\n        if (currentEvent !== null) {\n          this.notifyConsumedEvent(currentEvent);\n        }\n        // consumer handled this event, so increase the event index\n        this.eventIndex++;\n\n        // remove the callback if it has finished\n        if (handled === EventConsumerResult.Finished) {\n          this.callbacks.splice(i, 1);\n        }\n\n        // continue to the next event\n        process.nextTick(this.consume);\n        return;\n      }\n    }\n\n    // If we reach here, all callbacks returned NotConsumed.\n    // If the current event is non-null (a real event, not end-of-events),\n    // schedule a deferred check. We chain onto the promiseQueue so that any\n    // pending async work (e.g., deserialization/decryption that triggers\n    // resolve() → user code → subscribe()) completes first. If the event\n    // is still unconsumed after the queue drains, it's truly orphaned.\n    if (currentEvent !== null) {\n      const checkVersion = ++this.unconsumedCheckVersion;\n      this.pendingUnconsumedCheck = this.getPromiseQueue()\n        .then(\n          // Yield once after the first queue drain so promise chains resumed by\n          // that drain can run across the VM boundary and append any follow-up\n          // async work (for example: step_completed resolves -> for-await loop\n          // resumes -> the next hook payload starts hydrating).\n          () => new Promise<void>((resolve) => setTimeout(resolve, 0))\n        )\n        .then(() => this.getPromiseQueue())\n        .then(() => {\n          // Use a delayed setTimeout after the queue drains. The delay must be\n          // long enough for promise chains to propagate across the VM boundary\n          // (from resolve() in the host context through to the workflow code\n          // calling subscribe() in the VM context). Node.js does not guarantee\n          // that setTimeout(0) fires after all cross-context microtasks settle,\n          // so we use a small but non-zero delay. Any subscribe() call that\n          // arrives during this window will cancel the check via version\n          // invalidation + clearTimeout.\n          this.pendingUnconsumedTimeout = setTimeout(() => {\n            this.pendingUnconsumedTimeout = null;\n            if (this.unconsumedCheckVersion === checkVersion) {\n              this.pendingUnconsumedCheck = null;\n              this.onUnconsumedEvent(currentEvent);\n            }\n          }, 100);\n        });\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events-consumer.js","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Event } from '@workflow/world';\nimport { eventsLogger } from './logger.js';\n\nexport enum EventConsumerResult {\n  /**\n   * Callback consumed the event, but should not be removed from the callbacks list\n   */\n  Consumed,\n  /**\n   * Callback did not consume the event, so it should be passed to the next callback\n   */\n  NotConsumed,\n  /**\n   * Callback consumed the event, and should be removed from the callbacks list\n   */\n  Finished,\n}\n\ntype EventConsumerCallback = (event: Event | null) => EventConsumerResult;\n\nexport interface EventsConsumerOptions {\n  /**\n   * Callback invoked after an event has been consumed. Consumers such as the\n   * deterministic workflow clock must not observe events that are merely\n   * inspected while waiting for user code to subscribe to the next operation.\n   */\n  onConsumedEvent?: (event: Event) => void;\n  /**\n   * Callback invoked when a non-null event cannot be consumed by any registered\n   * callback, indicating an orphaned or invalid event in the event log. The\n   * check is deferred until after the promise queue has drained, ensuring that\n   * any pending async work (e.g., deserialization/decryption) completes and\n   * downstream subscribe() calls have a chance to cancel the check first.\n   */\n  onUnconsumedEvent: (event: Event) => void;\n  /**\n   * Returns the current promise queue. The unconsumed event check is chained\n   * onto this queue so it only fires after all pending async work (e.g.,\n   * deserialization) has completed. This prevents false positives when async\n   * deserialization delays the resolve() that triggers the next subscribe().\n   */\n  getPromiseQueue: () => Promise<void>;\n}\n\nexport class EventsConsumer {\n  eventIndex: number;\n  readonly events: Event[] = [];\n  readonly callbacks: EventConsumerCallback[] = [];\n  private onConsumedEvent?: (event: Event) => void;\n  private onUnconsumedEvent: (event: Event) => void;\n  private getPromiseQueue: () => Promise<void>;\n  private pendingUnconsumedCheck: Promise<void> | null = null;\n  private pendingUnconsumedTimeout: ReturnType<typeof setTimeout> | null = null;\n  private unconsumedCheckVersion = 0;\n\n  constructor(events: Event[], options: EventsConsumerOptions) {\n    this.events = events;\n    this.eventIndex = 0;\n    this.onConsumedEvent = options.onConsumedEvent;\n    this.onUnconsumedEvent = options.onUnconsumedEvent;\n    this.getPromiseQueue = options.getPromiseQueue;\n  }\n\n  /**\n   * Registers a callback function to be called after an event has been consumed\n   * by a different callback. The callback can return:\n   *  - `EventConsumerResult.Consumed` the event is considered consumed and will not be passed to any other callback, but the callback will remain in the callbacks list\n   *  - `EventConsumerResult.NotConsumed` the event is passed to the next callback\n   *  - `EventConsumerResult.Finished` the event is considered consumed and the callback is removed from the callbacks list\n   *\n   * @param fn - The callback function to register.\n   */\n  subscribe(fn: EventConsumerCallback) {\n    this.callbacks.push(fn);\n    // Cancel any pending unconsumed check since a new callback may consume the event.\n    // Incrementing the version causes any in-flight promise chain check to no-op.\n    // Also clear the pending setTimeout if it hasn't fired yet.\n    if (this.pendingUnconsumedCheck !== null) {\n      this.unconsumedCheckVersion++;\n      this.pendingUnconsumedCheck = null;\n      if (this.pendingUnconsumedTimeout !== null) {\n        clearTimeout(this.pendingUnconsumedTimeout);\n        this.pendingUnconsumedTimeout = null;\n      }\n    }\n    process.nextTick(this.consume);\n  }\n\n  private notifyConsumedEvent(event: Event) {\n    if (!this.onConsumedEvent) {\n      return;\n    }\n    try {\n      this.onConsumedEvent(event);\n    } catch (error) {\n      eventsLogger.error('onConsumedEvent callback threw an error', {\n        error,\n      });\n    }\n  }\n\n  private consume = () => {\n    // Drain consecutively consumable events synchronously within a single\n    // pass instead of paying one `process.nextTick` per consumed event.\n    //\n    // Why this is safe: a callback only consumes an event using a consumer\n    // that is ALREADY registered (e.g. a long-lived step consumer walking\n    // `step_created` → `step_started` → `step_completed`, or the structural\n    // lifecycle consumer). New consumers are only ever registered by workflow\n    // VM body code that runs asynchronously off `ctx.promiseQueue` after a\n    // delivery `resolve()`; none of the callbacks here call `subscribe()`\n    // synchronously. So within one pass `this.callbacks` is mutated only by\n    // this loop (the `Finished` splice), and the next event's consumer is\n    // either already present (advance now) or not yet registered — in which\n    // case no callback consumes the event and we fall through to the\n    // cross-VM-safe deferred unconsumed-event check below, exactly as before.\n    while (true) {\n      const currentEvent = this.events[this.eventIndex] ?? null;\n      if (!this.consumeOne(currentEvent)) {\n        // No callback consumed the current event; handle the terminal case.\n        this.handleUnconsumed(currentEvent);\n        return;\n      }\n      // A real event was consumed — advance to the next in the same pass. A\n      // consumed `null` sentinel never returns true (see consumeOne), so the\n      // synchronous drain can't spin past the end of the log.\n    }\n  };\n\n  /**\n   * Offer `currentEvent` to each registered callback in turn. Returns true\n   * when a callback consumed a real (non-null) event and the drain should\n   * advance to the next event in the same synchronous pass; false otherwise\n   * (nothing consumed it, or the consumed event was the end-of-events\n   * sentinel).\n   */\n  private consumeOne(currentEvent: Event | null): boolean {\n    for (let i = 0; i < this.callbacks.length; i++) {\n      const callback = this.callbacks[i];\n      let handled = EventConsumerResult.NotConsumed;\n      try {\n        handled = callback(currentEvent);\n      } catch (error) {\n        eventsLogger.error('EventConsumer callback threw an error', { error });\n      }\n      if (\n        handled !== EventConsumerResult.Consumed &&\n        handled !== EventConsumerResult.Finished\n      ) {\n        continue;\n      }\n      if (currentEvent !== null) {\n        this.notifyConsumedEvent(currentEvent);\n      }\n      // consumer handled this event, so increase the event index\n      this.eventIndex++;\n      // remove the callback if it has finished\n      if (handled === EventConsumerResult.Finished) {\n        this.callbacks.splice(i, 1);\n      }\n      // Continue draining only for real events. Real consumers return\n      // NotConsumed for the `null` sentinel, but guard against a pathological\n      // callback consuming it so the drain never spins past end-of-log.\n      return currentEvent !== null;\n    }\n    return false;\n  }\n\n  private handleUnconsumed(currentEvent: Event | null) {\n    // All callbacks returned NotConsumed for the current event.\n    // If the current event is non-null (a real event, not end-of-events),\n    // schedule a deferred check. We chain onto the promiseQueue so that any\n    // pending async work (e.g., deserialization/decryption that triggers\n    // resolve() → user code → subscribe()) completes first. If the event\n    // is still unconsumed after the queue drains, it's truly orphaned.\n    if (currentEvent !== null) {\n      const checkVersion = ++this.unconsumedCheckVersion;\n      this.pendingUnconsumedCheck = this.getPromiseQueue()\n        .then(\n          // Yield once after the first queue drain so promise chains resumed by\n          // that drain can run across the VM boundary and append any follow-up\n          // async work (for example: step_completed resolves -> for-await loop\n          // resumes -> the next hook payload starts hydrating).\n          () => new Promise<void>((resolve) => setTimeout(resolve, 0))\n        )\n        .then(() => this.getPromiseQueue())\n        .then(() => {\n          // Use a delayed setTimeout after the queue drains. The delay must be\n          // long enough for promise chains to propagate across the VM boundary\n          // (from resolve() in the host context through to the workflow code\n          // calling subscribe() in the VM context). Node.js does not guarantee\n          // that setTimeout(0) fires after all cross-context microtasks settle,\n          // so we use a small but non-zero delay. Any subscribe() call that\n          // arrives during this window will cancel the check via version\n          // invalidation + clearTimeout.\n          this.pendingUnconsumedTimeout = setTimeout(() => {\n            this.pendingUnconsumedTimeout = null;\n            if (this.unconsumedCheckVersion === checkVersion) {\n              this.pendingUnconsumedCheck = null;\n              this.onUnconsumedEvent(currentEvent);\n            }\n          }, 100);\n        });\n    }\n  }\n}\n"]}

package/dist/global.d.ts

@@ -14,6 +14,8 @@ export interface HookInvocationQueueItem {
     token: string;
     metadata?: Serializable;
     hasCreatedEvent?: boolean;
+    /** Whether the workflow is awaiting `hook.getConflict()` for this hook */
+    hasConflictAwaiter?: boolean;
     disposed?: boolean;
     isWebhook?: boolean;
 }