@workflow/core 5.0.0-beta.41 → 5.0.0-beta.42

package/dist/events-consumer.d.ts

@@ -45,6 +45,16 @@ export interface EventsConsumerOptions {
      * downstream subscribe() calls have a chance to cancel the check first.
      */
     onUnconsumedEvent: (event: Event) => void;
+    /**
+     * Callback invoked when an event is skipped because it repeats an event
+     * class the walk already consumed for the same entity. `firstEventType` is
+     * the type that recorded the class, which is the one the workflow observed.
+     * Diagnostics only: skipping is a normal outcome, not an error — though a
+     * `firstEventType` differing from `event.eventType` says the two writers
+     * decided the entity's outcome differently, which is worth more than an
+     * info log.
+     */
+    onDuplicateEvent?: (event: Event, firstEventType: Event['eventType']) => void;
     /**
      * Returns the current promise queue. The unconsumed event check is chained
      * onto this queue so it only fires after all pending async work (e.g.,
@@ -87,8 +97,17 @@ export declare class EventsConsumer {
      * rather than parked for a consumer that cannot exist.
      */
     private readonly resolved;
+    /**
+     * `<class>:<correlationId>` for every event class the walk has already
+     * consumed, mapped to the event type that recorded it. The type is kept so a
+     * repeat that decided the same class *differently* (a `step_failed` behind a
+     * `step_completed`) can be reported as more than a re-commit. See
+     * {@link EventsConsumer.firstEventTypeOfClass}.
+     */
+    private readonly seenEventClasses;
     private onConsumedEvent?;
     private onUnconsumedEvent;
+    private onDuplicateEvent?;
     private getPromiseQueue;
     private isDeliveryIdle;
     private pendingUnconsumedCheck;
@@ -153,8 +172,86 @@ export declare class EventsConsumer {
      * replay diverged.
      */
     private park;
+    /**
+     * The key `event`'s class is tracked under, or `undefined` for the event
+     * types that belong to no class (`hook_received`, `hook_conflict`,
+     * `attr_set`, `run_created`) and are therefore never skipped.
+     *
+     * Run events carry no correlation id. They are classes of the run itself, so
+     * they all key off the same bucket.
+     */
+    private eventClassKey;
+    /**
+     * Remembers that `event`'s class is now decided for its entity, if the type
+     * belongs to a class. First writer wins: the recorded type is the one the
+     * workflow observed, and a later repeat is measured against it.
+     */
+    private recordEventClass;
+    /**
+     * The type that already decided `event`'s class for the same entity, or
+     * `undefined` when nothing has: a second `step_created` for one step, a
+     * second terminal outcome, a second `step_started` after the step's result is
+     * already in the log.
+     *
+     * Such an event is committed but inert. Concurrent replays write into one
+     * log without a currency guard, so a replay working from a prefix that
+     * predates another replay's write can commit its own copy of work the log
+     * already records. That copy cannot change what the workflow observed: the
+     * outcome was decided by the first event of the class and every later replay
+     * reads that same event at the same log position, so ignoring the straggler
+     * is deterministic across replays.
+     *
+     * Classes are tracked separately, so passing one does not suppress another.
+     * A step whose result is in the log still reaches its `step_created` and
+     * `step_started` consumers if it has yet to see those classes.
+     *
+     * Consulted only after every registered callback has declined the event, so
+     * it can never take an event a consumer wanted. A retry's `step_started` is
+     * claimed by the step's live consumer and counts as an attempt exactly as
+     * before, and a second `step_created` reaching a step that has not finished
+     * is likewise consumed rather than skipped; only the copies nobody claims are
+     * skipped.
+     *
+     * Unlike the divergence report, this does *not* wait out the deferred window
+     * first, and it does not need to. The window buys time for a consumer that
+     * has yet to register, and no such consumer can want this event: the class
+     * was recorded by a consumption in this same replay, which means the entity's
+     * consumer was registered and took an event of this class, and correlation
+     * ids are minted from a monotonic ULID per body position, so nothing later in
+     * the body registers a second consumer under this id. Waiting would cost
+     * `getDeferredCheckDelayMs()` per straggler per replay for information that
+     * cannot arrive — 0.75% of production runs carry at least one straggler, and
+     * the p99 among those carries 155.
+     *
+     * The invariant to preserve if hook identity ever becomes caller-supplied
+     * (an idempotency key rather than a minted id): two `createHook` calls in one
+     * body could then share a correlation id, and the second consumer's
+     * `hook_created` would be a repeat of a class this replay already recorded.
+     * That would make skipping wrong for `hook_created`, and is the reason the
+     * class map lives next to the event types rather than being inferred.
+     */
+    private firstEventTypeOfClass;
+    /** Steps the walk over a repeat of an already-consumed class. */
+    private skipDuplicateEvent;
     private handleEndOfLog;
     private scheduleUnconsumedCheck;
+    /**
+     * Decide what a still-unconsumed event is, now that the promise queue has
+     * drained and the delivery gate says the VM is not mid-reaction.
+     *
+     * `mayPark` is false only for the end-of-log recheck of an event {@link park}
+     * already holds. Nothing in the first branch applies to one of those: it is
+     * not the event at the cursor, so the identity guard is not meaningful, and
+     * it is parked already.
+     *
+     * A duplicate class never arrives here. {@link consume} steps over one in the
+     * pass that offered it, before this check is ever scheduled, and a class
+     * recorded while the check was in flight can only have been recorded by a
+     * consumption inside {@link consume}, whose next pass re-offers this event
+     * and steps over it there — leaving the identity guard above to drop the
+     * in-flight check.
+     */
+    private resolveUnconsumedEvent;
     /**
      * Run `fn` once no data delivery is in flight, polling the way
      * `scheduleWhenIdle` does: let the promise queue drain, re-check a timer

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,EAAE,KAAK,KAAK,EAAa,MAAM,iBAAiB,CAAC;AAGxD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAgG9C,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;;;;;;;;;;;OAWG;IACH,cAAc,EAAE,MAAM,OAAO,CAAC;CAC/B;AAED,qBAAa,cAAc;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,qBAAqB,EAAE,CAAM;IACjD;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyC;IAChE;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,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;IAY3D;;;;;OAKG;IACH,IAAI,aAAa,IAAI,KAAK,GAAG,SAAS,CAErC;IAED;;;;;;;;;;OAUG;IACH,IAAI,aAAa,IACb;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;KAAE,GACjE,SAAS,CAUZ;IAED,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAK7B;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,EAAE,qBAAqB;IAgBnC,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,OAAO,CA4Cb;IAEF;;;;OAIG;IACH,OAAO,CAAC,KAAK;IAmCb;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;IAyBnB;;;;;OAKG;IACH,OAAO,CAAC,IAAI;IAqBZ,OAAO,CAAC,cAAc;IA2BtB,OAAO,CAAC,uBAAuB;IAqD/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,OAAO,CAAC,gBAAgB;CA2BzB"}
+{"version":3,"file":"events-consumer.d.ts","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAA+B,MAAM,iBAAiB,CAAC;AAG1E;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAgG9C,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;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,KAAK,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;IAC9E;;;;;OAKG;IACH,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC;;;;;;;;;;;OAWG;IACH,cAAc,EAAE,MAAM,OAAO,CAAC;CAC/B;AAED,qBAAa,cAAc;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,qBAAqB,EAAE,CAAM;IACjD;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyC;IAChE;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAyC;IAC1E,OAAO,CAAC,eAAe,CAAC,CAAyB;IACjD,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,gBAAgB,CAAC,CAGf;IACV,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;IAa3D;;;;;OAKG;IACH,IAAI,aAAa,IAAI,KAAK,GAAG,SAAS,CAErC;IAED;;;;;;;;;;OAUG;IACH,IAAI,aAAa,IACb;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;KAAE,GACjE,SAAS,CAUZ;IAED,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAK7B;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,EAAE,qBAAqB;IAgBnC,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,OAAO,CAqDb;IAEF;;;;OAIG;IACH,OAAO,CAAC,KAAK;IAoCb;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;IAyBnB;;;;;OAKG;IACH,OAAO,CAAC,IAAI;IAqBZ;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAOrB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAOxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,OAAO,CAAC,qBAAqB;IAK7B,iEAAiE;IACjE,OAAO,CAAC,kBAAkB;IAwB1B,OAAO,CAAC,cAAc;IA2BtB,OAAO,CAAC,uBAAuB;IA0C/B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,OAAO,CAAC,gBAAgB;CA2BzB"}

package/dist/events-consumer.js

@@ -1,4 +1,4 @@
-import { envNumber } from '@workflow/world';
+import { entityEventClass, envNumber } from '@workflow/world';
 import { eventsLogger } from './logger.js';
 /**
  * Delay before firing the deferred unconsumed-event check after the promise
@@ -140,8 +140,17 @@ export class EventsConsumer {
      * rather than parked for a consumer that cannot exist.
      */
     resolved = new Set();
+    /**
+     * `<class>:<correlationId>` for every event class the walk has already
+     * consumed, mapped to the event type that recorded it. The type is kept so a
+     * repeat that decided the same class *differently* (a `step_failed` behind a
+     * `step_completed`) can be reported as more than a re-commit. See
+     * {@link EventsConsumer.firstEventTypeOfClass}.
+     */
+    seenEventClasses = new Map();
     onConsumedEvent;
     onUnconsumedEvent;
+    onDuplicateEvent;
     getPromiseQueue;
     isDeliveryIdle;
     pendingUnconsumedCheck = null;
@@ -155,6 +164,7 @@ export class EventsConsumer {
         this.eventIndex = 0;
         this.onConsumedEvent = options.onConsumedEvent;
         this.onUnconsumedEvent = options.onUnconsumedEvent;
+        this.onDuplicateEvent = options.onDuplicateEvent;
         this.getPromiseQueue = options.getPromiseQueue;
         this.isDeliveryIdle = options.isDeliveryIdle;
     }
@@ -270,6 +280,15 @@ export class EventsConsumer {
                 return;
             }
             if (!consumed) {
+                // Nobody wanted it. If it repeats a class this walk already consumed
+                // for the same entity it is a straggler from a concurrent replay:
+                // step over it in this pass rather than paying the deferred window for
+                // a consumer that cannot come (see `firstEventTypeOfClass`).
+                const firstType = this.firstEventTypeOfClass(currentEvent);
+                if (firstType !== undefined) {
+                    this.skipDuplicateEvent(currentEvent, firstType);
+                    continue;
+                }
                 this.scheduleUnconsumedCheck(currentEvent, true);
                 return;
             }
@@ -300,6 +319,7 @@ export class EventsConsumer {
                     ONE_SHOT_EVENT_TYPES.has(currentEvent.eventType)) {
                     this.resolved.add(resolutionKey(currentEvent.eventType, currentEvent.correlationId));
                 }
+                this.recordEventClass(currentEvent);
                 this.notifyConsumedEvent(currentEvent);
             }
             // remove the callback if it has finished
@@ -367,6 +387,100 @@ export class EventsConsumer {
         });
         return true;
     }
