@workflow/world-testing 4.1.19 → 4.1.20

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");
   }
 });
@@ -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.5";
 
 // ../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}`);
@@ -52523,8 +52563,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 +52707,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 +52737,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 +53086,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 +53170,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 +53192,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 +53236,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 +53261,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 +53399,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 +53800,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 +53828,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 +53866,7 @@ function createLocalWorld(args) {
         })));
         clearCreatedFilesCache();
       } else {
+        clearCreatedFilesCache();
         await (0, import_promises6.rm)(mergedConfig.dataDir, { recursive: true, force: true });
         await initDataDir(mergedConfig.dataDir);
       }
@@ -61451,7 +61571,7 @@ var import_oidc3 = __toESM(require_dist(), 1);
 init_dist();
 
 // ../world-vercel/dist/version.js
-var version3 = "4.7.0";
+var version3 = "4.7.1";
 
 // ../world-vercel/dist/utils.js
 var WORKFLOW_SERVER_URL_OVERRIDE = "";
@@ -62473,10 +62593,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 +63011,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 +64591,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 +64653,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 +64663,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 +64679,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 +64736,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 +65881,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 +66034,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 +66193,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 +69028,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: {