@workflow/world-testing 4.1.19 → 4.1.21

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

@@ -15411,7 +15411,8 @@ var init_queue = __esm({
 });
 
 // ../world/dist/recovery.js
-async function reenqueueActiveRuns(runs, enqueue, label) {
+async function reenqueueActiveRuns(runs, enqueue, label, namespace) {
+  const workflowQueuePrefix = getQueueTopicPrefix("workflow", resolveQueueNamespace(namespace));
   let reenqueued = 0;
   for (const status of ["pending", "running"]) {
     let cursor;
@@ -15424,7 +15425,7 @@ async function reenqueueActiveRuns(runs, enqueue, label) {
       });
       for (const run2 of page.data) {
         try {
-          const queueName = `__wkf_workflow_${run2.workflowName}`;
+          const queueName = `${workflowQueuePrefix}${run2.workflowName}`;
           await enqueue(queueName, { runId: run2.runId });
           reenqueued++;
         } catch (err) {
@@ -15442,6 +15443,7 @@ async function reenqueueActiveRuns(runs, enqueue, label) {
 var init_recovery = __esm({
   "../world/dist/recovery.js"() {
     "use strict";
+    init_queue();
     __name(reenqueueActiveRuns, "reenqueueActiveRuns");
   }
 });
@@ -44744,7 +44746,7 @@ var require_token_util = __commonJS({
       findProjectInfo: /* @__PURE__ */ __name(() => findProjectInfo, "findProjectInfo"),
       getTokenPayload: /* @__PURE__ */ __name(() => getTokenPayload, "getTokenPayload"),
       getVercelDataDir: /* @__PURE__ */ __name(() => getVercelDataDir, "getVercelDataDir"),
-      getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken5, "getVercelOidcToken"),
+      getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken6, "getVercelOidcToken"),
       getVercelToken: /* @__PURE__ */ __name(() => getVercelToken2, "getVercelToken"),
       isExpired: /* @__PURE__ */ __name(() => isExpired, "isExpired"),
       loadToken: /* @__PURE__ */ __name(() => loadToken, "loadToken"),
@@ -44806,7 +44808,7 @@ var require_token_util = __commonJS({
       }
     }
     __name(getVercelToken2, "getVercelToken");
-    async function getVercelOidcToken5(authToken, projectId, teamId) {
+    async function getVercelOidcToken6(authToken, projectId, teamId) {
       const url2 = `https://api.vercel.com/v1/projects/${projectId}/token?source=vercel-oidc-refresh${teamId ? `&teamId=${teamId}` : ""}`;
       const res = await fetch(url2, {
         method: "POST",
@@ -44823,7 +44825,7 @@ var require_token_util = __commonJS({
       assertVercelOidcTokenResponse(tokenRes);
       return tokenRes;
     }
-    __name(getVercelOidcToken5, "getVercelOidcToken");
+    __name(getVercelOidcToken6, "getVercelOidcToken");
     function assertVercelOidcTokenResponse(res) {
       if (!res || typeof res !== "object") {
         throw new TypeError(
@@ -44998,13 +45000,13 @@ var require_get_vercel_oidc_token = __commonJS({
     var __toCommonJS2 = /* @__PURE__ */ __name((mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod), "__toCommonJS");
     var get_vercel_oidc_token_exports = {};
     __export2(get_vercel_oidc_token_exports, {
-      getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken5, "getVercelOidcToken"),
+      getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken6, "getVercelOidcToken"),
       getVercelOidcTokenSync: /* @__PURE__ */ __name(() => getVercelOidcTokenSync2, "getVercelOidcTokenSync")
     });
     module2.exports = __toCommonJS2(get_vercel_oidc_token_exports);
     var import_get_context = require_get_context();
     var import_token_error = require_token_error();
-    async function getVercelOidcToken5(options) {
+    async function getVercelOidcToken6(options) {
       let token = "";
       let err;
       try {
@@ -45034,7 +45036,7 @@ ${error48.message}`;
       }
       return token;
     }
-    __name(getVercelOidcToken5, "getVercelOidcToken");
+    __name(getVercelOidcToken6, "getVercelOidcToken");
     function getVercelOidcTokenSync2() {
       const token = (0, import_get_context.getContext)().headers?.["x-vercel-oidc-token"] ?? process.env.VERCEL_OIDC_TOKEN;
       if (!token) {
@@ -50258,6 +50260,7 @@ var WorkflowErrorCode = SemanticConvention("workflow.error.code");
 var WorkflowStepsCreated = SemanticConvention("workflow.steps.created");
 var WorkflowHooksCreated = SemanticConvention("workflow.hooks.created");
 var WorkflowWaitsCreated = SemanticConvention("workflow.waits.created");
+var WorkflowStepsFailedSerialization = SemanticConvention("workflow.steps.failed_serialization");
 var StepName = SemanticConvention("step.name");
 var StepId = SemanticConvention("step.id");
 var StepAttempt = SemanticConvention("step.attempt");
@@ -50523,7 +50526,7 @@ init_dist();
 init_node();
 
 // ../core/dist/version.js
-var version2 = "4.8.4";
+var version2 = "4.8.6";
 
 // ../core/dist/runtime/world.js
 var import_node_module = require("node:module");
@@ -50800,6 +50803,18 @@ var config2 = once2(() => {
   const baseUrl = getBaseUrlFromEnv();
   return { dataDir, baseUrl };
 });
+function resolveRecoverActiveRuns(config3) {
+  if (config3.recoverActiveRuns !== void 0) {
+    return config3.recoverActiveRuns;
+  }
+  const raw = process.env.WORKFLOW_LOCAL_RECOVER_ACTIVE_RUNS?.toLowerCase();
+  if (raw === "0" || raw === "false")
+    return false;
+  if (raw === "1" || raw === "true")
+    return true;
+  return true;
+}
+__name(resolveRecoverActiveRuns, "resolveRecoverActiveRuns");
 function resolveDirectBaseUrl(config3) {
   return config3.baseUrl ?? process.env.WORKFLOW_LOCAL_BASE_URL ?? createWorkflowBaseUrl("http://localhost");
 }
@@ -50888,8 +50903,10 @@ async function withWindowsRetry(fn, maxRetries = 5) {
 }
 __name(withWindowsRetry, "withWindowsRetry");
 var createdFilesCache = /* @__PURE__ */ new Set();
+var createdDirectoriesCache = /* @__PURE__ */ new Set();
 function clearCreatedFilesCache() {
   createdFilesCache.clear();
+  createdDirectoriesCache.clear();
 }
 __name(clearCreatedFilesCache, "clearCreatedFilesCache");
 var TAG_PATTERN = /\.[a-zA-Z][a-zA-Z0-9-]*$/;
@@ -50950,12 +50967,31 @@ async function listTaggedFilesByExtension(dirPath, tag, extension) {
 }
 __name(listTaggedFilesByExtension, "listTaggedFilesByExtension");
 async function ensureDir(dirPath) {
+  const resolvedPath = import_node_path.default.resolve(dirPath);
+  if (createdDirectoriesCache.has(resolvedPath)) {
+    return;
+  }
   try {
-    await import_node_fs.promises.mkdir(dirPath, { recursive: true });
+    await import_node_fs.promises.mkdir(resolvedPath, { recursive: true });
+    createdDirectoriesCache.add(resolvedPath);
   } catch (_error) {
   }
 }
 __name(ensureDir, "ensureDir");
+async function withEnsuredDirectory(dirPath, operation) {
+  await ensureDir(dirPath);
+  try {
+    return await operation();
+  } catch (error48) {
+    if (error48.code !== "ENOENT") {
+      throw error48;
+    }
+    createdDirectoriesCache.delete(import_node_path.default.resolve(dirPath));
+    await ensureDir(dirPath);
+    return operation();
+  }
+}
+__name(withEnsuredDirectory, "withEnsuredDirectory");
 function jsonReplacer(_key, value) {
   if (value instanceof Uint8Array) {
     return {
@@ -50995,10 +51031,11 @@ async function write(filePath, data, opts) {
   const tempPath = `${filePath}.tmp.${ulid3()}`;
   let tempFileCreated = false;
   try {
-    await ensureDir(import_node_path.default.dirname(filePath));
-    await import_node_fs.promises.writeFile(tempPath, data);
-    tempFileCreated = true;
-    await withWindowsRetry(() => import_node_fs.promises.rename(tempPath, filePath));
+    await withEnsuredDirectory(import_node_path.default.dirname(filePath), async () => {
+      await import_node_fs.promises.writeFile(tempPath, data);
+      tempFileCreated = true;
+      await withWindowsRetry(() => import_node_fs.promises.rename(tempPath, filePath));
+    });
     createdFilesCache.add(filePath);
   } catch (error48) {
     if (tempFileCreated) {
@@ -51046,21 +51083,22 @@ async function deleteJSON(filePath) {
 }
 __name(deleteJSON, "deleteJSON");
 async function writeExclusive(filePath, data) {
-  await ensureDir(import_node_path.default.dirname(filePath));
   const tempPath = `${filePath}.tmp.${ulid3()}`;
   let tempFileCreated = false;
   try {
-    await import_node_fs.promises.writeFile(tempPath, data, { flag: "wx" });
-    tempFileCreated = true;
-    try {
-      await withWindowsRetry(() => import_node_fs.promises.link(tempPath, filePath));
-      return true;
-    } catch (error48) {
-      if (error48.code === "EEXIST") {
-        return false;
+    return await withEnsuredDirectory(import_node_path.default.dirname(filePath), async () => {
+      await import_node_fs.promises.writeFile(tempPath, data, { flag: "wx" });
+      tempFileCreated = true;
+      try {
+        await withWindowsRetry(() => import_node_fs.promises.link(tempPath, filePath));
+        return true;
+      } catch (error48) {
+        if (error48.code === "EEXIST") {
+          return false;
+        }
+        throw error48;
       }
-      throw error48;
-    }
+    });
   } finally {
     if (tempFileCreated) {
       await withWindowsRetry(() => import_node_fs.promises.unlink(tempPath), 3).catch(() => {
@@ -51099,11 +51137,12 @@ function createCursor(timestamp, id) {
 }
 __name(createCursor, "createCursor");
 async function paginatedFileSystemQuery(config3) {
-  const { directory, schema, filePrefix, fileIdFilter, filter: filter2, sortOrder = "desc", limit = 20, cursor, getCreatedAt, getId } = config3;
+  const { directory, schema, cachedItems, filePrefix, fileIdFilter, filter: filter2, sortOrder = "desc", limit = 20, cursor, getCreatedAt, getId } = config3;
   if (filePrefix !== void 0) {
     assertSafeEntityId("filePrefix", filePrefix);
   }
-  const fileIds = await listJSONFiles(directory);
+  const resolvedDirectory = import_node_path.default.resolve(directory);
+  const fileIds = await listJSONFiles(resolvedDirectory);
   const relevantFileIds = filePrefix ? fileIds.filter((fileId) => fileId.startsWith(filePrefix)) : fileIds;
   const filteredFileIds = fileIdFilter ? relevantFileIds.filter(fileIdFilter) : relevantFileIds;
   const parsedCursor = parseCursor(cursor);
@@ -51125,10 +51164,11 @@ async function paginatedFileSystemQuery(config3) {
   }
   const validItems = [];
   for (const fileId of candidateFileIds) {
-    const filePath = import_node_path.default.join(directory, `${fileId}.json`);
+    const filePath = import_node_path.default.join(resolvedDirectory, `${fileId}.json`);
     let item = null;
     try {
-      item = await readJSON(filePath, schema);
+      const cachedItem = cachedItems?.get(filePath);
+      item = cachedItem === void 0 ? await readJSON(filePath, schema) : structuredClone(cachedItem);
     } catch (error48) {
       if (error48 instanceof external_exports.ZodError) {
         console.warn(`Skipping item ${fileId} due to malformed JSON: ${error48.message}`);
@@ -51888,6 +51928,8 @@ function createQueue(config3) {
   const transport = new TypedJsonTransport();
   const generateId2 = monotonicFactory();
   const semaphore = new import_async_sema.Sema(WORKFLOW_LOCAL_QUEUE_CONCURRENCY);
+  const closeController = new AbortController();
+  const closeSignal = closeController.signal;
   const inflightMessages = /* @__PURE__ */ new Map();
   const directHandlers = /* @__PURE__ */ new Map();
   const queue = /* @__PURE__ */ __name(async (queueName, message, opts) => {
@@ -51946,6 +51988,7 @@ function createQueue(config3) {
               headers: new Headers(headers),
               body,
               agents: nodeHttpAgents,
+              signal: closeSignal,
               headersTimeoutMs: agentOptions.headersTimeout,
               bodyTimeoutMs: agentOptions.bodyTimeout
             }) : (
@@ -51955,7 +51998,8 @@ function createQueue(config3) {
                 duplex: "half",
                 dispatcher: httpAgent,
                 headers,
-                body
+                body,
+                signal: closeSignal
               })
             );
           }
@@ -52061,6 +52105,9 @@ function createQueue(config3) {
       directHandlers.set(prefix, handler);
     },
     async close() {
+      if (closeSignal.aborted)
+        return;
+      closeController.abort();
       if (nodeHttpAgents)
         destroyNodeHttpAgents(nodeHttpAgents);
       await httpAgent?.close();
@@ -52523,8 +52570,81 @@ async function deleteAllWaitsForRun(basedir, runId) {
 }
 __name(deleteAllWaitsForRun, "deleteAllWaitsForRun");
 function createEventsStorage(basedir, tag) {
+  const maxCachedEventBytes = 4 * 1024 * 1024;
+  const maxCachedEventEntries = 1e3;
+  const eventCache = /* @__PURE__ */ new Map();
+  const cachedEventBytes = /* @__PURE__ */ new Map();
+  const cachedPathsByRunId = /* @__PURE__ */ new Map();
+  let totalCachedEventBytes = 0;
+  function deleteCachedEvent(eventPath) {
+    const event = eventCache.get(eventPath);
+    if (!event) {
+      return;
+    }
+    eventCache.delete(eventPath);
+    totalCachedEventBytes -= cachedEventBytes.get(eventPath) ?? 0;
+    cachedEventBytes.delete(eventPath);
+    const cachedPaths = cachedPathsByRunId.get(event.runId);
+    cachedPaths?.delete(eventPath);
+    if (cachedPaths?.size === 0) {
+      cachedPathsByRunId.delete(event.runId);
+    }
+  }
+  __name(deleteCachedEvent, "deleteCachedEvent");
+  function clearRunCache(runId) {
+    for (const cachedPath of cachedPathsByRunId.get(runId) ?? []) {
+      deleteCachedEvent(cachedPath);
+    }
+  }
+  __name(clearRunCache, "clearRunCache");
+  function clearCache() {
+    eventCache.clear();
+    cachedEventBytes.clear();
+    cachedPathsByRunId.clear();
+    totalCachedEventBytes = 0;
+  }
+  __name(clearCache, "clearCache");
+  function cacheEvent(eventPath, cachedEvent, serializedBytes) {
+    if (serializedBytes > maxCachedEventBytes) {
+      return;
+    }
+    while (eventCache.size > 0 && (eventCache.size >= maxCachedEventEntries || totalCachedEventBytes + serializedBytes > maxCachedEventBytes)) {
+      const oldestPath = eventCache.keys().next().value;
+      deleteCachedEvent(oldestPath);
+    }
+    eventCache.set(eventPath, cachedEvent);
+    cachedEventBytes.set(eventPath, serializedBytes);
+    totalCachedEventBytes += serializedBytes;
+    const cachedPaths = cachedPathsByRunId.get(cachedEvent.runId) ?? /* @__PURE__ */ new Set();
+    cachedPaths.add(eventPath);
+    cachedPathsByRunId.set(cachedEvent.runId, cachedPaths);
+  }
+  __name(cacheEvent, "cacheEvent");
+  function rememberStoredEvent(event, eventPath, serializedEvent) {
+    if (event.eventType === "run_completed" || event.eventType === "run_failed" || event.eventType === "run_cancelled") {
+      clearRunCache(event.runId);
+      return;
+    }
+    const serializedBytes = Buffer.byteLength(serializedEvent);
+    if (serializedBytes > maxCachedEventBytes) {
+      return;
+    }
+    const cachedEvent = EventSchema.safeParse(JSON.parse(serializedEvent, jsonReviver));
+    if (cachedEvent.success) {
+      cacheEvent(eventPath, cachedEvent.data, serializedBytes);
+    }
+  }
+  __name(rememberStoredEvent, "rememberStoredEvent");
+  async function storeEvent(event) {
+    const eventPath = taggedPath(basedir, "events", `${event.runId}-${event.eventId}`, tag);
+    const serializedEvent = JSON.stringify(event, jsonReplacer, 2);
+    await write(eventPath, serializedEvent);
+    rememberStoredEvent(event, eventPath, serializedEvent);
+  }
+  __name(storeEvent, "storeEvent");
   const hookLocks = /* @__PURE__ */ new Map();
   return {
+    clearCache,
     async create(runId, data, params) {
       if (runId != null && runId !== "") {
         assertSafeEntityId("runId", runId);
@@ -52594,8 +52714,7 @@ function createEventsStorage(basedir, tag) {
                     executionContext: runInputData.executionContext
                   }
                 };
-                const createdCompositeKey = `${effectiveRunId}-${runCreatedEventId}`;
-                await writeJSON(taggedPath(basedir, "events", createdCompositeKey, tag), runCreatedEvent);
+                await storeEvent(runCreatedEvent);
                 currentRun = createdRun;
               } else {
                 currentRun = await readJSONWithFallback(basedir, "runs", effectiveRunId, WorkflowRunSchema, tag);
@@ -52625,8 +52744,7 @@ function createEventsStorage(basedir, tag) {
               createdAt: now,
               specVersion: effectiveSpecVersion
             };
-            const compositeKey2 = `${effectiveRunId}-${eventId}`;
-            await writeJSON(taggedPath(basedir, "events", compositeKey2, tag), event2);
+            await storeEvent(event2);
             const resolveData2 = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
             return {
               event: stripEventDataRefs(event2, resolveData2),
@@ -52975,8 +53093,7 @@ function createEventsStorage(basedir, tag) {
                 createdAt: now,
                 specVersion: effectiveSpecVersion
               };
-              const compositeKey2 = `${effectiveRunId}-${eventId}`;
-              await writeJSON(taggedPath(basedir, "events", compositeKey2, tag), conflictEvent);
+              await storeEvent(conflictEvent);
               const resolveData2 = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
               const filteredEvent2 = stripEventDataRefs(conflictEvent, resolveData2);
               return {
@@ -53060,13 +53177,16 @@ function createEventsStorage(basedir, tag) {
           await writeJSON(taggedPath(basedir, "waits", waitCompositeKey, tag), wait, { overwrite: true });
         }
         const compositeKey = `${effectiveRunId}-${eventId}`;
-        const eventPublished = await writeExclusive(taggedPath(basedir, "events", compositeKey, tag), JSON.stringify(event, jsonReplacer, 2));
+        const eventPath = taggedPath(basedir, "events", compositeKey, tag);
+        const serializedEvent = JSON.stringify(event, jsonReplacer, 2);
+        const eventPublished = await writeExclusive(eventPath, serializedEvent);
         if (!eventPublished) {
           if (data.eventType === "hook_created" && data.correlationId) {
             await repairHookEntityFromPersistedEvent(basedir, effectiveRunId, data.correlationId, eventId, tag);
           }
           throw new EntityConflictError(`Event "${eventId}" already exists for run "${effectiveRunId}"`);
         }
+        rememberStoredEvent(event, eventPath, serializedEvent);
         if (hook && data.eventType === "hook_created") {
           await writeJSON(taggedPath(basedir, "hooks", hook.hookId, tag), hook, hookEntityWriteOptions);
         }
@@ -53079,6 +53199,7 @@ function createEventsStorage(basedir, tag) {
           const allEvents = await paginatedFileSystemQuery({
             directory: import_node_path5.default.join(basedir, "events"),
             schema: EventSchema,
+            cachedItems: eventCache,
             filePrefix: `${effectiveRunId}-`,
             sortOrder: "asc",
             limit: 1e3,
@@ -53122,6 +53243,7 @@ function createEventsStorage(basedir, tag) {
       const result = await paginatedFileSystemQuery({
         directory: import_node_path5.default.join(basedir, "events"),
         schema: EventSchema,
+        cachedItems: eventCache,
         filePrefix: `${runId}-`,
         // Events in chronological order (oldest first) by default,
         // different from the default for other list calls.
@@ -53146,8 +53268,9 @@ function createEventsStorage(basedir, tag) {
       const result = await paginatedFileSystemQuery({
         directory: import_node_path5.default.join(basedir, "events"),
         schema: EventSchema,
+        cachedItems: eventCache,
         // No filePrefix - search all events
-        filter: /* @__PURE__ */ __name((event) => event.correlationId === correlationId, "filter"),
+        filter: /* @__PURE__ */ __name((event) => event.correlationId === correlationId && (params.runId === void 0 || event.runId === params.runId), "filter"),
         // Events in chronological order (oldest first) by default,
         // different from the default for other list calls.
         sortOrder: params.pagination?.sortOrder ?? "asc",
@@ -53283,7 +53406,8 @@ function createStorage(basedir, tag) {
     runs: instrumentObject("world.runs", runs),
     steps: instrumentObject("world.steps", steps),
     events: instrumentObject("world.events", events),
-    hooks: instrumentObject("world.hooks", hooks)
+    hooks: instrumentObject("world.hooks", hooks),
+    clearCache: /* @__PURE__ */ __name(() => events.clearCache(), "clearCache")
   };
 }
 __name(createStorage, "createStorage");
@@ -53683,8 +53807,8 @@ function createLocalWorld(args) {
   const mergedConfig = { ...config2.value, ...definedArgs };
   const tag = mergedConfig.tag;
   const queue = createQueue(mergedConfig);
-  const storage = createStorage(mergedConfig.dataDir, tag);
-  const recoverActiveRuns = mergedConfig.recoverActiveRuns ?? true;
+  const { clearCache: clearStorageCache, ...storage } = createStorage(mergedConfig.dataDir, tag);
+  const recoverActiveRuns = resolveRecoverActiveRuns(mergedConfig);
   return {
     specVersion: SPEC_VERSION_CURRENT,
     ...queue,
@@ -53711,9 +53835,11 @@ function createLocalWorld(args) {
       await reenqueueActiveRuns(recoveryRuns, queue.queue, "world-local");
     },
     async close() {
+      clearStorageCache();
       await queue.close();
     },
     async clear() {
+      clearStorageCache();
       if (tag) {
         const basedir = mergedConfig.dataDir;
         const hooksDir = import_node_path9.default.join(basedir, "hooks");
@@ -53747,6 +53873,7 @@ function createLocalWorld(args) {
         })));
         clearCreatedFilesCache();
       } else {
+        clearCreatedFilesCache();
         await (0, import_promises6.rm)(mergedConfig.dataDir, { recursive: true, force: true });
         await initDataDir(mergedConfig.dataDir);
       }
@@ -54247,7 +54374,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, onTransportOutcome } = opts;
+  const { method, url: url2, headers, body, dispatcher, peerService = "workflow-server", timeoutMs = REQUEST_TIMEOUT_MS, signal: callerSignal, injectTraceContext = true, cacheBust = true, logLabel, buildError, onTransportOutcome, deferTransportSuccessUntilBody = false } = opts;
   const label = logLabel ?? url2;
   return trace4(`http ${method}`, { kind: await getSpanKind3("CLIENT") }, async (span) => {
     span?.setAttributes(httpClientSpanAttributes({ method, url: url2, peerService }));
@@ -54295,18 +54422,31 @@ async function instrumentedFetch(opts) {
       throw error48;
     }
     const ms2 = Date.now() - start2;
-    onTransportOutcome?.();
+    if (!deferTransportSuccessUntilBody)
+      onTransportOutcome?.();
     httpLog(method, label, response, ms2);
     span?.setAttributes({ ...HttpResponseStatusCode2(response.status) });
     if (!response.ok) {
       span?.setAttributes({ ...ErrorType2(`HTTP ${response.status}`) });
       logCurlRepro(method, url2, headers);
       if (buildError) {
-        const error49 = await buildError(response);
+        let error49;
+        try {
+          error49 = await buildError(response);
+        } catch (cause) {
+          if (deferTransportSuccessUntilBody) {
+            onTransportOutcome?.(cause);
+          }
+          throw cause;
+        }
+        if (deferTransportSuccessUntilBody)
+          onTransportOutcome?.();
         span?.recordException?.(error49);
         throw error49;
       }
       const text = await response.text().catch(() => "");
+      if (deferTransportSuccessUntilBody)
+        onTransportOutcome?.();
       const error48 = errorForResponse(response.status, `${method} ${label} -> HTTP ${response.status}: ${response.statusText}${text ? ` ${text}` : ""}${formatVercelDiagnostics(response.headers)}`, {
         url: url2,
         retryAfter: parseRetryAfter(response.headers.get("Retry-After"))
@@ -61451,7 +61591,7 @@ var import_oidc3 = __toESM(require_dist(), 1);
 init_dist();
 
 // ../world-vercel/dist/version.js
-var version3 = "4.7.0";
+var version3 = "4.7.2";
 
 // ../world-vercel/dist/utils.js
 var WORKFLOW_SERVER_URL_OVERRIDE = "";
@@ -61968,21 +62108,35 @@ function createQueue2(config3) {
 __name(createQueue2, "createQueue");
 
 // ../world-vercel/dist/resolve-latest-deployment.js
+var import_oidc4 = __toESM(require_dist(), 1);
 init_zod();
 var ResolveLatestDeploymentResponseSchema = object({
   id: string2()
 });
+async function resolveDeploymentIdentityToken(config3) {
+  if (config3?.token)
+    return config3.token;
+  if (process.env.VERCEL === "1") {
+    const oidcToken = await (0, import_oidc4.getVercelOidcToken)().catch(() => null);
+    if (oidcToken)
+      return oidcToken;
+  }
+  return resolveVercelApiToken(config3);
+}
+__name(resolveDeploymentIdentityToken, "resolveDeploymentIdentityToken");
 function createResolveLatestDeploymentId(config3) {
   return /* @__PURE__ */ __name(async function resolveLatestDeploymentId() {
     const currentDeploymentId = process.env.VERCEL_DEPLOYMENT_ID;
     if (!currentDeploymentId) {
       throw new Error("Cannot resolve latest deployment: VERCEL_DEPLOYMENT_ID environment variable is not set");
     }
-    const token = await resolveVercelApiToken(config3);
+    const token = await resolveDeploymentIdentityToken(config3);
     if (!token) {
       throw new Error("Cannot resolve latest deployment: no OIDC token or VERCEL_TOKEN available");
     }
-    const url2 = `https://api.vercel.com/v1/workflow/resolve-latest-deployment/${encodeURIComponent(currentDeploymentId)}`;
+    const teamId = config3?.projectConfig?.teamId;
+    const query = teamId ? `?${new URLSearchParams({ teamId })}` : "";
+    const url2 = `https://api.vercel.com/v1/workflow/resolve-latest-deployment/${encodeURIComponent(currentDeploymentId)}${query}`;
     const response = await instrumentedFetch({
       method: "GET",
       url: url2,
@@ -61999,7 +62153,8 @@ function createResolveLatestDeploymentId(config3) {
         } catch {
           body = "<unable to read response body>";
         }
-        return new Error(`Failed to resolve latest deployment for ${currentDeploymentId}: HTTP ${res.status} ${res.statusText}${body ? ` \u2014 ${body}` : ""}`);
+        const hint = res.status === 404 ? ". The deployment exists but was not visible to the identity this request authenticated as, which means the request resolved to a different team. Set the World's `projectConfig.teamId` to scope it explicitly." : "";
+        return new Error(`Failed to resolve latest deployment for ${currentDeploymentId}: HTTP ${res.status} ${res.statusText}${body ? ` \u2014 ${body}` : ""}${hint}`);
       }, "buildError")
     });
     const data = await response.json();
@@ -62280,7 +62435,7 @@ __name(readerToIterator, "readerToIterator");
 // ../world-vercel/dist/events-v4.js
 async function fetchV4(url2, init, config3, opName) {
   const dispatcher = getEventsDispatcher(config3);
-  return instrumentedFetch({
+  const response = await instrumentedFetch({
     method: init.method,
     url: url2,
     headers: init.headers,
@@ -62291,9 +62446,40 @@ async function fetchV4(url2, init, config3, opName) {
     // 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"),
+    deferTransportSuccessUntilBody: true,
     timeoutMs: null,
     logLabel: opName,
-    buildError: /* @__PURE__ */ __name(async (response) => errorFromV4Response(response.status, headersToRecord(response.headers), await response.text(), opName, url2), "buildError")
+    buildError: /* @__PURE__ */ __name(async (response2) => errorFromV4Response(response2.status, headersToRecord(response2.headers), await response2.text(), opName, url2), "buildError")
+  });
+  if (!response.body) {
+    noteEventsTransportOutcome(dispatcher);
+    return response;
+  }
+  const reader = response.body.getReader();
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          noteEventsTransportOutcome(dispatcher);
+          controller.close();
+        } else {
+          controller.enqueue(chunk.value);
+        }
+      } catch (cause) {
+        noteEventsTransportOutcome(dispatcher, cause);
+        controller.error(cause);
+      }
+    },
+    cancel(reason) {
+      noteEventsTransportOutcome(dispatcher);
+      return reader.cancel(reason);
+    }
+  });
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
   });
 }
 __name(fetchV4, "fetchV4");
@@ -62473,10 +62659,12 @@ async function getWorkflowRunEventsV4(runId, params = {}, config3) {
   return consumeListFrameStream(url2, headers, config3, "listEvents");
 }
 __name(getWorkflowRunEventsV4, "getWorkflowRunEventsV4");
-async function getEventsByCorrelationIdV4(correlationId, params = {}, config3) {
+async function getEventsByCorrelationIdV4(correlationId, params = {}, config3, runId) {
   const { baseUrl, headers } = await getHttpConfig(config3);
   const sp = new URLSearchParams();
   sp.set("correlationId", correlationId);
+  if (runId !== void 0)
+    sp.set("runId", runId);
   appendListParams(sp, params);
   const url2 = `${baseUrl}/v4/events?${sp.toString()}`;
   return consumeListFrameStream(url2, headers, config3, "listEventsByCorrelationId");
@@ -62889,10 +63077,13 @@ async function getWorkflowRunEvents(params, config3) {
     sortOrder: pagination?.sortOrder,
     remoteRefBehavior: resolveData === "none" ? "lazy" : "resolve"
   };
-  const result = await ("correlationId" in params ? getEventsByCorrelationIdV4(params.correlationId, wirePagination, config3) : getWorkflowRunEventsV4(params.runId, wirePagination, config3));
+  const runId = "correlationId" in params ? params.runId : void 0;
+  const result = await ("correlationId" in params ? getEventsByCorrelationIdV4(params.correlationId, wirePagination, config3, runId) : getWorkflowRunEventsV4(params.runId, wirePagination, config3));
   const events = result.events.map((listed) => buildEventFromV4(listed.event, listed.body, resolveData));
   return {
-    data: events,
+    // Older servers may ignore the runId query parameter. Keep the client
+    // filter as a compatibility guard until every server honors it.
+    data: runId !== void 0 ? events.filter((event) => event.runId === runId) : events,
     cursor: result.next ?? null,
     hasMore: Boolean(result.next)
   };
@@ -64466,7 +64657,7 @@ function getStepFunction(stepId) {
 }
 __name(getStepFunction, "getStepFunction");
 var DEFER_BEHIND = {
-  hook: ["wait", "step"],
+  hook: ["hook", "wait", "step"],
   wait: ["hook", "step"],
   step: ["wait", "hook", "step"]
 };
@@ -64528,12 +64719,6 @@ function registerDeliveryBarrier(ctx, eventIndex, kind, options = {}) {
   }
   let done = false;
   const { promise: promise2, resolve: resolve3 } = withResolvers();
-  const entry = {
-    kind,
-    delivered: promise2,
-    armed: options.armed ?? true
-  };
-  barriers.set(eventIndex, entry);
   const finish = /* @__PURE__ */ __name(() => {
     if (done) {
       return;
@@ -64544,7 +64729,14 @@ function registerDeliveryBarrier(ctx, eventIndex, kind, options = {}) {
     }
     resolve3();
   }, "finish");
-  scheduleWhenIdle(ctx, finish);
+  const entry = {
+    kind,
+    delivered: promise2,
+    armed: options.armed ?? true,
+    retire: finish
+  };
+  barriers.set(eventIndex, entry);
+  ensureBarrierSafetyNet(ctx);
   return {
     markDelivered: finish,
     arm: /* @__PURE__ */ __name(() => {
@@ -64553,6 +64745,48 @@ function registerDeliveryBarrier(ctx, eventIndex, kind, options = {}) {
   };
 }
 __name(registerDeliveryBarrier, "registerDeliveryBarrier");
+var activeBarrierSafetyNets = /* @__PURE__ */ new WeakSet();
+function ensureBarrierSafetyNet(ctx) {
+  const barriers = ctx.pendingDeliveryBarriers;
+  if (!barriers || activeBarrierSafetyNets.has(ctx)) {
+    return;
+  }
+  activeBarrierSafetyNets.add(ctx);
+  const rearm = /* @__PURE__ */ __name(() => {
+    setTimeout(check2, 0);
+  }, "rearm");
+  const rearmAfterRejection = /* @__PURE__ */ __name(() => {
+    setTimeout(check2, 50);
+  }, "rearmAfterRejection");
+  const check2 = /* @__PURE__ */ __name(() => {
+    if (barriers.size === 0) {
+      activeBarrierSafetyNets.delete(ctx);
+      return;
+    }
+    if (!canRetireAbandonedBarriers(ctx)) {
+      ctx.promiseQueue.then(rearm, rearmAfterRejection);
+      return;
+    }
+    while (barriers.size > 0 && canRetireAbandonedBarriers(ctx)) {
+      let lowestIndex;
+      let lowestEntry;
+      for (const [index, entry] of barriers) {
+        if (lowestIndex === void 0 || index < lowestIndex) {
+          lowestIndex = index;
+          lowestEntry = entry;
+        }
+      }
+      lowestEntry?.retire();
+    }
+    setTimeout(check2, 0);
+  }, "check");
+  setTimeout(check2, 0);
+}
+__name(ensureBarrierSafetyNet, "ensureBarrierSafetyNet");
+function canRetireAbandonedBarriers(ctx) {
+  return ctx.pendingDeliveries === 0 && !hasParkedCommittedDelivery(ctx);
+}
+__name(canRetireAbandonedBarriers, "canRetireAbandonedBarriers");
 function hasParkedCommittedDelivery(ctx) {
   const barriers = ctx.pendingDeliveryBarriers;
   if (!barriers || barriers.size === 0) {
@@ -64568,7 +64802,7 @@ function hasParkedCommittedDelivery(ctx) {
 }
 __name(hasParkedCommittedDelivery, "hasParkedCommittedDelivery");
 function isDeliveryIdle(ctx) {
-  return ctx.pendingDeliveries === 0 && !hasParkedCommittedDelivery(ctx);
+  return ctx.pendingDeliveries === 0 && (!ctx.pendingDeliveryBarriers || ctx.pendingDeliveryBarriers.size === 0);
 }
 __name(isDeliveryIdle, "isDeliveryIdle");
 function scheduleWhenIdle(ctx, fn) {
@@ -65713,6 +65947,23 @@ async function hydrateStepReturnValue(value, _runId, key, global2 = globalThis,
 }
 __name(hydrateStepReturnValue, "hydrateStepReturnValue");
 
+// ../core/dist/runtime/unserializable-step.js
+var UNSERIALIZABLE_STEP_INPUT_MARKER = "[input unavailable: step argument serialization failed]";
+var UNSERIALIZABLE_FLAG = "__workflowUnserializableStepInput";
+function unserializableStepInputPlaceholder() {
+  return {
+    args: [UNSERIALIZABLE_STEP_INPUT_MARKER],
+    closureVars: [],
+    thisVal: void 0,
+    [UNSERIALIZABLE_FLAG]: true
+  };
+}
+__name(unserializableStepInputPlaceholder, "unserializableStepInputPlaceholder");
+function isUnserializableStepInputPlaceholder(hydratedInput) {
+  return typeof hydratedInput === "object" && hydratedInput !== null && hydratedInput[UNSERIALIZABLE_FLAG] === true;
+}
+__name(isUnserializableStepInputPlaceholder, "isUnserializableStepInputPlaceholder");
+
 // ../core/dist/runtime/suspension-handler.js
 function extractTraceHeaders(traceCarrier) {
   const headers = {};
@@ -65849,15 +66100,84 @@ async function handleSuspension({ suspension, world, run: run2, span, requestId,
     }));
   }
   const stepsNeedingCreation = new Set(stepItems.filter((queueItem) => !queueItem.hasCreatedEvent).map((queueItem) => queueItem.correlationId));
+  const failedStepCorrelationIds = /* @__PURE__ */ new Set();
+  const finalizeUnserializableStep = /* @__PURE__ */ __name(async (queueItem, error48) => {
+    runtimeLogger.warn("Step arguments failed to serialize; failing the step so the workflow can observe the error", {
+      workflowRunId: runId,
+      correlationId: queueItem.correlationId,
+      stepName: queueItem.stepName,
+      error: error48.message
+    });
+    const placeholderInput = await dehydrateStepArguments(unserializableStepInputPlaceholder(), runId, encryptionKey, suspension.globalThis);
+    try {
+      await createGuarded({
+        eventType: "step_created",
+        specVersion: SPEC_VERSION_CURRENT,
+        correlationId: queueItem.correlationId,
+        eventData: {
+          stepName: queueItem.stepName,
+          workflowName: run2.workflowName,
+          input: placeholderInput
+        }
+      }, { requestId });
+    } catch (createErr) {
+      if (EntityConflictError.is(createErr)) {
+        runtimeLogger.info("Step already exists, continuing", {
+          workflowRunId: runId,
+          correlationId: queueItem.correlationId,
+          message: createErr.message
+        });
+      } else if (RunExpiredError.is(createErr)) {
+        return;
+      } else {
+        throw createErr;
+      }
+    }
+    try {
+      await createGuarded({
+        eventType: "step_failed",
+        specVersion: SPEC_VERSION_CURRENT,
+        correlationId: queueItem.correlationId,
+        eventData: {
+          stepName: queueItem.stepName,
+          // The message carries the framed serialization hint; the step
+          // consumer rejects the step's promise with a FatalError built
+          // from it, exactly like any other step failure.
+          error: error48.message,
+          stack: error48.stack
+        }
+      }, { requestId });
+    } catch (failErr) {
+      if (EntityConflictError.is(failErr) || RunExpiredError.is(failErr)) {
+        runtimeLogger.info("Tried failing step, but step or run has already finished.", {
+          workflowRunId: runId,
+          correlationId: queueItem.correlationId,
+          message: failErr.message
+        });
+      } else {
+        throw failErr;
+      }
+    }
+    failedStepCorrelationIds.add(queueItem.correlationId);
+  }, "finalizeUnserializableStep");
   const ops = [];
   for (const queueItem of stepItems) {
     ops.push((async () => {
       if (stepsNeedingCreation.has(queueItem.correlationId)) {
-        const dehydratedInput = await dehydrateStepArguments({
-          args: queueItem.args,
-          closureVars: queueItem.closureVars,
-          thisVal: queueItem.thisVal
-        }, runId, encryptionKey, suspension.globalThis);
+        let dehydratedInput;
+        try {
+          dehydratedInput = await dehydrateStepArguments({
+            args: queueItem.args,
+            closureVars: queueItem.closureVars,
+            thisVal: queueItem.thisVal
+          }, runId, encryptionKey, suspension.globalThis);
+        } catch (err) {
+          if (RuntimeDecryptionError.is(err)) {
+            throw err;
+          }
+          await finalizeUnserializableStep(queueItem, err instanceof Error ? err : new Error(String(err)));
+          return;
+        }
         const stepEvent = {
           eventType: "step_created",
           specVersion: SPEC_VERSION_CURRENT,
@@ -65939,8 +66259,12 @@ async function handleSuspension({ suspension, world, run: run2, span, requestId,
     ...WorkflowRunStatus("workflow_suspended"),
     ...WorkflowStepsCreated(stepItems.length),
     ...WorkflowHooksCreated(hooksNeedingCreation.length),
-    ...WorkflowWaitsCreated(waitItems.length)
+    ...WorkflowWaitsCreated(waitItems.length),
+    ...failedStepCorrelationIds.size > 0 ? WorkflowStepsFailedSerialization(failedStepCorrelationIds.size) : {}
   });
+  if (failedStepCorrelationIds.size > 0) {
+    return { timeoutSeconds: 0, failedStepCorrelationIds };
+  }
   if (hasHookConflict) {
     return { timeoutSeconds: 0 };
   }
@@ -68770,6 +69094,9 @@ var stepHandler = createQueueHandler(stepPrefix, async (message_, metadata) => {
       let userCodeFailed = false;
       const executionStartTime = Date.now();
       try {
+        if (isUnserializableStepInputPlaceholder(hydratedInput)) {
+          throw new FatalError(formatSerializationError("step arguments", void 0));
+        }
         result = await trace2("step.execute", {}, async () => {
           return await contextStorage.run({
             stepMetadata: {