+    /**
+     * The key `event`'s class is tracked under, or `undefined` for the event
+     * types that belong to no class (`hook_received`, `hook_conflict`,
+     * `attr_set`, `run_created`) and are therefore never skipped.
+     *
+     * Run events carry no correlation id. They are classes of the run itself, so
+     * they all key off the same bucket.
+     */
+    eventClassKey(event) {
+        const eventClass = entityEventClass(event.eventType);
+        return eventClass === undefined
+            ? undefined
+            : `${eventClass}:${event.correlationId}`;
+    }
+    /**
+     * Remembers that `event`'s class is now decided for its entity, if the type
+     * belongs to a class. First writer wins: the recorded type is the one the
+     * workflow observed, and a later repeat is measured against it.
+     */
+    recordEventClass(event) {
+        const key = this.eventClassKey(event);
+        if (key !== undefined && !this.seenEventClasses.has(key)) {
+            this.seenEventClasses.set(key, event.eventType);
+        }
+    }
+    /**
+     * The type that already decided `event`'s class for the same entity, or
+     * `undefined` when nothing has: a second `step_created` for one step, a
+     * second terminal outcome, a second `step_started` after the step's result is
+     * already in the log.
+     *
+     * Such an event is committed but inert. Concurrent replays write into one
+     * log without a currency guard, so a replay working from a prefix that
+     * predates another replay's write can commit its own copy of work the log
+     * already records. That copy cannot change what the workflow observed: the
+     * outcome was decided by the first event of the class and every later replay
+     * reads that same event at the same log position, so ignoring the straggler
+     * is deterministic across replays.
+     *
+     * Classes are tracked separately, so passing one does not suppress another.
+     * A step whose result is in the log still reaches its `step_created` and
+     * `step_started` consumers if it has yet to see those classes.
+     *
+     * Consulted only after every registered callback has declined the event, so
+     * it can never take an event a consumer wanted. A retry's `step_started` is
+     * claimed by the step's live consumer and counts as an attempt exactly as
+     * before, and a second `step_created` reaching a step that has not finished
+     * is likewise consumed rather than skipped; only the copies nobody claims are
+     * skipped.
+     *
+     * Unlike the divergence report, this does *not* wait out the deferred window
+     * first, and it does not need to. The window buys time for a consumer that
+     * has yet to register, and no such consumer can want this event: the class
+     * was recorded by a consumption in this same replay, which means the entity's
+     * consumer was registered and took an event of this class, and correlation
+     * ids are minted from a monotonic ULID per body position, so nothing later in
+     * the body registers a second consumer under this id. Waiting would cost
+     * `getDeferredCheckDelayMs()` per straggler per replay for information that
+     * cannot arrive — 0.75% of production runs carry at least one straggler, and
+     * the p99 among those carries 155.
+     *
+     * The invariant to preserve if hook identity ever becomes caller-supplied
+     * (an idempotency key rather than a minted id): two `createHook` calls in one
+     * body could then share a correlation id, and the second consumer's
+     * `hook_created` would be a repeat of a class this replay already recorded.
+     * That would make skipping wrong for `hook_created`, and is the reason the
+     * class map lives next to the event types rather than being inferred.
+     */
+    firstEventTypeOfClass(event) {
+        const key = this.eventClassKey(event);
+        return key === undefined ? undefined : this.seenEventClasses.get(key);
+    }
+    /** Steps the walk over a repeat of an already-consumed class. */
+    skipDuplicateEvent(event, firstType) {
+        this.eventIndex++;
+        // Deliberately not routed through `notifyConsumedEvent`: the deterministic
+        // clock advances only on events the workflow actually observed. A skipped
+        // event is invisible to the workflow body, and a log that happens to
+        // contain one must produce the same timestamps as a log that does not.
+        eventsLogger.debug('Skipping event that repeats a class already in the log', {
+            eventId: event.eventId,
+            eventType: event.eventType,
+            firstEventType: firstType,
+            correlationId: event.correlationId,
+        });
+        try {
+            this.onDuplicateEvent?.(event, firstType);
+        }
+        catch (error) {
+            eventsLogger.error('onDuplicateEvent callback threw an error', {
+                error,
+            });
+        }
+    }
     handleEndOfLog() {
         // Everything still parked is waiting for a consumer some later replay will
         // register, which is the whole point of parking — except once the log
@@ -428,22 +542,41 @@ export class EventsConsumer {
                         return;
                     }
                     this.pendingUnconsumedCheck = null;
-                    if (mayPark) {
-                        if (this.events[this.eventIndex] !== currentEvent) {
-                            // An append() drain claimed it while the check was in flight.
-                            // Only subscribe() cancels the check, so this is reachable.
-                            return;
-                        }
-                        if (this.park(currentEvent)) {
-                            this.consume();
-                            return;
-                        }
-                    }
-                    this.onUnconsumedEvent(currentEvent);
+                    this.resolveUnconsumedEvent(currentEvent, mayPark);
                 }, getDeferredCheckDelayMs());
             });
         });
     }
