@workflow/world-testing 4.1.5 → 4.1.6

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

@@ -15370,7 +15370,7 @@ var init_runs = __esm({
       // Optional in database for backwards compatibility, defaults to 1 (legacy) when reading
       specVersion: external_exports.number().optional(),
       executionContext: external_exports.record(external_exports.string(), external_exports.any()).optional(),
-      input: SerializedDataSchema,
+      input: SerializedDataSchema.optional(),
       output: SerializedDataSchema.optional(),
       error: StructuredErrorSchema.optional(),
       expiredAt: external_exports.coerce.date().optional(),
@@ -15474,7 +15474,7 @@ var init_steps = __esm({
        */
       stepName: external_exports.string(),
       status: StepStatusSchema,
-      input: SerializedDataSchema,
+      input: SerializedDataSchema.optional(),
       output: SerializedDataSchema.optional(),
       /**
        * The error from a step_retrying or step_failed event.
@@ -42942,7 +42942,7 @@ var require_auth_config = __commonJS({
       writeAuthConfig: /* @__PURE__ */ __name(() => writeAuthConfig, "writeAuthConfig")
     });
     module2.exports = __toCommonJS2(auth_config_exports);
-    var fs5 = __toESM2(require("fs"));
+    var fs6 = __toESM2(require("fs"));
     var path11 = __toESM2(require("path"));
     var import_token_util = require_token_util();
     function getAuthConfigPath() {
@@ -42958,10 +42958,10 @@ var require_auth_config = __commonJS({
     function readAuthConfig() {
       try {
         const authPath = getAuthConfigPath();
-        if (!fs5.existsSync(authPath)) {
+        if (!fs6.existsSync(authPath)) {
           return null;
         }
-        const content = fs5.readFileSync(authPath, "utf8");
+        const content = fs6.readFileSync(authPath, "utf8");
         if (!content) {
           return null;
         }
@@ -42974,10 +42974,10 @@ var require_auth_config = __commonJS({
     function writeAuthConfig(config3) {
       const authPath = getAuthConfigPath();
       const authDir = path11.dirname(authPath);
-      if (!fs5.existsSync(authDir)) {
-        fs5.mkdirSync(authDir, { mode: 504, recursive: true });
+      if (!fs6.existsSync(authDir)) {
+        fs6.mkdirSync(authDir, { mode: 504, recursive: true });
       }
-      fs5.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
+      fs6.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
     }
     __name(writeAuthConfig, "writeAuthConfig");
     function isValidAccessToken(authConfig, expirationBufferMs = 0) {
@@ -43180,7 +43180,7 @@ var require_token_util = __commonJS({
     });
     module2.exports = __toCommonJS2(token_util_exports);
     var path11 = __toESM2(require("path"));
-    var fs5 = __toESM2(require("fs"));
+    var fs6 = __toESM2(require("fs"));
     var import_token_error = require_token_error();
     var import_token_io = require_token_io();
     var import_auth_config = require_auth_config();
@@ -43273,12 +43273,12 @@ var require_token_util = __commonJS({
         );
       }
       const prjPath = path11.join(dir, ".vercel", "project.json");
-      if (!fs5.existsSync(prjPath)) {
+      if (!fs6.existsSync(prjPath)) {
         throw new import_token_error.VercelOidcTokenError(
           "project.json not found, have you linked your project with `vc link?`"
         );
       }
-      const prj = JSON.parse(fs5.readFileSync(prjPath, "utf8"));
+      const prj = JSON.parse(fs6.readFileSync(prjPath, "utf8"));
       if (typeof prj.projectId !== "string" && typeof prj.orgId !== "string") {
         throw new TypeError(
           "Expected a string-valued projectId property. Try running `vc link` to re-link your project."
@@ -43296,9 +43296,9 @@ var require_token_util = __commonJS({
       }
       const tokenPath = path11.join(dir, "com.vercel.token", `${projectId}.json`);
       const tokenJson = JSON.stringify(token);
-      fs5.mkdirSync(path11.dirname(tokenPath), { mode: 504, recursive: true });
-      fs5.writeFileSync(tokenPath, tokenJson);
-      fs5.chmodSync(tokenPath, 432);
+      fs6.mkdirSync(path11.dirname(tokenPath), { mode: 504, recursive: true });
+      fs6.writeFileSync(tokenPath, tokenJson);
+      fs6.chmodSync(tokenPath, 432);
       return;
     }
     __name(saveToken, "saveToken");
@@ -43310,10 +43310,10 @@ var require_token_util = __commonJS({
         );
       }
       const tokenPath = path11.join(dir, "com.vercel.token", `${projectId}.json`);
-      if (!fs5.existsSync(tokenPath)) {
+      if (!fs6.existsSync(tokenPath)) {
         return null;
       }
-      const token = JSON.parse(fs5.readFileSync(tokenPath, "utf8"));
+      const token = JSON.parse(fs6.readFileSync(tokenPath, "utf8"));
       assertVercelOidcTokenResponse(token);
       return token;
     }
@@ -43613,27 +43613,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js"(exports2, module2) {
     "use strict";
-    var fs5 = require("fs");
+    var fs6 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
     var readFileSync2 = /* @__PURE__ */ __name((path11) => {
-      const fd = fs5.openSync(path11, "r");
+      const fd = fs6.openSync(path11, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs5.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs5.close(fd, () => {
+      const bytesRead = fs6.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs6.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     }, "readFileSync");
     var readFile3 = /* @__PURE__ */ __name((path11) => new Promise((resolve3, reject) => {
-      fs5.open(path11, "r", (err, fd) => {
+      fs6.open(path11, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs5.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs6.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve3(buffer.subarray(0, bytesRead));
-            fs5.close(fd, () => {
+            fs6.close(fd, () => {
             });
           });
         }
@@ -43943,7 +43943,7 @@ var require_detect_libc = __commonJS({
 // ../../node_modules/.pnpm/node-gyp-build-optional-packages@5.1.1/node_modules/node-gyp-build-optional-packages/index.js
 var require_node_gyp_build_optional_packages = __commonJS({
   "../../node_modules/.pnpm/node-gyp-build-optional-packages@5.1.1/node_modules/node-gyp-build-optional-packages/index.js"(exports2, module2) {
-    var fs5 = require("fs");
+    var fs6 = require("fs");
     var path11 = require("path");
     var url2 = require("url");
     var vars = process.config && process.config.variables || {};
@@ -44026,7 +44026,7 @@ var require_node_gyp_build_optional_packages = __commonJS({
     };
     function readdirSync(dir) {
       try {
-        return fs5.readdirSync(dir);
+        return fs6.readdirSync(dir);
       } catch (err) {
         return [];
       }
@@ -48688,7 +48688,7 @@ init_dist();
 init_node();
 
 // ../core/dist/version.js
-var version2 = "4.2.5";
+var version2 = "4.2.6";
 
 // ../core/dist/runtime/world.js
 var import_node_module = require("node:module");
@@ -48696,7 +48696,7 @@ var import_node_path9 = require("node:path");
 
 // ../world-local/dist/index.js
 var import_node_fs2 = require("node:fs");
-var import_promises5 = require("node:fs/promises");
+var import_promises6 = require("node:fs/promises");
 var import_node_path8 = __toESM(require("node:path"), 1);
 init_dist();
 
@@ -49180,6 +49180,17 @@ async function readBuffer(filePath) {
   return content;
 }
 __name(readBuffer, "readBuffer");
+async function readFirstByte(filePath) {
+  const file2 = await import_node_fs.promises.open(filePath, "r");
+  try {
+    const byte = Buffer.allocUnsafe(1);
+    const { bytesRead } = await file2.read(byte, 0, 1, 0);
+    return bytesRead === 0 ? void 0 : byte[0];
+  } finally {
+    await file2.close();
+  }
+}
+__name(readFirstByte, "readFirstByte");
 async function deleteJSON(filePath) {
   try {
     await import_node_fs.promises.unlink(filePath);
@@ -50762,6 +50773,7 @@ __name(createStorage, "createStorage");
 
 // ../world-local/dist/streamer.js
 var import_node_events = require("node:events");
+var import_promises5 = __toESM(require("node:fs/promises"), 1);
 var import_node_path7 = __toESM(require("node:path"), 1);
 init_node();
 init_zod();
@@ -50769,43 +50781,56 @@ var monotonicUlid2 = monotonicFactory(() => Math.random());
 var RunStreamsSchema = external_exports.object({
   streams: external_exports.array(external_exports.string())
 });
+var EOF_MARKER = 1;
+function isEofByte(byte) {
+  return byte === EOF_MARKER;
+}
+__name(isEofByte, "isEofByte");
 function serializeChunk(chunk) {
-  const eofByte = Buffer.from([chunk.eof ? 1 : 0]);
+  const eofByte = Buffer.from([chunk.eof ? EOF_MARKER : 0]);
   return Buffer.concat([eofByte, chunk.chunk]);
 }
 __name(serializeChunk, "serializeChunk");
 function isEofChunk(serialized) {
-  return serialized[0] === 1;
+  return isEofByte(serialized[0]);
 }
 __name(isEofChunk, "isEofChunk");
 function deserializeChunk(serialized) {
-  const eof = serialized[0] === 1;
+  const eof = isEofChunk(serialized);
   const chunk = Buffer.from(serialized.subarray(1));
   return { eof, chunk };
 }
 __name(deserializeChunk, "deserializeChunk");
+async function listChunkEntries(chunksDir) {
+  try {
+    return await import_promises5.default.readdir(chunksDir);
+  } catch (error48) {
+    if (error48.code === "ENOENT")
+      return [];
+    throw error48;
+  }
+}
+__name(listChunkEntries, "listChunkEntries");
+function addChunkFilesByExtension(extMap, entries, sourceExtension, fileExtension = sourceExtension, include = () => true) {
+  for (const entry of entries) {
+    if (!entry.endsWith(sourceExtension))
+      continue;
+    const file2 = entry.slice(0, -sourceExtension.length);
+    if (include(file2))
+      extMap.set(file2, fileExtension);
+  }
+}
+__name(addChunkFilesByExtension, "addChunkFilesByExtension");
 async function listChunkFilesForStream(chunksDir, name, tag) {
   assertSafeEntityId("streamName", name);
-  const listPromises = [
-    listFilesByExtension(chunksDir, ".bin"),
-    listFilesByExtension(chunksDir, ".json")
-  ];
-  if (tag) {
-    listPromises.push(listFilesByExtension(chunksDir, `.${tag}.bin`));
-  }
-  const [binFiles, jsonFiles, ...taggedResults] = await Promise.all(listPromises);
-  const taggedBinFiles = taggedResults[0] ?? [];
+  const entries = await listChunkEntries(chunksDir);
   const extMap = /* @__PURE__ */ new Map();
-  for (const f of jsonFiles)
-    extMap.set(f, ".json");
-  const tagSfx = tag ? `.${tag}` : "";
-  for (const f of binFiles) {
-    if (tag && f.endsWith(tagSfx))
-      continue;
-    extMap.set(f, ".bin");
+  addChunkFilesByExtension(extMap, entries, ".json");
+  addChunkFilesByExtension(extMap, entries, ".bin", ".bin", tag ? (file2) => !file2.endsWith(`.${tag}`) : void 0);
+  if (tag) {
+    const taggedExtension = `.${tag}.bin`;
+    addChunkFilesByExtension(extMap, entries, taggedExtension);
   }
-  for (const f of taggedBinFiles)
-    extMap.set(f, `.${tag}.bin`);
   const files = [...extMap.keys()].filter((file2) => file2.startsWith(`${name}-`)).sort();
   return { files, extMap };
 }
@@ -50922,7 +50947,7 @@ function createStreamer(basedir, tag) {
         const ext2 = fileExtMap.get(file2) ?? ".bin";
         const filePath = import_node_path7.default.join(chunksDir, `${file2}${ext2}`);
         if (dataIndex < startIndex) {
-          if (isEofChunk(await readBuffer(filePath))) {
+          if (isEofByte(await readFirstByte(filePath))) {
             streamDone = true;
             break;
           }
@@ -50930,7 +50955,7 @@ function createStreamer(basedir, tag) {
           continue;
         }
         if (resultChunks.length >= limit) {
-          if (isEofChunk(await readBuffer(filePath))) {
+          if (isEofByte(await readFirstByte(filePath))) {
             streamDone = true;
           } else {
             dataIndex++;
@@ -50965,7 +50990,7 @@ function createStreamer(basedir, tag) {
       let dataCount = 0;
       for (const file2 of chunkFiles) {
         const ext2 = fileExtMap.get(file2) ?? ".bin";
-        if (isEofChunk(await readBuffer(import_node_path7.default.join(chunksDir, `${file2}${ext2}`)))) {
+        if (isEofByte(await readFirstByte(import_node_path7.default.join(chunksDir, `${file2}${ext2}`)))) {
           streamDone = true;
           break;
         }
@@ -51026,8 +51051,7 @@ function createStreamer(basedir, tag) {
           if (typeof startIndex === "number" && startIndex < 0 && chunkFiles.length > 0) {
             const lastFile = chunkFiles[chunkFiles.length - 1];
             const lastExt = fileExtMap.get(lastFile) ?? ".bin";
-            const lastChunk = deserializeChunk(await readBuffer(import_node_path7.default.join(chunksDir, `${lastFile}${lastExt}`)));
-            if (lastChunk?.eof === true) {
+            if (isEofByte(await readFirstByte(import_node_path7.default.join(chunksDir, `${lastFile}${lastExt}`)))) {
               dataChunkCount--;
             }
           }
@@ -51204,7 +51228,7 @@ function createLocalWorld(args) {
         })));
         clearCreatedFilesCache();
       } else {
-        await (0, import_promises5.rm)(mergedConfig.dataDir, { recursive: true, force: true });
+        await (0, import_promises6.rm)(mergedConfig.dataDir, { recursive: true, force: true });
         await initDataDir(mergedConfig.dataDir);
       }
     }
@@ -51923,7 +51947,7 @@ var StreamingMultipartParser = class {
 };
 
 // ../../node_modules/.pnpm/@vercel+queue@0.1.7/node_modules/@vercel/queue/dist/index.mjs
-var fs4 = __toESM(require("fs"), 1);
+var fs5 = __toESM(require("fs"), 1);
 var net = __toESM(require("net"), 1);
 var path10 = __toESM(require("path"), 1);
 
@@ -54490,11 +54514,11 @@ function getDevRouteMappings() {
   }
   try {
     const vercelJsonPath = path10.join(process.cwd(), "vercel.json");
-    if (!fs4.existsSync(vercelJsonPath)) {
+    if (!fs5.existsSync(vercelJsonPath)) {
       g[ROUTE_MAPPINGS_KEY] = null;
       return null;
     }
-    const vercelJson = JSON.parse(fs4.readFileSync(vercelJsonPath, "utf-8"));
+    const vercelJson = JSON.parse(fs5.readFileSync(vercelJsonPath, "utf-8"));
     if (!vercelJson.functions) {
       g[ROUTE_MAPPINGS_KEY] = null;
       return null;
@@ -54619,7 +54643,7 @@ function extractCallerFilePath() {
     const absolute = path10.isAbsolute(fp) ? fp : path10.resolve(process.cwd(), fp);
     let realFp;
     try {
-      realFp = fs4.realpathSync(absolute);
+      realFp = fs5.realpathSync(absolute);
     } catch {
       realFp = absolute;
     }
@@ -58273,7 +58297,7 @@ var import_oidc3 = __toESM(require_dist(), 1);
 init_dist();
 
 // ../world-vercel/dist/version.js
-var version3 = "4.2.0";
+var version3 = "4.3.0";
 
 // ../world-vercel/dist/utils.js
 var HTTP_DEBUG_ENABLED = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
@@ -59566,6 +59590,17 @@ async function fetchStreamMutation(url2, init, operation) {
   }
 }
 __name(fetchStreamMutation, "fetchStreamMutation");
+function createStreamRequestError(operation, url2, response, text) {
+  const context2 = [`PUT ${url2.origin}${url2.pathname}`];
+  for (const header of ["x-vercel-id", "x-vercel-error"]) {
+    const value = response.headers.get(header);
+    if (value) {
+      context2.push(`${header}=${value}`);
+    }
+  }
+  return new Error(`Stream ${operation} failed: HTTP ${response.status} (${context2.join("; ")}): ${text}`);
+}
+__name(createStreamRequestError, "createStreamRequestError");
 function encodeMultiChunks(chunks) {
   const encoder = new TextEncoder();
   const binaryChunks = [];
@@ -59605,14 +59640,15 @@ function createStreamer2(config3) {
     async writeToStream(name, runId, chunk) {
       const resolvedRunId = await runId;
       const httpConfig = await getHttpConfig(config3);
-      const response = await fetchStreamMutation(getStreamUrl(name, resolvedRunId, httpConfig), {
+      const url2 = getStreamUrl(name, resolvedRunId, httpConfig);
+      const response = await fetchStreamMutation(url2, {
         method: "PUT",
         body: chunk,
         headers: httpConfig.headers
       }, "write");
       const text = await response.text();
       if (!response.ok) {
-        throw new Error(`Stream write failed: HTTP ${response.status}: ${text}`);
+        throw createStreamRequestError("write", url2, response, text);
       }
     },
     async writeToStreamMulti(name, runId, chunks) {
@@ -59624,14 +59660,15 @@ function createStreamer2(config3) {
       for (let i = 0; i < chunks.length; i += MAX_CHUNKS_PER_REQUEST) {
         const batch = chunks.slice(i, i + MAX_CHUNKS_PER_REQUEST);
         const body = encodeMultiChunks(batch);
-        const response = await fetchStreamMutation(getStreamUrl(name, resolvedRunId, httpConfig), {
+        const url2 = getStreamUrl(name, resolvedRunId, httpConfig);
+        const response = await fetchStreamMutation(url2, {
           method: "PUT",
           body,
           headers: httpConfig.headers
         }, "write");
         const text = await response.text();
         if (!response.ok) {
-          throw new Error(`Stream write failed: HTTP ${response.status}: ${text}`);
+          throw createStreamRequestError("write", url2, response, text);
         }
       }
     },
@@ -59639,13 +59676,14 @@ function createStreamer2(config3) {
       const resolvedRunId = await runId;
       const httpConfig = await getHttpConfig(config3);
       httpConfig.headers.set("X-Stream-Done", "true");
-      const response = await fetchStreamMutation(getStreamUrl(name, resolvedRunId, httpConfig), {
+      const url2 = getStreamUrl(name, resolvedRunId, httpConfig);
+      const response = await fetchStreamMutation(url2, {
         method: "PUT",
         headers: httpConfig.headers
       }, "close");
       const text = await response.text();
       if (!response.ok) {
-        throw new Error(`Stream close failed: HTTP ${response.status}: ${text}`);
+        throw createStreamRequestError("close", url2, response, text);
       }
     },
     async readFromStream(name, startIndex) {
@@ -59813,29 +59851,80 @@ async function handleHealthCheckMessage(healthCheck2, endpoint, worldSpecVersion
   await world.closeStream(streamName, fakeRunId);
 }
 __name(handleHealthCheckMessage, "handleHealthCheckMessage");
+function eventPaginationContractError(runId, message) {
+  return new WorkflowWorldError(`Event pagination ${message} for workflow run "${runId}".`, { code: RUN_ERROR_CODES.WORLD_CONTRACT_ERROR });
+}
+__name(eventPaginationContractError, "eventPaginationContractError");
+function appendUniqueEvents(target2, targetIds, events) {
+  for (const event of events) {
+    if (!targetIds.has(event.eventId)) {
+      targetIds.add(event.eventId);
+      target2.push(event);
+    }
+  }
+}
+__name(appendUniqueEvents, "appendUniqueEvents");
+function assertEventPaginationProgress(runId, hasMore, cursor, requestedCursors) {
+  if (!hasMore) {
+    return;
+  }
+  if (cursor === null) {
+    throw eventPaginationContractError(runId, "returned more pages without a cursor");
+  }
+  if (requestedCursors.has(cursor)) {
+    throw eventPaginationContractError(runId, "repeated a cursor");
+  }
+}
+__name(assertEventPaginationProgress, "assertEventPaginationProgress");
+function shouldRetryWithoutEventCursor(error48, cursor, alreadyRetried) {
+  return cursor !== null && !alreadyRetried && WorkflowWorldError.is(error48) && error48.status === 400;
+}
+__name(shouldRetryWithoutEventCursor, "shouldRetryWithoutEventCursor");
 async function getWorkflowRunEvents2(runId, cursor) {
   return trace2("workflow.loadEvents", async (span) => {
     span?.setAttributes({
       ...WorkflowRunId(runId)
     });
     const allEvents = [];
+    const loadedEventIds = /* @__PURE__ */ new Set();
+    const requestedCursors = /* @__PURE__ */ new Set();
     let nextCursor = cursor ?? null;
     let hasMore = true;
     let pagesLoaded = 0;
+    let retriedWithoutCursor = false;
     const world = getWorld();
     const loadStart = Date.now();
     while (hasMore) {
       const pageStart = Date.now();
-      const response = await world.events.list({
-        runId,
-        pagination: {
-          sortOrder: "asc",
-          // Required: events must be in chronological order for replay
-          cursor: nextCursor ?? void 0
+      const requestedCursor = nextCursor;
+      if (requestedCursor) {
+        requestedCursors.add(requestedCursor);
+      }
+      let response;
+      try {
+        response = await world.events.list({
+          runId,
+          pagination: {
+            sortOrder: "asc",
+            // Required: events must be in chronological order for replay
+            cursor: requestedCursor ?? void 0
+          }
+        });
+      } catch (error48) {
+        if (shouldRetryWithoutEventCursor(error48, requestedCursor, retriedWithoutCursor)) {
+          runtimeLogger.warn("Event cursor was rejected; retrying with a full event reload.", { workflowRunId: runId });
+          allEvents.length = 0;
+          loadedEventIds.clear();
+          requestedCursors.clear();
+          nextCursor = null;
+          retriedWithoutCursor = true;
+          continue;
         }
-      });
-      allEvents.push(...response.data);
+        throw error48;
+      }
+      appendUniqueEvents(allEvents, loadedEventIds, response.data);
       hasMore = response.hasMore;
+      assertEventPaginationProgress(runId, hasMore, response.cursor, requestedCursors);
       nextCursor = response.cursor ?? nextCursor;
       pagesLoaded++;
       runtimeLogger.debug("Loaded event page", {
@@ -60575,12 +60664,15 @@ __name(getSerializationClass, "getSerializationClass");
 // ../core/dist/flushable-stream.js
 var LOCK_POLL_INTERVAL_MS = 100;
 function createFlushableState() {
-  return {
+  const state = {
     ...withResolvers(),
     pendingOps: 0,
     doneResolved: false,
     streamEnded: false
   };
+  state.promise.catch(() => {
+  });
+  return state;
 }
 __name(createFlushableState, "createFlushableState");
 function isWritableUnlockedNotClosed(writable) {
@@ -60781,6 +60873,45 @@ function getStepFunction(stepId) {
   return void 0;
 }
 __name(getStepFunction, "getStepFunction");
+async function awaitEarlierDeliveries(ctx, eventIndex, deferBehindKinds) {
+  if (eventIndex === void 0 || !ctx.pendingDeliveryBarriers || ctx.pendingDeliveryBarriers.size === 0) {
+    return;
+  }
+  const earlier = [];
+  for (const [index, entry] of ctx.pendingDeliveryBarriers) {
+    if (index < eventIndex && deferBehindKinds.includes(entry.kind)) {
+      earlier.push(entry.delivered);
+    }
+  }
+  if (earlier.length > 0) {
+    await Promise.all(earlier);
+  }
+}
+__name(awaitEarlierDeliveries, "awaitEarlierDeliveries");
+function registerDeliveryBarrier(ctx, eventIndex, kind) {
+  const barriers = ctx.pendingDeliveryBarriers;
+  if (!barriers || eventIndex === void 0) {
+    return { markDelivered: /* @__PURE__ */ __name(() => {
+    }, "markDelivered") };
+  }
+  let done = false;
+  const { promise: promise2, resolve: resolve3 } = withResolvers();
+  const entry = { kind, delivered: promise2 };
+  barriers.set(eventIndex, entry);
+  const finish = /* @__PURE__ */ __name(() => {
+    if (done) {
+      return;
+    }
+    done = true;
+    if (barriers.get(eventIndex) === entry) {
+      barriers.delete(eventIndex);
+    }
+    resolve3();
+  }, "finish");
+  scheduleWhenIdle(ctx, finish);
+  return { markDelivered: finish };
+}
+__name(registerDeliveryBarrier, "registerDeliveryBarrier");
 function scheduleWhenIdle(ctx, fn) {
   const check2 = /* @__PURE__ */ __name(() => {
     if (ctx.pendingDeliveries > 0) {
@@ -62455,13 +62586,49 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
 __name(traceSegmentInternal, "traceSegmentInternal");
 
 // ../core/dist/source-map.js
+function isBase64Char(code) {
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 43 || code === 47 || code === 61;
+}
+__name(isBase64Char, "isBase64Char");
+function extractInlineSourceMapBase64(source) {
+  const sourceMapPrefix = "//# sourceMappingURL=data:application/json";
+  const base64Marker = ";base64,";
+  let scanFrom = 0;
+  while (scanFrom < source.length) {
+    const prefixIdx = source.indexOf(sourceMapPrefix, scanFrom);
+    if (prefixIdx === -1)
+      return void 0;
+    const base64Start = source.indexOf(base64Marker, prefixIdx + sourceMapPrefix.length);
+    if (base64Start === -1) {
+      scanFrom = prefixIdx + sourceMapPrefix.length;
+      continue;
+    }
+    const commaBefore = source.indexOf(",", prefixIdx);
+    if (commaBefore !== -1 && commaBefore < base64Start) {
+      scanFrom = base64Start + base64Marker.length;
+      continue;
+    }
+    const valueStart = base64Start + base64Marker.length;
+    let valueEnd = valueStart;
+    while (valueEnd < source.length) {
+      if (!isBase64Char(source.charCodeAt(valueEnd))) {
+        break;
+      }
+      valueEnd++;
+    }
+    if (valueEnd > valueStart) {
+      return source.slice(valueStart, valueEnd);
+    }
+    scanFrom = valueEnd;
+  }
+}
+__name(extractInlineSourceMapBase64, "extractInlineSourceMapBase64");
 function remapErrorStack(stack, filename, workflowCode2) {
-  const sourceMapMatch = workflowCode2.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
-  if (!sourceMapMatch) {
+  const base643 = extractInlineSourceMapBase64(workflowCode2);
+  if (!base643) {
     return stack;
   }
   try {
-    const base643 = sourceMapMatch[1];
     const sourceMapJson = Buffer.from(base643, "base64").toString("utf-8");
     const sourceMapData = JSON.parse(sourceMapJson);
     const tracer = new TraceMap(sourceMapData);
@@ -62489,7 +62656,7 @@ function remapErrorStack(stack, filename, workflowCode2) {
       return line;
     });
     return remappedLines.join("\n");
-  } catch (e) {
+  } catch {
     return stack;
   }
 }
@@ -63426,23 +63593,55 @@ function createCreateHook(ctx) {
         return EventConsumerResult.Consumed;
       }
       if (event.eventType === "hook_received") {
+        const eventIndex = ctx.eventsConsumer.eventIndex;
+        const barrier = registerDeliveryBarrier(ctx, eventIndex, "hook");
         if (promises.length > 0) {
           const next2 = promises.shift();
           if (next2) {
             ctx.pendingDeliveries++;
+            let hydrateOutcome;
             ctx.promiseQueue = ctx.promiseQueue.then(async () => {
               try {
                 const payload = await hydrateStepReturnValue(event.eventData.payload, ctx.runId, ctx.encryptionKey, ctx.globalThis);
-                next2.resolve(payload);
+                hydrateOutcome = { ok: true, value: payload };
               } catch (error48) {
-                next2.reject(error48);
+                hydrateOutcome = { ok: false, error: error48 };
               } finally {
                 ctx.pendingDeliveries--;
               }
+              void awaitEarlierDeliveries(ctx, eventIndex, ["wait"]).then(() => {
+                barrier.markDelivered();
+                if (hydrateOutcome.ok) {
+                  next2.resolve(hydrateOutcome.value);
+                } else {
+                  next2.reject(hydrateOutcome.error);
+                }
+              });
             });
           }
         } else {
-          payloadsQueue.push(event);
+          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");
+          ctx.pendingDeliveries++;
+          ctx.promiseQueue = ctx.promiseQueue.then(async () => {
+            try {
+              const payload = await hydrateStepReturnValue(event.eventData.payload, ctx.runId, ctx.encryptionKey, ctx.globalThis);
+              outcome = { ok: true, value: payload };
+            } catch (error48) {
+              outcome = { ok: false, error: error48 };
+            } finally {
+              ctx.pendingDeliveries--;
+              hydrated.resolve();
+            }
+          });
+          payloadsQueue.push({ claim });
         }
         return EventConsumerResult.Consumed;
       }
@@ -63466,20 +63665,9 @@ function createCreateHook(ctx) {
         return resolvers.promise;
       }
       if (payloadsQueue.length > 0) {
-        const nextPayload = payloadsQueue.shift();
-        if (nextPayload) {
-          ctx.pendingDeliveries++;
-          ctx.promiseQueue = ctx.promiseQueue.then(async () => {
-            try {
-              const payload = await hydrateStepReturnValue(nextPayload.eventData.payload, ctx.runId, ctx.encryptionKey, ctx.globalThis);
-              resolvers.resolve(payload);
-            } catch (error48) {
-              resolvers.reject(error48);
-            } finally {
-              ctx.pendingDeliveries--;
-            }
-          });
-          return resolvers.promise;
+        const nextDelivery = payloadsQueue.shift();
+        if (nextDelivery) {
+          return nextDelivery.claim();
         }
       }
       if (eventLogEmpty) {
@@ -63583,7 +63771,11 @@ function createSleep(ctx) {
           }
         }
         ctx.invocationsQueue.delete(correlationId);
-        ctx.promiseQueue = ctx.promiseQueue.then(() => {
+        const eventIndex = ctx.eventsConsumer.eventIndex;
+        const barrier = registerDeliveryBarrier(ctx, eventIndex, "wait");
+        const queueAtCompletion = ctx.promiseQueue;
+        void queueAtCompletion.then(() => awaitEarlierDeliveries(ctx, eventIndex, ["hook"])).then(() => {
+          barrier.markDelivered();
           resolve3();
         });
         return EventConsumerResult.Finished;
@@ -63663,7 +63855,8 @@ async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey) {
       set promiseQueue(value) {
         promiseQueueHolder.current = value;
       },
-      pendingDeliveries: 0
+      pendingDeliveries: 0,
+      pendingDeliveryBarriers: /* @__PURE__ */ new Map()
     };
     workflowContext.eventsConsumer.subscribe((event) => {
       const createdAt = event?.createdAt;
@@ -64972,7 +65165,13 @@ function workflowEntrypoint(workflowCode2) {
               const completedWaitIdsAfterCursor = new Set(newEvents.events.filter((e) => e.eventType === "wait_completed").map((e) => e.correlationId));
               const sawAllWaitCompletions = waitsToComplete.every((waitEvent) => completedWaitIdsAfterCursor.has(waitEvent.correlationId));
               if (sawAllWaitCompletions) {
-                events.push(...newEvents.events);
+                const existingIds = new Set(events.map((event) => event.eventId));
+                for (const event of newEvents.events) {
+                  if (!existingIds.has(event.eventId)) {
+                    existingIds.add(event.eventId);
+                    events.push(event);
+                  }
+                }
               } else {
                 const loadedEvents = await getWorkflowRunEvents2(workflowRun.runId);
                 events = loadedEvents.events;