@workflow/world-testing 4.1.15 → 4.1.17

package/dist/.well-known/workflow/v1/flow.js

@@ -50439,7 +50439,7 @@ init_dist();
 init_node();
 
 // ../core/dist/version.js
-var version2 = "4.8.0";
+var version2 = "4.8.2";
 
 // ../core/dist/runtime/world.js
 var import_node_module = require("node:module");
@@ -53391,7 +53391,6 @@ init_zod();
 // ../world-vercel/dist/http-client.js
 var import_undici2 = __toESM(require_undici(), 1);
 var _dispatcher;
-var _eventsDispatcher;
 var _streamDispatcher;
 var _streamCloseDispatcher;
 var DEFAULT_HEADERS_TIMEOUT_MS = 3e4;
@@ -53450,6 +53449,14 @@ function getEventsAgentOptions() {
   };
 }
 __name(getEventsAgentOptions, "getEventsAgentOptions");
+function getEventsAgentOptionsNoH2() {
+  return {
+    ...getBaseAgentOptions(),
+    allowH2: false,
+    pipelining: 1
+  };
+}
+__name(getEventsAgentOptionsNoH2, "getEventsAgentOptionsNoH2");
 function getStreamAgentOptions() {
   return {
     ...getBaseAgentOptions(),
@@ -53488,10 +53495,10 @@ var STREAM_CLOSE_RETRY_OPTIONS = {
   statusCodes: [429, 500, 502, 503, 504]
 };
 var H2_REBUFFER_MAX_BYTES = 1 << 20;
-function h2MultiplexEnabled() {
+function h2EventsEnabled() {
   return process.env.WORKFLOW_H2_MULTIPLEX !== "0";
 }
-__name(h2MultiplexEnabled, "h2MultiplexEnabled");
+__name(h2EventsEnabled, "h2EventsEnabled");
 function contentLength(headers) {
   if (!headers || typeof headers !== "object" || Array.isArray(headers)) {
     return Number.NaN;
@@ -53524,12 +53531,86 @@ function h2MultiplexInterceptor(dispatch) {
   };
 }
 __name(h2MultiplexInterceptor, "h2MultiplexInterceptor");
+var EVENTS_RECYCLE_AFTER_CONSECUTIVE_FAILURES = 3;
+var RECYCLE_MIN_INTERVAL_MS = 5e3;
+var RETIRED_CLOSE_DELAY_MS = 5e3;
+var RETIRED_DESTROY_DELAY_MS = 6e4;
+var RECYCLABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  // Covers H2 stream timeout, frameError and GOAWAY (undici InformationalError).
+  "UND_ERR_INFO",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT"
+]);
+var MAX_CAUSE_DEPTH = 8;
+function isRecyclableTransportError(error48) {
+  let current = error48;
+  for (let depth = 0; current && depth < MAX_CAUSE_DEPTH; depth++) {
+    const code = current.code;
+    if (typeof code === "string" && RECYCLABLE_ERROR_CODES.has(code)) {
+      return true;
+    }
+    current = current.cause;
+  }
+  return false;
+}
+__name(isRecyclableTransportError, "isRecyclableTransportError");
+function createDispatcherRecycler(factory, label) {
+  let current;
+  let consecutiveFailures = 0;
+  let lastRecycledAt = 0;
+  function retire(stale) {
+    const closeTimer = setTimeout(() => {
+      void Promise.resolve(stale.close?.()).catch(() => void 0);
+    }, RETIRED_CLOSE_DELAY_MS);
+    const destroyTimer = setTimeout(() => {
+      void Promise.resolve(stale.destroy?.()).catch(() => void 0);
+    }, RETIRED_DESTROY_DELAY_MS);
+    closeTimer.unref?.();
+    destroyTimer.unref?.();
+  }
+  __name(retire, "retire");
+  return {
+    get() {
+      current ??= factory();
+      return current;
+    },
+    note(dispatcher, error48) {
+      if (!current || dispatcher !== current)
+        return;
+      if (error48 === void 0) {
+        consecutiveFailures = 0;
+        return;
+      }
+      if (!isRecyclableTransportError(error48))
+        return;
+      consecutiveFailures++;
+      if (consecutiveFailures < EVENTS_RECYCLE_AFTER_CONSECUTIVE_FAILURES) {
+        return;
+      }
+      const now = Date.now();
+      if (now - lastRecycledAt < RECYCLE_MIN_INTERVAL_MS)
+        return;
+      lastRecycledAt = now;
+      consecutiveFailures = 0;
+      const stale = current;
+      current = void 0;
+      console.warn(`[workflow] ${label}: rebuilding connection pool after ${EVENTS_RECYCLE_AFTER_CONSECUTIVE_FAILURES} consecutive transport failures`);
+      retire(stale);
+    }
+  };
+}
+__name(createDispatcherRecycler, "createDispatcherRecycler");
+var eventsRecycler = createDispatcherRecycler(() => createEventsDispatcher(), "events transport");
+function noteEventsTransportOutcome(dispatcher, error48) {
+  eventsRecycler.note(dispatcher, error48);
+}
+__name(noteEventsTransportOutcome, "noteEventsTransportOutcome");
 function getDispatcher(config3) {
   return config3?.dispatcher ?? getDefaultDispatcher();
 }
 __name(getDispatcher, "getDispatcher");
 function getEventsDispatcher(config3) {
-  return config3?.dispatcher ?? getDefaultEventsDispatcher();
+  return config3?.dispatcher ?? eventsRecycler.get();
 }
 __name(getEventsDispatcher, "getEventsDispatcher");
 function getStreamDispatcher(config3) {
@@ -53541,8 +53622,12 @@ function getStreamCloseDispatcher(config3) {
 }
 __name(getStreamCloseDispatcher, "getStreamCloseDispatcher");
 function createEventsDispatcher(agentOverrides) {
-  const agent = new import_undici2.RetryAgent(new import_undici2.Agent({ ...getEventsAgentOptions(), ...agentOverrides }), getRetryAgentOptions());
-  if (!h2MultiplexEnabled()) {
+  const h2 = h2EventsEnabled();
+  const agent = new import_undici2.RetryAgent(new import_undici2.Agent({
+    ...h2 ? getEventsAgentOptions() : getEventsAgentOptionsNoH2(),
+    ...agentOverrides
+  }), getRetryAgentOptions());
+  if (!h2) {
     return agent;
   }
   return withBoundLifecycle(agent, agent.compose(h2MultiplexInterceptor));
@@ -53563,11 +53648,6 @@ function getDefaultDispatcher() {
   return _dispatcher;
 }
 __name(getDefaultDispatcher, "getDefaultDispatcher");
-function getDefaultEventsDispatcher() {
-  _eventsDispatcher ??= createEventsDispatcher();
-  return _eventsDispatcher;
-}
-__name(getDefaultEventsDispatcher, "getDefaultEventsDispatcher");
 function getDefaultStreamDispatcher() {
   _streamDispatcher ??= createStreamDispatcher(STREAM_RETRY_OPTIONS);
   return _streamDispatcher;
@@ -53762,7 +53842,7 @@ function httpClientSpanAttributes(args) {
 }
 __name(httpClientSpanAttributes, "httpClientSpanAttributes");
 async function instrumentedFetch(opts) {
-  const { method, url: url2, headers, body, dispatcher, peerService = "workflow-server", timeoutMs = REQUEST_TIMEOUT_MS, signal: callerSignal, injectTraceContext = true, cacheBust = true, logLabel, buildError } = opts;
+  const { method, url: url2, headers, body, dispatcher, peerService = "workflow-server", timeoutMs = REQUEST_TIMEOUT_MS, signal: callerSignal, injectTraceContext = true, cacheBust = true, logLabel, buildError, onTransportOutcome } = opts;
   const label = logLabel ?? url2;
   return trace4(`http ${method}`, { kind: await getSpanKind3("CLIENT") }, async (span) => {
     span?.setAttributes(httpClientSpanAttributes({ method, url: url2, peerService }));
@@ -53785,6 +53865,7 @@ async function instrumentedFetch(opts) {
       });
     } catch (error48) {
       const elapsed = Date.now() - start2;
+      onTransportOutcome?.(error48);
       if (error48 instanceof Error && (error48.name === "TimeoutError" || error48.name === "AbortError")) {
         const timeoutError = new WorkflowWorldError(`${method} ${label} timed out after ${elapsed}ms`, { url: url2, cause: error48 });
         span?.setAttributes({ ...ErrorType2("TIMEOUT") });
@@ -53794,6 +53875,7 @@ async function instrumentedFetch(opts) {
       throw error48;
     }
     const ms2 = Date.now() - start2;
+    onTransportOutcome?.();
     httpLog(method, label, response, ms2);
     span?.setAttributes({ ...HttpResponseStatusCode2(response.status) });
     if (!response.ok) {
@@ -60949,7 +61031,7 @@ var import_oidc3 = __toESM(require_dist(), 1);
 init_dist();
 
 // ../world-vercel/dist/version.js
-var version3 = "4.6.1";
+var version3 = "4.6.2";
 
 // ../world-vercel/dist/utils.js
 var WORKFLOW_SERVER_URL_OVERRIDE = "";
@@ -61767,12 +61849,18 @@ __name(readerToIterator, "readerToIterator");
 
 // ../world-vercel/dist/events-v4.js
 async function fetchV4(url2, init, config3, opName) {
+  const dispatcher = getEventsDispatcher(config3);
   return instrumentedFetch({
     method: init.method,
     url: url2,
     headers: init.headers,
     body: init.body,
-    dispatcher: getEventsDispatcher(config3),
+    dispatcher,
+    // Repeated transport failures retire the shared events pool and the next
+    // request builds a fresh one. undici keeps a black-holed HTTP/2 session in
+    // service indefinitely, so without this every request routed onto it fails
+    // until the compute instance is recycled — see noteEventsTransportOutcome.
+    onTransportOutcome: /* @__PURE__ */ __name((error48) => noteEventsTransportOutcome(dispatcher, error48), "onTransportOutcome"),
     timeoutMs: null,
     logLabel: opName,
     buildError: /* @__PURE__ */ __name(async (response) => errorFromV4Response(response.status, headersToRecord(response.headers), await response.text(), opName, url2), "buildError")
@@ -63947,30 +64035,74 @@ function getStepFunction(stepId) {
   return void 0;
 }
 __name(getStepFunction, "getStepFunction");
-async function awaitEarlierDeliveries(ctx, eventIndex, deferBehindKinds) {
+var DEFER_BEHIND = {
+  hook: ["wait", "step"],
+  wait: ["hook", "step"],
+  step: ["wait", "hook", "step"]
+};
+function resolvesOnItsOwn(barriers, index, entry, memo) {
+  const cached2 = memo.get(index);
+  if (cached2 !== void 0) {
+    return cached2;
+  }
+  const result = computeResolvesOnItsOwn(barriers, index, entry, memo);
+  memo.set(index, result);
+  return result;
+}
+__name(resolvesOnItsOwn, "resolvesOnItsOwn");
+function computeResolvesOnItsOwn(barriers, index, entry, memo) {
+  if (!entry.armed) {
+    return false;
+  }
+  if (entry.kind === "step") {
+    return true;
+  }
+  const deferBehind = DEFER_BEHIND[entry.kind];
+  for (const [otherIndex, other] of barriers) {
+    if (otherIndex < index && deferBehind.includes(other.kind) && !resolvesOnItsOwn(barriers, otherIndex, other, memo)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(computeResolvesOnItsOwn, "computeResolvesOnItsOwn");
+async function awaitEarlierDeliveries(ctx, eventIndex, kind) {
   if (eventIndex === void 0 || !ctx.pendingDeliveryBarriers || ctx.pendingDeliveryBarriers.size === 0) {
     return;
   }
+  const barriers = ctx.pendingDeliveryBarriers;
+  const deferBehind = DEFER_BEHIND[kind];
   const earlier = [];
-  for (const [index, entry] of ctx.pendingDeliveryBarriers) {
-    if (index < eventIndex && deferBehindKinds.includes(entry.kind)) {
-      earlier.push(entry.delivered);
+  const selfResolving = /* @__PURE__ */ new Map();
+  for (const [index, entry] of barriers) {
+    if (index >= eventIndex || !deferBehind.includes(entry.kind)) {
+      continue;
+    }
+    if (kind === "step" && !resolvesOnItsOwn(barriers, index, entry, selfResolving)) {
+      continue;
     }
+    earlier.push(entry.delivered);
   }
   if (earlier.length > 0) {
     await Promise.all(earlier);
+    await new Promise((resolve3) => setTimeout(resolve3, 0));
   }
 }
 __name(awaitEarlierDeliveries, "awaitEarlierDeliveries");
-function registerDeliveryBarrier(ctx, eventIndex, kind) {
+function registerDeliveryBarrier(ctx, eventIndex, kind, options = {}) {
   const barriers = ctx.pendingDeliveryBarriers;
   if (!barriers || eventIndex === void 0) {
     return { markDelivered: /* @__PURE__ */ __name(() => {
-    }, "markDelivered") };
+    }, "markDelivered"), arm: /* @__PURE__ */ __name(() => {
+    }, "arm") };
   }
   let done = false;
   const { promise: promise2, resolve: resolve3 } = withResolvers();
-  const entry = { kind, delivered: promise2 };
+  const entry = {
+    kind,
+    delivered: promise2,
+    armed: options.armed ?? true
+  };
   barriers.set(eventIndex, entry);
   const finish = /* @__PURE__ */ __name(() => {
     if (done) {
@@ -63983,12 +64115,35 @@ function registerDeliveryBarrier(ctx, eventIndex, kind) {
     resolve3();
   }, "finish");
   scheduleWhenIdle(ctx, finish);
-  return { markDelivered: finish };
+  return {
+    markDelivered: finish,
+    arm: /* @__PURE__ */ __name(() => {
+      entry.armed = true;
+    }, "arm")
+  };
 }
 __name(registerDeliveryBarrier, "registerDeliveryBarrier");
+function hasParkedCommittedDelivery(ctx) {
+  const barriers = ctx.pendingDeliveryBarriers;
+  if (!barriers || barriers.size === 0) {
+    return false;
+  }
+  const selfResolving = /* @__PURE__ */ new Map();
+  for (const [index, entry] of barriers) {
+    if (resolvesOnItsOwn(barriers, index, entry, selfResolving)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(hasParkedCommittedDelivery, "hasParkedCommittedDelivery");
+function isDeliveryIdle(ctx) {
+  return ctx.pendingDeliveries === 0 && !hasParkedCommittedDelivery(ctx);
+}
+__name(isDeliveryIdle, "isDeliveryIdle");
 function scheduleWhenIdle(ctx, fn) {
   const check2 = /* @__PURE__ */ __name(() => {
-    if (ctx.pendingDeliveries > 0) {
+    if (!isDeliveryIdle(ctx)) {
       ctx.promiseQueue.then(() => {
         setTimeout(check2, 0);
       });
@@ -66079,6 +66234,7 @@ __name(customRandom, "customRandom");
 init_node();
 
 // ../core/dist/events-consumer.js
+var DEFERRED_CHECK_DELAY_MS = 100;
 var EventConsumerResult;
 (function(EventConsumerResult2) {
   EventConsumerResult2[EventConsumerResult2["Consumed"] = 0] = "Consumed";
@@ -66095,6 +66251,7 @@ var EventsConsumer = class {
   onConsumedEvent;
   onUnconsumedEvent;
   getPromiseQueue;
+  isDeliveryIdle;
   pendingUnconsumedCheck = null;
   pendingUnconsumedTimeout = null;
   unconsumedCheckVersion = 0;
@@ -66104,6 +66261,7 @@ var EventsConsumer = class {
     this.onConsumedEvent = options.onConsumedEvent;
     this.onUnconsumedEvent = options.onUnconsumedEvent;
     this.getPromiseQueue = options.getPromiseQueue;
+    this.isDeliveryIdle = options.isDeliveryIdle ?? (() => true);
   }
   /**
    * Registers a callback function to be called after an event has been consumed
@@ -66187,16 +66345,58 @@ var EventsConsumer = class {
         // resumes -> the next hook payload starts hydrating).
         () => new Promise((resolve3) => setTimeout(resolve3, 0))
       ).then(() => this.getPromiseQueue()).then(() => {
-        this.pendingUnconsumedTimeout = setTimeout(() => {
-          this.pendingUnconsumedTimeout = null;
-          if (this.unconsumedCheckVersion === checkVersion) {
-            this.pendingUnconsumedCheck = null;
-            this.onUnconsumedEvent(currentEvent);
-          }
-        }, 100);
+        this.whenDeliveryIdle(checkVersion, () => {
+          this.pendingUnconsumedTimeout = setTimeout(() => {
+            this.pendingUnconsumedTimeout = null;
+            if (this.unconsumedCheckVersion === checkVersion) {
+              this.pendingUnconsumedCheck = null;
+              this.onUnconsumedEvent(currentEvent);
+            }
+          }, DEFERRED_CHECK_DELAY_MS);
+        });
       });
     }
   }
+  /**
+   * Run `fn` once no data delivery is in flight, polling the way
+   * `scheduleWhenIdle` does: let the promise queue drain, re-check a timer
+   * tick later, repeat.
+   *
+   * Without this the check is a bet that every delivery the walk is running
+   * ahead of lands inside a fixed window. Consumption is synchronous while the
+   * resolution it triggers is not: a step result hydrates in the host, resolves
+   * from a detached continuation behind `awaitEarlierDeliveries`, and only then
+   * does VM code run far enough to subscribe the next consumer. Replaying a
+   * batch of N parallel step results leaves N-1 of them on that detached path
+   * with the queue already drained, so the walk sits on the ordered event the
+   * VM is about to draw and the window is the only thing standing between a
+   * healthy run and `ReplayDivergenceError`. On a backend whose deliveries take
+   * longer than the window, that bet loses.
+   *
+   * Termination is `hasParkedCommittedDelivery`'s: it counts only deliveries
+   * that resolve on their own, so nothing here can gate its own retirement. A
+   * genuinely orphaned event has no delivery to wait on and reaches `fn` on the
+   * first poll.
+   */
+  whenDeliveryIdle(checkVersion, fn) {
+    const poll = /* @__PURE__ */ __name(() => {
+      this.pendingUnconsumedTimeout = null;
+      if (this.unconsumedCheckVersion !== checkVersion) {
+        return;
+      }
+      if (this.isDeliveryIdle()) {
+        fn();
+        return;
+      }
+      this.getPromiseQueue().then(() => {
+        if (this.unconsumedCheckVersion !== checkVersion) {
+          return;
+        }
+        this.pendingUnconsumedTimeout = setTimeout(poll, 0);
+      });
+    }, "poll");
+    poll();
+  }
 };
 
 // ../core/dist/runtime/get-port-lazy.js
@@ -66323,6 +66523,9 @@ function createUseStep(ctx) {
         }
         if (event.eventType === "step_failed") {
           ctx.invocationsQueue.delete(event.correlationId);
+          const eventIndex = ctx.eventsConsumer.eventIndex;
+          const barrier = registerDeliveryBarrier(ctx, eventIndex, "step");
+          const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, "step");
           ctx.promiseQueue = ctx.promiseQueue.then(() => {
             const errorData = event.eventData.error;
             const isErrorObject = typeof errorData === "object" && errorData !== null;
@@ -66332,7 +66535,10 @@ function createUseStep(ctx) {
             if (errorStack) {
               error48.stack = errorStack;
             }
-            reject(error48);
+            void earlierDelivered.then(() => {
+              barrier.markDelivered();
+              reject(error48);
+            });
           });
           return EventConsumerResult.Finished;
         }
@@ -66340,16 +66546,28 @@ function createUseStep(ctx) {
           ctx.invocationsQueue.delete(event.correlationId);
           const completedEventId = event.eventId;
           const serializedResult = event.eventData.result;
+          const eventIndex = ctx.eventsConsumer.eventIndex;
+          const barrier = registerDeliveryBarrier(ctx, eventIndex, "step");
+          let outcome;
+          const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, "step");
           ctx.pendingDeliveries++;
           ctx.promiseQueue = ctx.promiseQueue.then(async () => {
             try {
               const hydratedResult = await getOrHydrateStepReturnValue(ctx.stepHydrationCache, completedEventId, () => hydrateStepReturnValue(serializedResult, ctx.runId, ctx.encryptionKey, ctx.globalThis));
-              resolve3(hydratedResult);
+              outcome = { ok: true, value: hydratedResult };
             } catch (error48) {
-              reject(error48);
+              outcome = { ok: false, error: error48 };
             } finally {
               ctx.pendingDeliveries--;
             }
+            void earlierDelivered.then(() => {
+              barrier.markDelivered();
+              if (outcome.ok) {
+                resolve3(outcome.value);
+              } else {
+                reject(outcome.error);
+              }
+            });
           });
           return EventConsumerResult.Finished;
         }
@@ -66823,10 +67041,10 @@ function createContext(options) {
   g.Math.random = rng;
   const Date_ = g.Date;
   g.Date = /* @__PURE__ */ __name(function Date2(...args) {
-    if (args.length === 0) {
-      return new Date_(fixedTimestamp);
+    if (new.target === void 0) {
+      return new Date_(fixedTimestamp).toString();
     }
-    return new Date_(...args);
+    return Reflect.construct(Date_, args.length === 0 ? [fixedTimestamp] : args, new.target);
   }, "Date");
   g.Date.prototype = Date_.prototype;
   Object.setPrototypeOf(g.Date, Date_);
@@ -67030,8 +67248,12 @@ function createCreateHook(ctx) {
       }
       if (event.eventType === "hook_received") {
         const eventIndex = ctx.eventsConsumer.eventIndex;
-        const barrier = registerDeliveryBarrier(ctx, eventIndex, "hook");
-        if (promises.length > 0) {
+        const hasWaitingConsumer = promises.length > 0;
+        const barrier = registerDeliveryBarrier(ctx, eventIndex, "hook", {
+          armed: hasWaitingConsumer
+        });
+        if (hasWaitingConsumer) {
+          const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, "hook");
           const next2 = promises.shift();
           if (next2) {
             ctx.pendingDeliveries++;
@@ -67045,7 +67267,7 @@ function createCreateHook(ctx) {
               } finally {
                 ctx.pendingDeliveries--;
               }
-              void awaitEarlierDeliveries(ctx, eventIndex, ["wait"]).then(() => {
+              void earlierDelivered.then(() => {
                 barrier.markDelivered();
                 if (hydrateOutcome.ok) {
                   next2.resolve(hydrateOutcome.value);
@@ -67058,13 +67280,16 @@ function createCreateHook(ctx) {
         } else {
           let outcome;
           const hydrated = withResolvers();
-          const claim = /* @__PURE__ */ __name(() => hydrated.promise.then(() => awaitEarlierDeliveries(ctx, eventIndex, ["wait"])).then(() => {
-            barrier.markDelivered();
-            if (outcome && !outcome.ok) {
-              throw outcome.error;
-            }
-            return outcome.value;
-          }), "claim");
+          const claim = /* @__PURE__ */ __name(() => {
+            barrier.arm();
+            return hydrated.promise.then(() => awaitEarlierDeliveries(ctx, eventIndex, "hook")).then(() => {
+              barrier.markDelivered();
+              if (outcome && !outcome.ok) {
+                throw outcome.error;
+              }
+              return outcome.value;
+            });
+          }, "claim");
           ctx.pendingDeliveries++;
           ctx.promiseQueue = ctx.promiseQueue.then(async () => {
             try {
@@ -67243,8 +67468,9 @@ function createSleep(ctx) {
         ctx.invocationsQueue.delete(correlationId);
         const eventIndex = ctx.eventsConsumer.eventIndex;
         const barrier = registerDeliveryBarrier(ctx, eventIndex, "wait");
+        const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, "wait");
         const queueAtCompletion = ctx.promiseQueue;
-        void queueAtCompletion.then(() => awaitEarlierDeliveries(ctx, eventIndex, ["hook"])).then(() => {
+        void queueAtCompletion.then(() => earlierDelivered).then(() => {
           barrier.markDelivered();
           resolve3();
         });
@@ -67302,6 +67528,7 @@ async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, st
     const ulid5 = monotonicFactory(() => vmGlobalThis.Math.random());
     const generateNanoid = customRandom(urlAlphabet, 21, (size) => new Uint8Array(size).map(() => 256 * vmGlobalThis.Math.random()));
     const promiseQueueHolder = { current: Promise.resolve() };
+    const deliveryIdleHolder = { current: /* @__PURE__ */ __name(() => true, "current") };
     const eventsConsumer = new EventsConsumer(events, {
       onConsumedEvent: /* @__PURE__ */ __name((event) => {
         updateTimestamp(+event.createdAt);
@@ -67309,7 +67536,8 @@ async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, st
       onUnconsumedEvent: /* @__PURE__ */ __name((event) => {
         workflowDiscontinuation.reject(new ReplayDivergenceError(`Replay could not consume event: eventType=${event.eventType}, correlationId=${event.correlationId}, eventId=${event.eventId}.`, { eventId: event.eventId }));
       }, "onUnconsumedEvent"),
-      getPromiseQueue: /* @__PURE__ */ __name(() => promiseQueueHolder.current, "getPromiseQueue")
+      getPromiseQueue: /* @__PURE__ */ __name(() => promiseQueueHolder.current, "getPromiseQueue"),
+      isDeliveryIdle: /* @__PURE__ */ __name(() => deliveryIdleHolder.current(), "isDeliveryIdle")
     });
     const workflowContext = {
       runId: workflowRun.runId,
@@ -67332,6 +67560,7 @@ async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, st
       pendingDeliveryBarriers: /* @__PURE__ */ new Map(),
       stepHydrationCache
     };
+    deliveryIdleHolder.current = () => isDeliveryIdle(workflowContext);
     workflowContext.eventsConsumer.subscribe((event) => {
       if (!event) {
         return EventConsumerResult.NotConsumed;