@workflow/core 5.0.0-beta.25 → 5.0.0-beta.27

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

@@ -1,4 +1,4 @@
-import type { Event } from '@workflow/world';
+import { type Event } from '@workflow/world';
 /**
  * Delay before firing the deferred unconsumed-event check after the promise
  * queue has drained. Must be long enough for cross-VM microtask chains to

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;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C,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"}
+{"version":3,"file":"events-consumer.d.ts","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAa,MAAM,iBAAiB,CAAC;AAGxD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAmB3C,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

@@ -1,3 +1,4 @@
+import { envNumber } from '@workflow/world';
 import { eventsLogger } from './logger.js';
 /**
  * Delay before firing the deferred unconsumed-event check after the promise
@@ -6,6 +7,21 @@ import { eventsLogger } from './logger.js';
  * in host). Any subscribe() arriving during this window cancels the check.
  */
 export const DEFERRED_CHECK_DELAY_MS = 100;
+/**
+ * Effective deferred-check delay. Override: `WORKFLOW_DEFERRED_CHECK_DELAY_MS`.
+ *
+ * Unlike the other timing knobs this is not a polling interval but a
+ * determinism safety margin: firing the unconsumed-event check before the
+ * cross-VM subscribe() chain has landed rejects a healthy run with
+ * `ReplayDivergenceError`. Floored at 10ms so a too-low override can't
+ * manufacture spurious divergence (each false positive burns a
+ * divergence-recovery retry and can escalate to a terminal
+ * `CorruptedEventLogError`).
+ */
+const getDeferredCheckDelayMs = () => envNumber('WORKFLOW_DEFERRED_CHECK_DELAY_MS', DEFERRED_CHECK_DELAY_MS, {
+    integer: true,
+    min: 10,
+});
 export var EventConsumerResult;
 (function (EventConsumerResult) {
     /**
@@ -171,9 +187,9 @@ export class EventsConsumer {
                         this.pendingUnconsumedCheck = null;
                         this.onUnconsumedEvent(currentEvent);
                     }
-                }, DEFERRED_CHECK_DELAY_MS);
+                }, getDeferredCheckDelayMs());
             });
         }
     }
 }
-//# 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\n/**\n * Delay before firing the deferred unconsumed-event check after the promise\n * queue has drained. Must be long enough for cross-VM microtask chains to\n * propagate (resolve in host → workflow code in VM → subscribe call back\n * in host). Any subscribe() arriving during this window cancels the check.\n */\nexport const DEFERRED_CHECK_DELAY_MS = 100;\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          }, DEFERRED_CHECK_DELAY_MS);\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, envNumber } from '@workflow/world';\nimport { eventsLogger } from './logger.js';\n\n/**\n * Delay before firing the deferred unconsumed-event check after the promise\n * queue has drained. Must be long enough for cross-VM microtask chains to\n * propagate (resolve in host → workflow code in VM → subscribe call back\n * in host). Any subscribe() arriving during this window cancels the check.\n */\nexport const DEFERRED_CHECK_DELAY_MS = 100;\n\n/**\n * Effective deferred-check delay. Override: `WORKFLOW_DEFERRED_CHECK_DELAY_MS`.\n *\n * Unlike the other timing knobs this is not a polling interval but a\n * determinism safety margin: firing the unconsumed-event check before the\n * cross-VM subscribe() chain has landed rejects a healthy run with\n * `ReplayDivergenceError`. Floored at 10ms so a too-low override can't\n * manufacture spurious divergence (each false positive burns a\n * divergence-recovery retry and can escalate to a terminal\n * `CorruptedEventLogError`).\n */\nconst getDeferredCheckDelayMs = (): number =>\n  envNumber('WORKFLOW_DEFERRED_CHECK_DELAY_MS', DEFERRED_CHECK_DELAY_MS, {\n    integer: true,\n    min: 10,\n  });\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          }, getDeferredCheckDelayMs());\n        });\n    }\n  }\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"flushable-stream.d.ts","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,iBAAiB,CAAC;AAE3E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB,CAAC,IAAI,CAAC;IACtE,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;CAC1D;AAED,wBAAgB,oBAAoB,IAAI,oBAAoB,CAa3D;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAoEf"}
+{"version":3,"file":"flushable-stream.d.ts","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,iBAAiB,CAAC;AAG3E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AASxC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB,CAAC,IAAI,CAAC;IACtE,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;CAC1D;AAED,wBAAgB,oBAAoB,IAAI,oBAAoB,CAa3D;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAoEf"}

package/dist/flushable-stream.js

