@workflow/core 5.0.0-beta.5 → 5.0.0-beta.51

package/dist/events-consumer.js

@@ -1,3 +1,5 @@
+import { envNumber } from '@workflow/world/env-config';
+import { classifyEntityEvent, isSealedNoopEvent, } from '@workflow/world/event-metadata';
 import { eventsLogger } from './logger.js';
 /**
  * Delay before firing the deferred unconsumed-event check after the promise
@@ -6,6 +8,109 @@ import { eventsLogger } from './logger.js';
  * in host). Any subscribe() arriving during this window cancels the check.
  */
 export const DEFERRED_CHECK_DELAY_MS = 100;
+/**
+ * Floor for the deferred-check delay, so a too-low override can't manufacture
+ * spurious divergence (each false positive burns a divergence-recovery retry
+ * and can escalate to a terminal `CorruptedEventLogError`).
+ *
+ * Exported so tests needing the shortest legal delay can ask for it instead of
+ * hardcoding a number this floor would silently clamp up.
+ */
+export const MIN_DEFERRED_CHECK_DELAY_MS = 10;
+/**
+ * Effective deferred-check delay. Override: `WORKFLOW_DEFERRED_CHECK_DELAY_MS`.
+ *
+ * Unlike the other timing knobs this is not a polling interval but a
+ * determinism safety margin: firing the unconsumed-event check before the
+ * cross-VM subscribe() chain has landed rejects a healthy run with
+ * `ReplayDivergenceError`.
+ */
+const getDeferredCheckDelayMs = () => envNumber('WORKFLOW_DEFERRED_CHECK_DELAY_MS', DEFERRED_CHECK_DELAY_MS, {
+    integer: true,
+    min: MIN_DEFERRED_CHECK_DELAY_MS,
+});
+/**
+ * Event types the ordered walk may step over and deliver later.
+ *
+ * Membership is not about who wrote the event. It is about whether the event
+ * can reach the head of the walk with nothing registered to consume it, which
+ * is the only situation parking exists for.
+ *
+ * Most types cannot. They are replay-origin: a replay emits them, in the order
+ * its code reaches them, so their position in the log is the record of what
+ * that replay decided. Reaching one of those out of order means this replay
+ * decided differently than the log holds, which is divergence and nothing else.
+ *
+ * Step lifecycle events are not replay-origin, and are still absent, because
+ * they always have a claimant. `step()` subscribes its consumer before the
+ * step's first event can exist; `step_created` is ordered, so the walk cannot
+ * pass it unless a consumer takes it; and that consumer stays subscribed until
+ * `step_completed` or `step_failed`, after which the World refuses any further
+ * write for that step. There is no window in which a replay knows about a step
+ * and has nothing registered to consume its events, so parking them would only
+ * defer reports of what is divergence either way. The same holds for
+ * `wait_created` and its consumer. `wait_completed` is listed anyway: a sleep
+ * can also be completed out of band, by the API that force-completes pending
+ * waits, and tolerating a stray one is the cheaper direction to be wrong in.
+ *
+ * An allowlist rather than the complement of the ordered set, so a type this
+ * file has not been taught about keeps the strict old behavior.
+ *
+ * `hook_disposed` is deliberately absent despite being about a hook: it is
+ * written when the workflow's own `using` scope exits, so it is replay-origin.
+ *
+ * `attr_set` is listed by type even though a given instance of it may be
+ * replay-origin, since it is replay-origin when its writer is the workflow.
+ * Splitting that out per event was considered and rejected. A replay that
+ * reaches one of its own writes out of position has diverged, but a replay that
+ * reaches an event it did NOT write, sitting where its own write would go, has
+ * not: the writer field says who wrote the event, and not whether this replay
+ * is the same one. Guessing wrong in that direction fails healthy runs, which
+ * is the failure this file exists to stop, so the whole type is tolerated. The
+ * cost is that a divergence involving `attr_set` surfaces at the end of the
+ * replay, through `strandedEvent`, rather than at the offending event.
+ *
+ * Parking here is for an `attr_set` the walk reaches *before* the body has made
+ * the call that claims it. A second event under an id already claimed is a
+ * different thing: `attr_set` has an entity event class, so the duplicate skip
+ * takes it before this set is consulted, and a copy that parked ahead of any
+ * consumption is released by {@link dropParkedDuplicates} once one lands.
+ */
+const PARKABLE_EVENT_TYPES = new Set([
+    'hook_received',
+    'hook_conflict',
+    'wait_completed',
+    'attr_set',
+    'run_cancelled',
+]);
+/**
+ * Parkable types that can only ever resolve their correlation id once.
+ *
+ * A second one for the same id is not a delivery this replay has not reached
+ * yet: it is a resolution for something already resolved, which no consumer
+ * this replay or any later one registers can ever claim. `hook_received` is
+ * absent because a hook legitimately fires many times under one id.
+ *
+ * Must stay a subset of {@link PARKABLE_EVENT_TYPES}: {@link park} is the only
+ * reader of what this records, and it rejects a non-parkable type before it
+ * looks, so an entry outside that set is dead weight on a hot path.
+ */
+const ONE_SHOT_EVENT_TYPES = new Set([
+    'wait_completed',
+]);
+/** Identifies the thing a one-shot resolution event resolves. */
+function resolutionKey(eventType, correlationId) {
+    return `${eventType}:${correlationId}`;
+}
+/**
+ * Types that end a run. Once one is in the log, no consumer will ever be
+ * registered again, so a parked event still parked here will never be claimed.
+ */
+const TERMINAL_EVENT_TYPES = new Set([
+    'run_completed',
+    'run_failed',
+    'run_cancelled',
+]);
 export var EventConsumerResult;
 (function (EventConsumerResult) {
     /**
@@ -23,18 +128,114 @@ export var EventConsumerResult;
 })(EventConsumerResult || (EventConsumerResult = {}));
 export class EventsConsumer {
     eventIndex;
-    events = [];
+    events;
     callbacks = [];
+    /**
+     * Events the ordered walk stepped over because nobody claimed them and their
+     * type carries no ordering claim. Each keeps the index it held in the log:
+     * consumers read {@link eventIndex} at consumption time to order their
+     * delivery against the rest of the log, and a late delivery must still make
+     * the claim its position gave it.
+     *
+     * Held in log order, drained in log order, and drained before every offer so
+     * a consumer registered after the walk passed the event still receives it.
+     */
+    parked = [];
+    /**
+     * Correlation ids of the {@link ONE_SHOT_EVENT_TYPES} events consumed so
+     * far, so a second resolution for one of them is recognized as unclaimable
+     * 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;
     pendingUnconsumedTimeout = null;
     unconsumedCheckVersion = 0;
+    /**
+     * The event a callback most recently claimed, for {@link describe}. Tracked
+     * separately from {@link eventIndex} because the walk also steps over events
+     * (parked, sealed no-ops, duplicates) without anyone consuming them, so
+     * `events[eventIndex - 1]` does not say what replay last acted on.
+     */
+    lastConsumed;
     constructor(events, options) {
-        this.events = events;
+        // Own copy: the runtime mutates its event array in place, and a retained
+        // session must only observe new events through append() so resume()'s
+        // strict-extension check stays meaningful.
+        this.events = [...events];
         this.eventIndex = 0;
+        this.onConsumedEvent = options.onConsumedEvent;
         this.onUnconsumedEvent = options.onUnconsumedEvent;
+        this.onDuplicateEvent = options.onDuplicateEvent;
         this.getPromiseQueue = options.getPromiseQueue;
+        this.isDeliveryIdle = options.isDeliveryIdle;
+    }
+    /**
+     * The oldest event the walk stepped over that no consumer has claimed yet,
+     * if any. Parking is a bet that a consumer will be registered later, so at
+     * any point where no consumer ever will be again (the replay finishing is
+     * the definitive one), this answers which event the bet lost on.
+     */
+    get strandedEvent() {
+        return this.parked[0]?.event;
+    }
+    /**
+     * What the walk is still holding, or `undefined` when it holds nothing.
+     *
+     * Read at every point a replay stops, including the suspensions that are not
+     * settling points, so the held state reaches telemetry. A replay cannot tell
+     * a delivery awaiting a later consumer from one no consumer will ever
+     * register, so it reports rather than decides: the same `eventId` reported on
+     * suspension after suspension of one run is the shape that says the bet
+     * parking made is not going to pay off, and that shape is only visible across
+     * replays.
+     */
+    get parkedSummary() {
+        const oldest = this.parked[0]?.event;
+        if (!oldest) {
+            return undefined;
+        }
+        return {
+            count: this.parked.length,
+            eventId: oldest.eventId,
+            eventType: oldest.eventType,
+        };
+    }
+    /**
+     * Where the walk stands, for a divergence message. Everything here is
+     * already known to the consumer; the point of the method is that the
+     * orchestrator can print it without reaching into private state.
+     *
+     * `index` is the ordered walk's position (the offset of the event it is
+     * stuck on, when it is stuck), `length` the log as this consumer holds it,
+     * `parked` how many events the walk stepped over and still holds, and
+     * `lastConsumedEventId` the id of the event a callback most recently
+     * claimed, `undefined` before the first claim.
+     */
+    describe() {
+        return {
+            index: this.eventIndex,
+            length: this.events.length,
+            parked: this.parked.length,
+            lastConsumedEventId: this.lastConsumed?.eventId,
+        };
+    }
+    append(events) {
+        for (const event of events)
+            this.events.push(event);
+        process.nextTick(this.consume);
     }
     /**
      * Registers a callback function to be called after an event has been consumed
@@ -60,8 +261,83 @@ export class EventsConsumer {
         }
         process.nextTick(this.consume);
     }
+    notifyConsumedEvent(event) {
+        if (!this.onConsumedEvent) {
+            return;
+        }
+        try {
+            this.onConsumedEvent(event);
+        }
+        catch (error) {
+            eventsLogger.error('onConsumedEvent callback threw an error', {
+                error,
+            });
+        }
+    }
     consume = () => {
-        const currentEvent = this.events[this.eventIndex] ?? null;
+        // Drain consecutively consumable events synchronously within a single
+        // pass instead of paying one `process.nextTick` per consumed event.
+        //
+        // Why this is safe: a callback only consumes an event using a consumer
+        // that is ALREADY registered (e.g. a long-lived step consumer walking
+        // `step_created` → `step_started` → `step_completed`, or the structural
+        // lifecycle consumer). New consumers are only ever registered by workflow
+        // VM body code that runs asynchronously off `ctx.promiseQueue` after a
+        // delivery `resolve()`; none of the callbacks here call `subscribe()`
+        // synchronously. So within one pass `this.callbacks` is mutated only by
+        // this loop (the `Finished` splice), and the next event's consumer is
+        // either already present (advance now) or not yet registered, in which
+        // case no callback consumes the event and we fall through to the
+        // cross-VM-safe deferred unconsumed-event check below, exactly as before.
+        while (true) {
+            // Before every offer, not just on subscribe: a callback registered by
+            // the work this same pass kicked off may be the owner of something
+            // parked, and the parked event's delivery is ordered ahead of the head
+            // event's by the index it holds.
+            this.drainParked();
+            const currentEvent = this.events[this.eventIndex] ?? null;
+            if (currentEvent !== null && isSealedNoopEvent(currentEvent)) {
+                this.skipSealedNoop(currentEvent);
+                continue;
+            }
+            const consumed = this.offer(currentEvent);
+            if (consumed) {
+                this.eventIndex++;
+            }
+            if (currentEvent === null) {
+                // End of log. Consumers return NotConsumed for the `null` sentinel
+                // (the one that recognizes it as its own boundary schedules the
+                // suspension as a side effect and still declines it), so the drain
+                // stops here rather than spinning past the end. `consumed` is only
+                // true for a callback that claims the sentinel outright, which no
+                // production consumer does.
+                if (!consumed) {
+                    this.handleEndOfLog();
+                }
+                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;
+            }
+            // A real event was consumed, so advance to the next in the same pass.
+        }
+    };
+    /**
+     * Offer `currentEvent` to each registered callback in turn. Returns true
+     * when a callback consumed it. Does not move {@link eventIndex}: the ordered
+     * walk and the parked drain advance differently, so each does its own.
+     */
+    offer(currentEvent) {
         for (let i = 0; i < this.callbacks.length; i++) {
             const callback = this.callbacks[i];
             let handled = EventConsumerResult.NotConsumed;
@@ -71,53 +347,408 @@ export class EventsConsumer {
             catch (error) {
                 eventsLogger.error('EventConsumer callback threw an error', { error });
             }
-            if (handled === EventConsumerResult.Consumed ||
-                handled === EventConsumerResult.Finished) {
-                // consumer handled this event, so increase the event index
-                this.eventIndex++;
-                // remove the callback if it has finished
-                if (handled === EventConsumerResult.Finished) {
-                    this.callbacks.splice(i, 1);
+            if (handled !== EventConsumerResult.Consumed &&
+                handled !== EventConsumerResult.Finished) {
+                continue;
+            }
+            if (currentEvent !== null) {
+                if (currentEvent.correlationId &&
+                    ONE_SHOT_EVENT_TYPES.has(currentEvent.eventType)) {
+                    this.resolved.add(resolutionKey(currentEvent.eventType, currentEvent.correlationId));
                 }
-                // continue to the next event
-                process.nextTick(this.consume);
-                return;
+                this.recordEventClass(currentEvent);
+                this.lastConsumed = currentEvent;
+                this.notifyConsumedEvent(currentEvent);
+            }
+            // remove the callback if it has finished
+            if (handled === EventConsumerResult.Finished) {
+                this.callbacks.splice(i, 1);
             }
+            return true;
         }
-        // If we reach here, all callbacks returned NotConsumed.
-        // If the current event is non-null (a real event, not end-of-events),
-        // schedule a deferred check. We chain onto the promiseQueue so that any
+        return false;
+    }
+    /**
+     * Offer everything parked, oldest first, until a pass claims nothing.
+     *
+     * Each offer runs with {@link eventIndex} moved back to the position the
+     * parked event held in the log, because that is the position its consumer
+     * will register a delivery barrier under. Restoring the walk pointer
+     * afterwards is what keeps the two pointers from interfering.
+     */
+    drainParked() {
+        let progressed = this.parked.length > 0;
+        while (progressed) {
+            progressed = false;
+            this.dropParkedDuplicates();
+            for (let i = 0; i < this.parked.length; i++) {
+                const entry = this.parked[i];
+                const walkIndex = this.eventIndex;
+                this.eventIndex = entry.index;
+                let consumed;
+                try {
+                    consumed = this.offer(entry.event);
+                }
+                finally {
+                    this.eventIndex = walkIndex;
+                }
+                if (consumed) {
+                    this.parked.splice(i, 1);
+                    // A `Finished` callback was spliced out of the list this pass, so
+                    // restart rather than keep walking a mutated array.
+                    progressed = this.parked.length > 0;
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     * Release anything parked whose class a consumption has since recorded for
+     * the same entity, on the same terms as {@link skipDuplicateEvent}.
+     *
+     * The ordered walk decides a straggler at the event, but only for one of the
+     * two orders the copies can arrive in. When neither copy has a consumer yet,
+     * both park — the walk steps over the first and re-enters immediately, so
+     * the second is offered in the same tick, with no class recorded because
+     * nothing has been *consumed*. The drain then claims the first and the
+     * second is left held by a consumer list that will never grow the callback
+     * it needs, which the workflow function returning reports through
+     * {@link strandedEvent} as a replay divergence.
+     *
+     * Run before each offer pass rather than once, because the consumption that
+     * records the class happens inside the drain itself.
+     *
+     * Not specific to `attr_set`: `wait_completed` reaches the same state, and
+     * {@link ONE_SHOT_EVENT_TYPES} only covers it in the order where the
+     * consumption came first.
+     */
+    dropParkedDuplicates() {
+        for (let i = this.parked.length - 1; i >= 0; i--) {
+            const event = this.parked[i].event;
+            const firstType = this.firstEventTypeOfClass(event);
+            if (firstType === undefined) {
+                continue;
+            }
+            this.parked.splice(i, 1);
+            // The walk index moved past this event when it was parked, so unlike
+            // `skipDuplicateEvent` there is nothing to advance here.
+            eventsLogger.debug('Releasing a parked 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,
+                });
+            }
+        }
+    }
+    /**
+     * Step the ordered walk over an event nobody claimed, holding on to it for a
+     * later consumer. Returns false when the event's type makes its position a
+     * decision record, which is the one case where nobody claiming it means the
+     * replay diverged.
+     */
+    park(event) {
+        if (!PARKABLE_EVENT_TYPES.has(event.eventType)) {
+            return false;
+        }
+        if (event.correlationId &&
+            this.resolved.has(resolutionKey(event.eventType, event.correlationId))) {
+            return false;
+        }
+        this.parked.push({ event, index: this.eventIndex });
+        this.eventIndex++;
+        eventsLogger.debug('Parked an unclaimed event for later delivery', {
+            eventId: event.eventId,
+            eventType: event.eventType,
+            correlationId: event.correlationId,
+            parked: this.parked.length,
+        });
+        return true;
+    }
+    /**
+     * The key `event`'s class is tracked under, or `undefined` for the events
+     * that belong to no class and are therefore never skipped: the types with no
+     * entry at all (`hook_received`, `hook_conflict`, `run_created`), and a
+     * classed type carrying no entity to track it under.
+     *
+     * {@link classifyEntityEvent} owns that rule, because the observability UI
+     * decides the same question about the same log and the two must not drift.
+     */
+    eventClassKey(event) {
+        const classification = classifyEntityEvent(event);
+        return classification === undefined
+            ? undefined
+            : `${classification.eventClass}:${classification.entity}`;
+    }
+    /**
+     * 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 sealed-log `noop` (specVersion >= 7): the World's
+     * backend wrote it to occupy a slot whose writer allocated the position and
+     * died, so the log's density arithmetic holds. It is invisible to the
+     * workflow: no consumer is offered it, no event class is recorded, and the
+     * deterministic clock does not advance, exactly as with
+     * {@link skipDuplicateEvent}, so a log that happens to contain one produces the same
+     * timestamps as a log that does not. (Its `createdAt` is the seal time,
+     * which can even postdate later slots' events; letting it touch the clock
+     * would leak the sealer's wall clock into replay.)
+     */
+    skipSealedNoop(event) {
+        this.eventIndex++;
+        eventsLogger.debug('Skipping sealed-log noop event', {
+            eventId: event.eventId,
+        });
+    }
+    /** 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
+        // already holds the run's terminal event, because then there is no later
+        // replay and no consumer will ever come.
+        if (this.parked.length === 0) {
+            return;
+        }
+        const last = this.events.at(-1);
+        if (!last || !TERMINAL_EVENT_TYPES.has(last.eventType)) {
+            // A later replay is still expected, so nothing here is decidable and
+            // escalating would fail the healthy runs parking exists to keep alive.
+            // Reaching the end of the log holding something is not by itself a fault,
+            // so this stays at `debug`; {@link parkedSummary} is what carries the
+            // state to the span, where a run that keeps stopping on the same held
+            // event is visible and a single replay's view is not.
+            eventsLogger.debug('Reached the end of the log still holding events', {
+                eventId: this.parked[0].event.eventId,
+                eventType: this.parked[0].event.eventType,
+                correlationId: this.parked[0].event.correlationId,
+                parked: this.parked.length,
+            });
+            return;
+        }
+        this.scheduleUnconsumedCheck(this.parked[0].event, false);
+    }
+    scheduleUnconsumedCheck(currentEvent, mayPark) {
+        // All callbacks returned NotConsumed for the current event.
+        // Schedule a deferred check. We chain onto the promiseQueue so that any
         // pending async work (e.g., deserialization/decryption that triggers
         // resolve() → user code → subscribe()) completes first. If the event
-        // is still unconsumed after the queue drains, it's truly orphaned.
-        if (currentEvent !== null) {
-            const checkVersion = ++this.unconsumedCheckVersion;
-            this.pendingUnconsumedCheck = this.getPromiseQueue()
-                .then(
-            // Yield once after the first queue drain so promise chains resumed by
-            // that drain can run across the VM boundary and append any follow-up
-            // async work (for example: step_completed resolves -> for-await loop
-            // resumes -> the next hook payload starts hydrating).
-            () => 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.
+        // is still unconsumed after the queue drains, it's truly orphaned, or,
+        // when its type carries no ordering claim, parked for a later consumer.
+        const checkVersion = ++this.unconsumedCheckVersion;
+        this.pendingUnconsumedCheck = this.getPromiseQueue()
+            .then(
+        // Yield once after the first queue drain so promise chains resumed by
+        // that drain can run across the VM boundary and append any follow-up
+        // async work (for example: step_completed resolves -> for-await loop
+        // resumes -> the next hook payload starts hydrating).
+        () => new Promise((resolve) => setTimeout(resolve, 0)))
+            .then(() => this.getPromiseQueue())
+            .then(() => {
+            // 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);
+                    if (this.unconsumedCheckVersion !== checkVersion) {
+                        return;
                     }
-                }, DEFERRED_CHECK_DELAY_MS);
+                    this.pendingUnconsumedCheck = null;
+                    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. One that parks before any consumption records its class
+     * is released later by {@link dropParkedDuplicates} instead.
+     */
+    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
+     * 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`.
+     *
+     * Shortening the window shows that mechanism directly: on identical event logs
+     * the local race repro corrupts 34 of 42 runs at a 10ms window and 0 of 114 at
+     * the 100ms default. That measures how the bet loses, not that the default
+     * loses it, and no measurement of a delivery outrunning 100ms exists either
+     * way. So read this as retiring the bet rather than as repairing an observed
+     * failure of that number: the delay is a user-settable env override, which
+     * leaves the old behavior one configuration away from losing on any backend.
+     *
+     * 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.
+     *
+     * What the gate gives up: for the ordered events that still reach
+     * `onUnconsumedEvent` rather than {@link park}, this stops being the thing
+     * that catches a diverged log while a delivery is in flight. The suspension
+     * and this check now wake from the same `isDeliveryIdle` edge, and
+     * `scheduleWhenIdle` fires on the first timer tick after idle while this waits
+     * a further `getDeferredCheckDelayMs()`. So a run with a pending `sleep()`
+     * suspends first, and `onWorkflowError` drops the divergence arriving second
+     * (its `'suspended'` branch demotes to `'replay'` and surfaces nothing),
+     * leaving a later `resume()` to decline into a cold replay. Pre-gate the
+     * suspension already won that race whenever the delivery landed inside the
+     * fixed window, so what changed is that the outcome stopped depending on
+     * timing. Nothing should treat this check as the mechanism that reports
+     * divergence on a log the run is still delivering into.
+     */
+    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 too. The two cancellations are not identical: for the
+                // poll it is the version bump that does the work and the clearTimeout is
+                // belt-and-braces. Two state machines write this one field, so a poll
+                // invalidated between scheduling and firing can null out a handle the
+                // live chain has since stored, which is why every path out of `poll` and
+                // out of the fired check re-checks the version rather than trusting the
+                // handle.
+                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\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 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 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.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 consume = () => {\n    const currentEvent = this.events[this.eventIndex] ?? null;\n    for (let i = 0; i < this.callbacks.length; i++) {\n      const callback = this.callbacks[i];\n      let handled = EventConsumerResult.NotConsumed;\n      try {\n        handled = callback(currentEvent);\n      } catch (error) {\n        eventsLogger.error('EventConsumer callback threw an error', { error });\n      }\n      if (\n        handled === EventConsumerResult.Consumed ||\n        handled === EventConsumerResult.Finished\n      ) {\n        // consumer handled this event, so increase the event index\n        this.eventIndex++;\n\n        // remove the callback if it has finished\n        if (handled === EventConsumerResult.Finished) {\n          this.callbacks.splice(i, 1);\n        }\n\n        // continue to the next event\n        process.nextTick(this.consume);\n        return;\n      }\n    }\n\n    // If we reach here, all callbacks returned NotConsumed.\n    // If the current event is non-null (a real event, not end-of-events),\n    // schedule a deferred check. We chain onto the promiseQueue so that any\n    // pending async work (e.g., deserialization/decryption that triggers\n    // resolve() → user code → subscribe()) completes first. If the event\n    // is still unconsumed after the queue drains, it's truly orphaned.\n    if (currentEvent !== null) {\n      const checkVersion = ++this.unconsumedCheckVersion;\n      this.pendingUnconsumedCheck = this.getPromiseQueue()\n        .then(\n          // Yield once after the first queue drain so promise chains resumed by\n          // that drain can run across the VM boundary and append any follow-up\n          // async work (for example: step_completed resolves -> for-await loop\n          // resumes -> the next hook payload starts hydrating).\n          () => new Promise<void>((resolve) => setTimeout(resolve, 0))\n        )\n        .then(() => this.getPromiseQueue())\n        .then(() => {\n          // Use a delayed setTimeout after the queue drains. The delay must be\n          // long enough for promise chains to propagate across the VM boundary\n          // (from resolve() in the host context through to the workflow code\n          // calling subscribe() in the VM context). Node.js does not guarantee\n          // that setTimeout(0) fires after all cross-context microtasks settle,\n          // so we use a small but non-zero delay. Any subscribe() call that\n          // arrives during this window will cancel the check via version\n          // invalidation + clearTimeout.\n          this.pendingUnconsumedTimeout = setTimeout(() => {\n            this.pendingUnconsumedTimeout = null;\n            if (this.unconsumedCheckVersion === checkVersion) {\n              this.pendingUnconsumedCheck = null;\n              this.onUnconsumedEvent(currentEvent);\n            }\n          }, DEFERRED_CHECK_DELAY_MS);\n        });\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events-consumer.js","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EACL,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,uBAAuB,GAAG,GAAW,EAAE,CAC3C,SAAS,CAAC,kCAAkC,EAAE,uBAAuB,EAAE;IACrE,OAAO,EAAE,IAAI;IACb,GAAG,EAAE,2BAA2B;CACjC,CAAC,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,oBAAoB,GAAoC,IAAI,GAAG,CAAC;IACpE,eAAe;IACf,eAAe;IACf,gBAAgB;IAChB,UAAU;IACV,eAAe;CAChB,CAAC,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,oBAAoB,GAAoC,IAAI,GAAG,CAAC;IACpE,gBAAgB;CACjB,CAAC,CAAC;AAEH,iEAAiE;AACjE,SAAS,aAAa,CAAC,SAAiB,EAAE,aAAqB;IAC7D,OAAO,GAAG,SAAS,IAAI,aAAa,EAAE,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,MAAM,oBAAoB,GAAoC,IAAI,GAAG,CAAC;IACpE,eAAe;IACf,YAAY;IACZ,eAAe;CAChB,CAAC,CAAC;AAEH,MAAM,CAAN,IAAY,mBAaX;AAbD,WAAY,mBAAmB;IAC7B;;OAEG;IACH,qEAAQ,CAAA;IACR;;OAEG;IACH,2EAAW,CAAA;IACX;;OAEG;IACH,qEAAQ,CAAA;AACV,CAAC,EAbW,mBAAmB,KAAnB,mBAAmB,QAa9B;AA2DD,MAAM,OAAO,cAAc;IACzB,UAAU,CAAS;IACV,MAAM,CAAU;IAChB,SAAS,GAA4B,EAAE,CAAC;IACjD;;;;;;;;;OASG;IACc,MAAM,GAAsC,EAAE,CAAC;IAChE;;;;OAIG;IACc,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9C;;;;;;OAMG;IACc,gBAAgB,GAAG,IAAI,GAAG,EAA8B,CAAC;IAClE,eAAe,CAA0B;IACzC,iBAAiB,CAAyB;IAC1C,gBAAgB,CAGd;IACF,eAAe,CAAsB;IACrC,cAAc,CAAgB;IAC9B,sBAAsB,GAAyB,IAAI,CAAC;IACpD,wBAAwB,GAAyC,IAAI,CAAC;IACtE,sBAAsB,GAAG,CAAC,CAAC;IACnC;;;;;OAKG;IACK,YAAY,CAAoB;IAExC,YAAY,MAAe,EAAE,OAA8B;QACzD,yEAAyE;QACzE,sEAAsE;QACtE,2CAA2C;QAC3C,IAAI,CAAC,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;QAC1B,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;QACpB,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;QAC/C,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;QACnD,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;QACjD,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;QAC/C,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;IAC/C,CAAC;IAED;;;;;OAKG;IACH,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;OAUG;IACH,IAAI,aAAa;QAGf,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;QACrC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;YACzB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,SAAS,EAAE,MAAM,CAAC,SAAS;SAC5B,CAAC;IACJ,CAAC;IAED;;;;;;;;;;OAUG;IACH,QAAQ;QACN,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,UAAU;YACtB,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;YAC1B,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;YAC1B,mBAAmB,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO;SAChD,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,MAAe;QACpB,KAAK,MAAM,KAAK,IAAI,MAAM;YAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAyB;QACjC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACxB,kFAAkF;QAClF,8EAA8E;QAC9E,4DAA4D;QAC5D,IAAI,IAAI,CAAC,sBAAsB,KAAK,IAAI,EAAE,CAAC;YACzC,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAC9B,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;YACnC,IAAI,IAAI,CAAC,wBAAwB,KAAK,IAAI,EAAE,CAAC;gBAC3C,YAAY,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;gBAC5C,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC;YACvC,CAAC;QACH,CAAC;QACD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;IAEO,mBAAmB,CAAC,KAAY;QACtC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QACD,IAAI,CAAC;YACH,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QAC9B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,YAAY,CAAC,KAAK,CAAC,yCAAyC,EAAE;gBAC5D,KAAK;aACN,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEO,OAAO,GAAG,GAAG,EAAE;QACrB,sEAAsE;QACtE,oEAAoE;QACpE,EAAE;QACF,uEAAuE;QACvE,sEAAsE;QACtE,wEAAwE;QACxE,0EAA0E;QAC1E,uEAAuE;QACvE,sEAAsE;QACtE,wEAAwE;QACxE,sEAAsE;QACtE,uEAAuE;QACvE,iEAAiE;QACjE,0EAA0E;QAC1E,OAAO,IAAI,EAAE,CAAC;YACZ,sEAAsE;YACtE,mEAAmE;YACnE,uEAAuE;YACvE,iCAAiC;YACjC,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC;YAC1D,IAAI,YAAY,KAAK,IAAI,IAAI,iBAAiB,CAAC,YAAY,CAAC,EAAE,CAAC;gBAC7D,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;gBAClC,SAAS;YACX,CAAC;YACD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC1C,IAAI,QAAQ,EAAE,CAAC;gBACb,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,CAAC;YACD,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;gBAC1B,mEAAmE;gBACnE,gEAAgE;gBAChE,mEAAmE;gBACnE,mEAAmE;gBACnE,kEAAkE;gBAClE,4BAA4B;gBAC5B,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACd,IAAI,CAAC,cAAc,EAAE,CAAC;gBACxB,CAAC;gBACD,OAAO;YACT,CAAC;YACD,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,qEAAqE;gBACrE,kEAAkE;gBAClE,uEAAuE;gBACvE,6DAA6D;gBAC7D,MAAM,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAC;gBAC3D,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;oBAC5B,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;oBACjD,SAAS;gBACX,CAAC;gBACD,IAAI,CAAC,uBAAuB,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;gBACjD,OAAO;YACT,CAAC;YACD,sEAAsE;QACxE,CAAC;IACH,CAAC,CAAC;IAEF;;;;OAIG;IACK,KAAK,CAAC,YAA0B;QACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YACnC,IAAI,OAAO,GAAG,mBAAmB,CAAC,WAAW,CAAC;YAC9C,IAAI,CAAC;gBACH,OAAO,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;YACnC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,YAAY,CAAC,KAAK,CAAC,uCAAuC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YACzE,CAAC;YACD,IACE,OAAO,KAAK,mBAAmB,CAAC,QAAQ;gBACxC,OAAO,KAAK,mBAAmB,CAAC,QAAQ,EACxC,CAAC;gBACD,SAAS;YACX,CAAC;YACD,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;gBAC1B,IACE,YAAY,CAAC,aAAa;oBAC1B,oBAAoB,CAAC,GAAG,CAAC,YAAY,CAAC,SAAS,CAAC,EAChD,CAAC;oBACD,IAAI,CAAC,QAAQ,CAAC,GAAG,CACf,aAAa,CAAC,YAAY,CAAC,SAAS,EAAE,YAAY,CAAC,aAAa,CAAC,CAClE,CAAC;gBACJ,CAAC;gBACD,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;gBACpC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;gBACjC,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;YACzC,CAAC;YACD,yCAAyC;YACzC,IAAI,OAAO,KAAK,mBAAmB,CAAC,QAAQ,EAAE,CAAC;gBAC7C,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAC9B,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;OAOG;IACK,WAAW;QACjB,IAAI,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;QACxC,OAAO,UAAU,EAAE,CAAC;YAClB,UAAU,GAAG,KAAK,CAAC;YACnB,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC;gBAClC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC;gBAC9B,IAAI,QAAiB,CAAC;gBACtB,IAAI,CAAC;oBACH,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACrC,CAAC;wBAAS,CAAC;oBACT,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;gBAC9B,CAAC;gBACD,IAAI,QAAQ,EAAE,CAAC;oBACb,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;oBACzB,kEAAkE;oBAClE,oDAAoD;oBACpD,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;oBACpC,MAAM;gBACR,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACK,oBAAoB;QAC1B,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACjD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;YACnC,MAAM,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;YACpD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;gBAC5B,SAAS;YACX,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACzB,qEAAqE;YACrE,yDAAyD;YACzD,YAAY,CAAC,KAAK,CAChB,kEAAkE,EAClE;gBACE,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,cAAc,EAAE,SAAS;gBACzB,aAAa,EAAE,KAAK,CAAC,aAAa;aACnC,CACF,CAAC;YACF,IAAI,CAAC;gBACH,IAAI,CAAC,gBAAgB,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;YAC5C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,YAAY,CAAC,KAAK,CAAC,0CAA0C,EAAE;oBAC7D,KAAK;iBACN,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,IAAI,CAAC,KAAY;QACvB,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/C,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IACE,KAAK,CAAC,aAAa;YACnB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,EACtE,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,YAAY,CAAC,KAAK,CAAC,8CAA8C,EAAE;YACjE,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;SAC3B,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;OAQG;IACK,aAAa,CAAC,KAAY;QAChC,MAAM,cAAc,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAClD,OAAO,cAAc,KAAK,SAAS;YACjC,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,GAAG,cAAc,CAAC,UAAU,IAAI,cAAc,CAAC,MAAM,EAAE,CAAC;IAC9D,CAAC;IAED;;;;OAIG;IACK,gBAAgB,CAAC,KAAY;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,GAAG,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACzD,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACK,qBAAqB,CAAC,KAAY;QACxC,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACtC,OAAO,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACxE,CAAC;IAED;;;;;;;;;;OAUG;IACK,cAAc,CAAC,KAAY;QACjC,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,YAAY,CAAC,KAAK,CAAC,gCAAgC,EAAE;YACnD,OAAO,EAAE,KAAK,CAAC,OAAO;SACvB,CAAC,CAAC;IACL,CAAC;IAED,iEAAiE;IACzD,kBAAkB,CAAC,KAAY,EAAE,SAA6B;QACpE,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,2EAA2E;QAC3E,0EAA0E;QAC1E,qEAAqE;QACrE,uEAAuE;QACvE,YAAY,CAAC,KAAK,CAChB,wDAAwD,EACxD;YACE,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,cAAc,EAAE,SAAS;YACzB,aAAa,EAAE,KAAK,CAAC,aAAa;SACnC,CACF,CAAC;QACF,IAAI,CAAC;YACH,IAAI,CAAC,gBAAgB,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC5C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,YAAY,CAAC,KAAK,CAAC,0CAA0C,EAAE;gBAC7D,KAAK;aACN,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEO,cAAc;QACpB,2EAA2E;QAC3E,qEAAqE;QACrE,yEAAyE;QACzE,yCAAyC;QACzC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC7B,OAAO;QACT,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAChC,IAAI,CAAC,IAAI,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YACvD,qEAAqE;YACrE,uEAAuE;YACvE,0EAA0E;YAC1E,sEAAsE;YACtE,sEAAsE;YACtE,sDAAsD;YACtD,YAAY,CAAC,KAAK,CAAC,iDAAiD,EAAE;gBACpE,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO;gBACrC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS;gBACzC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa;gBACjD,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;aAC3B,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QACD,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC5D,CAAC;IAEO,uBAAuB,CAAC,YAAmB,EAAE,OAAgB;QACnE,4DAA4D;QAC5D,wEAAwE;QACxE,qEAAqE;QACrE,qEAAqE;QACrE,uEAAuE;QACvE,wEAAwE;QACxE,MAAM,YAAY,GAAG,EAAE,IAAI,CAAC,sBAAsB,CAAC;QACnD,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,eAAe,EAAE;aACjD,IAAI;QACH,sEAAsE;QACtE,qEAAqE;QACrE,qEAAqE;QACrE,sDAAsD;QACtD,GAAG,EAAE,CAAC,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAC7D;aACA,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;aAClC,IAAI,CAAC,GAAG,EAAE;YACT,mEAAmE;YACnE,kEAAkE;YAClE,kEAAkE;YAClE,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,GAAG,EAAE;gBACvC,oEAAoE;gBACpE,+DAA+D;gBAC/D,8DAA8D;gBAC9D,qEAAqE;gBACrE,iEAAiE;gBACjE,+DAA+D;gBAC/D,mEAAmE;gBACnE,iDAAiD;gBACjD,IAAI,CAAC,wBAAwB,GAAG,UAAU,CAAC,GAAG,EAAE;oBAC9C,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC;oBACrC,IAAI,IAAI,CAAC,sBAAsB,KAAK,YAAY,EAAE,CAAC;wBACjD,OAAO;oBACT,CAAC;oBACD,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;oBACnC,IAAI,CAAC,sBAAsB,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;gBACrD,CAAC,EAAE,uBAAuB,EAAE,CAAC,CAAC;YAChC,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACK,sBAAsB,CAAC,YAAmB,EAAE,OAAgB;QAClE,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,YAAY,EAAE,CAAC;gBAClD,8DAA8D;gBAC9D,4DAA4D;gBAC5D,OAAO;YACT,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;gBAC5B,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,OAAO;YACT,CAAC;QACH,CAAC;QACD,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACK,gBAAgB,CAAC,YAAoB,EAAE,EAAc;QAC3D,MAAM,IAAI,GAAG,GAAG,EAAE;YAChB,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC;YACrC,IAAI,IAAI,CAAC,sBAAsB,KAAK,YAAY,EAAE,CAAC;gBACjD,OAAO;YACT,CAAC;YACD,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;gBAC1B,EAAE,EAAE,CAAC;gBACL,OAAO;YACT,CAAC;YACD,IAAI,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC/B,IAAI,IAAI,CAAC,sBAAsB,KAAK,YAAY,EAAE,CAAC;oBACjD,OAAO;gBACT,CAAC;gBACD,uEAAuE;gBACvE,yEAAyE;gBACzE,yEAAyE;gBACzE,sEAAsE;gBACtE,sEAAsE;gBACtE,yEAAyE;gBACzE,wEAAwE;gBACxE,UAAU;gBACV,IAAI,CAAC,wBAAwB,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;YACtD,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;QACF,IAAI,EAAE,CAAC;IACT,CAAC;CACF","sourcesContent":["import type { Event } from '@workflow/world';\nimport { envNumber } from '@workflow/world/env-config';\nimport {\n  classifyEntityEvent,\n  isSealedNoopEvent,\n} from '@workflow/world/event-metadata';\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 behavior.\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 *\n * Parking here is for an `attr_set` the walk reaches *before* the body has made\n * the call that claims it. A second event under an id already claimed is a\n * different thing: `attr_set` has an entity event class, so the duplicate skip\n * takes it before this set is consulted, and a copy that parked ahead of any\n * consumption is released by {@link dropParkedDuplicates} once one lands.\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 behavior, 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\n/** See {@link EventsConsumer.describe}. */\nexport interface EventsConsumerSnapshot {\n  index: number;\n  length: number;\n  parked: number;\n  lastConsumedEventId: string | undefined;\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   * The event a callback most recently claimed, for {@link describe}. Tracked\n   * separately from {@link eventIndex} because the walk also steps over events\n   * (parked, sealed no-ops, duplicates) without anyone consuming them, so\n   * `events[eventIndex - 1]` does not say what replay last acted on.\n   */\n  private lastConsumed: Event | undefined;\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  /**\n   * Where the walk stands, for a divergence message. Everything here is\n   * already known to the consumer; the point of the method is that the\n   * orchestrator can print it without reaching into private state.\n   *\n   * `index` is the ordered walk's position (the offset of the event it is\n   * stuck on, when it is stuck), `length` the log as this consumer holds it,\n   * `parked` how many events the walk stepped over and still holds, and\n   * `lastConsumedEventId` the id of the event a callback most recently\n   * claimed, `undefined` before the first claim.\n   */\n  describe(): EventsConsumerSnapshot {\n    return {\n      index: this.eventIndex,\n      length: this.events.length,\n      parked: this.parked.length,\n      lastConsumedEventId: this.lastConsumed?.eventId,\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      if (currentEvent !== null && isSealedNoopEvent(currentEvent)) {\n        this.skipSealedNoop(currentEvent);\n        continue;\n      }\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, so 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.lastConsumed = 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      this.dropParkedDuplicates();\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   * Release anything parked whose class a consumption has since recorded for\n   * the same entity, on the same terms as {@link skipDuplicateEvent}.\n   *\n   * The ordered walk decides a straggler at the event, but only for one of the\n   * two orders the copies can arrive in. When neither copy has a consumer yet,\n   * both park — the walk steps over the first and re-enters immediately, so\n   * the second is offered in the same tick, with no class recorded because\n   * nothing has been *consumed*. The drain then claims the first and the\n   * second is left held by a consumer list that will never grow the callback\n   * it needs, which the workflow function returning reports through\n   * {@link strandedEvent} as a replay divergence.\n   *\n   * Run before each offer pass rather than once, because the consumption that\n   * records the class happens inside the drain itself.\n   *\n   * Not specific to `attr_set`: `wait_completed` reaches the same state, and\n   * {@link ONE_SHOT_EVENT_TYPES} only covers it in the order where the\n   * consumption came first.\n   */\n  private dropParkedDuplicates(): void {\n    for (let i = this.parked.length - 1; i >= 0; i--) {\n      const event = this.parked[i].event;\n      const firstType = this.firstEventTypeOfClass(event);\n      if (firstType === undefined) {\n        continue;\n      }\n      this.parked.splice(i, 1);\n      // The walk index moved past this event when it was parked, so unlike\n      // `skipDuplicateEvent` there is nothing to advance here.\n      eventsLogger.debug(\n        'Releasing a parked 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\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 events\n   * that belong to no class and are therefore never skipped: the types with no\n   * entry at all (`hook_received`, `hook_conflict`, `run_created`), and a\n   * classed type carrying no entity to track it under.\n   *\n   * {@link classifyEntityEvent} owns that rule, because the observability UI\n   * decides the same question about the same log and the two must not drift.\n   */\n  private eventClassKey(event: Event): string | undefined {\n    const classification = classifyEntityEvent(event);\n    return classification === undefined\n      ? undefined\n      : `${classification.eventClass}:${classification.entity}`;\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  /**\n   * Steps the walk over a sealed-log `noop` (specVersion >= 7): the World's\n   * backend wrote it to occupy a slot whose writer allocated the position and\n   * died, so the log's density arithmetic holds. It is invisible to the\n   * workflow: no consumer is offered it, no event class is recorded, and the\n   * deterministic clock does not advance, exactly as with\n   * {@link skipDuplicateEvent}, so a log that happens to contain one produces the same\n   * timestamps as a log that does not. (Its `createdAt` is the seal time,\n   * which can even postdate later slots' events; letting it touch the clock\n   * would leak the sealer's wall clock into replay.)\n   */\n  private skipSealedNoop(event: Event) {\n    this.eventIndex++;\n    eventsLogger.debug('Skipping sealed-log noop event', {\n      eventId: event.eventId,\n    });\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. One that parks before any consumption records its class\n   * is released later by {@link dropParkedDuplicates} instead.\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 behavior 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"]}