@workflow/core 4.8.0 → 4.8.2

package/dist/events-consumer.d.ts

@@ -1,4 +1,11 @@
 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
+ * propagate (resolve in host → workflow code in VM → subscribe call back
+ * in host). Any subscribe() arriving during this window cancels the check.
+ */
+export declare const DEFERRED_CHECK_DELAY_MS = 100;
 export declare enum EventConsumerResult {
     /**
      * Callback consumed the event, but should not be removed from the callbacks list
@@ -36,6 +43,16 @@ export interface EventsConsumerOptions {
      * deserialization delays the resolve() that triggers the next subscribe().
      */
     getPromiseQueue: () => Promise<void>;
+    /**
+     * Whether no data delivery is in flight (`isDeliveryIdle` in private.ts).
+     * The unconsumed-event check waits for this before it fires: a delivery in
+     * flight means the workflow VM is mid-reaction, and an event it has not
+     * claimed yet is an event it has not reached yet.
+     *
+     * Defaults to always-idle so the tests that drive a consumer with no
+     * orchestrator context keep the pre-existing timing.
+     */
+    isDeliveryIdle?: () => boolean;
 }
 export declare class EventsConsumer {
     eventIndex: number;
@@ -44,6 +61,7 @@ export declare class EventsConsumer {
     private onConsumedEvent?;
     private onUnconsumedEvent;
     private getPromiseQueue;
+    private isDeliveryIdle;
     private pendingUnconsumedCheck;
     private pendingUnconsumedTimeout;
     private unconsumedCheckVersion;
@@ -69,6 +87,28 @@ export declare class EventsConsumer {
      */
     private consumeOne;
     private handleUnconsumed;
+    /**
+     * Run `fn` once no data delivery is in flight, polling the way
+     * `scheduleWhenIdle` does: let the promise queue drain, re-check a timer
+     * tick later, repeat.
+     *
+     * Without this the check is a bet that every delivery the walk is running
+     * ahead of lands inside a fixed window. Consumption is synchronous while the
+     * resolution it triggers is not: a step result hydrates in the host, resolves
+     * from a detached continuation behind `awaitEarlierDeliveries`, and only then
+     * does VM code run far enough to subscribe the next consumer. Replaying a
+     * batch of N parallel step results leaves N-1 of them on that detached path
+     * with the queue already drained, so the walk sits on the ordered event the
+     * VM is about to draw and the window is the only thing standing between a
+     * healthy run and `ReplayDivergenceError`. On a backend whose deliveries take
+     * longer than the window, that bet loses.
+     *
+     * Termination is `hasParkedCommittedDelivery`'s: it counts only deliveries
+     * that resolve on their own, so nothing here can gate its own retirement. A
+     * genuinely orphaned event has no delivery to wait on and reaches `fn` on the
+     * first poll.
+     */
+    private whenDeliveryIdle;
 }
 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,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,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;IACrC;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC;CAChC;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,cAAc,CAAgB;IACtC,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,wBAAwB,CAA8C;IAC9E,OAAO,CAAC,sBAAsB,CAAK;gBAEvB,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,qBAAqB;IAS3D;;;;;;;;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;IA2CxB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,gBAAgB;CAqBzB"}

package/dist/events-consumer.js

@@ -1,4 +1,11 @@
 import { eventsLogger } from './logger.js';
+/**
+ * Delay before firing the deferred unconsumed-event check after the promise
+ * queue has drained. Must be long enough for cross-VM microtask chains to
+ * propagate (resolve in host → workflow code in VM → subscribe call back
+ * in host). Any subscribe() arriving during this window cancels the check.
+ */
+export const DEFERRED_CHECK_DELAY_MS = 100;
 export var EventConsumerResult;
 (function (EventConsumerResult) {
     /**
@@ -21,6 +28,7 @@ export class EventsConsumer {
     onConsumedEvent;
     onUnconsumedEvent;
     getPromiseQueue;
+    isDeliveryIdle;
     pendingUnconsumedCheck = null;
     pendingUnconsumedTimeout = null;
     unconsumedCheckVersion = 0;
@@ -30,6 +38,7 @@ export class EventsConsumer {
         this.onConsumedEvent = options.onConsumedEvent;
         this.onUnconsumedEvent = options.onUnconsumedEvent;
         this.getPromiseQueue = options.getPromiseQueue;
+        this.isDeliveryIdle = options.isDeliveryIdle ?? (() => true);
     }
     /**
      * Registers a callback function to be called after an event has been consumed
@@ -150,23 +159,70 @@ export class EventsConsumer {
             () => new Promise((resolve) => setTimeout(resolve, 0)))
                 .then(() => this.getPromiseQueue())
                 .then(() => {
-                // Use a delayed setTimeout after the queue drains. The delay must be
-                // long enough for promise chains to propagate across the VM boundary
-                // (from resolve() in the host context through to the workflow code
-                // calling subscribe() in the VM context). Node.js does not guarantee
-                // that setTimeout(0) fires after all cross-context microtasks settle,
-                // so we use a small but non-zero delay. Any subscribe() call that
-                // arrives during this window will cancel the check via version
-                // invalidation + clearTimeout.
-                this.pendingUnconsumedTimeout = setTimeout(() => {
-                    this.pendingUnconsumedTimeout = null;
-                    if (this.unconsumedCheckVersion === checkVersion) {
-                        this.pendingUnconsumedCheck = null;
-                        this.onUnconsumedEvent(currentEvent);
-                    }
-                }, 100);
+                // Wait out any delivery still in flight before starting the timer.
+                // The queue draining says the host has no hydration work left; it
+                // does not say the VM has finished reacting to what was hydrated.
+                this.whenDeliveryIdle(checkVersion, () => {
+                    // Use a delayed setTimeout once deliveries are idle. The delay must
+                    // be long enough for promise chains to propagate across the VM
+                    // boundary (from resolve() in the host context through to the
+                    // workflow code calling subscribe() in the VM context). Node.js
+                    // does not guarantee that setTimeout(0) fires after all
+                    // cross-context microtasks settle, so we use a small but non-zero
+                    // delay. Any subscribe() call that arrives during this window will
+                    // cancel the check via version invalidation + clearTimeout.
+                    this.pendingUnconsumedTimeout = setTimeout(() => {
+                        this.pendingUnconsumedTimeout = null;
+                        if (this.unconsumedCheckVersion === checkVersion) {
+                            this.pendingUnconsumedCheck = null;
+                            this.onUnconsumedEvent(currentEvent);
+                        }
+                    }, DEFERRED_CHECK_DELAY_MS);
+                });
             });
         }
     }
+    /**
+     * Run `fn` once no data delivery is in flight, polling the way
+     * `scheduleWhenIdle` does: let the promise queue drain, re-check a timer
+     * tick later, repeat.
+     *
+     * Without this the check is a bet that every delivery the walk is running
+     * ahead of lands inside a fixed window. Consumption is synchronous while the
+     * resolution it triggers is not: a step result hydrates in the host, resolves
+     * from a detached continuation behind `awaitEarlierDeliveries`, and only then
+     * does VM code run far enough to subscribe the next consumer. Replaying a
+     * batch of N parallel step results leaves N-1 of them on that detached path
+     * with the queue already drained, so the walk sits on the ordered event the
+     * VM is about to draw and the window is the only thing standing between a
+     * healthy run and `ReplayDivergenceError`. On a backend whose deliveries take
+     * longer than the window, that bet loses.
+     *
+     * Termination is `hasParkedCommittedDelivery`'s: it counts only deliveries
+     * that resolve on their own, so nothing here can gate its own retirement. A
+     * genuinely orphaned event has no delivery to wait on and reaches `fn` on the
+     * first poll.
+     */
+    whenDeliveryIdle(checkVersion, fn) {
+        const poll = () => {
+            this.pendingUnconsumedTimeout = null;
+            if (this.unconsumedCheckVersion !== checkVersion) {
+                return;
+            }
+            if (this.isDeliveryIdle()) {
+                fn();
+                return;
+            }
+            this.getPromiseQueue().then(() => {
+                if (this.unconsumedCheckVersion !== checkVersion) {
+                    return;
+                }
+                // Held in the same field the fired check uses so subscribe() cancels a
+                // poll in progress exactly as it cancels the check itself.
+                this.pendingUnconsumedTimeout = setTimeout(poll, 0);
+            });
+        };
+        poll();
+    }
 }
-//# 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"]}
+//# 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   * Whether no data delivery is in flight (`isDeliveryIdle` in private.ts).\n   * The unconsumed-event check waits for this before it fires: a delivery in\n   * flight means the workflow VM is mid-reaction, and an event it has not\n   * claimed yet is an event it has not reached yet.\n   *\n   * Defaults to always-idle so the tests that drive a consumer with no\n   * orchestrator context keep the pre-existing timing.\n   */\n  isDeliveryIdle?: () => boolean;\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 isDeliveryIdle: () => boolean;\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    this.isDeliveryIdle = options.isDeliveryIdle ?? (() => true);\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          // Wait out any delivery still in flight before starting the timer.\n          // The queue draining says the host has no hydration work left; it\n          // does not say the VM has finished reacting to what was hydrated.\n          this.whenDeliveryIdle(checkVersion, () => {\n            // Use a delayed setTimeout once deliveries are idle. The delay must\n            // be long enough for promise chains to propagate across the VM\n            // boundary (from resolve() in the host context through to the\n            // workflow code calling subscribe() in the VM context). Node.js\n            // does not guarantee that setTimeout(0) fires after all\n            // cross-context microtasks settle, so we use a small but non-zero\n            // delay. Any subscribe() call that arrives during this window will\n            // cancel the check via version 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\n  /**\n   * Run `fn` once no data delivery is in flight, polling the way\n   * `scheduleWhenIdle` does: let the promise queue drain, re-check a timer\n   * tick later, repeat.\n   *\n   * Without this the check is a bet that every delivery the walk is running\n   * ahead of lands inside a fixed window. Consumption is synchronous while the\n   * resolution it triggers is not: a step result hydrates in the host, resolves\n   * from a detached continuation behind `awaitEarlierDeliveries`, and only then\n   * does VM code run far enough to subscribe the next consumer. Replaying a\n   * batch of N parallel step results leaves N-1 of them on that detached path\n   * with the queue already drained, so the walk sits on the ordered event the\n   * VM is about to draw and the window is the only thing standing between a\n   * healthy run and `ReplayDivergenceError`. On a backend whose deliveries take\n   * longer than the window, that bet loses.\n   *\n   * Termination is `hasParkedCommittedDelivery`'s: it counts only deliveries\n   * that resolve on their own, so nothing here can gate its own retirement. A\n   * genuinely orphaned event has no delivery to wait on and reaches `fn` on the\n   * first poll.\n   */\n  private whenDeliveryIdle(checkVersion: number, fn: () => void): void {\n    const poll = () => {\n      this.pendingUnconsumedTimeout = null;\n      if (this.unconsumedCheckVersion !== checkVersion) {\n        return;\n      }\n      if (this.isDeliveryIdle()) {\n        fn();\n        return;\n      }\n      this.getPromiseQueue().then(() => {\n        if (this.unconsumedCheckVersion !== checkVersion) {\n          return;\n        }\n        // Held in the same field the fired check uses so subscribe() cancels a\n        // poll in progress exactly as it cancels the check itself.\n        this.pendingUnconsumedTimeout = setTimeout(poll, 0);\n      });\n    };\n    poll();\n  }\n}\n"]}

package/dist/private.d.ts

@@ -53,26 +53,33 @@ export interface WorkflowOrchestratorContext {
     pendingDeliveries: number;
     /**
      * Ordered registry of in-flight "branch-deciding" deliveries — the
-     * resolutions a workflow typically `Promise.race`s on: buffered hook
-     * payloads (`hook_received`) and wait completions (`wait_completed`).
-     * Keyed by the delivery's position (index) in the consumed event log.
+     * resolutions a workflow typically `Promise.race`s on, or awaits from
+     * independent concurrent branches: hook payloads (`hook_received`), wait
+     * completions (`wait_completed`), and step results (`step_completed` /
+     * `step_failed`). Keyed by the delivery's position (index) in the consumed
+     * event log.
      *
-     * The problem: a buffered hook payload is observed via the async hook
-     * iterator (`yield await this`), costing extra microtask hops, while a
-     * `wait_completed` resolves with fewer hops — and a reused sleep can
-     * resolve in an entirely earlier loop iteration. Either way, the
-     * resolution that the committed event log ordered first can lose a
-     * `Promise.race` to a faster- or already-resolved competitor, diverging
-     * from the log and surfacing as `ReplayDivergenceError`.
+     * The problem: each of these resolutions reaches workflow code after a
+     * different, workload-dependent number of microtask hops. A buffered hook
+     * payload is observed via the async hook iterator (`yield await this`),
+     * costing extra hops; a `wait_completed` resolves with fewer, and a reused
+     * sleep can resolve in an entirely earlier loop iteration; a step result is
+     * gated on hydration whose cost varies between replays of the SAME
+     * invocation — the first replay pays the full decrypt/decompress/revive,
+     * while later replays sharing the invocation's `stepHydrationCache`
+     * memo-hit small primitive results and resolve in one or two hops. Either
+     * way, the resolution that the committed event log ordered first can lose a
+     * `Promise.race` (or a `useStep` ULID allocation) to a faster- or
+     * already-resolved competitor, diverging from the log and surfacing as
+     * `ReplayDivergenceError`.
      *
      * The fix is a strict, deterministic delivery order anchored on
      * event-log position: a delivery does not resolve to the workflow until
-     * every earlier-in-log delivery of the OPPOSITE kind has been delivered.
-     * (Opposite kind only: sequential same-kind hook payloads must not block
-     * one another, and a wait need not wait behind a later wait.) Because the
+     * every relevant earlier-in-log delivery has been delivered. Because the
      * gate is "the earlier delivery resolved", not "won a timing race", the
      * outcome is independent of microtask hops, hydration/decryption time,
-     * and `Promise.race` argument order.
+     * and `Promise.race` argument order. Which earlier kinds a delivery defers
+     * behind is spelled out on {@link awaitEarlierDeliveries}.
      *
      * Index is used rather than the `eventId` string because `eventId` is an
      * opaque, world-assigned value not guaranteed to sort in creation order
@@ -102,52 +109,115 @@ export interface WorkflowOrchestratorContext {
     stepHydrationCache?: StepHydrationCache;
 }
 /** The kind of branch-deciding delivery a barrier represents. */
-export type DeliveryKind = 'hook' | 'wait';
+export type DeliveryKind = 'hook' | 'wait' | 'step';
 interface DeliveryBarrierEntry {
     kind: DeliveryKind;
     /** Resolves once this delivery has resolved to the workflow. */
     delivered: Promise<void>;
+    /**
+     * Whether this delivery is committed to reaching the workflow without any
+     * further action by workflow code. True for wait completions and step
+     * results, which always resolve from their own chain, and for a hook payload
+     * that already had a waiting consumer when it was consumed.
+     *
+     * False for a BUFFERED hook payload no consumer has claimed yet: it is
+     * delivered by `claim()`, i.e. whenever the workflow next reads the hook —
+     * which may be causally *after* a later-in-log delivery. `arm()` flips it
+     * once a consumer takes the payload.
+     */
+    armed: boolean;
 }
 /**
- * Awaits, in strict event-log order, every still-registered delivery whose
- * index is earlier than `eventIndex` AND whose kind is in `deferBehindKinds`,
- * so that this resolution is handed to the workflow only after all relevant
- * earlier-in-log deliveries have been. This is what keeps a `Promise.race`
- * deterministic and aligned with the committed event log, independent of
- * microtask-hop counts, hydration time, or race-argument order.
+ * Awaits, in strict event-log order, every still-registered delivery that is
+ * earlier in the log than `eventIndex` and that a delivery of `kind` defers
+ * behind (see {@link DEFER_BEHIND}), so that this resolution is handed to the
+ * workflow only after all relevant earlier-in-log deliveries have been. This
+ * is what keeps a `Promise.race` — or the ULID a follow-up `useStep` draws on
+ * a concurrent branch — deterministic and aligned with the committed event
+ * log, independent of microtask-hop counts, hydration time, or race-argument
+ * order. When this delivery does have to wait, it also yields a macrotask
+ * afterwards so the earlier delivery's consumer can run to its own next
+ * suspension point first; see the comment at that `await` for why ordering the
+ * `resolve()` calls alone is not enough.
  *
- * `deferBehindKinds` is the opposite kind(s): a hook defers behind earlier
- * WAITS (not earlier hooks — those are sequential same-entity payloads), a
- * wait defers behind earlier HOOKS.
+ * One asymmetry: a STEP result additionally skips any earlier delivery that
+ * will not resolve on its own, i.e. one blocked (directly or transitively) on
+ * a buffered hook payload no consumer has claimed. Such a payload is delivered
+ * only when the workflow next reads the hook, and reaching that read very
+ * commonly requires the step result itself (`await stepX()` before the read).
+ * Gating the step on it would stall the workflow until the barrier's idle
+ * safety net fires, which then releases every delivery queued behind that
+ * payload at once — losing exactly the race this ordering exists to protect.
+ * Waits and hooks keep gating on unclaimed payloads: for them, waiting for the
+ * claim IS the ordering guarantee (a `wait_completed` must not preempt a
+ * payload the log ordered first).
  */
-export declare function awaitEarlierDeliveries(ctx: WorkflowOrchestratorContext, eventIndex: number | undefined, deferBehindKinds: readonly DeliveryKind[]): Promise<void>;
+export declare function awaitEarlierDeliveries(ctx: WorkflowOrchestratorContext, eventIndex: number | undefined, kind: DeliveryKind): Promise<void>;
 /** Handle for a registered branch-deciding delivery barrier. */
 export interface DeliveryBarrier {
     /**
      * Mark this delivery as delivered to the workflow. Resolves its
-     * `delivered` promise so any later-in-log opposite-kind delivery gated on
-     * it (via {@link awaitEarlierDeliveries}) may proceed, and removes it from
-     * the registry. Idempotent.
+     * `delivered` promise so any later-in-log delivery gated on it (via
+     * {@link awaitEarlierDeliveries}) may proceed, and removes it from the
+     * registry. Idempotent.
      */
     markDelivered: () => void;
+    /**
+     * Mark this delivery as committed to happening, for a barrier registered
+     * unarmed (a buffered hook payload) once a consumer has claimed it. From
+     * then on a later step result may be ordered behind it. Idempotent.
+     */
+    arm: () => void;
 }
 /**
  * Register a branch-deciding delivery at its event-log index so that later
- * opposite-kind deliveries can be ordered strictly after it. Returns an inert
- * handle when `pendingDeliveryBarriers` is not initialized.
+ * deliveries can be ordered strictly after it. Returns an inert handle when
+ * `pendingDeliveryBarriers` is not initialized.
+ *
+ * Pass `armed: false` for a delivery whose resolution waits on workflow code
+ * asking for it (a buffered hook payload); call `arm()` when it does.
  *
  * To guarantee a later delivery gated on this one can never hang when this
  * delivery is abandoned (the workflow took a different branch or is
  * suspending and never observes it), the barrier auto-resolves at idle.
+ *
+ * INVARIANT required of every call site: a barrier that is ever `armed` must
+ * be paired with a delivery chain that runs unconditionally — attached when
+ * the event is consumed (waits, step results, waiting-consumer hook
+ * payloads), or by the `claim()` whose invocation is what arms it (buffered
+ * hook payloads). The idle check ({@link scheduleWhenIdle}) refuses to
+ * observe idle while an armed, self-resolving barrier is undelivered, and the
+ * safety net below is itself idle-gated — so an armed barrier with no
+ * unconditional chain would livelock every idle check in the run, including
+ * its own retirement.
+ */
+export declare function registerDeliveryBarrier(ctx: WorkflowOrchestratorContext, eventIndex: number | undefined, kind: DeliveryKind, options?: {
+    armed?: boolean;
+}): DeliveryBarrier;
+/**
+ * Whether no data delivery (step result, hook payload) is in flight right now.
+ *
+ * "In flight" is two distinct windows, each with its own guard:
+ * `pendingDeliveries > 0` covers hydration inside the serial queue slots, and
+ * {@link hasParkedCommittedDelivery} covers the detached gap between a slot
+ * releasing that counter and the delivery's `resolve()` actually running —
+ * deliberately outside `pendingDeliveries` (see step.ts), and invisible to it.
+ *
+ * Anything that decides a replay is over, or that a replay went wrong, has to
+ * consult this first: while it is false the workflow VM is mid-reaction, so
+ * what it has and has not done yet says nothing about the run. Two callers
+ * read it, for the two such decisions: {@link scheduleWhenIdle} for the
+ * suspension, and the events consumer's unconsumed-event check for divergence.
  */
-export declare function registerDeliveryBarrier(ctx: WorkflowOrchestratorContext, eventIndex: number | undefined, kind: DeliveryKind): DeliveryBarrier;
+export declare function isDeliveryIdle(ctx: WorkflowOrchestratorContext): boolean;
 /**
  * Schedule a callback to fire only after all pending data deliveries
  * (step results, hook payloads) and async deserialization have completed.
- * Uses a polling loop: setTimeout(0) → check pendingDeliveries →
- * if > 0, wait for promiseQueue → repeat. This handles the multi-round
- * delivery pattern where each hook payload delivery cycle appends new
- * async work to the promiseQueue.
+ * Uses a polling loop: setTimeout(0) → check pendingDeliveries and the
+ * barrier registry → if anything is still in flight, wait for promiseQueue →
+ * repeat. This handles the multi-round delivery pattern where each hook
+ * payload delivery cycle appends new async work to the promiseQueue. What
+ * counts as in flight is {@link isDeliveryIdle}.
  *
  * The initial `setTimeout(0)` macrotask is load-bearing and must NOT be
  * downgraded to a microtask (`queueMicrotask`/`Promise.resolve().then`).

package/dist/private.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"private.d.ts","sourceRoot":"","sources":["../src/private.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,MAAM,MAAM,YAAY,CACtB,IAAI,SAAS,YAAY,EAAE,GAAG,GAAG,EAAE,EACnC,MAAM,SAAS,YAAY,GAAG,OAAO,GAAG,OAAO,IAC7C,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAsEF;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAGxE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAoBxE;AAED;;;GAGG;AACH,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,SAAS,GAAG,SAAS,CAAC;IACrC,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,cAAc,EAAE,cAAc,CAAC;IAC/B;;;OAGG;IACH,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACzC,eAAe,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACxC,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,MAAM,CAAC;IAC7B;;;;;;OAMG;IACH,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,uBAAuB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC5D;;;;;;;;;;;;;;;;OAgBG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED,iEAAiE;AACjE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3C,UAAU,oBAAoB;IAC5B,IAAI,EAAE,YAAY,CAAC;IACnB,gEAAgE;IAChE,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,2BAA2B,EAChC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,gBAAgB,EAAE,SAAS,YAAY,EAAE,GACxC,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,aAAa,EAAE,MAAM,IAAI,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,2BAA2B,EAChC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,IAAI,EAAE,YAAY,GACjB,eAAe,CA6BjB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,2BAA2B,EAChC,EAAE,EAAE,MAAM,IAAI,GACb,IAAI,CAYN"}
+{"version":3,"file":"private.d.ts","sourceRoot":"","sources":["../src/private.ts"],"names":[],"mappings":"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"}