@workflow/core 4.5.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/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/logger.d.ts

@@ -28,4 +28,10 @@ export declare const adapterLogger: {
     warn: (message: string, metadata?: Record<string, any>) => void;
     error: (message: string, metadata?: Record<string, any>) => void;
 };
+export declare const buildLogger: {
+    debug: (message: string, metadata?: Record<string, any>) => void;
+    info: (message: string, metadata?: Record<string, any>) => void;
+    warn: (message: string, metadata?: Record<string, any>) => void;
+    error: (message: string, metadata?: Record<string, any>) => void;
+};
 //# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAyCA,eAAO,MAAM,UAAU;qBAhCF,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAgCb,CAAC;AAC/C,eAAO,MAAM,aAAa;qBAjCL,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAiCP,CAAC;AACrD,eAAO,MAAM,aAAa;qBAlCL,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAkCP,CAAC;AACrD,eAAO,MAAM,YAAY;qBAnCJ,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAmCT,CAAC;AACnD,eAAO,MAAM,aAAa;qBApCL,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAoCP,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAuGA,eAAO,MAAM,UAAU;qBAtDF,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAsDb,CAAC;AAC/C,eAAO,MAAM,aAAa;qBAvDL,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAuDP,CAAC;AACrD,eAAO,MAAM,aAAa;qBAxDL,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAwDP,CAAC;AACrD,eAAO,MAAM,YAAY;qBAzDJ,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAyDT,CAAC;AACnD,eAAO,MAAM,aAAa;qBA1DL,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CA0DP,CAAC;AACrD,eAAO,MAAM,WAAW;qBA3DH,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CA6DzD,CAAC"}

package/dist/logger.js

@@ -1,9 +1,35 @@
 import debug from 'debug';
 import { getActiveSpan } from './telemetry.js';
