@workflow/world-testing 4.1.16 → 4.1.18

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

@@ -50439,7 +50439,7 @@ init_dist();
 init_node();
 
 // ../core/dist/version.js
-var version2 = "4.8.1";
+var version2 = "4.8.3";
 
 // ../core/dist/runtime/world.js
 var import_node_module = require("node:module");
@@ -64035,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) {
@@ -64071,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);
       });
@@ -66167,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";
@@ -66183,6 +66251,7 @@ var EventsConsumer = class {
   onConsumedEvent;
   onUnconsumedEvent;
   getPromiseQueue;
+  isDeliveryIdle;
   pendingUnconsumedCheck = null;
   pendingUnconsumedTimeout = null;
   unconsumedCheckVersion = 0;
@@ -66192,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
@@ -66275,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
@@ -66411,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;
@@ -66420,7 +66535,10 @@ function createUseStep(ctx) {
             if (errorStack) {
               error48.stack = errorStack;
             }
-            reject(error48);
+            void earlierDelivered.then(() => {
+              barrier.markDelivered();
+              reject(error48);
+            });
           });
           return EventConsumerResult.Finished;
         }
@@ -66428,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;
         }
@@ -66911,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_);
@@ -67118,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++;
@@ -67133,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);
@@ -67146,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 {
@@ -67331,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();
         });
@@ -67390,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);
@@ -67397,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,
@@ -67420,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;