@workflow/core 5.0.0-beta.44 → 5.0.0-beta.47

package/dist/events-consumer.js

@@ -1,4 +1,5 @@
-import { entityEventClass, envNumber, isSealedNoopEvent, } from '@workflow/world';
+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
@@ -68,6 +69,12 @@ const getDeferredCheckDelayMs = () => envNumber('WORKFLOW_DEFERRED_CHECK_DELAY_M
  * 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',
@@ -346,6 +353,7 @@ export class EventsConsumer {
         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;
@@ -367,6 +375,52 @@ export class EventsConsumer {
             }
         }
     }
+    /**
+     * 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
@@ -392,18 +446,19 @@ export class EventsConsumer {
         return true;
     }
     /**
-     * The key `event`'s class is tracked under, or `undefined` for the event
-     * types that belong to no class (`hook_received`, `hook_conflict`,
-     * `attr_set`, `run_created`) and are therefore never skipped.
+     * 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.
      *
-     * Run events carry no correlation id. They are classes of the run itself, so
-     * they all key off the same bucket.
+     * {@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 eventClass = entityEventClass(event.eventType);
-        return eventClass === undefined
+        const classification = classifyEntityEvent(event);
+        return classification === undefined
             ? undefined
-            : `${eventClass}:${event.correlationId}`;
+            : `${classification.eventClass}:${classification.entity}`;
     }
     /**
      * Remembers that `event`'s class is now decided for its entity, if the type
@@ -582,7 +637,8 @@ export class EventsConsumer {
      * 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.
+     * in-flight check. One that parks before any consumption records its class
+     * is released later by {@link dropParkedDuplicates} instead.
      */
     resolveUnconsumedEvent(currentEvent, mayPark) {
         if (mayPark) {
@@ -668,4 +724,4 @@ export class EventsConsumer {
         poll();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events-consumer.js","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type Event,\n  entityEventClass,\n  envNumber,\n  isSealedNoopEvent,\n} from '@workflow/world';\nimport { eventsLogger } from './logger.js';\n\n/**\n * Delay before firing the deferred unconsumed-event check after the promise\n * queue has drained. Must be long enough for cross-VM microtask chains to\n * propagate (resolve in host → workflow code in VM → subscribe call back\n * in host). Any subscribe() arriving during this window cancels the check.\n */\nexport const DEFERRED_CHECK_DELAY_MS = 100;\n\n/**\n * Floor for the deferred-check delay, so a too-low override can't manufacture\n * spurious divergence (each false positive burns a divergence-recovery retry\n * and can escalate to a terminal `CorruptedEventLogError`).\n *\n * Exported so tests needing the shortest legal delay can ask for it instead of\n * hardcoding a number this floor would silently clamp up.\n */\nexport const MIN_DEFERRED_CHECK_DELAY_MS = 10;\n\n/**\n * Effective deferred-check delay. Override: `WORKFLOW_DEFERRED_CHECK_DELAY_MS`.\n *\n * Unlike the other timing knobs this is not a polling interval but a\n * determinism safety margin: firing the unconsumed-event check before the\n * cross-VM subscribe() chain has landed rejects a healthy run with\n * `ReplayDivergenceError`.\n */\nconst getDeferredCheckDelayMs = (): number =>\n  envNumber('WORKFLOW_DEFERRED_CHECK_DELAY_MS', DEFERRED_CHECK_DELAY_MS, {\n    integer: true,\n    min: MIN_DEFERRED_CHECK_DELAY_MS,\n  });\n\n/**\n * Event types the ordered walk may step over and deliver later.\n *\n * Membership is not about who wrote the event. It is about whether the event\n * can reach the head of the walk with nothing registered to consume it, which\n * is the only situation parking exists for.\n *\n * Most types cannot. They are replay-origin: a replay emits them, in the order\n * its code reaches them, so their position in the log is the record of what\n * that replay decided. Reaching one of those out of order means this replay\n * decided differently than the log holds, which is divergence and nothing else.\n *\n * Step lifecycle events are not replay-origin, and are still absent, because\n * they always have a claimant. `step()` subscribes its consumer before the\n * step's first event can exist; `step_created` is ordered, so the walk cannot\n * pass it unless a consumer takes it; and that consumer stays subscribed until\n * `step_completed` or `step_failed`, after which the World refuses any further\n * write for that step. There is no window in which a replay knows about a step\n * and has nothing registered to consume its events, so parking them would only\n * defer reports of what is divergence either way. The same holds for\n * `wait_created` and its consumer. `wait_completed` is listed anyway: a sleep\n * can also be completed out of band, by the API that force-completes pending\n * waits, and tolerating a stray one is the cheaper direction to be wrong in.\n *\n * An allowlist rather than the complement of the ordered set, so a type this\n * file has not been taught about keeps the strict old 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 */\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\nexport class EventsConsumer {\n  eventIndex: number;\n  readonly events: Event[];\n  readonly callbacks: EventConsumerCallback[] = [];\n  /**\n   * Events the ordered walk stepped over because nobody claimed them and their\n   * type carries no ordering claim. Each keeps the index it held in the log:\n   * consumers read {@link eventIndex} at consumption time to order their\n   * delivery against the rest of the log, and a late delivery must still make\n   * the claim its position gave it.\n   *\n   * Held in log order, drained in log order, and drained before every offer so\n   * a consumer registered after the walk passed the event still receives it.\n   */\n  private readonly parked: { event: Event; index: number }[] = [];\n  /**\n   * Correlation ids of the {@link ONE_SHOT_EVENT_TYPES} events consumed so\n   * far, so a second resolution for one of them is recognized as unclaimable\n   * rather than parked for a consumer that cannot exist.\n   */\n  private readonly resolved = new Set<string>();\n  /**\n   * `<class>:<correlationId>` for every event class the walk has already\n   * consumed, mapped to the event type that recorded it. The type is kept so a\n   * repeat that decided the same class *differently* (a `step_failed` behind a\n   * `step_completed`) can be reported as more than a re-commit. See\n   * {@link EventsConsumer.firstEventTypeOfClass}.\n   */\n  private readonly seenEventClasses = new Map<string, Event['eventType']>();\n  private onConsumedEvent?: (event: Event) => void;\n  private onUnconsumedEvent: (event: Event) => void;\n  private onDuplicateEvent?: (\n    event: Event,\n    firstType: Event['eventType']\n  ) => void;\n  private getPromiseQueue: () => Promise<void>;\n  private isDeliveryIdle: () => boolean;\n  private pendingUnconsumedCheck: Promise<void> | null = null;\n  private pendingUnconsumedTimeout: ReturnType<typeof setTimeout> | null = null;\n  private unconsumedCheckVersion = 0;\n\n  constructor(events: Event[], options: EventsConsumerOptions) {\n    // Own copy: the runtime mutates its event array in place, and a retained\n    // session must only observe new events through append() so resume()'s\n    // strict-extension check stays meaningful.\n    this.events = [...events];\n    this.eventIndex = 0;\n    this.onConsumedEvent = options.onConsumedEvent;\n    this.onUnconsumedEvent = options.onUnconsumedEvent;\n    this.onDuplicateEvent = options.onDuplicateEvent;\n    this.getPromiseQueue = options.getPromiseQueue;\n    this.isDeliveryIdle = options.isDeliveryIdle;\n  }\n\n  /**\n   * The oldest event the walk stepped over that no consumer has claimed yet,\n   * if any. Parking is a bet that a consumer will be registered later, so at\n   * any point where no consumer ever will be again (the replay finishing is\n   * the definitive one), this answers which event the bet lost on.\n   */\n  get strandedEvent(): Event | undefined {\n    return this.parked[0]?.event;\n  }\n\n  /**\n   * What the walk is still holding, or `undefined` when it holds nothing.\n   *\n   * Read at every point a replay stops, including the suspensions that are not\n   * settling points, so the held state reaches telemetry. A replay cannot tell\n   * a delivery awaiting a later consumer from one no consumer will ever\n   * register, so it reports rather than decides: the same `eventId` reported on\n   * suspension after suspension of one run is the shape that says the bet\n   * parking made is not going to pay off, and that shape is only visible across\n   * replays.\n   */\n  get parkedSummary():\n    | { count: number; eventId: string; eventType: Event['eventType'] }\n    | undefined {\n    const oldest = this.parked[0]?.event;\n    if (!oldest) {\n      return undefined;\n    }\n    return {\n      count: this.parked.length,\n      eventId: oldest.eventId,\n      eventType: oldest.eventType,\n    };\n  }\n\n  append(events: Event[]): void {\n    for (const event of events) this.events.push(event);\n    process.nextTick(this.consume);\n  }\n\n  /**\n   * Registers a callback function to be called after an event has been consumed\n   * by a different callback. The callback can return:\n   *  - `EventConsumerResult.Consumed` the event is considered consumed and will not be passed to any other callback, but the callback will remain in the callbacks list\n   *  - `EventConsumerResult.NotConsumed` the event is passed to the next callback\n   *  - `EventConsumerResult.Finished` the event is considered consumed and the callback is removed from the callbacks list\n   *\n   * @param fn - The callback function to register.\n   */\n  subscribe(fn: EventConsumerCallback) {\n    this.callbacks.push(fn);\n    // Cancel any pending unconsumed check since a new callback may consume the event.\n    // Incrementing the version causes any in-flight promise chain check to no-op.\n    // Also clear the pending setTimeout if it hasn't fired yet.\n    if (this.pendingUnconsumedCheck !== null) {\n      this.unconsumedCheckVersion++;\n      this.pendingUnconsumedCheck = null;\n      if (this.pendingUnconsumedTimeout !== null) {\n        clearTimeout(this.pendingUnconsumedTimeout);\n        this.pendingUnconsumedTimeout = null;\n      }\n    }\n    process.nextTick(this.consume);\n  }\n\n  private notifyConsumedEvent(event: Event) {\n    if (!this.onConsumedEvent) {\n      return;\n    }\n    try {\n      this.onConsumedEvent(event);\n    } catch (error) {\n      eventsLogger.error('onConsumedEvent callback threw an error', {\n        error,\n      });\n    }\n  }\n\n  private consume = () => {\n    // Drain consecutively consumable events synchronously within a single\n    // pass instead of paying one `process.nextTick` per consumed event.\n    //\n    // Why this is safe: a callback only consumes an event using a consumer\n    // that is ALREADY registered (e.g. a long-lived step consumer walking\n    // `step_created` → `step_started` → `step_completed`, or the structural\n    // lifecycle consumer). New consumers are only ever registered by workflow\n    // VM body code that runs asynchronously off `ctx.promiseQueue` after a\n    // delivery `resolve()`; none of the callbacks here call `subscribe()`\n    // synchronously. So within one pass `this.callbacks` is mutated only by\n    // this loop (the `Finished` splice), and the next event's consumer is\n    // either already present (advance now) or not yet registered, in which\n    // case no callback consumes the event and we fall through to the\n    // cross-VM-safe deferred unconsumed-event check below, exactly as before.\n    while (true) {\n      // Before every offer, not just on subscribe: a callback registered by\n      // the work this same pass kicked off may be the owner of something\n      // parked, and the parked event's delivery is ordered ahead of the head\n      // event's by the index it holds.\n      this.drainParked();\n      const currentEvent = this.events[this.eventIndex] ?? null;\n      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.notifyConsumedEvent(currentEvent);\n      }\n      // remove the callback if it has finished\n      if (handled === EventConsumerResult.Finished) {\n        this.callbacks.splice(i, 1);\n      }\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Offer everything parked, oldest first, until a pass claims nothing.\n   *\n   * Each offer runs with {@link eventIndex} moved back to the position the\n   * parked event held in the log, because that is the position its consumer\n   * will register a delivery barrier under. Restoring the walk pointer\n   * afterwards is what keeps the two pointers from interfering.\n   */\n  private drainParked(): void {\n    let progressed = this.parked.length > 0;\n    while (progressed) {\n      progressed = false;\n      for (let i = 0; i < this.parked.length; i++) {\n        const entry = this.parked[i];\n        const walkIndex = this.eventIndex;\n        this.eventIndex = entry.index;\n        let consumed: boolean;\n        try {\n          consumed = this.offer(entry.event);\n        } finally {\n          this.eventIndex = walkIndex;\n        }\n        if (consumed) {\n          this.parked.splice(i, 1);\n          // A `Finished` callback was spliced out of the list this pass, so\n          // restart rather than keep walking a mutated array.\n          progressed = this.parked.length > 0;\n          break;\n        }\n      }\n    }\n  }\n\n  /**\n   * Step the ordered walk over an event nobody claimed, holding on to it for a\n   * later consumer. Returns false when the event's type makes its position a\n   * decision record, which is the one case where nobody claiming it means the\n   * replay diverged.\n   */\n  private park(event: Event): boolean {\n    if (!PARKABLE_EVENT_TYPES.has(event.eventType)) {\n      return false;\n    }\n    if (\n      event.correlationId &&\n      this.resolved.has(resolutionKey(event.eventType, event.correlationId))\n    ) {\n      return false;\n    }\n    this.parked.push({ event, index: this.eventIndex });\n    this.eventIndex++;\n    eventsLogger.debug('Parked an unclaimed event for later delivery', {\n      eventId: event.eventId,\n      eventType: event.eventType,\n      correlationId: event.correlationId,\n      parked: this.parked.length,\n    });\n    return true;\n  }\n\n  /**\n   * The key `event`'s class is tracked under, or `undefined` for the event\n   * types that belong to no class (`hook_received`, `hook_conflict`,\n   * `attr_set`, `run_created`) and are therefore never skipped.\n   *\n   * Run events carry no correlation id. They are classes of the run itself, so\n   * they all key off the same bucket.\n   */\n  private eventClassKey(event: Event): string | undefined {\n    const eventClass = entityEventClass(event.eventType);\n    return eventClass === undefined\n      ? undefined\n      : `${eventClass}:${event.correlationId}`;\n  }\n\n  /**\n   * Remembers that `event`'s class is now decided for its entity, if the type\n   * belongs to a class. First writer wins: the recorded type is the one the\n   * workflow observed, and a later repeat is measured against it.\n   */\n  private recordEventClass(event: Event) {\n    const key = this.eventClassKey(event);\n    if (key !== undefined && !this.seenEventClasses.has(key)) {\n      this.seenEventClasses.set(key, event.eventType);\n    }\n  }\n\n  /**\n   * The type that already decided `event`'s class for the same entity, or\n   * `undefined` when nothing has: a second `step_created` for one step, a\n   * second terminal outcome, a second `step_started` after the step's result is\n   * already in the log.\n   *\n   * Such an event is committed but inert. Concurrent replays write into one\n   * log without a currency guard, so a replay working from a prefix that\n   * predates another replay's write can commit its own copy of work the log\n   * already records. That copy cannot change what the workflow observed: the\n   * outcome was decided by the first event of the class and every later replay\n   * reads that same event at the same log position, so ignoring the straggler\n   * is deterministic across replays.\n   *\n   * Classes are tracked separately, so passing one does not suppress another.\n   * A step whose result is in the log still reaches its `step_created` and\n   * `step_started` consumers if it has yet to see those classes.\n   *\n   * Consulted only after every registered callback has declined the event, so\n   * it can never take an event a consumer wanted. A retry's `step_started` is\n   * claimed by the step's live consumer and counts as an attempt exactly as\n   * before, and a second `step_created` reaching a step that has not finished\n   * is likewise consumed rather than skipped; only the copies nobody claims are\n   * skipped.\n   *\n   * Unlike the divergence report, this does *not* wait out the deferred window\n   * first, and it does not need to. The window buys time for a consumer that\n   * has yet to register, and no such consumer can want this event: the class\n   * was recorded by a consumption in this same replay, which means the entity's\n   * consumer was registered and took an event of this class, and correlation\n   * ids are minted from a monotonic ULID per body position, so nothing later in\n   * the body registers a second consumer under this id. Waiting would cost\n   * `getDeferredCheckDelayMs()` per straggler per replay for information that\n   * cannot arrive: 0.75% of production runs carry at least one straggler, and\n   * the p99 among those carries 155.\n   *\n   * The invariant to preserve if hook identity ever becomes caller-supplied\n   * (an idempotency key rather than a minted id): two `createHook` calls in one\n   * body could then share a correlation id, and the second consumer's\n   * `hook_created` would be a repeat of a class this replay already recorded.\n   * That would make skipping wrong for `hook_created`, and is the reason the\n   * class map lives next to the event types rather than being inferred.\n   */\n  private firstEventTypeOfClass(event: Event): Event['eventType'] | undefined {\n    const key = this.eventClassKey(event);\n    return key === undefined ? undefined : this.seenEventClasses.get(key);\n  }\n\n  /**\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.\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"]}
+//# 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 { 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\nexport class EventsConsumer {\n  eventIndex: number;\n  readonly events: Event[];\n  readonly callbacks: EventConsumerCallback[] = [];\n  /**\n   * Events the ordered walk stepped over because nobody claimed them and their\n   * type carries no ordering claim. Each keeps the index it held in the log:\n   * consumers read {@link eventIndex} at consumption time to order their\n   * delivery against the rest of the log, and a late delivery must still make\n   * the claim its position gave it.\n   *\n   * Held in log order, drained in log order, and drained before every offer so\n   * a consumer registered after the walk passed the event still receives it.\n   */\n  private readonly parked: { event: Event; index: number }[] = [];\n  /**\n   * Correlation ids of the {@link ONE_SHOT_EVENT_TYPES} events consumed so\n   * far, so a second resolution for one of them is recognized as unclaimable\n   * rather than parked for a consumer that cannot exist.\n   */\n  private readonly resolved = new Set<string>();\n  /**\n   * `<class>:<correlationId>` for every event class the walk has already\n   * consumed, mapped to the event type that recorded it. The type is kept so a\n   * repeat that decided the same class *differently* (a `step_failed` behind a\n   * `step_completed`) can be reported as more than a re-commit. See\n   * {@link EventsConsumer.firstEventTypeOfClass}.\n   */\n  private readonly seenEventClasses = new Map<string, Event['eventType']>();\n  private onConsumedEvent?: (event: Event) => void;\n  private onUnconsumedEvent: (event: Event) => void;\n  private onDuplicateEvent?: (\n    event: Event,\n    firstType: Event['eventType']\n  ) => void;\n  private getPromiseQueue: () => Promise<void>;\n  private isDeliveryIdle: () => boolean;\n  private pendingUnconsumedCheck: Promise<void> | null = null;\n  private pendingUnconsumedTimeout: ReturnType<typeof setTimeout> | null = null;\n  private unconsumedCheckVersion = 0;\n\n  constructor(events: Event[], options: EventsConsumerOptions) {\n    // Own copy: the runtime mutates its event array in place, and a retained\n    // session must only observe new events through append() so resume()'s\n    // strict-extension check stays meaningful.\n    this.events = [...events];\n    this.eventIndex = 0;\n    this.onConsumedEvent = options.onConsumedEvent;\n    this.onUnconsumedEvent = options.onUnconsumedEvent;\n    this.onDuplicateEvent = options.onDuplicateEvent;\n    this.getPromiseQueue = options.getPromiseQueue;\n    this.isDeliveryIdle = options.isDeliveryIdle;\n  }\n\n  /**\n   * The oldest event the walk stepped over that no consumer has claimed yet,\n   * if any. Parking is a bet that a consumer will be registered later, so at\n   * any point where no consumer ever will be again (the replay finishing is\n   * the definitive one), this answers which event the bet lost on.\n   */\n  get strandedEvent(): Event | undefined {\n    return this.parked[0]?.event;\n  }\n\n  /**\n   * What the walk is still holding, or `undefined` when it holds nothing.\n   *\n   * Read at every point a replay stops, including the suspensions that are not\n   * settling points, so the held state reaches telemetry. A replay cannot tell\n   * a delivery awaiting a later consumer from one no consumer will ever\n   * register, so it reports rather than decides: the same `eventId` reported on\n   * suspension after suspension of one run is the shape that says the bet\n   * parking made is not going to pay off, and that shape is only visible across\n   * replays.\n   */\n  get parkedSummary():\n    | { count: number; eventId: string; eventType: Event['eventType'] }\n    | undefined {\n    const oldest = this.parked[0]?.event;\n    if (!oldest) {\n      return undefined;\n    }\n    return {\n      count: this.parked.length,\n      eventId: oldest.eventId,\n      eventType: oldest.eventType,\n    };\n  }\n\n  append(events: Event[]): void {\n    for (const event of events) this.events.push(event);\n    process.nextTick(this.consume);\n  }\n\n  /**\n   * Registers a callback function to be called after an event has been consumed\n   * by a different callback. The callback can return:\n   *  - `EventConsumerResult.Consumed` the event is considered consumed and will not be passed to any other callback, but the callback will remain in the callbacks list\n   *  - `EventConsumerResult.NotConsumed` the event is passed to the next callback\n   *  - `EventConsumerResult.Finished` the event is considered consumed and the callback is removed from the callbacks list\n   *\n   * @param fn - The callback function to register.\n   */\n  subscribe(fn: EventConsumerCallback) {\n    this.callbacks.push(fn);\n    // Cancel any pending unconsumed check since a new callback may consume the event.\n    // Incrementing the version causes any in-flight promise chain check to no-op.\n    // Also clear the pending setTimeout if it hasn't fired yet.\n    if (this.pendingUnconsumedCheck !== null) {\n      this.unconsumedCheckVersion++;\n      this.pendingUnconsumedCheck = null;\n      if (this.pendingUnconsumedTimeout !== null) {\n        clearTimeout(this.pendingUnconsumedTimeout);\n        this.pendingUnconsumedTimeout = null;\n      }\n    }\n    process.nextTick(this.consume);\n  }\n\n  private notifyConsumedEvent(event: Event) {\n    if (!this.onConsumedEvent) {\n      return;\n    }\n    try {\n      this.onConsumedEvent(event);\n    } catch (error) {\n      eventsLogger.error('onConsumedEvent callback threw an error', {\n        error,\n      });\n    }\n  }\n\n  private consume = () => {\n    // Drain consecutively consumable events synchronously within a single\n    // pass instead of paying one `process.nextTick` per consumed event.\n    //\n    // Why this is safe: a callback only consumes an event using a consumer\n    // that is ALREADY registered (e.g. a long-lived step consumer walking\n    // `step_created` → `step_started` → `step_completed`, or the structural\n    // lifecycle consumer). New consumers are only ever registered by workflow\n    // VM body code that runs asynchronously off `ctx.promiseQueue` after a\n    // delivery `resolve()`; none of the callbacks here call `subscribe()`\n    // synchronously. So within one pass `this.callbacks` is mutated only by\n    // this loop (the `Finished` splice), and the next event's consumer is\n    // either already present (advance now) or not yet registered, in which\n    // case no callback consumes the event and we fall through to the\n    // cross-VM-safe deferred unconsumed-event check below, exactly as before.\n    while (true) {\n      // Before every offer, not just on subscribe: a callback registered by\n      // the work this same pass kicked off may be the owner of something\n      // parked, and the parked event's delivery is ordered ahead of the head\n      // event's by the index it holds.\n      this.drainParked();\n      const currentEvent = this.events[this.eventIndex] ?? null;\n      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.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"]}

package/dist/flushable-stream.js

@@ -1,6 +1,6 @@
 import { WorkflowRuntimeError } from '@workflow/errors';
 import { withResolvers } from '@workflow/utils';
-import { envNumber } from '@workflow/world';
+import { envNumber } from '@workflow/world/env-config';
 import { STREAM_DRAIN_SYMBOL } from './symbols.js';
 /**
  * Flow-control knob: upper bound on chunks read-but-not-yet-durably-written
@@ -336,4 +336,4 @@ async function flushablePipePerChunk(source, sink, state) {
         writer.releaseLock();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flushable-stream.js","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { type PromiseWithResolvers, withResolvers } from '@workflow/utils';\nimport { envNumber } from '@workflow/world';\nimport { STREAM_DRAIN_SYMBOL } from './symbols.js';\n\n/**\n * A durability barrier a sink may expose under {@link STREAM_DRAIN_SYMBOL}:\n * resolves once every chunk the sink has accepted is durably written, rejects\n * if any server write failed. See `WorkflowServerWritableStream`.\n */\ntype DrainBarrier = () => Promise<void>;\n\n/**\n * Flow-control knob: upper bound on chunks read-but-not-yet-durably-written\n * while coalescing. Once this many chunks are outstanding the producer stops\n * reading until the consumer drains a batch, so a fast producer paired with a\n * slow server can't grow the in-memory queue without bound. Override:\n * `WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS`.\n *\n * This is deliberately distinct from the per-request batch caps below: this\n * bounds how much is *buffered*, those bound how much goes out in one\n * `writeMulti`. Raising this must never let a single request exceed a wire\n * limit, since batch sizing enforces that independently.\n */\nexport const MAX_INFLIGHT_CHUNKS = 1000;\n\nexport const getMaxInflightChunks = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS', MAX_INFLIGHT_CHUNKS, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Wire limit: maximum number of chunks in a single coalesced `writeMulti`.\n * The server enforces a per-multi-write chunk cap (1,000 today); a batch is\n * split at this bound so it can never be rejected wholesale, independently of\n * the backpressure knob above. Override: `WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH`.\n */\nexport const MAX_CHUNKS_PER_BATCH = 1000;\n\nexport const getMaxChunksPerBatch = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH', MAX_CHUNKS_PER_BATCH, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Wire limit: maximum cumulative bytes in a single coalesced `writeMulti`.\n * Chunk *count* alone is not enough: 1,000 small chunks are ~100KB but 1,000\n * file-sized chunks can be hundreds of MB, which platform request-body limits\n * reject long before the count cap matters. A batch is split once adding the\n * next chunk would exceed this (a single chunk larger than the cap still goes\n * out alone). Default 1 MiB. Override: `WORKFLOW_STREAM_MAX_BYTES_PER_BATCH`.\n */\nexport const MAX_BYTES_PER_BATCH = 1024 * 1024;\n\nexport const getMaxBytesPerBatch = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_BYTES_PER_BATCH', MAX_BYTES_PER_BATCH, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Buffer bound (bytes) for the server writable's group-commit buffer, the\n * byte-denominated counterpart of {@link MAX_INFLIGHT_CHUNKS}. `write()`\n * blocks once this much data is buffered-but-not-durable, so a fast producer\n * of large chunks can't grow client memory without bound. Default 8 MiB\n * (eight request-sized groups). Override: `WORKFLOW_STREAM_MAX_BUFFERED_BYTES`.\n */\nexport const MAX_BUFFERED_BYTES = 8 * 1024 * 1024;\n\nexport const getMaxBufferedBytes = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_BUFFERED_BYTES', MAX_BUFFERED_BYTES, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Polling interval (in ms) for lock release detection.\n *\n * The Web Streams API does not expose an event for \"lock released but stream\n * still open\"; we can only distinguish that state by periodically attempting\n * to acquire a reader/writer. For that reason we use polling instead of a\n * fully event-driven approach here.\n *\n * 10ms is chosen so the polling tick almost never sits on the critical path:\n * the V2 step-executor's `opsSettled` race waits for this state to resolve\n * after each step body returns, so a coarser interval (the previous 100ms)\n * adds visible per-step latency to streaming workflows. With a uniformly\n * distributed offset between step return and the next tick, the expected\n * wait is half the interval, so 10ms means ~5ms average wait per step\n * instead of ~50ms. The per-tick work is `writable.locked` plus a\n * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more\n * ticks during a stream's lifetime is not measurable in practice.\n */\nexport const LOCK_POLL_INTERVAL_MS = 10;\n\n/** Effective lock-poll interval. Override: `WORKFLOW_LOCK_POLL_INTERVAL_MS`. */\nconst getLockPollIntervalMs = (): number =>\n  envNumber('WORKFLOW_LOCK_POLL_INTERVAL_MS', LOCK_POLL_INTERVAL_MS, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * State tracker for flushable stream operations.\n * Resolves when either:\n * 1. Stream completes (close/error), OR\n * 2. Lock is released AND all pending operations are flushed\n *\n * Note: `doneResolved` and `streamEnded` are separate:\n * - `doneResolved`: The `done` promise has been resolved (step can complete)\n * - `streamEnded`: The underlying stream has actually closed/errored\n *\n * Once `doneResolved` is set to true, the `done` promise will not resolve\n * again. Re-acquiring locks after release is not supported as a way to\n * trigger additional completion signaling.\n */\nexport interface FlushableStreamState extends PromiseWithResolvers<void> {\n  /** Number of write operations currently in flight to the server */\n  pendingOps: number;\n  /** Whether the `done` promise has been resolved */\n  doneResolved: boolean;\n  /** Whether the underlying stream has actually closed/errored */\n  streamEnded: boolean;\n  /** Interval ID for writable lock polling (if active) */\n  writablePollingInterval?: ReturnType<typeof setInterval>;\n  /** Interval ID for readable lock polling (if active) */\n  readablePollingInterval?: ReturnType<typeof setInterval>;\n  /**\n   * Durability barrier of the pipe's sink, when it acks writes on buffer\n   * entry (see {@link STREAM_DRAIN_SYMBOL}). Lock-release completion awaits\n   * this before resolving so `pendingOps === 0` (fast, buffered acks) can't\n   * complete a step while data is still client-side.\n   */\n  drainBarrier?: DrainBarrier;\n}\n\nexport function createFlushableState(): FlushableStreamState {\n  const state: FlushableStreamState = {\n    ...withResolvers<void>(),\n    pendingOps: 0,\n    doneResolved: false,\n    streamEnded: false,\n  };\n\n  // The runtime awaits this promise after user code returns. Observe early\n  // stream failures now so they do not become unhandled rejections first.\n  state.promise.catch(() => {});\n\n  return state;\n}\n\n/**\n * Checks if a WritableStream is unlocked (user released lock) vs closed.\n * When a stream is closed, .locked is false but getWriter() throws.\n * We only want to resolve via polling when the stream is unlocked, not closed.\n * If closed, the pump will handle resolution via the stream ending naturally.\n */\nfunction isWritableUnlockedNotClosed(writable: WritableStream): boolean {\n  if (writable.locked) return false;\n\n  let writer: WritableStreamDefaultWriter | undefined;\n  try {\n    // Try to acquire writer - if successful, stream is unlocked (not closed)\n    writer = writable.getWriter();\n  } catch {\n    // getWriter() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    writer.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Checks if a ReadableStream is unlocked (user released lock) vs closed.\n */\nfunction isReadableUnlockedNotClosed(readable: ReadableStream): boolean {\n  if (readable.locked) return false;\n\n  let reader: ReadableStreamDefaultReader | undefined;\n  try {\n    // Try to acquire reader - if successful, stream is unlocked (not closed)\n    reader = readable.getReader();\n  } catch {\n    // getReader() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    reader.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Settle the flushable completion after the sink's durability barrier.\n *\n * Lock release means the producer is done *writing*; with a group-commit\n * sink, accepted chunks may still be client-buffered or in a request that is\n * in flight. Awaiting the barrier here keeps the completion's meaning\n * (\"everything written so far is durable\") identical to the pre-batching\n * behavior where each write() was individually durable.\n */\nfunction resolveAfterDrain(state: FlushableStreamState): void {\n  const barrier = state.drainBarrier;\n  if (!barrier) {\n    state.resolve();\n    return;\n  }\n  barrier().then(\n    () => state.resolve(),\n    (err) => state.reject(err)\n  );\n}\n\n/**\n * Polls a WritableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollWritableLock(\n  writable: WritableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.writablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      resolveAfterDrain(state);\n    }\n  }, getLockPollIntervalMs());\n\n  state.writablePollingInterval = intervalId;\n}\n\n/**\n * Polls a ReadableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollReadableLock(\n  readable: ReadableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.readablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      resolveAfterDrain(state);\n    }\n  }, getLockPollIntervalMs());\n\n  state.readablePollingInterval = intervalId;\n}\n\n/**\n * Creates a flushable pipe from a ReadableStream to a WritableStream.\n * Unlike pipeTo(), this resolves when:\n * 1. The source stream completes (close/error), OR\n * 2. The user releases their lock on userStream AND all pending writes are flushed\n *\n * @param source - The readable stream to read from (e.g., transform's readable)\n * @param sink - The writable stream to write to (e.g., server writable)\n * @param state - The flushable state tracker\n * @returns Promise that resolves when stream ends (not when done promise resolves)\n */\nexport function flushablePipe(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  // Batching lives in the sink (`WorkflowServerWritableStream` group-commits\n  // its buffer), so this pipe is a plain per-chunk pump regardless of path:\n  // its only responsibilities are lock-release completion and durability\n  // tracking. Group-commit sinks ack write() on buffer entry; adopt their\n  // durability barrier so the lock-release completion still means\n  // \"everything written is durable\" (see resolveAfterDrain).\n  const drain = (sink as { [STREAM_DRAIN_SYMBOL]?: DrainBarrier })[\n    STREAM_DRAIN_SYMBOL\n  ];\n  if (typeof drain === 'function') {\n    state.drainBarrier = drain;\n  }\n  return flushablePipePerChunk(source, sink, state);\n}\n\n/**\n * The pump behind {@link flushablePipe}: awaits each `writer.write()` before\n * reading the next chunk. Against a group-commit sink, write() acks on buffer\n * entry, so this loop feeds the sink as fast as the producer emits (bounded\n * by the sink's buffer bound) and batching happens inside the sink; against a\n * plain sink each write is individually durable, as before. The source-done\n * path closes the sink, which drains it, so completion always implies\n * durability.\n */\nasync function flushablePipePerChunk(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  const reader = source.getReader();\n  const writer = sink.getWriter();\n  let cancelReason: unknown;\n\n  try {\n    while (true) {\n      // Check if stream has ended\n      if (state.streamEnded) {\n        return;\n      }\n\n      // Read from the source. Don't count this as a pending operation because\n      // reads wait for data. The important operations are writes to the sink.\n      const readResult = await Promise.race([\n        reader.read(),\n        writer.closed.then(() => {\n          throw new WorkflowRuntimeError('Writable stream closed prematurely');\n        }),\n      ]);\n\n      // Check if stream has ended (e.g., due to error in another path) before processing\n      if (state.streamEnded) {\n        return;\n      }\n\n      if (readResult.done) {\n        // Source stream completed - close sink and resolve\n        state.streamEnded = true;\n        await writer.close();\n        // Resolve done promise if not already resolved\n        if (!state.doneResolved) {\n          state.doneResolved = true;\n          state.resolve();\n        }\n        return;\n      }\n\n      // Count write as a pending op - this is what we need to flush\n      state.pendingOps++;\n      try {\n        await writer.write(readResult.value);\n      } finally {\n        state.pendingOps--;\n      }\n    }\n  } catch (err) {\n    state.streamEnded = true;\n    cancelReason = err;\n    // Against an early-ack sink, chunks can still be buffered or in flight\n    // when the pipe fails (pendingOps only counts un-acked writes). Deliver\n    // that accepted prefix before settling the failure: once the state\n    // rejects, the step may persist its failure and the invocation finish,\n    // and anything still client-side would be lost. The original pipe error\n    // stays primary, since a drain failure is already sticky on the sink.\n    if (state.drainBarrier) {\n      await state.drainBarrier().catch(() => {});\n    }\n    if (!state.doneResolved) {\n      state.doneResolved = true;\n      state.reject(err);\n    }\n    // Propagate error through flushablePipe's own promise as well.\n    // Callers that rely on the FlushableStreamState should use `state.promise`,\n    // while other callers may depend on this rejection. Some known callers\n    // explicitly ignore this rejection (`.catch(() => {})`) and rely solely\n    // on `state.reject(err)` for error handling.\n    throw err;\n  } finally {\n    // Cancel the upstream reader so the source knows to stop generating data.\n    // Uses cancelReason (set in the catch block) so the source receives context\n    // about why it was canceled. On normal completion cancelReason is undefined,\n    // which is a harmless no-op on an already-done reader.\n    reader.cancel(cancelReason).catch(() => {});\n    reader.releaseLock();\n    writer.releaseLock();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flushable-stream.js","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { type PromiseWithResolvers, withResolvers } from '@workflow/utils';\nimport { envNumber } from '@workflow/world/env-config';\nimport { STREAM_DRAIN_SYMBOL } from './symbols.js';\n\n/**\n * A durability barrier a sink may expose under {@link STREAM_DRAIN_SYMBOL}:\n * resolves once every chunk the sink has accepted is durably written, rejects\n * if any server write failed. See `WorkflowServerWritableStream`.\n */\ntype DrainBarrier = () => Promise<void>;\n\n/**\n * Flow-control knob: upper bound on chunks read-but-not-yet-durably-written\n * while coalescing. Once this many chunks are outstanding the producer stops\n * reading until the consumer drains a batch, so a fast producer paired with a\n * slow server can't grow the in-memory queue without bound. Override:\n * `WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS`.\n *\n * This is deliberately distinct from the per-request batch caps below: this\n * bounds how much is *buffered*, those bound how much goes out in one\n * `writeMulti`. Raising this must never let a single request exceed a wire\n * limit, since batch sizing enforces that independently.\n */\nexport const MAX_INFLIGHT_CHUNKS = 1000;\n\nexport const getMaxInflightChunks = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS', MAX_INFLIGHT_CHUNKS, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Wire limit: maximum number of chunks in a single coalesced `writeMulti`.\n * The server enforces a per-multi-write chunk cap (1,000 today); a batch is\n * split at this bound so it can never be rejected wholesale, independently of\n * the backpressure knob above. Override: `WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH`.\n */\nexport const MAX_CHUNKS_PER_BATCH = 1000;\n\nexport const getMaxChunksPerBatch = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH', MAX_CHUNKS_PER_BATCH, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Wire limit: maximum cumulative bytes in a single coalesced `writeMulti`.\n * Chunk *count* alone is not enough: 1,000 small chunks are ~100KB but 1,000\n * file-sized chunks can be hundreds of MB, which platform request-body limits\n * reject long before the count cap matters. A batch is split once adding the\n * next chunk would exceed this (a single chunk larger than the cap still goes\n * out alone). Default 1 MiB. Override: `WORKFLOW_STREAM_MAX_BYTES_PER_BATCH`.\n */\nexport const MAX_BYTES_PER_BATCH = 1024 * 1024;\n\nexport const getMaxBytesPerBatch = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_BYTES_PER_BATCH', MAX_BYTES_PER_BATCH, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Buffer bound (bytes) for the server writable's group-commit buffer, the\n * byte-denominated counterpart of {@link MAX_INFLIGHT_CHUNKS}. `write()`\n * blocks once this much data is buffered-but-not-durable, so a fast producer\n * of large chunks can't grow client memory without bound. Default 8 MiB\n * (eight request-sized groups). Override: `WORKFLOW_STREAM_MAX_BUFFERED_BYTES`.\n */\nexport const MAX_BUFFERED_BYTES = 8 * 1024 * 1024;\n\nexport const getMaxBufferedBytes = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_BUFFERED_BYTES', MAX_BUFFERED_BYTES, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Polling interval (in ms) for lock release detection.\n *\n * The Web Streams API does not expose an event for \"lock released but stream\n * still open\"; we can only distinguish that state by periodically attempting\n * to acquire a reader/writer. For that reason we use polling instead of a\n * fully event-driven approach here.\n *\n * 10ms is chosen so the polling tick almost never sits on the critical path:\n * the V2 step-executor's `opsSettled` race waits for this state to resolve\n * after each step body returns, so a coarser interval (the previous 100ms)\n * adds visible per-step latency to streaming workflows. With a uniformly\n * distributed offset between step return and the next tick, the expected\n * wait is half the interval, so 10ms means ~5ms average wait per step\n * instead of ~50ms. The per-tick work is `writable.locked` plus a\n * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more\n * ticks during a stream's lifetime is not measurable in practice.\n */\nexport const LOCK_POLL_INTERVAL_MS = 10;\n\n/** Effective lock-poll interval. Override: `WORKFLOW_LOCK_POLL_INTERVAL_MS`. */\nconst getLockPollIntervalMs = (): number =>\n  envNumber('WORKFLOW_LOCK_POLL_INTERVAL_MS', LOCK_POLL_INTERVAL_MS, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * State tracker for flushable stream operations.\n * Resolves when either:\n * 1. Stream completes (close/error), OR\n * 2. Lock is released AND all pending operations are flushed\n *\n * Note: `doneResolved` and `streamEnded` are separate:\n * - `doneResolved`: The `done` promise has been resolved (step can complete)\n * - `streamEnded`: The underlying stream has actually closed/errored\n *\n * Once `doneResolved` is set to true, the `done` promise will not resolve\n * again. Re-acquiring locks after release is not supported as a way to\n * trigger additional completion signaling.\n */\nexport interface FlushableStreamState extends PromiseWithResolvers<void> {\n  /** Number of write operations currently in flight to the server */\n  pendingOps: number;\n  /** Whether the `done` promise has been resolved */\n  doneResolved: boolean;\n  /** Whether the underlying stream has actually closed/errored */\n  streamEnded: boolean;\n  /** Interval ID for writable lock polling (if active) */\n  writablePollingInterval?: ReturnType<typeof setInterval>;\n  /** Interval ID for readable lock polling (if active) */\n  readablePollingInterval?: ReturnType<typeof setInterval>;\n  /**\n   * Durability barrier of the pipe's sink, when it acks writes on buffer\n   * entry (see {@link STREAM_DRAIN_SYMBOL}). Lock-release completion awaits\n   * this before resolving so `pendingOps === 0` (fast, buffered acks) can't\n   * complete a step while data is still client-side.\n   */\n  drainBarrier?: DrainBarrier;\n}\n\nexport function createFlushableState(): FlushableStreamState {\n  const state: FlushableStreamState = {\n    ...withResolvers<void>(),\n    pendingOps: 0,\n    doneResolved: false,\n    streamEnded: false,\n  };\n\n  // The runtime awaits this promise after user code returns. Observe early\n  // stream failures now so they do not become unhandled rejections first.\n  state.promise.catch(() => {});\n\n  return state;\n}\n\n/**\n * Checks if a WritableStream is unlocked (user released lock) vs closed.\n * When a stream is closed, .locked is false but getWriter() throws.\n * We only want to resolve via polling when the stream is unlocked, not closed.\n * If closed, the pump will handle resolution via the stream ending naturally.\n */\nfunction isWritableUnlockedNotClosed(writable: WritableStream): boolean {\n  if (writable.locked) return false;\n\n  let writer: WritableStreamDefaultWriter | undefined;\n  try {\n    // Try to acquire writer - if successful, stream is unlocked (not closed)\n    writer = writable.getWriter();\n  } catch {\n    // getWriter() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    writer.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Checks if a ReadableStream is unlocked (user released lock) vs closed.\n */\nfunction isReadableUnlockedNotClosed(readable: ReadableStream): boolean {\n  if (readable.locked) return false;\n\n  let reader: ReadableStreamDefaultReader | undefined;\n  try {\n    // Try to acquire reader - if successful, stream is unlocked (not closed)\n    reader = readable.getReader();\n  } catch {\n    // getReader() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    reader.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Settle the flushable completion after the sink's durability barrier.\n *\n * Lock release means the producer is done *writing*; with a group-commit\n * sink, accepted chunks may still be client-buffered or in a request that is\n * in flight. Awaiting the barrier here keeps the completion's meaning\n * (\"everything written so far is durable\") identical to the pre-batching\n * behavior where each write() was individually durable.\n */\nfunction resolveAfterDrain(state: FlushableStreamState): void {\n  const barrier = state.drainBarrier;\n  if (!barrier) {\n    state.resolve();\n    return;\n  }\n  barrier().then(\n    () => state.resolve(),\n    (err) => state.reject(err)\n  );\n}\n\n/**\n * Polls a WritableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollWritableLock(\n  writable: WritableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.writablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      resolveAfterDrain(state);\n    }\n  }, getLockPollIntervalMs());\n\n  state.writablePollingInterval = intervalId;\n}\n\n/**\n * Polls a ReadableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollReadableLock(\n  readable: ReadableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.readablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      resolveAfterDrain(state);\n    }\n  }, getLockPollIntervalMs());\n\n  state.readablePollingInterval = intervalId;\n}\n\n/**\n * Creates a flushable pipe from a ReadableStream to a WritableStream.\n * Unlike pipeTo(), this resolves when:\n * 1. The source stream completes (close/error), OR\n * 2. The user releases their lock on userStream AND all pending writes are flushed\n *\n * @param source - The readable stream to read from (e.g., transform's readable)\n * @param sink - The writable stream to write to (e.g., server writable)\n * @param state - The flushable state tracker\n * @returns Promise that resolves when stream ends (not when done promise resolves)\n */\nexport function flushablePipe(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  // Batching lives in the sink (`WorkflowServerWritableStream` group-commits\n  // its buffer), so this pipe is a plain per-chunk pump regardless of path:\n  // its only responsibilities are lock-release completion and durability\n  // tracking. Group-commit sinks ack write() on buffer entry; adopt their\n  // durability barrier so the lock-release completion still means\n  // \"everything written is durable\" (see resolveAfterDrain).\n  const drain = (sink as { [STREAM_DRAIN_SYMBOL]?: DrainBarrier })[\n    STREAM_DRAIN_SYMBOL\n  ];\n  if (typeof drain === 'function') {\n    state.drainBarrier = drain;\n  }\n  return flushablePipePerChunk(source, sink, state);\n}\n\n/**\n * The pump behind {@link flushablePipe}: awaits each `writer.write()` before\n * reading the next chunk. Against a group-commit sink, write() acks on buffer\n * entry, so this loop feeds the sink as fast as the producer emits (bounded\n * by the sink's buffer bound) and batching happens inside the sink; against a\n * plain sink each write is individually durable, as before. The source-done\n * path closes the sink, which drains it, so completion always implies\n * durability.\n */\nasync function flushablePipePerChunk(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  const reader = source.getReader();\n  const writer = sink.getWriter();\n  let cancelReason: unknown;\n\n  try {\n    while (true) {\n      // Check if stream has ended\n      if (state.streamEnded) {\n        return;\n      }\n\n      // Read from the source. Don't count this as a pending operation because\n      // reads wait for data. The important operations are writes to the sink.\n      const readResult = await Promise.race([\n        reader.read(),\n        writer.closed.then(() => {\n          throw new WorkflowRuntimeError('Writable stream closed prematurely');\n        }),\n      ]);\n\n      // Check if stream has ended (e.g., due to error in another path) before processing\n      if (state.streamEnded) {\n        return;\n      }\n\n      if (readResult.done) {\n        // Source stream completed - close sink and resolve\n        state.streamEnded = true;\n        await writer.close();\n        // Resolve done promise if not already resolved\n        if (!state.doneResolved) {\n          state.doneResolved = true;\n          state.resolve();\n        }\n        return;\n      }\n\n      // Count write as a pending op - this is what we need to flush\n      state.pendingOps++;\n      try {\n        await writer.write(readResult.value);\n      } finally {\n        state.pendingOps--;\n      }\n    }\n  } catch (err) {\n    state.streamEnded = true;\n    cancelReason = err;\n    // Against an early-ack sink, chunks can still be buffered or in flight\n    // when the pipe fails (pendingOps only counts un-acked writes). Deliver\n    // that accepted prefix before settling the failure: once the state\n    // rejects, the step may persist its failure and the invocation finish,\n    // and anything still client-side would be lost. The original pipe error\n    // stays primary, since a drain failure is already sticky on the sink.\n    if (state.drainBarrier) {\n      await state.drainBarrier().catch(() => {});\n    }\n    if (!state.doneResolved) {\n      state.doneResolved = true;\n      state.reject(err);\n    }\n    // Propagate error through flushablePipe's own promise as well.\n    // Callers that rely on the FlushableStreamState should use `state.promise`,\n    // while other callers may depend on this rejection. Some known callers\n    // explicitly ignore this rejection (`.catch(() => {})`) and rely solely\n    // on `state.reject(err)` for error handling.\n    throw err;\n  } finally {\n    // Cancel the upstream reader so the source knows to stop generating data.\n    // Uses cancelReason (set in the catch block) so the source receives context\n    // about why it was canceled. On normal completion cancelReason is undefined,\n    // which is a harmless no-op on an already-done reader.\n    reader.cancel(cancelReason).catch(() => {});\n    reader.releaseLock();\n    writer.releaseLock();\n  }\n}\n"]}

package/dist/global.d.ts

@@ -65,6 +65,8 @@ export type QueueItem = StepInvocationQueueItem | HookInvocationQueueItem | Wait
  * onto the queue.
  */
 export declare class WorkflowSuspension extends Error {
+    items: QueueItem[];
+    /** @deprecated Use `items` instead. */
     steps: QueueItem[];
     globalThis: typeof globalThis;
     stepCount: number;
@@ -73,7 +75,7 @@ export declare class WorkflowSuspension extends Error {
     attributeCount: number;
     hookDisposedCount: number;
     abortCount: number;
-    constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis);
+    constructor(itemsInput: Map<string, QueueItem>, global: typeof globalThis);
     static is(value: unknown): value is WorkflowSuspension;
 }
 export declare function ENOTSUP(): never;

package/dist/global.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,mBAAmB,CAAC,EAAE,IAAI,CAAC;IAC3B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,0EAA0E;IAC1E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,IAAI,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,WAAW,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,uBAAuB,CAAC,EAAE,IAAI,CAAC;CAChC;AAED,MAAM,MAAM,SAAS,GACjB,uBAAuB,GACvB,uBAAuB,GACvB,uBAAuB,GACvB,4BAA4B,CAAC;AAEjC;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;gBAEP,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,UAAU;IAuFzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB;CAGvD;AAED,wBAAgB,OAAO,IAAI,KAAK,CAI/B"}
+{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,mBAAmB,CAAC,EAAE,IAAI,CAAC;IAC3B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,0EAA0E;IAC1E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,IAAI,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,WAAW,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,uBAAuB,CAAC,EAAE,IAAI,CAAC;CAChC;AAED,MAAM,MAAM,SAAS,GACjB,uBAAuB,GACvB,uBAAuB,GACvB,uBAAuB,GACvB,4BAA4B,CAAC;AAEjC;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,uCAAuC;IACvC,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;gBAEP,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,UAAU;IAwFzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB;CAGvD;AAED,wBAAgB,OAAO,IAAI,KAAK,CAI/B"}