+    /**
+     * Decide what a still-unconsumed event is, now that the promise queue has
+     * drained and the delivery gate says the VM is not mid-reaction.
+     *
+     * `mayPark` is false only for the end-of-log recheck of an event {@link park}
+     * already holds. Nothing in the first branch applies to one of those: it is
+     * not the event at the cursor, so the identity guard is not meaningful, and
+     * it is parked already.
+     *
+     * A duplicate class never arrives here. {@link consume} steps over one in the
+     * pass that offered it, before this check is ever scheduled, and a class
+     * recorded while the check was in flight can only have been recorded by a
+     * consumption inside {@link consume}, whose next pass re-offers this event
+     * and steps over it there — leaving the identity guard above to drop the
+     * in-flight check.
+     */
+    resolveUnconsumedEvent(currentEvent, mayPark) {
+        if (mayPark) {
+            if (this.events[this.eventIndex] !== currentEvent) {
+                // An append() drain claimed it while the check was in flight.
+                // Only subscribe() cancels the check, so this is reachable.
+                return;
+            }
+            if (this.park(currentEvent)) {
+                this.consume();
+                return;
+            }
+        }
+        this.onUnconsumedEvent(currentEvent);
+    }
     /**
      * Run `fn` once no data delivery is in flight, polling the way
      * `scheduleWhenIdle` does: let the promise queue drain, re-check a timer
@@ -514,4 +647,4 @@ export class EventsConsumer {
         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, 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 * Floor for the deferred-check delay, so a too-low override can't manufacture\n * spurious divergence (each false positive burns a divergence-recovery retry\n * and can escalate to a terminal `CorruptedEventLogError`).\n *\n * Exported so tests needing the shortest legal delay can ask for it instead of\n * hardcoding a number this floor would silently clamp up.\n */\nexport const MIN_DEFERRED_CHECK_DELAY_MS = 10;\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`.\n */\nconst getDeferredCheckDelayMs = (): number =>\n  envNumber('WORKFLOW_DEFERRED_CHECK_DELAY_MS', DEFERRED_CHECK_DELAY_MS, {\n    integer: true,\n    min: MIN_DEFERRED_CHECK_DELAY_MS,\n  });\n\n/**\n * Event types the ordered walk may step over and deliver later.\n *\n * Membership is not about who wrote the event. It is about whether the event\n * can reach the head of the walk with nothing registered to consume it, which\n * is the only situation parking exists for.\n *\n * Most types cannot. They are replay-origin: a replay emits them, in the order\n * its code reaches them, so their position in the log is the record of what\n * that replay decided. Reaching one of those out of order means this replay\n * decided differently than the log holds, which is divergence and nothing else.\n *\n * Step lifecycle events are not replay-origin, and are still absent, because\n * they always have a claimant. `step()` subscribes its consumer before the\n * step's first event can exist; `step_created` is ordered, so the walk cannot\n * pass it unless a consumer takes it; and that consumer stays subscribed until\n * `step_completed` or `step_failed`, after which the World refuses any further\n * write for that step. There is no window in which a replay knows about a step\n * and has nothing registered to consume its events, so parking them would only\n * defer reports of what is divergence either way. The same holds for\n * `wait_created` and its consumer. `wait_completed` is listed anyway: a sleep\n * can also be completed out of band, by the API that force-completes pending\n * waits, and tolerating a stray one is the cheaper direction to be wrong in.\n *\n * An allowlist rather than the complement of the ordered set, so a type this\n * file has not been taught about keeps the strict old behaviour.\n *\n * `hook_disposed` is deliberately absent despite being about a hook: it is\n * written when the workflow's own `using` scope exits, so it is replay-origin.\n *\n * `attr_set` is listed by type even though a given instance of it may be\n * replay-origin, since it is replay-origin when its writer is the workflow.\n * Splitting that out per event was considered and rejected. A replay that\n * reaches one of its own writes out of position has diverged, but a replay that\n * reaches an event it did NOT write, sitting where its own write would go, has\n * not: the writer field says who wrote the event, and not whether this replay\n * is the same one. Guessing wrong in that direction fails healthy runs, which\n * is the failure this file exists to stop, so the whole type is tolerated. The\n * cost is that a divergence involving `attr_set` surfaces at the end of the\n * replay, through `strandedEvent`, rather than at the offending event.\n */\nconst PARKABLE_EVENT_TYPES: ReadonlySet<Event['eventType']> = new Set([\n  'hook_received',\n  'hook_conflict',\n  'wait_completed',\n  'attr_set',\n  'run_cancelled',\n]);\n\n/**\n * Parkable types that can only ever resolve their correlation id once.\n *\n * A second one for the same id is not a delivery this replay has not reached\n * yet: it is a resolution for something already resolved, which no consumer\n * this replay or any later one registers can ever claim. `hook_received` is\n * absent because a hook legitimately fires many times under one id.\n *\n * Must stay a subset of {@link PARKABLE_EVENT_TYPES}: {@link park} is the only\n * reader of what this records, and it rejects a non-parkable type before it\n * looks, so an entry outside that set is dead weight on a hot path.\n */\nconst ONE_SHOT_EVENT_TYPES: ReadonlySet<Event['eventType']> = new Set([\n  'wait_completed',\n]);\n\n/** Identifies the thing a one-shot resolution event resolves. */\nfunction resolutionKey(eventType: string, correlationId: string): string {\n  return `${eventType}:${correlationId}`;\n}\n\n/**\n * Types that end a run. Once one is in the log, no consumer will ever be\n * registered again, so a parked event still parked here will never be claimed.\n */\nconst TERMINAL_EVENT_TYPES: ReadonlySet<Event['eventType']> = new Set([\n  'run_completed',\n  'run_failed',\n  'run_cancelled',\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   * 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   * Required rather than defaulting to always-idle: always-idle is exactly the\n   * pre-gate behaviour, so a defaulted option would let a construction site opt\n   * a whole replay path back out without saying so. Tests that drive a consumer\n   * with no orchestrator context pass `() => true` to keep the pre-existing\n   * timing, and say so at the call site.\n   */\n  isDeliveryIdle: () => boolean;\n}\n\nexport class EventsConsumer {\n  eventIndex: number;\n  readonly events: Event[];\n  readonly callbacks: EventConsumerCallback[] = [];\n  /**\n   * Events the ordered walk stepped over because nobody claimed them and their\n   * type carries no ordering claim. Each keeps the index it held in the log:\n   * consumers read {@link eventIndex} at consumption time to order their\n   * delivery against the rest of the log, and a late delivery must still make\n   * the claim its position gave it.\n   *\n   * Held in log order, drained in log order, and drained before every offer so\n   * a consumer registered after the walk passed the event still receives it.\n   */\n  private readonly parked: { event: Event; index: number }[] = [];\n  /**\n   * Correlation ids of the {@link ONE_SHOT_EVENT_TYPES} events consumed so\n   * far, so a second resolution for one of them is recognized as unclaimable\n   * rather than parked for a consumer that cannot exist.\n   */\n  private readonly resolved = new Set<string>();\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    // Own copy: the runtime mutates its event array in place, and a retained\n    // session must only observe new events through append() so resume()'s\n    // strict-extension check stays meaningful.\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;\n  }\n\n  /**\n   * The oldest event the walk stepped over that no consumer has claimed yet,\n   * if any. Parking is a bet that a consumer will be registered later, so at\n   * any point where no consumer ever will be again — the replay finishing is\n   * the definitive one — this answers which event the bet lost on.\n   */\n  get strandedEvent(): Event | undefined {\n    return this.parked[0]?.event;\n  }\n\n  /**\n   * What the walk is still holding, or `undefined` when it holds nothing.\n   *\n   * Read at every point a replay stops, including the suspensions that are not\n   * settling points, so the held state reaches telemetry. A replay cannot tell\n   * a delivery awaiting a later consumer from one no consumer will ever\n   * register, so it reports rather than decides: the same `eventId` reported on\n   * suspension after suspension of one run is the shape that says the bet\n   * parking made is not going to pay off, and that shape is only visible across\n   * replays.\n   */\n  get parkedSummary():\n    | { count: number; eventId: string; eventType: Event['eventType'] }\n    | undefined {\n    const oldest = this.parked[0]?.event;\n    if (!oldest) {\n      return undefined;\n    }\n    return {\n      count: this.parked.length,\n      eventId: oldest.eventId,\n      eventType: oldest.eventType,\n    };\n  }\n\n  append(events: Event[]): void {\n    for (const event of events) this.events.push(event);\n    process.nextTick(this.consume);\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      // Before every offer, not just on subscribe: a callback registered by\n      // the work this same pass kicked off may be the owner of something\n      // parked, and the parked event's delivery is ordered ahead of the head\n      // event's by the index it holds.\n      this.drainParked();\n      const currentEvent = this.events[this.eventIndex] ?? null;\n      const consumed = this.offer(currentEvent);\n      if (consumed) {\n        this.eventIndex++;\n      }\n      if (currentEvent === null) {\n        // End of log. Consumers return NotConsumed for the `null` sentinel\n        // (the one that recognizes it as its own boundary schedules the\n        // suspension as a side effect and still declines it), so the drain\n        // stops here rather than spinning past the end. `consumed` is only\n        // true for a callback that claims the sentinel outright, which no\n        // production consumer does.\n        if (!consumed) {\n          this.handleEndOfLog();\n        }\n        return;\n      }\n      if (!consumed) {\n        this.scheduleUnconsumedCheck(currentEvent, true);\n        return;\n      }\n      // A real event was consumed — advance to the next in the same pass.\n    }\n  };\n\n  /**\n   * Offer `currentEvent` to each registered callback in turn. Returns true\n   * when a callback consumed it. Does not move {@link eventIndex}: the ordered\n   * walk and the parked drain advance differently, so each does its own.\n   */\n  private offer(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        if (\n          currentEvent.correlationId &&\n          ONE_SHOT_EVENT_TYPES.has(currentEvent.eventType)\n        ) {\n          this.resolved.add(\n            resolutionKey(currentEvent.eventType, currentEvent.correlationId)\n          );\n        }\n        this.notifyConsumedEvent(currentEvent);\n      }\n      // remove the callback if it has finished\n      if (handled === EventConsumerResult.Finished) {\n        this.callbacks.splice(i, 1);\n      }\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Offer everything parked, oldest first, until a pass claims nothing.\n   *\n   * Each offer runs with {@link eventIndex} moved back to the position the\n   * parked event held in the log, because that is the position its consumer\n   * will register a delivery barrier under. Restoring the walk pointer\n   * afterwards is what keeps the two pointers from interfering.\n   */\n  private drainParked(): void {\n    let progressed = this.parked.length > 0;\n    while (progressed) {\n      progressed = false;\n      for (let i = 0; i < this.parked.length; i++) {\n        const entry = this.parked[i];\n        const walkIndex = this.eventIndex;\n        this.eventIndex = entry.index;\n        let consumed: boolean;\n        try {\n          consumed = this.offer(entry.event);\n        } finally {\n          this.eventIndex = walkIndex;\n        }\n        if (consumed) {\n          this.parked.splice(i, 1);\n          // A `Finished` callback was spliced out of the list this pass, so\n          // restart rather than keep walking a mutated array.\n          progressed = this.parked.length > 0;\n          break;\n        }\n      }\n    }\n  }\n\n  /**\n   * Step the ordered walk over an event nobody claimed, holding on to it for a\n   * later consumer. Returns false when the event's type makes its position a\n   * decision record, which is the one case where nobody claiming it means the\n   * replay diverged.\n   */\n  private park(event: Event): boolean {\n    if (!PARKABLE_EVENT_TYPES.has(event.eventType)) {\n      return false;\n    }\n    if (\n      event.correlationId &&\n      this.resolved.has(resolutionKey(event.eventType, event.correlationId))\n    ) {\n      return false;\n    }\n    this.parked.push({ event, index: this.eventIndex });\n    this.eventIndex++;\n    eventsLogger.debug('Parked an unclaimed event for later delivery', {\n      eventId: event.eventId,\n      eventType: event.eventType,\n      correlationId: event.correlationId,\n      parked: this.parked.length,\n    });\n    return true;\n  }\n\n  private handleEndOfLog() {\n    // Everything still parked is waiting for a consumer some later replay will\n    // register, which is the whole point of parking — except once the log\n    // already holds the run's terminal event, because then there is no later\n    // replay and no consumer will ever come.\n    if (this.parked.length === 0) {\n      return;\n    }\n    const last = this.events.at(-1);\n    if (!last || !TERMINAL_EVENT_TYPES.has(last.eventType)) {\n      // A later replay is still expected, so nothing here is decidable and\n      // escalating would fail the healthy runs parking exists to keep alive.\n      // Reaching the end of the log holding something is not by itself a fault,\n      // so this stays at `debug`; {@link parkedSummary} is what carries the\n      // state to the span, where a run that keeps stopping on the same held\n      // event is visible and a single replay's view is not.\n      eventsLogger.debug('Reached the end of the log still holding events', {\n        eventId: this.parked[0].event.eventId,\n        eventType: this.parked[0].event.eventType,\n        correlationId: this.parked[0].event.correlationId,\n        parked: this.parked.length,\n      });\n      return;\n    }\n    this.scheduleUnconsumedCheck(this.parked[0].event, false);\n  }\n\n  private scheduleUnconsumedCheck(currentEvent: Event, mayPark: boolean) {\n    // All callbacks returned NotConsumed for the current event.\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 — or,\n    // when its type carries no ordering claim, parked for a later consumer.\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 does\n          // not guarantee that setTimeout(0) fires after all cross-context\n          // microtasks settle, so we use a small but non-zero delay. Any\n          // subscribe() call that arrives during this window will cancel the\n          // check via version invalidation + clearTimeout.\n          this.pendingUnconsumedTimeout = setTimeout(() => {\n            this.pendingUnconsumedTimeout = null;\n            if (this.unconsumedCheckVersion !== checkVersion) {\n              return;\n            }\n            this.pendingUnconsumedCheck = null;\n            if (mayPark) {\n              if (this.events[this.eventIndex] !== currentEvent) {\n                // An append() drain claimed it while the check was in flight.\n                // Only subscribe() cancels the check, so this is reachable.\n                return;\n              }\n              if (this.park(currentEvent)) {\n                this.consume();\n                return;\n              }\n            }\n            this.onUnconsumedEvent(currentEvent);\n          }, getDeferredCheckDelayMs());\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`.\n   *\n   * Shortening the window shows that mechanism directly: on identical event logs\n   * the local race repro corrupts 34 of 42 runs at a 10ms window and 0 of 114 at\n   * the 100ms default. That measures how the bet loses, not that the default\n   * loses it, and no measurement of a delivery outrunning 100ms exists either\n   * way. So read this as retiring the bet rather than as repairing an observed\n   * failure of that number: the delay is a user-settable env override, which\n   * leaves the old behaviour one configuration away from losing on any backend.\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   * What the gate gives up: for the ordered events that still reach\n   * `onUnconsumedEvent` rather than {@link park}, this stops being the thing\n   * that catches a diverged log while a delivery is in flight. The suspension\n   * and this check now wake from the same `isDeliveryIdle` edge, and\n   * `scheduleWhenIdle` fires on the first timer tick after idle while this waits\n   * a further `getDeferredCheckDelayMs()`. So a run with a pending `sleep()`\n   * suspends first, and `onWorkflowError` drops the divergence arriving second\n   * (its `'suspended'` branch demotes to `'replay'` and surfaces nothing),\n   * leaving a later `resume()` to decline into a cold replay. Pre-gate the\n   * suspension already won that race whenever the delivery landed inside the\n   * fixed window, so what changed is that the outcome stopped depending on\n   * timing. Nothing should treat this check as the mechanism that reports\n   * divergence on a log the run is still delivering into.\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 too. The two cancellations are not identical: for the\n        // poll it is the version bump that does the work and the clearTimeout is\n        // belt-and-braces. Two state machines write this one field, so a poll\n        // invalidated between scheduling and firing can null out a handle the\n        // live chain has since stored, which is why every path out of `poll` and\n        // out of the fired check re-checks the version rather than trusting the\n        // handle.\n        this.pendingUnconsumedTimeout = setTimeout(poll, 0);\n      });\n    };\n    poll();\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, entityEventClass, 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 * Floor for the deferred-check delay, so a too-low override can't manufacture\n * spurious divergence (each false positive burns a divergence-recovery retry\n * and can escalate to a terminal `CorruptedEventLogError`).\n *\n * Exported so tests needing the shortest legal delay can ask for it instead of\n * hardcoding a number this floor would silently clamp up.\n */\nexport const MIN_DEFERRED_CHECK_DELAY_MS = 10;\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`.\n */\nconst getDeferredCheckDelayMs = (): number =>\n  envNumber('WORKFLOW_DEFERRED_CHECK_DELAY_MS', DEFERRED_CHECK_DELAY_MS, {\n    integer: true,\n    min: MIN_DEFERRED_CHECK_DELAY_MS,\n  });\n\n/**\n * Event types the ordered walk may step over and deliver later.\n *\n * Membership is not about who wrote the event. It is about whether the event\n * can reach the head of the walk with nothing registered to consume it, which\n * is the only situation parking exists for.\n *\n * Most types cannot. They are replay-origin: a replay emits them, in the order\n * its code reaches them, so their position in the log is the record of what\n * that replay decided. Reaching one of those out of order means this replay\n * decided differently than the log holds, which is divergence and nothing else.\n *\n * Step lifecycle events are not replay-origin, and are still absent, because\n * they always have a claimant. `step()` subscribes its consumer before the\n * step's first event can exist; `step_created` is ordered, so the walk cannot\n * pass it unless a consumer takes it; and that consumer stays subscribed until\n * `step_completed` or `step_failed`, after which the World refuses any further\n * write for that step. There is no window in which a replay knows about a step\n * and has nothing registered to consume its events, so parking them would only\n * defer reports of what is divergence either way. The same holds for\n * `wait_created` and its consumer. `wait_completed` is listed anyway: a sleep\n * can also be completed out of band, by the API that force-completes pending\n * waits, and tolerating a stray one is the cheaper direction to be wrong in.\n *\n * An allowlist rather than the complement of the ordered set, so a type this\n * file has not been taught about keeps the strict old behaviour.\n *\n * `hook_disposed` is deliberately absent despite being about a hook: it is\n * written when the workflow's own `using` scope exits, so it is replay-origin.\n *\n * `attr_set` is listed by type even though a given instance of it may be\n * replay-origin, since it is replay-origin when its writer is the workflow.\n * Splitting that out per event was considered and rejected. A replay that\n * reaches one of its own writes out of position has diverged, but a replay that\n * reaches an event it did NOT write, sitting where its own write would go, has\n * not: the writer field says who wrote the event, and not whether this replay\n * is the same one. Guessing wrong in that direction fails healthy runs, which\n * is the failure this file exists to stop, so the whole type is tolerated. The\n * cost is that a divergence involving `attr_set` surfaces at the end of the\n * replay, through `strandedEvent`, rather than at the offending event.\n */\nconst PARKABLE_EVENT_TYPES: ReadonlySet<Event['eventType']> = new Set([\n  'hook_received',\n  'hook_conflict',\n  'wait_completed',\n  'attr_set',\n  'run_cancelled',\n]);\n\n/**\n * Parkable types that can only ever resolve their correlation id once.\n *\n * A second one for the same id is not a delivery this replay has not reached\n * yet: it is a resolution for something already resolved, which no consumer\n * this replay or any later one registers can ever claim. `hook_received` is\n * absent because a hook legitimately fires many times under one id.\n *\n * Must stay a subset of {@link PARKABLE_EVENT_TYPES}: {@link park} is the only\n * reader of what this records, and it rejects a non-parkable type before it\n * looks, so an entry outside that set is dead weight on a hot path.\n */\nconst ONE_SHOT_EVENT_TYPES: ReadonlySet<Event['eventType']> = new Set([\n  'wait_completed',\n]);\n\n/** Identifies the thing a one-shot resolution event resolves. */\nfunction resolutionKey(eventType: string, correlationId: string): string {\n  return `${eventType}:${correlationId}`;\n}\n\n/**\n * Types that end a run. Once one is in the log, no consumer will ever be\n * registered again, so a parked event still parked here will never be claimed.\n */\nconst TERMINAL_EVENT_TYPES: ReadonlySet<Event['eventType']> = new Set([\n  'run_completed',\n  'run_failed',\n  'run_cancelled',\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   * Callback invoked when an event is skipped because it repeats an event\n   * class the walk already consumed for the same entity. `firstEventType` is\n   * the type that recorded the class, which is the one the workflow observed.\n   * Diagnostics only: skipping is a normal outcome, not an error — though a\n   * `firstEventType` differing from `event.eventType` says the two writers\n   * decided the entity's outcome differently, which is worth more than an\n   * info log.\n   */\n  onDuplicateEvent?: (event: Event, firstEventType: Event['eventType']) => 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   * Required rather than defaulting to always-idle: always-idle is exactly the\n   * pre-gate behaviour, so a defaulted option would let a construction site opt\n   * a whole replay path back out without saying so. Tests that drive a consumer\n   * with no orchestrator context pass `() => true` to keep the pre-existing\n   * timing, and say so at the call site.\n   */\n  isDeliveryIdle: () => boolean;\n}\n\nexport class EventsConsumer {\n  eventIndex: number;\n  readonly events: Event[];\n  readonly callbacks: EventConsumerCallback[] = [];\n  /**\n   * Events the ordered walk stepped over because nobody claimed them and their\n   * type carries no ordering claim. Each keeps the index it held in the log:\n   * consumers read {@link eventIndex} at consumption time to order their\n   * delivery against the rest of the log, and a late delivery must still make\n   * the claim its position gave it.\n   *\n   * Held in log order, drained in log order, and drained before every offer so\n   * a consumer registered after the walk passed the event still receives it.\n   */\n  private readonly parked: { event: Event; index: number }[] = [];\n  /**\n   * Correlation ids of the {@link ONE_SHOT_EVENT_TYPES} events consumed so\n   * far, so a second resolution for one of them is recognized as unclaimable\n   * rather than parked for a consumer that cannot exist.\n   */\n  private readonly resolved = new Set<string>();\n  /**\n   * `<class>:<correlationId>` for every event class the walk has already\n   * consumed, mapped to the event type that recorded it. The type is kept so a\n   * repeat that decided the same class *differently* (a `step_failed` behind a\n   * `step_completed`) can be reported as more than a re-commit. See\n   * {@link EventsConsumer.firstEventTypeOfClass}.\n   */\n  private readonly seenEventClasses = new Map<string, Event['eventType']>();\n  private onConsumedEvent?: (event: Event) => void;\n  private onUnconsumedEvent: (event: Event) => void;\n  private onDuplicateEvent?: (\n    event: Event,\n    firstType: Event['eventType']\n  ) => 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    // Own copy: the runtime mutates its event array in place, and a retained\n    // session must only observe new events through append() so resume()'s\n    // strict-extension check stays meaningful.\n    this.events = [...events];\n    this.eventIndex = 0;\n    this.onConsumedEvent = options.onConsumedEvent;\n    this.onUnconsumedEvent = options.onUnconsumedEvent;\n    this.onDuplicateEvent = options.onDuplicateEvent;\n    this.getPromiseQueue = options.getPromiseQueue;\n    this.isDeliveryIdle = options.isDeliveryIdle;\n  }\n\n  /**\n   * The oldest event the walk stepped over that no consumer has claimed yet,\n   * if any. Parking is a bet that a consumer will be registered later, so at\n   * any point where no consumer ever will be again — the replay finishing is\n   * the definitive one — this answers which event the bet lost on.\n   */\n  get strandedEvent(): Event | undefined {\n    return this.parked[0]?.event;\n  }\n\n  /**\n   * What the walk is still holding, or `undefined` when it holds nothing.\n   *\n   * Read at every point a replay stops, including the suspensions that are not\n   * settling points, so the held state reaches telemetry. A replay cannot tell\n   * a delivery awaiting a later consumer from one no consumer will ever\n   * register, so it reports rather than decides: the same `eventId` reported on\n   * suspension after suspension of one run is the shape that says the bet\n   * parking made is not going to pay off, and that shape is only visible across\n   * replays.\n   */\n  get parkedSummary():\n    | { count: number; eventId: string; eventType: Event['eventType'] }\n    | undefined {\n    const oldest = this.parked[0]?.event;\n    if (!oldest) {\n      return undefined;\n    }\n    return {\n      count: this.parked.length,\n      eventId: oldest.eventId,\n      eventType: oldest.eventType,\n    };\n  }\n\n  append(events: Event[]): void {\n    for (const event of events) this.events.push(event);\n    process.nextTick(this.consume);\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      // Before every offer, not just on subscribe: a callback registered by\n      // the work this same pass kicked off may be the owner of something\n      // parked, and the parked event's delivery is ordered ahead of the head\n      // event's by the index it holds.\n      this.drainParked();\n      const currentEvent = this.events[this.eventIndex] ?? null;\n      const consumed = this.offer(currentEvent);\n      if (consumed) {\n        this.eventIndex++;\n      }\n      if (currentEvent === null) {\n        // End of log. Consumers return NotConsumed for the `null` sentinel\n        // (the one that recognizes it as its own boundary schedules the\n        // suspension as a side effect and still declines it), so the drain\n        // stops here rather than spinning past the end. `consumed` is only\n        // true for a callback that claims the sentinel outright, which no\n        // production consumer does.\n        if (!consumed) {\n          this.handleEndOfLog();\n        }\n        return;\n      }\n      if (!consumed) {\n        // Nobody wanted it. If it repeats a class this walk already consumed\n        // for the same entity it is a straggler from a concurrent replay:\n        // step over it in this pass rather than paying the deferred window for\n        // a consumer that cannot come (see `firstEventTypeOfClass`).\n        const firstType = this.firstEventTypeOfClass(currentEvent);\n        if (firstType !== undefined) {\n          this.skipDuplicateEvent(currentEvent, firstType);\n          continue;\n        }\n        this.scheduleUnconsumedCheck(currentEvent, true);\n        return;\n      }\n      // A real event was consumed — advance to the next in the same pass.\n    }\n  };\n\n  /**\n   * Offer `currentEvent` to each registered callback in turn. Returns true\n   * when a callback consumed it. Does not move {@link eventIndex}: the ordered\n   * walk and the parked drain advance differently, so each does its own.\n   */\n  private offer(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        if (\n          currentEvent.correlationId &&\n          ONE_SHOT_EVENT_TYPES.has(currentEvent.eventType)\n        ) {\n          this.resolved.add(\n            resolutionKey(currentEvent.eventType, currentEvent.correlationId)\n          );\n        }\n        this.recordEventClass(currentEvent);\n        this.notifyConsumedEvent(currentEvent);\n      }\n      // remove the callback if it has finished\n      if (handled === EventConsumerResult.Finished) {\n        this.callbacks.splice(i, 1);\n      }\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Offer everything parked, oldest first, until a pass claims nothing.\n   *\n   * Each offer runs with {@link eventIndex} moved back to the position the\n   * parked event held in the log, because that is the position its consumer\n   * will register a delivery barrier under. Restoring the walk pointer\n   * afterwards is what keeps the two pointers from interfering.\n   */\n  private drainParked(): void {\n    let progressed = this.parked.length > 0;\n    while (progressed) {\n      progressed = false;\n      for (let i = 0; i < this.parked.length; i++) {\n        const entry = this.parked[i];\n        const walkIndex = this.eventIndex;\n        this.eventIndex = entry.index;\n        let consumed: boolean;\n        try {\n          consumed = this.offer(entry.event);\n        } finally {\n          this.eventIndex = walkIndex;\n        }\n        if (consumed) {\n          this.parked.splice(i, 1);\n          // A `Finished` callback was spliced out of the list this pass, so\n          // restart rather than keep walking a mutated array.\n          progressed = this.parked.length > 0;\n          break;\n        }\n      }\n    }\n  }\n\n  /**\n   * Step the ordered walk over an event nobody claimed, holding on to it for a\n   * later consumer. Returns false when the event's type makes its position a\n   * decision record, which is the one case where nobody claiming it means the\n   * replay diverged.\n   */\n  private park(event: Event): boolean {\n    if (!PARKABLE_EVENT_TYPES.has(event.eventType)) {\n      return false;\n    }\n    if (\n      event.correlationId &&\n      this.resolved.has(resolutionKey(event.eventType, event.correlationId))\n    ) {\n      return false;\n    }\n    this.parked.push({ event, index: this.eventIndex });\n    this.eventIndex++;\n    eventsLogger.debug('Parked an unclaimed event for later delivery', {\n      eventId: event.eventId,\n      eventType: event.eventType,\n      correlationId: event.correlationId,\n      parked: this.parked.length,\n    });\n    return true;\n  }\n\n  /**\n   * The key `event`'s class is tracked under, or `undefined` for the event\n   * types that belong to no class (`hook_received`, `hook_conflict`,\n   * `attr_set`, `run_created`) and are therefore never skipped.\n   *\n   * Run events carry no correlation id. They are classes of the run itself, so\n   * they all key off the same bucket.\n   */\n  private eventClassKey(event: Event): string | undefined {\n    const eventClass = entityEventClass(event.eventType);\n    return eventClass === undefined\n      ? undefined\n      : `${eventClass}:${event.correlationId}`;\n  }\n\n  /**\n   * Remembers that `event`'s class is now decided for its entity, if the type\n   * belongs to a class. First writer wins: the recorded type is the one the\n   * workflow observed, and a later repeat is measured against it.\n   */\n  private recordEventClass(event: Event) {\n    const key = this.eventClassKey(event);\n    if (key !== undefined && !this.seenEventClasses.has(key)) {\n      this.seenEventClasses.set(key, event.eventType);\n    }\n  }\n\n  /**\n   * The type that already decided `event`'s class for the same entity, or\n   * `undefined` when nothing has: a second `step_created` for one step, a\n   * second terminal outcome, a second `step_started` after the step's result is\n   * already in the log.\n   *\n   * Such an event is committed but inert. Concurrent replays write into one\n   * log without a currency guard, so a replay working from a prefix that\n   * predates another replay's write can commit its own copy of work the log\n   * already records. That copy cannot change what the workflow observed: the\n   * outcome was decided by the first event of the class and every later replay\n   * reads that same event at the same log position, so ignoring the straggler\n   * is deterministic across replays.\n   *\n   * Classes are tracked separately, so passing one does not suppress another.\n   * A step whose result is in the log still reaches its `step_created` and\n   * `step_started` consumers if it has yet to see those classes.\n   *\n   * Consulted only after every registered callback has declined the event, so\n   * it can never take an event a consumer wanted. A retry's `step_started` is\n   * claimed by the step's live consumer and counts as an attempt exactly as\n   * before, and a second `step_created` reaching a step that has not finished\n   * is likewise consumed rather than skipped; only the copies nobody claims are\n   * skipped.\n   *\n   * Unlike the divergence report, this does *not* wait out the deferred window\n   * first, and it does not need to. The window buys time for a consumer that\n   * has yet to register, and no such consumer can want this event: the class\n   * was recorded by a consumption in this same replay, which means the entity's\n   * consumer was registered and took an event of this class, and correlation\n   * ids are minted from a monotonic ULID per body position, so nothing later in\n   * the body registers a second consumer under this id. Waiting would cost\n   * `getDeferredCheckDelayMs()` per straggler per replay for information that\n   * cannot arrive — 0.75% of production runs carry at least one straggler, and\n   * the p99 among those carries 155.\n   *\n   * The invariant to preserve if hook identity ever becomes caller-supplied\n   * (an idempotency key rather than a minted id): two `createHook` calls in one\n   * body could then share a correlation id, and the second consumer's\n   * `hook_created` would be a repeat of a class this replay already recorded.\n   * That would make skipping wrong for `hook_created`, and is the reason the\n   * class map lives next to the event types rather than being inferred.\n   */\n  private firstEventTypeOfClass(event: Event): Event['eventType'] | undefined {\n    const key = this.eventClassKey(event);\n    return key === undefined ? undefined : this.seenEventClasses.get(key);\n  }\n\n  /** Steps the walk over a repeat of an already-consumed class. */\n  private skipDuplicateEvent(event: Event, firstType: Event['eventType']) {\n    this.eventIndex++;\n    // Deliberately not routed through `notifyConsumedEvent`: the deterministic\n    // clock advances only on events the workflow actually observed. A skipped\n    // event is invisible to the workflow body, and a log that happens to\n    // contain one must produce the same timestamps as a log that does not.\n    eventsLogger.debug(\n      'Skipping event that repeats a class already in the log',\n      {\n        eventId: event.eventId,\n        eventType: event.eventType,\n        firstEventType: firstType,\n        correlationId: event.correlationId,\n      }\n    );\n    try {\n      this.onDuplicateEvent?.(event, firstType);\n    } catch (error) {\n      eventsLogger.error('onDuplicateEvent callback threw an error', {\n        error,\n      });\n    }\n  }\n\n  private handleEndOfLog() {\n    // Everything still parked is waiting for a consumer some later replay will\n    // register, which is the whole point of parking — except once the log\n    // already holds the run's terminal event, because then there is no later\n    // replay and no consumer will ever come.\n    if (this.parked.length === 0) {\n      return;\n    }\n    const last = this.events.at(-1);\n    if (!last || !TERMINAL_EVENT_TYPES.has(last.eventType)) {\n      // A later replay is still expected, so nothing here is decidable and\n      // escalating would fail the healthy runs parking exists to keep alive.\n      // Reaching the end of the log holding something is not by itself a fault,\n      // so this stays at `debug`; {@link parkedSummary} is what carries the\n      // state to the span, where a run that keeps stopping on the same held\n      // event is visible and a single replay's view is not.\n      eventsLogger.debug('Reached the end of the log still holding events', {\n        eventId: this.parked[0].event.eventId,\n        eventType: this.parked[0].event.eventType,\n        correlationId: this.parked[0].event.correlationId,\n        parked: this.parked.length,\n      });\n      return;\n    }\n    this.scheduleUnconsumedCheck(this.parked[0].event, false);\n  }\n\n  private scheduleUnconsumedCheck(currentEvent: Event, mayPark: boolean) {\n    // All callbacks returned NotConsumed for the current event.\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 — or,\n    // when its type carries no ordering claim, parked for a later consumer.\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 does\n          // not guarantee that setTimeout(0) fires after all cross-context\n          // microtasks settle, so we use a small but non-zero delay. Any\n          // subscribe() call that arrives during this window will cancel the\n          // check via version invalidation + clearTimeout.\n          this.pendingUnconsumedTimeout = setTimeout(() => {\n            this.pendingUnconsumedTimeout = null;\n            if (this.unconsumedCheckVersion !== checkVersion) {\n              return;\n            }\n            this.pendingUnconsumedCheck = null;\n            this.resolveUnconsumedEvent(currentEvent, mayPark);\n          }, getDeferredCheckDelayMs());\n        });\n      });\n  }\n\n  /**\n   * Decide what a still-unconsumed event is, now that the promise queue has\n   * drained and the delivery gate says the VM is not mid-reaction.\n   *\n   * `mayPark` is false only for the end-of-log recheck of an event {@link park}\n   * already holds. Nothing in the first branch applies to one of those: it is\n   * not the event at the cursor, so the identity guard is not meaningful, and\n   * it is parked already.\n   *\n   * A duplicate class never arrives here. {@link consume} steps over one in the\n   * pass that offered it, before this check is ever scheduled, and a class\n   * recorded while the check was in flight can only have been recorded by a\n   * consumption inside {@link consume}, whose next pass re-offers this event\n   * and steps over it there — leaving the identity guard above to drop the\n   * in-flight check.\n   */\n  private resolveUnconsumedEvent(currentEvent: Event, mayPark: boolean) {\n    if (mayPark) {\n      if (this.events[this.eventIndex] !== currentEvent) {\n        // An append() drain claimed it while the check was in flight.\n        // Only subscribe() cancels the check, so this is reachable.\n        return;\n      }\n      if (this.park(currentEvent)) {\n        this.consume();\n        return;\n      }\n    }\n    this.onUnconsumedEvent(currentEvent);\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`.\n   *\n   * Shortening the window shows that mechanism directly: on identical event logs\n   * the local race repro corrupts 34 of 42 runs at a 10ms window and 0 of 114 at\n   * the 100ms default. That measures how the bet loses, not that the default\n   * loses it, and no measurement of a delivery outrunning 100ms exists either\n   * way. So read this as retiring the bet rather than as repairing an observed\n   * failure of that number: the delay is a user-settable env override, which\n   * leaves the old behaviour one configuration away from losing on any backend.\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   * What the gate gives up: for the ordered events that still reach\n   * `onUnconsumedEvent` rather than {@link park}, this stops being the thing\n   * that catches a diverged log while a delivery is in flight. The suspension\n   * and this check now wake from the same `isDeliveryIdle` edge, and\n   * `scheduleWhenIdle` fires on the first timer tick after idle while this waits\n   * a further `getDeferredCheckDelayMs()`. So a run with a pending `sleep()`\n   * suspends first, and `onWorkflowError` drops the divergence arriving second\n   * (its `'suspended'` branch demotes to `'replay'` and surfaces nothing),\n   * leaving a later `resume()` to decline into a cold replay. Pre-gate the\n   * suspension already won that race whenever the delivery landed inside the\n   * fixed window, so what changed is that the outcome stopped depending on\n   * timing. Nothing should treat this check as the mechanism that reports\n   * divergence on a log the run is still delivering into.\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 too. The two cancellations are not identical: for the\n        // poll it is the version bump that does the work and the clearTimeout is\n        // belt-and-braces. Two state machines write this one field, so a poll\n        // invalidated between scheduling and firing can null out a handle the\n        // live chain has since stored, which is why every path out of `poll` and\n        // out of the fired check re-checks the version rather than trusting the\n        // handle.\n        this.pendingUnconsumedTimeout = setTimeout(poll, 0);\n      });\n    };\n    poll();\n  }\n}\n"]}

package/dist/private.d.ts.map

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