-function createLogger(namespace) {
+/**
+ * Lightweight `DEBUG=` pattern matcher used for loggers that pin an explicit
+ * debug namespace (e.g. the build logger). Evaluated lazily against
+ * `process.env.DEBUG` on every call so tests and tooling can toggle the env
+ * var at runtime.
+ */
+function matchesDebugNamespace(namespace, patternList) {
+    if (!patternList) {
+        return false;
+    }
+    let enabled = false;
+    for (const rawPattern of patternList.split(',')) {
+        const pattern = rawPattern.trim();
+        if (!pattern) {
+            continue;
+        }
+        const isNegated = pattern.startsWith('-');
+        const candidate = isNegated ? pattern.slice(1) : pattern;
+        const regex = new RegExp(`^${candidate.replace(/[|\\{}()[\]^$+?.]/g, '\\$&').replace(/\*/g, '.*')}$`);
+        if (regex.test(namespace)) {
+            enabled = !isNegated;
+        }
+    }
+    return enabled;
+}
+function createLogger(namespace, options = {}) {
     const baseDebug = debug(`workflow:${namespace}`);
     const logger = (level) => {
         const levelDebug = baseDebug.extend(level);
+        const debugNamespace = options.debugNamespace;
         return (message, metadata) => {
             // Always output error/warn to console so users see critical issues
             // debug/info only output when DEBUG env var is set
@@ -13,6 +39,23 @@ function createLogger(namespace) {
             else if (level === 'warn') {
                 console.warn(`[Workflow] ${message}`, metadata ?? '');
             }
+            // Loggers pinned to an explicit debug namespace (e.g. the build logger)
+            // route through console.debug, gated by a lightweight DEBUG matcher that
+            // is evaluated lazily so the namespace can be toggled at runtime.
+            if (debugNamespace) {
+                const debugEnabled = matchesDebugNamespace(debugNamespace, process.env.DEBUG);
+                if (debugEnabled) {
+                    console.debug(`[${debugNamespace}] ${message}`, metadata ?? '');
+                    getActiveSpan()
+                        .then((span) => {
+                        span?.addEvent(`${level}.${namespace}`, { message, ...metadata });
+                    })
+                        .catch(() => {
+                        // Silently ignore telemetry errors
+                    });
+                }
+                return;
+            }
             // Also log to debug library for verbose output when DEBUG is enabled
             levelDebug(message, metadata);
             if (levelDebug.enabled) {
@@ -38,4 +81,7 @@ export const runtimeLogger = createLogger('runtime');
 export const webhookLogger = createLogger('webhook');
 export const eventsLogger = createLogger('events');
 export const adapterLogger = createLogger('adapter');
-//# sourceMappingURL=data:application/json;base64,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
+export const buildLogger = createLogger('build', {
+    debugNamespace: 'workflow:build',
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"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","sourcesContent":["import debug from 'debug';\nimport { getActiveSpan } from './telemetry.js';\n\ntype LoggerOptions = {\n  debugNamespace?: string;\n};\n\n/**\n * Lightweight `DEBUG=` pattern matcher used for loggers that pin an explicit\n * debug namespace (e.g. the build logger). Evaluated lazily against\n * `process.env.DEBUG` on every call so tests and tooling can toggle the env\n * var at runtime.\n */\nfunction matchesDebugNamespace(\n  namespace: string,\n  patternList: string | undefined\n): boolean {\n  if (!patternList) {\n    return false;\n  }\n\n  let enabled = false;\n  for (const rawPattern of patternList.split(',')) {\n    const pattern = rawPattern.trim();\n    if (!pattern) {\n      continue;\n    }\n\n    const isNegated = pattern.startsWith('-');\n    const candidate = isNegated ? pattern.slice(1) : pattern;\n    const regex = new RegExp(\n      `^${candidate.replace(/[|\\\\{}()[\\]^$+?.]/g, '\\\\$&').replace(/\\*/g, '.*')}$`\n    );\n\n    if (regex.test(namespace)) {\n      enabled = !isNegated;\n    }\n  }\n\n  return enabled;\n}\n\nfunction createLogger(namespace: string, options: LoggerOptions = {}) {\n  const baseDebug = debug(`workflow:${namespace}`);\n\n  const logger = (level: string) => {\n    const levelDebug = baseDebug.extend(level);\n    const debugNamespace = options.debugNamespace;\n\n    return (message: string, metadata?: Record<string, any>) => {\n      // Always output error/warn to console so users see critical issues\n      // debug/info only output when DEBUG env var is set\n      if (level === 'error') {\n        console.error(`[Workflow] ${message}`, metadata ?? '');\n      } else if (level === 'warn') {\n        console.warn(`[Workflow] ${message}`, metadata ?? '');\n      }\n\n      // Loggers pinned to an explicit debug namespace (e.g. the build logger)\n      // route through console.debug, gated by a lightweight DEBUG matcher that\n      // is evaluated lazily so the namespace can be toggled at runtime.\n      if (debugNamespace) {\n        const debugEnabled = matchesDebugNamespace(\n          debugNamespace,\n          process.env.DEBUG\n        );\n\n        if (debugEnabled) {\n          console.debug(`[${debugNamespace}] ${message}`, metadata ?? '');\n          getActiveSpan()\n            .then((span) => {\n              span?.addEvent(`${level}.${namespace}`, { message, ...metadata });\n            })\n            .catch(() => {\n              // Silently ignore telemetry errors\n            });\n        }\n        return;\n      }\n\n      // Also log to debug library for verbose output when DEBUG is enabled\n      levelDebug(message, metadata);\n\n      if (levelDebug.enabled) {\n        getActiveSpan()\n          .then((span) => {\n            span?.addEvent(`${level}.${namespace}`, { message, ...metadata });\n          })\n          .catch(() => {\n            // Silently ignore telemetry errors\n          });\n      }\n    };\n  };\n\n  return {\n    debug: logger('debug'),\n    info: logger('info'),\n    warn: logger('warn'),\n    error: logger('error'),\n  };\n}\n\nexport const stepLogger = createLogger('step');\nexport const runtimeLogger = createLogger('runtime');\nexport const webhookLogger = createLogger('webhook');\nexport const eventsLogger = createLogger('events');\nexport const adapterLogger = createLogger('adapter');\nexport const buildLogger = createLogger('build', {\n  debugNamespace: 'workflow:build',\n});\n"]}