@@ -1,5 +1,6 @@
 import { WorkflowRuntimeError } from '@workflow/errors';
 import { withResolvers } from '@workflow/utils';
+import { envNumber } from '@workflow/world';
 /**
  * Polling interval (in ms) for lock release detection.
  *
@@ -19,6 +20,11 @@ import { withResolvers } from '@workflow/utils';
  * ticks during a stream's lifetime is not measurable in practice.
  */
 export const LOCK_POLL_INTERVAL_MS = 10;
+/** Effective lock-poll interval. Override: `WORKFLOW_LOCK_POLL_INTERVAL_MS`. */
+const getLockPollIntervalMs = () => envNumber('WORKFLOW_LOCK_POLL_INTERVAL_MS', LOCK_POLL_INTERVAL_MS, {
+    integer: true,
+    min: 1,
+});
 export function createFlushableState() {
     const state = {
         ...withResolvers(),
@@ -115,7 +121,7 @@ export function pollWritableLock(writable, state) {
             clearInterval(intervalId);
             state.writablePollingInterval = undefined;
         }
-    }, LOCK_POLL_INTERVAL_MS);
+    }, getLockPollIntervalMs());
     state.writablePollingInterval = intervalId;
 }
 /**
@@ -147,7 +153,7 @@ export function pollReadableLock(readable, state) {
             clearInterval(intervalId);
             state.readablePollingInterval = undefined;
         }
-    }, LOCK_POLL_INTERVAL_MS);
+    }, getLockPollIntervalMs());
     state.readablePollingInterval = intervalId;
 }
 /**
@@ -228,4 +234,4 @@ export async function flushablePipe(source, sink, state) {
         writer.releaseLock();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flushable-stream.js","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { type PromiseWithResolvers, withResolvers } from '@workflow/utils';\n\n/**\n * Polling interval (in ms) for lock release detection.\n *\n * The Web Streams API does not expose an event for \"lock released but stream\n * still open\"; we can only distinguish that state by periodically attempting\n * to acquire a reader/writer. For that reason we use polling instead of a\n * fully event-driven approach here.\n *\n * 10ms is chosen so the polling tick almost never sits on the critical path:\n * the V2 step-executor's `opsSettled` race waits for this state to resolve\n * after each step body returns, so a coarser interval (the previous 100ms)\n * adds visible per-step latency to streaming workflows. With a uniformly\n * distributed offset between step return and the next tick, the expected\n * wait is half the interval — so 10ms means ~5ms average wait per step\n * instead of ~50ms. The per-tick work is `writable.locked` plus a\n * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more\n * ticks during a stream's lifetime is not measurable in practice.\n */\nexport const LOCK_POLL_INTERVAL_MS = 10;\n\n/**\n * State tracker for flushable stream operations.\n * Resolves when either:\n * 1. Stream completes (close/error), OR\n * 2. Lock is released AND all pending operations are flushed\n *\n * Note: `doneResolved` and `streamEnded` are separate:\n * - `doneResolved`: The `done` promise has been resolved (step can complete)\n * - `streamEnded`: The underlying stream has actually closed/errored\n *\n * Once `doneResolved` is set to true, the `done` promise will not resolve\n * again. Re-acquiring locks after release is not supported as a way to\n * trigger additional completion signaling.\n */\nexport interface FlushableStreamState extends PromiseWithResolvers<void> {\n  /** Number of write operations currently in flight to the server */\n  pendingOps: number;\n  /** Whether the `done` promise has been resolved */\n  doneResolved: boolean;\n  /** Whether the underlying stream has actually closed/errored */\n  streamEnded: boolean;\n  /** Interval ID for writable lock polling (if active) */\n  writablePollingInterval?: ReturnType<typeof setInterval>;\n  /** Interval ID for readable lock polling (if active) */\n  readablePollingInterval?: ReturnType<typeof setInterval>;\n}\n\nexport function createFlushableState(): FlushableStreamState {\n  const state: FlushableStreamState = {\n    ...withResolvers<void>(),\n    pendingOps: 0,\n    doneResolved: false,\n    streamEnded: false,\n  };\n\n  // The runtime awaits this promise after user code returns. Observe early\n  // stream failures now so they do not become unhandled rejections first.\n  state.promise.catch(() => {});\n\n  return state;\n}\n\n/**\n * Checks if a WritableStream is unlocked (user released lock) vs closed.\n * When a stream is closed, .locked is false but getWriter() throws.\n * We only want to resolve via polling when the stream is unlocked, not closed.\n * If closed, the pump will handle resolution via the stream ending naturally.\n */\nfunction isWritableUnlockedNotClosed(writable: WritableStream): boolean {\n  if (writable.locked) return false;\n\n  let writer: WritableStreamDefaultWriter | undefined;\n  try {\n    // Try to acquire writer - if successful, stream is unlocked (not closed)\n    writer = writable.getWriter();\n  } catch {\n    // getWriter() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    writer.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Checks if a ReadableStream is unlocked (user released lock) vs closed.\n */\nfunction isReadableUnlockedNotClosed(readable: ReadableStream): boolean {\n  if (readable.locked) return false;\n\n  let reader: ReadableStreamDefaultReader | undefined;\n  try {\n    // Try to acquire reader - if successful, stream is unlocked (not closed)\n    reader = readable.getReader();\n  } catch {\n    // getReader() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    reader.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Polls a WritableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollWritableLock(\n  writable: WritableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.writablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      state.resolve();\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n    }\n  }, LOCK_POLL_INTERVAL_MS);\n\n  state.writablePollingInterval = intervalId;\n}\n\n/**\n * Polls a ReadableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollReadableLock(\n  readable: ReadableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.readablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      state.resolve();\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n    }\n  }, LOCK_POLL_INTERVAL_MS);\n\n  state.readablePollingInterval = intervalId;\n}\n\n/**\n * Creates a flushable pipe from a ReadableStream to a WritableStream.\n * Unlike pipeTo(), this resolves when:\n * 1. The source stream completes (close/error), OR\n * 2. The user releases their lock on userStream AND all pending writes are flushed\n *\n * @param source - The readable stream to read from (e.g., transform's readable)\n * @param sink - The writable stream to write to (e.g., server writable)\n * @param state - The flushable state tracker\n * @returns Promise that resolves when stream ends (not when done promise resolves)\n */\nexport async function flushablePipe(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  const reader = source.getReader();\n  const writer = sink.getWriter();\n  let cancelReason: unknown;\n\n  try {\n    while (true) {\n      // Check if stream has ended\n      if (state.streamEnded) {\n        return;\n      }\n\n      // Read from source - don't count as pending op since we're just waiting for data\n      // The important ops are writes to the sink (server)\n      const readResult = await Promise.race([\n        reader.read(),\n        writer.closed.then(() => {\n          throw new WorkflowRuntimeError('Writable stream closed prematurely');\n        }),\n      ]);\n\n      // Check if stream has ended (e.g., due to error in another path) before processing\n      if (state.streamEnded) {\n        return;\n      }\n\n      if (readResult.done) {\n        // Source stream completed - close sink and resolve\n        state.streamEnded = true;\n        await writer.close();\n        // Resolve done promise if not already resolved\n        if (!state.doneResolved) {\n          state.doneResolved = true;\n          state.resolve();\n        }\n        return;\n      }\n\n      // Count write as a pending op - this is what we need to flush\n      state.pendingOps++;\n      try {\n        await writer.write(readResult.value);\n      } finally {\n        state.pendingOps--;\n      }\n    }\n  } catch (err) {\n    state.streamEnded = true;\n    cancelReason = err;\n    if (!state.doneResolved) {\n      state.doneResolved = true;\n      state.reject(err);\n    }\n    // Propagate error through flushablePipe's own promise as well.\n    // Callers that rely on the FlushableStreamState should use `state.promise`,\n    // while other callers may depend on this rejection. Some known callers\n    // explicitly ignore this rejection (`.catch(() => {})`) and rely solely\n    // on `state.reject(err)` for error handling.\n    throw err;\n  } finally {\n    // Cancel the upstream reader so the source knows to stop generating data.\n    // Uses cancelReason (set in the catch block) so the source receives context\n    // about why it was cancelled. On normal completion cancelReason is undefined,\n    // which is a harmless no-op on an already-done reader.\n    reader.cancel(cancelReason).catch(() => {});\n    reader.releaseLock();\n    writer.releaseLock();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flushable-stream.js","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { type PromiseWithResolvers, withResolvers } from '@workflow/utils';\nimport { envNumber } from '@workflow/world';\n\n/**\n * Polling interval (in ms) for lock release detection.\n *\n * The Web Streams API does not expose an event for \"lock released but stream\n * still open\"; we can only distinguish that state by periodically attempting\n * to acquire a reader/writer. For that reason we use polling instead of a\n * fully event-driven approach here.\n *\n * 10ms is chosen so the polling tick almost never sits on the critical path:\n * the V2 step-executor's `opsSettled` race waits for this state to resolve\n * after each step body returns, so a coarser interval (the previous 100ms)\n * adds visible per-step latency to streaming workflows. With a uniformly\n * distributed offset between step return and the next tick, the expected\n * wait is half the interval — so 10ms means ~5ms average wait per step\n * instead of ~50ms. The per-tick work is `writable.locked` plus a\n * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more\n * ticks during a stream's lifetime is not measurable in practice.\n */\nexport const LOCK_POLL_INTERVAL_MS = 10;\n\n/** Effective lock-poll interval. Override: `WORKFLOW_LOCK_POLL_INTERVAL_MS`. */\nconst getLockPollIntervalMs = (): number =>\n  envNumber('WORKFLOW_LOCK_POLL_INTERVAL_MS', LOCK_POLL_INTERVAL_MS, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * State tracker for flushable stream operations.\n * Resolves when either:\n * 1. Stream completes (close/error), OR\n * 2. Lock is released AND all pending operations are flushed\n *\n * Note: `doneResolved` and `streamEnded` are separate:\n * - `doneResolved`: The `done` promise has been resolved (step can complete)\n * - `streamEnded`: The underlying stream has actually closed/errored\n *\n * Once `doneResolved` is set to true, the `done` promise will not resolve\n * again. Re-acquiring locks after release is not supported as a way to\n * trigger additional completion signaling.\n */\nexport interface FlushableStreamState extends PromiseWithResolvers<void> {\n  /** Number of write operations currently in flight to the server */\n  pendingOps: number;\n  /** Whether the `done` promise has been resolved */\n  doneResolved: boolean;\n  /** Whether the underlying stream has actually closed/errored */\n  streamEnded: boolean;\n  /** Interval ID for writable lock polling (if active) */\n  writablePollingInterval?: ReturnType<typeof setInterval>;\n  /** Interval ID for readable lock polling (if active) */\n  readablePollingInterval?: ReturnType<typeof setInterval>;\n}\n\nexport function createFlushableState(): FlushableStreamState {\n  const state: FlushableStreamState = {\n    ...withResolvers<void>(),\n    pendingOps: 0,\n    doneResolved: false,\n    streamEnded: false,\n  };\n\n  // The runtime awaits this promise after user code returns. Observe early\n  // stream failures now so they do not become unhandled rejections first.\n  state.promise.catch(() => {});\n\n  return state;\n}\n\n/**\n * Checks if a WritableStream is unlocked (user released lock) vs closed.\n * When a stream is closed, .locked is false but getWriter() throws.\n * We only want to resolve via polling when the stream is unlocked, not closed.\n * If closed, the pump will handle resolution via the stream ending naturally.\n */\nfunction isWritableUnlockedNotClosed(writable: WritableStream): boolean {\n  if (writable.locked) return false;\n\n  let writer: WritableStreamDefaultWriter | undefined;\n  try {\n    // Try to acquire writer - if successful, stream is unlocked (not closed)\n    writer = writable.getWriter();\n  } catch {\n    // getWriter() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    writer.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Checks if a ReadableStream is unlocked (user released lock) vs closed.\n */\nfunction isReadableUnlockedNotClosed(readable: ReadableStream): boolean {\n  if (readable.locked) return false;\n\n  let reader: ReadableStreamDefaultReader | undefined;\n  try {\n    // Try to acquire reader - if successful, stream is unlocked (not closed)\n    reader = readable.getReader();\n  } catch {\n    // getReader() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    reader.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Polls a WritableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollWritableLock(\n  writable: WritableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.writablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      state.resolve();\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n    }\n  }, getLockPollIntervalMs());\n\n  state.writablePollingInterval = intervalId;\n}\n\n/**\n * Polls a ReadableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollReadableLock(\n  readable: ReadableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.readablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      state.resolve();\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n    }\n  }, getLockPollIntervalMs());\n\n  state.readablePollingInterval = intervalId;\n}\n\n/**\n * Creates a flushable pipe from a ReadableStream to a WritableStream.\n * Unlike pipeTo(), this resolves when:\n * 1. The source stream completes (close/error), OR\n * 2. The user releases their lock on userStream AND all pending writes are flushed\n *\n * @param source - The readable stream to read from (e.g., transform's readable)\n * @param sink - The writable stream to write to (e.g., server writable)\n * @param state - The flushable state tracker\n * @returns Promise that resolves when stream ends (not when done promise resolves)\n */\nexport async function flushablePipe(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  const reader = source.getReader();\n  const writer = sink.getWriter();\n  let cancelReason: unknown;\n\n  try {\n    while (true) {\n      // Check if stream has ended\n      if (state.streamEnded) {\n        return;\n      }\n\n      // Read from source - don't count as pending op since we're just waiting for data\n      // The important ops are writes to the sink (server)\n      const readResult = await Promise.race([\n        reader.read(),\n        writer.closed.then(() => {\n          throw new WorkflowRuntimeError('Writable stream closed prematurely');\n        }),\n      ]);\n\n      // Check if stream has ended (e.g., due to error in another path) before processing\n      if (state.streamEnded) {\n        return;\n      }\n\n      if (readResult.done) {\n        // Source stream completed - close sink and resolve\n        state.streamEnded = true;\n        await writer.close();\n        // Resolve done promise if not already resolved\n        if (!state.doneResolved) {\n          state.doneResolved = true;\n          state.resolve();\n        }\n        return;\n      }\n\n      // Count write as a pending op - this is what we need to flush\n      state.pendingOps++;\n      try {\n        await writer.write(readResult.value);\n      } finally {\n        state.pendingOps--;\n      }\n    }\n  } catch (err) {\n    state.streamEnded = true;\n    cancelReason = err;\n    if (!state.doneResolved) {\n      state.doneResolved = true;\n      state.reject(err);\n    }\n    // Propagate error through flushablePipe's own promise as well.\n    // Callers that rely on the FlushableStreamState should use `state.promise`,\n    // while other callers may depend on this rejection. Some known callers\n    // explicitly ignore this rejection (`.catch(() => {})`) and rely solely\n    // on `state.reject(err)` for error handling.\n    throw err;\n  } finally {\n    // Cancel the upstream reader so the source knows to stop generating data.\n    // Uses cancelReason (set in the catch block) so the source receives context\n    // about why it was cancelled. On normal completion cancelReason is undefined,\n    // which is a harmless no-op on an already-done reader.\n    reader.cancel(cancelReason).catch(() => {});\n    reader.releaseLock();\n    writer.releaseLock();\n  }\n}\n"]}

package/dist/runtime/constants.d.ts

@@ -1,4 +1,8 @@
 export declare const MAX_QUEUE_DELIVERIES = 48;
+/**
+ * Effective max queue deliveries. Override via `WORKFLOW_MAX_QUEUE_DELIVERIES`.
+ */
+export declare function getMaxQueueDeliveries(): number;
 /**
  * Default maximum time allowed for the *replay* portion of a single workflow
  * handler invocation (in ms). This budget only covers deterministic-replay
@@ -48,6 +52,11 @@ export declare function getReplayTimeoutMs(): number;
  */
 export declare function _resetReplayTimeoutWarnCacheForTests(): void;
 export declare const REPLAY_TIMEOUT_MAX_RETRIES = 3;
+/**
+ * Effective replay-timeout retry budget. Override via
+ * `WORKFLOW_REPLAY_TIMEOUT_MAX_RETRIES`.
+ */
+export declare function getReplayTimeoutMaxRetries(): number;
 /**
  * Default maximum number of steps the owned-inline path runs inline (in
  * parallel) per suspension. The rest are queued to background handlers. Each
@@ -122,4 +131,9 @@ export declare function isOptimisticInlineStartExplicitlyDisabled(): boolean;
  */
 export declare function isTurboEnabled(): boolean;
 export declare const REPLAY_DIVERGENCE_MAX_RETRIES = 3;
+/**
+ * Effective replay-divergence recovery budget. Override via
+ * `WORKFLOW_REPLAY_DIVERGENCE_MAX_RETRIES`.
+ */
+export declare function getReplayDivergenceMaxRetries(): number;
 //# sourceMappingURL=constants.d.ts.map

package/dist/runtime/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAEzC,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,SAAU,CAAC;AAgB7C;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CA6B3C;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,IAAI,IAAI,CAE3D;AAMD,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAKvC;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CA2B1C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,IAAI,OAAO,CAIxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,yCAAyC,IAAI,OAAO,CAInE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAIxC;AAKD,eAAO,MAAM,6BAA6B,IAAI,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAW9C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAEzC,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,SAAU,CAAC;AAgB7C;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CA6B3C;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,IAAI,IAAI,CAE3D;AAMD,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAMnD;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAKvC;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CA2B1C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,IAAI,OAAO,CAIxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,yCAAyC,IAAI,OAAO,CAInE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAIxC;AAKD,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAE/C;;;GAGG;AACH,wBAAgB,6BAA6B,IAAI,MAAM,CAMtD"}