@workflow/web 5.0.0-beta.40 → 5.0.0-beta.41

package/build/server/assets/{app-BJXoDV4n.js → app-D8GiFFR6.js}

@@ -61,6 +61,7 @@ import require$$0$9 from "constants";
 import require$$5$2 from "assert";
 import require$$2$4 from "os";
 import * as net from "net";
+import assert$1 from "node:assert/strict";
 import express from "express";
 function _mergeNamespaces(n, m2) {
   for (var i = 0; i < m2.length; i++) {
@@ -57804,6 +57805,11 @@ function envNumber(name2, fallback, options = {}) {
   }
   return parsed;
 }
+const DEFAULT_MAX_EVENTS_PER_RUN = 25e3;
+function getMaxEventsPerRun() {
+  const maxEvents = envNumber("WORKFLOW_MAX_EVENTS", DEFAULT_MAX_EVENTS_PER_RUN, { integer: true });
+  return maxEvents > 0 ? maxEvents : DEFAULT_MAX_EVENTS_PER_RUN;
+}
 const QueuePrefix = string$3().regex(/^__(?:[a-z][a-z0-9]*_)?wkf_workflow_$/, "Must match __wkf_workflow_ or __{namespace}_wkf_workflow_");
 const ValidQueueName = string$3().regex(/^__(?:[a-z][a-z0-9]*_)?wkf_workflow_.+$/, "Must be a valid queue name with a recognized prefix");
 const QueueNamespace = string$3().regex(/^[a-z][a-z0-9]*$/, "Must be lowercase alphanumeric, starting with a letter");
@@ -57885,7 +57891,17 @@ const HookResumeInputSchema = object$1({
    * `(runId, resumeId)` constraint — required because the v4 payload ref is not
    * content-stable server-side.
    */
-  payloadDigest: string$3()
+  payloadDigest: string$3(),
+  /**
+   * The deployment the run is pinned to, from the producer's resume context.
+   * Lets the consumer detect a misrouted delivery with a cheap ambient
+   * deployment-id comparison BEFORE its hoisted `hook_received` replay-preload
+   * write — only a detected mismatch pays for the authoritative run fetch and
+   * the deployment-affinity guard. Optional for queued-message compatibility:
+   * messages from older producers omit it and simply skip the pre-write
+   * check (the authoritative guard before replay still protects them).
+   */
+  deploymentId: string$3().optional()
 });
 const WorkflowInvokePayloadSchema = object$1({
   runId: string$3(),
@@ -58060,18 +58076,58 @@ const StructuredErrorSchema = object$1({
   code: string$3().optional()
   // Populated with RunErrorCode values (USER_ERROR, RUNTIME_ERROR, etc.) for run_failed events
 });
+const EVENT_ID_BODY_LENGTH = 26;
+const SLOT_LEADING_ZEROS = 10;
+const FIRST_EVENT_SLOT = 1;
+const EVENT_ID_PREFIX = "evnt_";
+function isSlotBody(body2) {
+  if (body2.length !== EVENT_ID_BODY_LENGTH)
+    return false;
+  for (let i = 0; i < SLOT_LEADING_ZEROS; i++) {
+    if (body2[i] !== "0")
+      return false;
+  }
+  for (let i = SLOT_LEADING_ZEROS; i < EVENT_ID_BODY_LENGTH; i++) {
+    const code2 = body2.charCodeAt(i);
+    if (code2 < 48 || code2 > 57)
+      return false;
+  }
+  return true;
+}
+function stripEventIdPrefix(eventId) {
+  const underscore = eventId.indexOf("_");
+  return underscore === -1 ? eventId : eventId.slice(underscore + 1);
+}
+function isSlotEventId(eventId) {
+  return isSlotBody(stripEventIdPrefix(eventId));
+}
+function slotToEventId(slot) {
+  if (!Number.isSafeInteger(slot) || slot < FIRST_EVENT_SLOT) {
+    throw new RangeError(`Invalid event slot: ${slot}`);
+  }
+  return `${EVENT_ID_PREFIX}${String(slot).padStart(EVENT_ID_BODY_LENGTH, "0")}`;
+}
+function eventIdToSlot(eventId) {
+  const body2 = stripEventIdPrefix(eventId);
+  if (!isSlotBody(body2))
+    return null;
+  const slot = Number(body2);
+  return Number.isSafeInteger(slot) && slot >= FIRST_EVENT_SLOT ? slot : null;
+}
 const SPEC_VERSION_LEGACY = 1;
 const SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT = 3;
 const SPEC_VERSION_SUPPORTS_ATTRIBUTES = 4;
 const SPEC_VERSION_SUPPORTS_COMPRESSION = 5;
+const SPEC_VERSION_SUPPORTS_SLOT_IDENTITY = 6;
 const SPEC_VERSION_CURRENT = SPEC_VERSION_SUPPORTS_COMPRESSION;
+const SPEC_VERSION_MAX_SUPPORTED = SPEC_VERSION_SUPPORTS_SLOT_IDENTITY;
 function isLegacySpecVersion(v2) {
   return v2 === void 0 || v2 === null || v2 <= SPEC_VERSION_LEGACY;
 }
 function requiresNewerWorld(v2) {
   if (v2 === void 0 || v2 === null)
     return false;
-  return v2 > SPEC_VERSION_CURRENT;
+  return v2 > SPEC_VERSION_MAX_SUPPORTED;
 }
 const ENCODING$1 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 const ENCODING_LEN = 32;
@@ -58227,6 +58283,9 @@ const workflowRunIdSchema = templateLiteral(["wrun_", ulid$4()]);
 const DEFAULT_TIMESTAMP_THRESHOLD_PAST_MS = 24 * 60 * 60 * 1e3;
 const DEFAULT_TIMESTAMP_THRESHOLD_FUTURE_MS = 5 * 60 * 1e3;
 function ulidToDate(maybeUlid) {
+  if (isSlotBody(maybeUlid)) {
+    return null;
+  }
   const ulid2 = UlidSchema.safeParse(maybeUlid);
   if (!ulid2.success) {
     return null;
@@ -60678,7 +60737,7 @@ function replaceEncryptedAndExpiredWithMarkers(resource) {
 }
 async function hydrateResourceIOAsync(resource, key) {
   const { hydrateDataWithKey: hydrateDataWithKey2, deriveRunPayloadKeys: deriveRunPayloadKeys2 } = await Promise.resolve().then(() => serializationFormat);
-  const { ensureZstdDecoderRegistered } = await import("./zstd-browser-decoder-CWJVPmcb.js");
+  const { ensureZstdDecoderRegistered } = await import("./zstd-browser-decoder-BCVvr1WT.js");
   ensureZstdDecoderRegistered();
   const cryptoKey = key ? await deriveRunPayloadKeys2(key) : void 0;
   const revivers = getRevivers();
@@ -91623,7 +91682,7 @@ var tn = f("block", "before:content-[counter(line)]", "before:inline-block", "be
 var et = ({ className: e, language: t, style: o, isIncomplete: n, ...s2 }) => jsxRuntimeExports.jsx("div", { className: f("my-4 flex w-full flex-col gap-2 rounded-xl border border-border bg-sidebar p-2", e), "data-incomplete": n || void 0, "data-language": t, "data-streamdown": "code-block", style: { contentVisibility: "auto", containIntrinsicSize: "auto 200px", ...o }, ...s2 });
 var Se = reactExports.createContext({ code: "" }), de = () => reactExports.useContext(Se);
 var ot = ({ language: e }) => jsxRuntimeExports.jsx("div", { className: "flex h-8 items-center text-muted-foreground text-xs", "data-language": e, "data-streamdown": "code-block-header", children: jsxRuntimeExports.jsx("span", { className: "ml-1 font-mono lowercase", children: e }) });
-var cn$1 = /\n+$/, dn = reactExports.lazy(() => import("./highlighted-body-B3W2YXNL-Kki0lKyo.js").then((e) => ({ default: e.HighlightedCodeBlockBody }))), rt = ({ code: e, language: t, className: o, children: n, isIncomplete: s2 = false, ...r2 }) => {
+var cn$1 = /\n+$/, dn = reactExports.lazy(() => import("./highlighted-body-B3W2YXNL-BZVc2guG.js").then((e) => ({ default: e.HighlightedCodeBlockBody }))), rt = ({ code: e, language: t, className: o, children: n, isIncomplete: s2 = false, ...r2 }) => {
   let i = reactExports.useMemo(() => e.replace(cn$1, ""), [e]), c = reactExports.useMemo(() => ({ bg: "transparent", fg: "inherit", tokens: i.split(`
 `).map((a2) => [{ content: a2, color: "inherit", bgColor: "transparent", htmlStyle: {}, offset: 0 }]) }), [i]);
   return jsxRuntimeExports.jsx(Se.Provider, { value: { code: e }, children: jsxRuntimeExports.jsxs(et, { isIncomplete: s2, language: t, children: [jsxRuntimeExports.jsx(ot, { language: t }), n ? jsxRuntimeExports.jsx("div", { className: "pointer-events-none sticky top-2 z-10 -mt-10 flex h-8 items-center justify-end", children: jsxRuntimeExports.jsx("div", { className: "pointer-events-auto flex shrink-0 items-center gap-2 rounded-md border border-sidebar bg-sidebar/80 px-1.5 py-1 supports-[backdrop-filter]:bg-sidebar/70 supports-[backdrop-filter]:backdrop-blur", "data-streamdown": "code-block-actions", children: n }) }) : null, jsxRuntimeExports.jsx(reactExports.Suspense, { fallback: jsxRuntimeExports.jsx(Qe, { className: o, language: t, result: c, ...r2 }), children: jsxRuntimeExports.jsx(dn, { className: o, code: i, language: t, raw: c, ...r2 }) })] }) });
@@ -91945,7 +92004,7 @@ var Dt = ({ children: e, className: t, onDownload: o, onError: n }) => {
   }, []), jsxRuntimeExports.jsxs("div", { className: "relative", ref: i, children: [jsxRuntimeExports.jsx("button", { className: f("cursor-pointer p-1 text-muted-foreground transition-all hover:text-foreground disabled:cursor-not-allowed disabled:opacity-50", t), disabled: c, onClick: () => r2(!s2), title: "Download table", type: "button", children: e != null ? e : jsxRuntimeExports.jsx(Z, { size: 14 }) }), s2 ? jsxRuntimeExports.jsxs("div", { className: "absolute top-full right-0 z-10 mt-1 min-w-[120px] overflow-hidden rounded-md border border-border bg-background shadow-lg", children: [jsxRuntimeExports.jsx("button", { className: "w-full px-3 py-2 text-left text-sm transition-colors hover:bg-muted/40", onClick: () => a2("csv"), title: "Download table as CSV", type: "button", children: "CSV" }), jsxRuntimeExports.jsx("button", { className: "w-full px-3 py-2 text-left text-sm transition-colors hover:bg-muted/40", onClick: () => a2("markdown"), title: "Download table as Markdown", type: "button", children: "Markdown" })] }) : null] });
 };
 var Vt = ({ children: e, className: t, showControls: o, ...n }) => jsxRuntimeExports.jsxs("div", { className: "my-4 flex flex-col gap-2 rounded-lg border border-border bg-sidebar p-2", "data-streamdown": "table-wrapper", children: [o ? jsxRuntimeExports.jsxs("div", { className: "flex items-center justify-end gap-1", children: [jsxRuntimeExports.jsx(Ht, {}), jsxRuntimeExports.jsx(Dt, {})] }) : null, jsxRuntimeExports.jsx("div", { className: "border-collapse overflow-x-auto overscroll-y-auto rounded-md border border-border bg-background", children: jsxRuntimeExports.jsx("table", { className: f("w-full divide-y divide-border", t), "data-streamdown": "table", ...n, children: e }) })] });
-var Jn = reactExports.lazy(() => import("./mermaid-3ZIDBTTL-Bh_zbSQ-.js").then((e) => ({ default: e.Mermaid }))), Kn = /language-([^\s]+)/;
+var Jn = reactExports.lazy(() => import("./mermaid-3ZIDBTTL-DOefrphg.js").then((e) => ({ default: e.Mermaid }))), Kn = /language-([^\s]+)/;
 function ke(e, t) {
   if (!(e != null && e.position || t != null && t.position)) return true;
   if (!(e != null && e.position && (t != null && t.position))) return false;
@@ -101072,11 +101131,12 @@ async function flushablePipePerChunk(source, sink, state) {
   }
 }
 function assertWorldSupportsRuntimeProtocol(world) {
-  if (world.specVersion === SPEC_VERSION_CURRENT) {
+  const declared = world.specVersion;
+  if (declared !== void 0 && declared !== null && declared >= SPEC_VERSION_CURRENT && declared <= SPEC_VERSION_MAX_SUPPORTED) {
     return;
   }
-  const supportedVersion = world.specVersion ?? "none";
-  throw new WorkflowRuntimeError(`This Workflow runtime requires a World with matching spec version ${SPEC_VERSION_CURRENT}, but the configured World declares spec version ${supportedVersion}. Install a World package version compatible with the current Workflow runtime.`);
+  const supportedVersion = declared ?? "none";
+  throw new WorkflowRuntimeError(`This Workflow runtime supports Worlds with spec version ${SPEC_VERSION_CURRENT} through ${SPEC_VERSION_MAX_SUPPORTED}, but the configured World declares spec version ${supportedVersion}. Install a World package version compatible with the current Workflow runtime.`);
 }
 const WorldCacheKey = Symbol.for("@workflow/world//cache");
 const WorldCachePromiseKey = Symbol.for("@workflow/world//cachePromise");
@@ -104016,7 +104076,7 @@ function getStreamAndRequestRevivers(allRevivers) {
   return extra;
 }
 `cinst_${ulid$3()}`;
-const version$1 = "5.0.0-beta.40";
+const version$1 = "5.0.0-beta.41";
 const DEFAULT_HEALTH_CHECK_TIMEOUT = 3e4;
 const SAFE_WORKFLOW_NAME_PATTERN = /^[a-zA-Z0-9_\-./@]+$/;
 function getWorkflowQueueName(workflowName, namespace2) {
@@ -104729,20 +104789,32 @@ async function listFilesByExtension(dirPath, extension2) {
     throw error2;
   }
 }
+const SORT_KEY_CURSOR_PREFIX = "key:";
 function parseCursor(cursor) {
   if (!cursor)
     return null;
+  if (cursor.startsWith(SORT_KEY_CURSOR_PREFIX)) {
+    return {
+      timestamp: /* @__PURE__ */ new Date(0),
+      id: null,
+      sortKey: cursor.slice(SORT_KEY_CURSOR_PREFIX.length)
+    };
+  }
   const parts = cursor.split("|");
   return {
     timestamp: new Date(parts[0]),
-    id: parts[1] || null
+    id: parts[1] || null,
+    sortKey: null
   };
 }
-function createCursor(timestamp, id2) {
+function createCursor(timestamp, id2, sortKey) {
+  if (sortKey) {
+    return `${SORT_KEY_CURSOR_PREFIX}${sortKey}`;
+  }
   return id2 ? `${timestamp.toISOString()}|${id2}` : timestamp.toISOString();
 }
 async function paginatedFileSystemQuery(config2) {
-  const { directory, schema, cachedItems, filePrefix, fileIdFilter, filter: filter2, sortOrder = "desc", limit = 20, cursor, getCreatedAt, getId } = config2;
+  const { directory, schema, cachedItems, filePrefix, fileIdFilter, filter: filter2, sortOrder = "desc", limit = 20, cursor, getCreatedAt, getId, getSortKey, getSortKeyFromFileId } = config2;
   if (filePrefix !== void 0) {
     assertSafeEntityId("filePrefix", filePrefix);
   }
@@ -104752,7 +104824,17 @@ async function paginatedFileSystemQuery(config2) {
   const filteredFileIds = fileIdFilter ? relevantFileIds.filter(fileIdFilter) : relevantFileIds;
   const parsedCursor = parseCursor(cursor);
   let candidateFileIds = filteredFileIds;
-  if (parsedCursor) {
+  if ((parsedCursor == null ? void 0 : parsedCursor.sortKey) && getSortKeyFromFileId) {
+    const cursorSortKey = parsedCursor.sortKey;
+    candidateFileIds = filteredFileIds.filter((fileId) => {
+      const key = getSortKeyFromFileId(fileId);
+      if (key === null) {
+        return true;
+      }
+      const comparison = key.localeCompare(cursorSortKey);
+      return sortOrder === "desc" ? comparison < 0 : comparison > 0;
+    });
+  } else if (parsedCursor && !parsedCursor.sortKey) {
     candidateFileIds = filteredFileIds.filter((fileId) => {
       const filenameDate = getCreatedAt(`${fileId}.json`);
       if (filenameDate) {
@@ -104789,6 +104871,17 @@ async function paginatedFileSystemQuery(config2) {
     for (const item of loadedBatch) {
       if (!item)
         continue;
+      const itemSortKey = (getSortKey == null ? void 0 : getSortKey(item)) ?? null;
+      if (parsedCursor == null ? void 0 : parsedCursor.sortKey) {
+        if (itemSortKey) {
+          const comparison = itemSortKey.localeCompare(parsedCursor.sortKey);
+          if (sortOrder === "desc" ? comparison >= 0 : comparison <= 0) {
+            continue;
+          }
+        }
+        validItems.push(item);
+        continue;
+      }
       if (parsedCursor) {
         const itemTime = item.createdAt.getTime();
         const cursorTime = parsedCursor.timestamp.getTime();
@@ -104814,6 +104907,13 @@ async function paginatedFileSystemQuery(config2) {
     }
   }
   validItems.sort((a2, b2) => {
+    if (getSortKey) {
+      const aKey = getSortKey(a2);
+      const bKey = getSortKey(b2);
+      if (aKey !== null && bKey !== null) {
+        return sortOrder === "asc" ? aKey.localeCompare(bKey) : bKey.localeCompare(aKey);
+      }
+    }
     const aTime = a2.createdAt.getTime();
     const bTime = b2.createdAt.getTime();
     const timeComparison = sortOrder === "asc" ? aTime - bTime : bTime - aTime;
@@ -104826,7 +104926,7 @@ async function paginatedFileSystemQuery(config2) {
   });
   const hasMore = validItems.length > limit;
   const items = hasMore ? validItems.slice(0, limit) : validItems;
-  const nextCursor = items.length > 0 ? createCursor(items[items.length - 1].createdAt, getId == null ? void 0 : getId(items[items.length - 1])) : null;
+  const nextCursor = items.length > 0 ? createCursor(items[items.length - 1].createdAt, getId == null ? void 0 : getId(items[items.length - 1]), getSortKey == null ? void 0 : getSortKey(items[items.length - 1])) : null;
   return {
     data: items,
     cursor: nextCursor,
@@ -133165,6 +133265,20 @@ async function reapPendingHookEvents(basedir, runId, tag) {
   }
 }
 async function mintRunDominantEventKey(basedir, runId, tag) {
+  const scan = await scanRunEventIds(basedir, runId, tag);
+  let ts = Date.now();
+  if (scan.maxId) {
+    try {
+      const maxTs = decodeTime(scan.maxId.replace(/^evnt_/, ""));
+      if (ts <= maxTs) {
+        ts = maxTs + 1;
+      }
+    } catch {
+    }
+  }
+  return { eventId: `evnt_${monotonicUlid$1(ts)}`, createdAt: new Date(ts) };
+}
+async function scanRunEventIds(basedir, runId, tag) {
   let files = [];
   try {
     files = await fs$1.readdir(path$3.join(basedir, "events"));
@@ -133174,7 +133288,11 @@ async function mintRunDominantEventKey(basedir, runId, tag) {
     }
   }
   const prefix = `${runId}-`;
-  let maxUlid = null;
+  const ids = [];
+  let maxId = null;
+  let maxSlot = 0;
+  let usesSlots = false;
+  let count2 = 0;
   for (const file2 of files) {
     if (!file2.startsWith(prefix) || !file2.endsWith(".json")) {
       continue;
@@ -133184,21 +133302,19 @@ async function mintRunDominantEventKey(basedir, runId, tag) {
       continue;
     }
     const candidate = stripTag(fileId).slice(prefix.length);
-    if (!maxUlid || candidate > maxUlid) {
-      maxUlid = candidate;
+    count2 += 1;
+    ids.push(candidate);
+    if (!maxId || candidate > maxId) {
+      maxId = candidate;
     }
-  }
-  let ts = Date.now();
-  if (maxUlid) {
-    try {
-      const maxTs = decodeTime(maxUlid.replace(/^evnt_/, ""));
-      if (ts <= maxTs) {
-        ts = maxTs + 1;
-      }
-    } catch {
+    const slot = eventIdToSlot(candidate);
+    if (slot !== null) {
+      usesSlots = true;
+      if (slot > maxSlot)
+        maxSlot = slot;
     }
   }
-  return { eventId: `evnt_${monotonicUlid$1(ts)}`, createdAt: new Date(ts) };
+  return { maxId, usesSlots, maxSlot, count: count2, ids };
 }
 function hookTokenClaimPath(basedir, token) {
   return path$3.join(basedir, "hooks", "tokens", `${hashToken(token)}.json`);
@@ -133901,12 +134017,6 @@ function createRunsStorage(basedir, tag) {
     }
   };
 }
-const DEFAULT_MAX_EVENTS_PER_RUN = 25e3;
-function getMaxEventsPerRun() {
-  const raw2 = process.env.WORKFLOW_MAX_EVENTS;
-  const parsed = raw2 !== void 0 ? Number(raw2) : Number.NaN;
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_EVENTS_PER_RUN;
-}
 const DAY_MS$1 = 24 * 60 * 60 * 1e3;
 function getHookRetentionLimitMs() {
   const days = Number(process.env.WORKFLOW_LOCAL_HOOK_RETENTION_LIMIT_DAYS ?? 30);
@@ -133925,6 +134035,22 @@ const HookResumeClaimSchema = object$1({
   eventId: string$3(),
   payloadDigest: string$3().optional()
 });
+function isResumeEvent(event, claim) {
+  return event.eventType === "hook_received" && event.correlationId === claim.hookId && // `resumeId` is persisted on every hook_received written through the
+  // resume path; an event without one predates that and can only be matched
+  // by position.
+  (event.resumeId === void 0 || event.resumeId === claim.resumeId);
+}
+async function findCommittedResumeEvent(basedir, runId, claim, tag) {
+  const scan = await scanRunEventIds(basedir, runId, tag);
+  for (const eventId of scan.ids) {
+    const event = await readJSONWithFallback(basedir, "events", `${runId}-${eventId}`, EventSchema, tag);
+    if (event && event.resumeId === claim.resumeId && isResumeEvent(event, claim)) {
+      return event;
+    }
+  }
+  return null;
+}
 async function isHookTokenClaimReleasable(basedir, claim, tag) {
   if (claim.hookId && await isHookDisposalCommitted(basedir, claim.hookId, tag)) {
     return true;
@@ -133948,6 +134074,13 @@ async function readHookRecoveryMarker(markerPath) {
     throw error2;
   }
 }
+function eventSortKey(event) {
+  return isSlotEventId(event.eventId) ? event.eventId : null;
+}
+function eventSortKeyFromFileId(runId, fileId) {
+  const eventId = stripTag(fileId).slice(runId.length + 1);
+  return isSlotEventId(eventId) ? eventId : null;
+}
 async function findExistingHookCreatedEventId(basedir, runId, correlationId) {
   var _a3;
   const result = await paginatedFileSystemQuery({
@@ -134060,6 +134193,71 @@ function createEventsStorage(basedir, tag) {
     cachedEventBytes.clear();
     cachedPathsByRunId.clear();
     totalCachedEventBytes = 0;
+    runSlotState.clear();
+  }
+  const runSlotState = /* @__PURE__ */ new Map();
+  function slotStateKey(runId) {
+    return tag ? `${runId}.${tag}` : runId;
+  }
+  async function slotOccupied(runId, slot) {
+    const fileId = `${runId}-${slotToEventId(slot)}`;
+    for (const candidate of tag ? [
+      taggedPath(basedir, "events", fileId, tag),
+      taggedPath(basedir, "events", fileId)
+    ] : [taggedPath(basedir, "events", fileId)]) {
+      try {
+        await fs$1.stat(candidate);
+        return true;
+      } catch (error2) {
+        if (error2.code !== "ENOENT") {
+          throw error2;
+        }
+      }
+    }
+    return false;
+  }
+  async function drawEventSlot(runId, opts) {
+    const key = slotStateKey(runId);
+    let state = runSlotState.get(key);
+    if (state === void 0 || (opts == null ? void 0 : opts.rescan)) {
+      const scan = await scanRunEventIds(basedir, runId, tag);
+      if (state === void 0) {
+        state = scan.count > 0 && !scan.usesSlots ? null : { published: scan.maxSlot };
+        runSlotState.set(key, state);
+      } else if (state !== null) {
+        state.published = Math.max(state.published, scan.maxSlot);
+      }
+    }
+    if (state === null) {
+      return null;
+    }
+    let slot = Math.max(state.published + 1, FIRST_EVENT_SLOT, (opts == null ? void 0 : opts.atLeast) ?? FIRST_EVENT_SLOT);
+    while (await slotOccupied(runId, slot)) {
+      state.published = Math.max(state.published, slot);
+      slot += 1;
+    }
+    return slot;
+  }
+  function notePublishedSlot(runId, eventId) {
+    const slot = eventIdToSlot(eventId);
+    if (slot === null) {
+      return;
+    }
+    const state = runSlotState.get(slotStateKey(runId));
+    if (state) {
+      state.published = Math.max(state.published, slot);
+    }
+  }
+  async function mintEventId(runId) {
+    const slot = await drawEventSlot(runId);
+    return slot === null ? `evnt_${monotonicUlid$1()}` : slotToEventId(slot);
+  }
+  async function mintDominantEventKey(runId) {
+    const slot = await drawEventSlot(runId, { rescan: true });
+    if (slot !== null) {
+      return { eventId: slotToEventId(slot), createdAt: /* @__PURE__ */ new Date() };
+    }
+    return mintRunDominantEventKey(basedir, runId, tag);
   }
   function cacheEvent(eventPath, cachedEvent, serializedBytes) {
     if (serializedBytes > maxCachedEventBytes) {
@@ -134091,14 +134289,45 @@ function createEventsStorage(basedir, tag) {
     }
   }
   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);
+    let current = event;
+    for (let attempt = 0; ; attempt++) {
+      const eventPath = taggedPath(basedir, "events", `${current.runId}-${current.eventId}`, tag);
+      const serializedEvent = JSON.stringify(current, jsonReplacer, 2);
+      const slot = eventIdToSlot(current.eventId);
+      if (slot === null) {
+        await write(eventPath, serializedEvent);
+        rememberStoredEvent(current, eventPath, serializedEvent);
+        return current;
+      }
+      if (await writeExclusive(eventPath, serializedEvent)) {
+        notePublishedSlot(current.runId, current.eventId);
+        rememberStoredEvent(current, eventPath, serializedEvent);
+        return current;
+      }
+      const next2 = await drawEventSlot(current.runId, {
+        rescan: attempt > 0 && attempt % 8 === 0,
+        atLeast: slot + 1
+      });
+      require$$0$4(next2 !== null);
+      current = { ...current, eventId: slotToEventId(next2) };
+    }
   }
+  const queryRunEvents = (runId, pagination) => paginatedFileSystemQuery({
+    directory: path$3.join(basedir, "events"),
+    schema: EventSchema,
+    cachedItems: eventCache,
+    filePrefix: `${runId}-`,
+    sortOrder: pagination.sortOrder ?? "asc",
+    limit: pagination.limit,
+    cursor: pagination.cursor,
+    getCreatedAt: getObjectCreatedAt("evnt"),
+    getId: (event) => event.eventId,
+    getSortKey: eventSortKey,
+    getSortKeyFromFileId: (fileId) => eventSortKeyFromFileId(runId, fileId)
+  });
   const stepLocks = /* @__PURE__ */ new Map();
   const hookLocks = /* @__PURE__ */ new Map();
-  return {
+  const storage = {
     clearCache,
     async create(runId, data, params) {
       if (data.eventType === "hook_created" && data.eventData.tokenRetentionUntil !== void 0 && data.eventData.tokenRetentionUntil.getTime() > Date.now() + hookRetentionLimitMs) {
@@ -134112,7 +134341,7 @@ function createEventsStorage(basedir, tag) {
       }
       if (isStepEventType(data.eventType) && runId && data.correlationId) {
         const lockKey = tag ? `${runId}-${data.correlationId}.${tag}` : `${runId}-${data.correlationId}`;
-        return withInProcessLock(stepLocks, lockKey, () => createImpl());
+        return withInProcessLock(stepLocks, lockKey, createImpl);
       }
       if (isHookLifecycleEventType(data.eventType) && runId && data.correlationId) {
         const lockKey = tag ? `${runId}-${data.correlationId}.hook.${tag}` : `${runId}-${data.correlationId}.hook`;
@@ -134120,7 +134349,9 @@ function createEventsStorage(basedir, tag) {
       }
       return createImpl();
       async function createImpl() {
-        let eventId = `evnt_${monotonicUlid$1()}`;
+        let eventId = "";
+        let eventIdPinned = false;
+        let resumeClaimRecordedId = null;
         const now2 = /* @__PURE__ */ new Date();
         let effectiveRunId;
         if (data.eventType === "run_created" && (!runId || runId === "")) {
@@ -134170,7 +134401,7 @@ function createEventsStorage(basedir, tag) {
               const runPath = taggedPath(basedir, "runs", effectiveRunId, tag);
               const created = await writeExclusive(runPath, JSON.stringify(createdRun, jsonReplacer));
               if (created) {
-                const runCreatedEventId = `evnt_${monotonicUlid$1()}`;
+                const runCreatedEventId = await mintEventId(effectiveRunId);
                 const runCreatedEvent = {
                   eventType: "run_created",
                   runId: effectiveRunId,
@@ -134195,10 +134426,8 @@ function createEventsStorage(basedir, tag) {
             }
           }
         }
-        if (data.eventType === "run_failed" && !currentRun) {
-          throw new WorkflowRunNotFoundError(effectiveRunId);
-        }
-        if (data.eventType === "attr_set" && !currentRun) {
+        eventId = await mintEventId(effectiveRunId);
+        if (!currentRun && (data.eventType === "run_failed" || data.eventType === "attr_set" || data.eventType === "run_started")) {
           throw new WorkflowRunNotFoundError(effectiveRunId);
         }
         if (currentRun) {
@@ -134213,17 +134442,16 @@ function createEventsStorage(basedir, tag) {
         const lazyStepStart = createsChildEntity && data.eventType === "step_started";
         if (currentRun && isTerminalWorkflowRunStatus(currentRun.status)) {
           if (data.eventType === "run_cancelled" && currentRun.status === "cancelled") {
-            const event2 = {
+            const stored = await storeEvent({
               ...data,
               runId: effectiveRunId,
               eventId,
               createdAt: now2,
               specVersion: effectiveSpecVersion
-            };
-            await storeEvent(event2);
+            });
             const resolveData2 = (params == null ? void 0 : params.resolveData) ?? DEFAULT_RESOLVE_DATA_OPTION$1;
             return {
-              event: stripEventDataRefs(event2, resolveData2),
+              event: stripEventDataRefs(stored, resolveData2),
               run: currentRun,
               ...currentRun ? { maxEvents: getMaxEventsPerRun() } : {}
             };
@@ -134267,7 +134495,8 @@ function createEventsStorage(basedir, tag) {
           if (data.eventType === "hook_received" && (params == null ? void 0 : params.resumeId)) {
             const committedClaim = await readJSON(hookResumeClaimPath(basedir, effectiveRunId, params.resumeId), HookResumeClaimSchema);
             if (committedClaim && committedClaim.hookId === data.correlationId && (!params.resumePayloadDigest || !committedClaim.payloadDigest || committedClaim.payloadDigest === params.resumePayloadDigest)) {
-              const committedEvent = await readJSONWithFallback(basedir, "events", `${effectiveRunId}-${committedClaim.eventId}`, EventSchema, tag);
+              const atClaimedId = await readJSONWithFallback(basedir, "events", `${effectiveRunId}-${committedClaim.eventId}`, EventSchema, tag);
+              const committedEvent = atClaimedId && isResumeEvent(atClaimedId, committedClaim) ? atClaimedId : await findCommittedResumeEvent(basedir, effectiveRunId, committedClaim, tag);
               if (committedEvent) {
                 return { event: committedEvent };
               }
@@ -134289,11 +134518,19 @@ function createEventsStorage(basedir, tag) {
               if (params.resumePayloadDigest && claim.payloadDigest && claim.payloadDigest !== params.resumePayloadDigest) {
                 throw new EntityConflictError(`hook_received resumeId "${params.resumeId}" already recorded with a different payload`);
               }
-              const existing = await readJSONWithFallback(basedir, "events", `${effectiveRunId}-${claim.eventId}`, EventSchema, tag);
-              if (existing) {
-                return { event: existing };
+              const atClaimedId = await readJSONWithFallback(basedir, "events", `${effectiveRunId}-${claim.eventId}`, EventSchema, tag);
+              if (atClaimedId && isResumeEvent(atClaimedId, claim)) {
+                return { event: atClaimedId };
+              }
+              const committed = await findCommittedResumeEvent(basedir, effectiveRunId, claim, tag);
+              if (committed) {
+                return { event: committed };
+              }
+              resumeClaimRecordedId = claim.eventId;
+              if (!atClaimedId) {
+                eventId = claim.eventId;
+                eventIdPinned = true;
               }
-              eventId = claim.eventId;
               return null;
             };
             const existingClaim = await readJSON(claimPath, HookResumeClaimSchema);
@@ -134303,6 +134540,8 @@ function createEventsStorage(basedir, tag) {
                 return converged;
               }
             } else {
+              eventIdPinned = !isSlotEventId(eventId);
+              resumeClaimRecordedId = eventId;
               const won = await writeExclusive(claimPath, JSON.stringify({
                 runId: effectiveRunId,
                 resumeId: params.resumeId,
@@ -134311,6 +134550,7 @@ function createEventsStorage(basedir, tag) {
                 ...params.resumePayloadDigest ? { payloadDigest: params.resumePayloadDigest } : {}
               }));
               if (!won) {
+                resumeClaimRecordedId = null;
                 const winner = await readJSON(claimPath, HookResumeClaimSchema);
                 if (winner) {
                   const converged = await converge(winner);
@@ -134353,7 +134593,7 @@ function createEventsStorage(basedir, tag) {
         if (isTerminalRunEventType(data.eventType) && currentRun) {
           await writeExclusive(runTerminalMarkerPath(basedir, effectiveRunId, tag), "");
           await reapPendingHookEvents(basedir, effectiveRunId, tag);
-          const dominantKey = await mintRunDominantEventKey(basedir, effectiveRunId, tag);
+          const dominantKey = await mintDominantEventKey(effectiveRunId);
           eventId = dominantKey.eventId;
           event = { ...event, eventId, createdAt: dominantKey.createdAt };
         }
@@ -134391,7 +134631,22 @@ function createEventsStorage(basedir, tag) {
         } else if (data.eventType === "run_started") {
           if (currentRun) {
             if (currentRun.status === "running") {
-              return { run: currentRun, maxEvents: getMaxEventsPerRun() };
+              if (params == null ? void 0 : params.skipPreload) {
+                return {
+                  run: currentRun,
+                  maxEvents: getMaxEventsPerRun()
+                };
+              }
+              const preloaded = await queryRunEvents(effectiveRunId, {
+                limit: getMaxEventsPerRun()
+              });
+              return {
+                run: currentRun,
+                events: preloaded.data,
+                cursor: preloaded.cursor,
+                hasMore: preloaded.hasMore,
+                maxEvents: getMaxEventsPerRun()
+              };
             }
             run2 = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
               runId: currentRun.runId,
@@ -134570,7 +134825,7 @@ function createEventsStorage(basedir, tag) {
                 specVersion: effectiveSpecVersion
               };
               await writeJSON(taggedPath(basedir, "steps", `${effectiveRunId}-${data.correlationId}`, tag), createdStep);
-              const stepCreatedEventId = `evnt_${monotonicUlid$1()}`;
+              const stepCreatedEventId = await mintEventId(effectiveRunId);
               const stepCreatedEvent = {
                 eventType: "step_created",
                 runId: effectiveRunId,
@@ -134583,7 +134838,7 @@ function createEventsStorage(basedir, tag) {
                   input: lazyData.input
                 }
               };
-              await writeJSON(taggedPath(basedir, "events", `${effectiveRunId}-${stepCreatedEventId}`, tag), stepCreatedEvent);
+              await storeEvent(stepCreatedEvent);
               validatedStep = createdStep;
               stepCreatedLazily = true;
             }
@@ -134724,6 +134979,7 @@ function createEventsStorage(basedir, tag) {
               canonicalEventId = pinned;
             }
             eventId = canonicalEventId;
+            eventIdPinned = true;
             const canonicalCreatedAt = ulidToDate(eventId.replace(/^evnt_/, "")) ?? now2;
             event = {
               ...data,
@@ -134753,10 +135009,10 @@ function createEventsStorage(basedir, tag) {
               createdAt: now2,
               specVersion: effectiveSpecVersion
             };
-            await storeEvent(conflictEvent);
+            const storedConflict = await storeEvent(conflictEvent);
             const resolveData2 = (params == null ? void 0 : params.resolveData) ?? DEFAULT_RESOLVE_DATA_OPTION$1;
             return {
-              event: stripEventDataRefs(conflictEvent, resolveData2),
+              event: stripEventDataRefs(storedConflict, resolveData2),
               run: run2,
               step,
               hook: void 0
@@ -134839,36 +135095,65 @@ function createEventsStorage(basedir, tag) {
         if (data.eventType === "hook_received" && data.correlationId && await isHookDisposalCommitted(basedir, data.correlationId, tag)) {
           throw new HookNotFoundError(data.correlationId);
         }
-        const compositeKey = `${effectiveRunId}-${eventId}`;
-        const eventPath = taggedPath(basedir, "events", compositeKey, tag);
-        const serializedEvent = JSON.stringify(event, jsonReplacer, 2);
-        let eventPublished;
-        if (data.eventType === "hook_received") {
-          const terminalByMarker = await isRunTerminalCommitted(basedir, effectiveRunId, tag);
-          const runNow = terminalByMarker ? null : await readJSONWithFallback(basedir, "runs", effectiveRunId, WorkflowRunSchema, tag);
-          if (terminalByMarker || runNow && isTerminalWorkflowRunStatus(runNow.status)) {
-            throw new RunExpiredError(`Workflow run "${effectiveRunId}" is already in a terminal state`);
-          }
-          const stagedPath = pendingHookEventPath(basedir, effectiveRunId, eventId, tag);
-          const staged = await writeExclusive(stagedPath, serializedEvent);
-          if (!staged) {
-            throw new EntityConflictError(`Event "${eventId}" already exists for run "${effectiveRunId}"`);
+        let eventPath = taggedPath(basedir, "events", `${effectiveRunId}-${eventId}`, tag);
+        let serializedEvent = JSON.stringify(event, jsonReplacer, 2);
+        const bumpEventSlot = async (attempt) => {
+          const current = eventIdToSlot(eventId);
+          if (eventIdPinned || current === null) {
+            return false;
           }
-          try {
-            if (await isRunTerminalCommitted(basedir, effectiveRunId, tag)) {
+          const slot = await drawEventSlot(effectiveRunId, {
+            rescan: attempt > 0 && attempt % 8 === 0,
+            atLeast: current + 1
+          });
+          if (slot === null) {
+            return false;
+          }
+          eventId = slotToEventId(slot);
+          event = { ...event, eventId };
+          eventPath = taggedPath(basedir, "events", `${effectiveRunId}-${eventId}`, tag);
+          serializedEvent = JSON.stringify(event, jsonReplacer, 2);
+          return true;
+        };
+        let eventPublished = false;
+        for (let attempt = 0; ; attempt++) {
+          if (data.eventType === "hook_received") {
+            const terminalByMarker = await isRunTerminalCommitted(basedir, effectiveRunId, tag);
+            const runNow = terminalByMarker ? null : await readJSONWithFallback(basedir, "runs", effectiveRunId, WorkflowRunSchema, tag);
+            if (terminalByMarker || runNow && isTerminalWorkflowRunStatus(runNow.status)) {
               throw new RunExpiredError(`Workflow run "${effectiveRunId}" is already in a terminal state`);
             }
-            const promoted = await promoteExclusive(stagedPath, eventPath);
-            if (promoted === "missing") {
-              throw new RunExpiredError(`Workflow run "${effectiveRunId}" is already in a terminal state`);
+            const stagedPath = pendingHookEventPath(basedir, effectiveRunId, eventId, tag);
+            const staged = await writeExclusive(stagedPath, serializedEvent);
+            if (!staged) {
+              if (await bumpEventSlot(attempt)) {
+                continue;
+              }
+              throw new EntityConflictError(`Event "${eventId}" already exists for run "${effectiveRunId}"`);
             }
-            eventPublished = promoted === "linked";
-          } finally {
-            await deleteJSON(stagedPath).catch(() => {
-            });
+            try {
+              if (await isRunTerminalCommitted(basedir, effectiveRunId, tag)) {
+                throw new RunExpiredError(`Workflow run "${effectiveRunId}" is already in a terminal state`);
+              }
+              const promoted = await promoteExclusive(stagedPath, eventPath);
+              if (promoted === "missing") {
+                throw new RunExpiredError(`Workflow run "${effectiveRunId}" is already in a terminal state`);
+              }
+              eventPublished = promoted === "linked";
+            } finally {
+              await deleteJSON(stagedPath).catch(() => {
+              });
+            }
+          } else {
+            eventPublished = await writeExclusive(eventPath, serializedEvent);
+          }
+          if (eventPublished) {
+            notePublishedSlot(effectiveRunId, eventId);
+            break;
+          }
+          if (!await bumpEventSlot(attempt)) {
+            break;
           }
-        } else {
-          eventPublished = await writeExclusive(eventPath, serializedEvent);
         }
         if (!eventPublished) {
           if (data.eventType === "hook_created" && data.correlationId) {
@@ -134877,57 +135162,55 @@ function createEventsStorage(basedir, tag) {
           throw new EntityConflictError(`Event "${eventId}" already exists for run "${effectiveRunId}"`);
         }
         rememberStoredEvent(event, eventPath, serializedEvent);
+        if (data.eventType === "hook_received" && (params == null ? void 0 : params.resumeId) && resumeClaimRecordedId !== null && resumeClaimRecordedId !== eventId) {
+          await write(hookResumeClaimPath(basedir, effectiveRunId, params.resumeId), JSON.stringify({
+            runId: effectiveRunId,
+            resumeId: params.resumeId,
+            hookId: data.correlationId,
+            eventId,
+            ...params.resumePayloadDigest ? { payloadDigest: params.resumePayloadDigest } : {}
+          }), { overwrite: true });
+        }
         if (hook && data.eventType === "hook_created") {
           await writeHookByRunMarker(basedir, hook.runId, hook.hookId, tag);
           await writeJSON(taggedPath(basedir, "hooks", hook.hookId, tag), hook, hookEntityWriteOptions);
         }
         const resolveData = (params == null ? void 0 : params.resolveData) ?? DEFAULT_RESOLVE_DATA_OPTION$1;
         const filteredEvent = stripEventDataRefs(event, resolveData);
-        let events2;
-        let cursor;
-        let hasMore;
-        if (data.eventType === "run_started" && run2) {
-          const allEvents = await paginatedFileSystemQuery({
-            directory: path$3.join(basedir, "events"),
-            schema: EventSchema,
-            cachedItems: eventCache,
-            filePrefix: `${effectiveRunId}-`,
-            sortOrder: "asc",
-            limit: 1e3,
-            getCreatedAt: getObjectCreatedAt("evnt"),
-            getId: (e) => e.eventId
+        let eventPage;
+        if (data.eventType === "run_started" && run2 && !(params == null ? void 0 : params.skipPreload)) {
+          eventPage = await queryRunEvents(effectiveRunId, {
+            limit: getMaxEventsPerRun()
           });
-          events2 = allEvents.data;
-          cursor = allEvents.cursor;
-          hasMore = allEvents.hasMore;
-        }
-        if (isTerminalStepEventType(data.eventType) && typeof (params == null ? void 0 : params.sinceCursor) === "string") {
-          const delta = await paginatedFileSystemQuery({
-            directory: path$3.join(basedir, "events"),
-            schema: EventSchema,
-            filePrefix: `${effectiveRunId}-`,
+        }
+        if (typeof (params == null ? void 0 : params.sinceCursor) === "string") {
+          const delta = await queryRunEvents(effectiveRunId, {
             sortOrder: "asc",
-            cursor: params.sinceCursor,
-            getCreatedAt: getObjectCreatedAt("evnt"),
-            getId: (e) => e.eventId
+            cursor: params.sinceCursor
           });
-          events2 = resolveData === "none" ? delta.data.map((e) => stripEventDataRefs(e, resolveData)) : delta.data;
-          cursor = delta.cursor;
-          hasMore = delta.hasMore;
+          eventPage = resolveData === "none" ? {
+            ...delta,
+            data: delta.data.map((event2) => stripEventDataRefs(event2, resolveData))
+          } : delta;
         }
-        return {
+        const result = {
           event: filteredEvent,
           run: run2,
           step,
           hook,
           wait,
-          events: events2,
-          cursor,
-          hasMore,
           ...stepCreatedLazily ? { stepCreated: true } : {},
           // Per-run event ceiling (mirrors the Vercel World).
           ...run2 ? { maxEvents: getMaxEventsPerRun() } : {}
         };
+        if (!eventPage)
+          return result;
+        return {
+          ...result,
+          events: eventPage.data,
+          cursor: eventPage.cursor,
+          hasMore: eventPage.hasMore
+        };
       }
     },
     async get(runId, eventId, params) {
@@ -134942,22 +135225,13 @@ function createEventsStorage(basedir, tag) {
       return stripEventDataRefs(event, resolveData);
     },
     async list(params) {
-      var _a3, _b2, _c2;
+      var _a3;
       const { runId } = params;
       assertSafeEntityId("runId", runId);
       const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION$1;
-      const result = await paginatedFileSystemQuery({
-        directory: path$3.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.
-        sortOrder: ((_a3 = params.pagination) == null ? void 0 : _a3.sortOrder) ?? "asc",
-        limit: (_b2 = params.pagination) == null ? void 0 : _b2.limit,
-        cursor: (_c2 = params.pagination) == null ? void 0 : _c2.cursor,
-        getCreatedAt: getObjectCreatedAt("evnt"),
-        getId: (event) => event.eventId
+      const result = await queryRunEvents(runId, {
+        ...params.pagination,
+        limit: ((_a3 = params.pagination) == null ? void 0 : _a3.limit) ?? getMaxEventsPerRun()
       });
       if (resolveData === "none") {
         return {
@@ -134989,7 +135263,9 @@ function createEventsStorage(basedir, tag) {
         limit: (_b2 = params.pagination) == null ? void 0 : _b2.limit,
         cursor: (_c2 = params.pagination) == null ? void 0 : _c2.cursor,
         getCreatedAt: getObjectCreatedAt("evnt"),
-        getId: (event) => event.eventId
+        getId: (event) => event.eventId,
+        getSortKey: eventSortKey,
+        getSortKeyFromFileId: (fileId) => eventSortKeyFromFileId(params.runId, fileId)
       });
       if (resolveData === "none") {
         return {
@@ -135000,6 +135276,48 @@ function createEventsStorage(basedir, tag) {
       return result;
     }
   };
+  async function reportSkippedSlots(result, askedFor, resolveData) {
+    if (!result.event) {
+      return result;
+    }
+    const committedSlot = eventIdToSlot(result.event.eventId);
+    if (committedSlot === null || askedFor < FIRST_EVENT_SLOT || committedSlot <= askedFor + 1) {
+      return result;
+    }
+    const span = committedSlot - askedFor - 1;
+    const page = await storage.list({
+      runId: result.event.runId,
+      pagination: {
+        cursor: `${SORT_KEY_CURSOR_PREFIX}${slotToEventId(askedFor)}`,
+        limit: span,
+        sortOrder: "asc"
+      },
+      resolveData
+    });
+    const committedEventId = result.event.eventId;
+    const events2 = page.data.filter((event) => event.eventId < committedEventId);
+    return {
+      ...result,
+      events: events2,
+      // Deliberately no cursor: the report is a lower bound on what this write
+      // skipped over, not a page the caller has now read to the end of, so it
+      // must not advance the caller's read position.
+      cursor: null,
+      hasMore: events2.length < committedSlot - askedFor - 1
+    };
+  }
+  const create2 = (async (runId, data, params) => {
+    if ((params == null ? void 0 : params.eventCount) === void 0) {
+      return storage.create(runId, data, params);
+    }
+    const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION$1;
+    const result = await storage.create(runId, data, params);
+    if (typeof params.sinceCursor === "string") {
+      return result;
+    }
+    return reportSkippedSlots(result, params.eventCount, resolveData);
+  });
+  return { ...storage, create: create2 };
 }
 function createStepsStorage(basedir, tag) {
   return {
@@ -135443,7 +135761,11 @@ function createWorld$2(args) {
       // `(runId, resumeId)` via a filesystem sidecar claim (see
       // events-storage.ts `claimHookResume`), so resumeHook()'s parallel fast
       // path converges on one event in dev exactly as it does on Vercel.
-      hookResumeDedup: true
+      hookResumeDedup: true,
+      // New runs get dense per-run slot event ids. Runs created before this
+      // keep their ULIDs; the scheme is pinned by a run's own first event id,
+      // not by this flag, which only says what new runs get.
+      slotEventIds: true
     },
     ...queue,
     ...storage,
@@ -135478,7 +135800,7 @@ function createWorld$2(args) {
         const basedir = mergedConfig.dataDir;
         const hooksDir = path$3.join(basedir, "hooks");
         const taggedHookFiles = await listTaggedFiles(hooksDir, tag);
-        const { HookSchema: HookSchema2 } = await import("./index-XksKPyou.js");
+        const { HookSchema: HookSchema2 } = await import("./index-BByEr1g6.js");
         await Promise.all(taggedHookFiles.map(async (hookFile) => {
           const hook = await readJSON(path$3.join(hooksDir, hookFile), HookSchema2);
           if (hook == null ? void 0 : hook.token) {
@@ -135661,8 +135983,8 @@ function requireGetVercelOidcToken() {
     }
     try {
       const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
-        await import("./token-util-DPJj3x0B.js").then((n) => n.t),
-        await import("./token-D8pb4TJ8.js").then((n) => n.t)
+        await import("./token-util-C2yENsqE.js").then((n) => n.t),
+        await import("./token-c3byIJRC.js").then((n) => n.t)
       ]);
       if (!token || isExpired(getTokenPayload(token), options == null ? void 0 : options.expirationBufferMs)) {
         await refreshToken(options);
@@ -136226,7 +136548,6 @@ function requireDist() {
 }
 var distExports = requireDist();
 let _dispatcher;
-let _eventsDispatcher;
 let _streamDispatcher;
 let _streamCloseDispatcher;
 const BASE_AGENT_OPTIONS = {
@@ -136250,6 +136571,11 @@ const EVENTS_AGENT_OPTIONS = {
   initialWindowSize: H2_STREAM_WINDOW_BYTES,
   connectionWindowSize: H2_CONNECTION_WINDOW_BYTES
 };
+const EVENTS_AGENT_OPTIONS_NO_H2 = {
+  ...BASE_AGENT_OPTIONS,
+  allowH2: false,
+  pipelining: 1
+};
 const STREAM_AGENT_OPTIONS = {
   ...BASE_AGENT_OPTIONS,
   allowH2: true,
@@ -136280,7 +136606,7 @@ const STREAM_CLOSE_RETRY_OPTIONS = {
   statusCodes: [429, 500, 502, 503, 504]
 };
 const H2_REBUFFER_MAX_BYTES = 1 << 20;
-function h2MultiplexEnabled() {
+function h2EventsEnabled() {
   return process.env.WORKFLOW_H2_MULTIPLEX !== "0";
 }
 function contentLength(headers2) {
@@ -136314,11 +136640,84 @@ function h2MultiplexInterceptor(dispatch2) {
     return true;
   };
 }
+const EVENTS_RECYCLE_AFTER_CONSECUTIVE_FAILURES = 3;
+const RECYCLE_MIN_INTERVAL_MS = 5e3;
+const RETIRED_CLOSE_DELAY_MS = 5e3;
+const RETIRED_DESTROY_DELAY_MS = 6e4;
+const RECYCLABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  // Covers H2 stream timeout, frameError and GOAWAY (undici InformationalError).
+  "UND_ERR_INFO",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT"
+]);
+const MAX_CAUSE_DEPTH = 8;
+function isRecyclableTransportError(error2) {
+  let current = error2;
+  for (let depth = 0; current && depth < MAX_CAUSE_DEPTH; depth++) {
+    const code2 = current.code;
+    if (typeof code2 === "string" && RECYCLABLE_ERROR_CODES.has(code2)) {
+      return true;
+    }
+    current = current.cause;
+  }
+  return false;
+}
+function createDispatcherRecycler(factory, label) {
+  let current;
+  let consecutiveFailures = 0;
+  let lastRecycledAt = 0;
+  function retire(stale) {
+    var _a3, _b2;
+    const closeTimer = setTimeout(() => {
+      var _a4;
+      void Promise.resolve((_a4 = stale.close) == null ? void 0 : _a4.call(stale)).catch(() => void 0);
+    }, RETIRED_CLOSE_DELAY_MS);
+    const destroyTimer = setTimeout(() => {
+      var _a4;
+      void Promise.resolve((_a4 = stale.destroy) == null ? void 0 : _a4.call(stale)).catch(() => void 0);
+    }, RETIRED_DESTROY_DELAY_MS);
+    (_a3 = closeTimer.unref) == null ? void 0 : _a3.call(closeTimer);
+    (_b2 = destroyTimer.unref) == null ? void 0 : _b2.call(destroyTimer);
+  }
+  return {
+    get() {
+      current ?? (current = factory());
+      return current;
+    },
+    note(dispatcher2, error2) {
+      if (!current || dispatcher2 !== current)
+        return;
+      if (error2 === void 0) {
+        consecutiveFailures = 0;
+        return;
+      }
+      if (!isRecyclableTransportError(error2))
+        return;
+      consecutiveFailures++;
+      if (consecutiveFailures < EVENTS_RECYCLE_AFTER_CONSECUTIVE_FAILURES) {
+        return;
+      }
+      const now2 = Date.now();
+      if (now2 - lastRecycledAt < RECYCLE_MIN_INTERVAL_MS)
+        return;
+      lastRecycledAt = now2;
+      consecutiveFailures = 0;
+      const stale = current;
+      current = void 0;
+      console.warn(`[workflow] ${label}: rebuilding connection pool after ${EVENTS_RECYCLE_AFTER_CONSECUTIVE_FAILURES} consecutive transport failures`);
+      retire(stale);
+    }
+  };
+}
+const eventsRecycler = createDispatcherRecycler(() => createEventsDispatcher(), "events transport");
+function noteEventsTransportOutcome(dispatcher2, error2) {
+  eventsRecycler.note(dispatcher2, error2);
+}
 function getDispatcher(config2) {
   return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultDispatcher();
 }
 function getEventsDispatcher(config2) {
-  return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultEventsDispatcher();
+  return (config2 == null ? void 0 : config2.dispatcher) ?? eventsRecycler.get();
 }
 function getStreamDispatcher(config2) {
   return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultStreamDispatcher();
@@ -136330,8 +136729,12 @@ function makeRetryDispatcher(agentOptions, retryOptions) {
   return new undiciExports.RetryAgent(new undiciExports.Agent(agentOptions), retryOptions);
 }
 function createEventsDispatcher(agentOverrides) {
-  const agent2 = new undiciExports.RetryAgent(new undiciExports.Agent({ ...EVENTS_AGENT_OPTIONS, ...agentOverrides }), RETRY_AGENT_OPTIONS);
-  if (!h2MultiplexEnabled()) {
+  const h2 = h2EventsEnabled();
+  const agent2 = new undiciExports.RetryAgent(new undiciExports.Agent({
+    ...h2 ? EVENTS_AGENT_OPTIONS : EVENTS_AGENT_OPTIONS_NO_H2,
+    ...agentOverrides
+  }), RETRY_AGENT_OPTIONS);
+  if (!h2) {
     return agent2;
   }
   return withBoundLifecycle(agent2, agent2.compose(h2MultiplexInterceptor));
@@ -136348,10 +136751,6 @@ function getDefaultDispatcher() {
   _dispatcher ?? (_dispatcher = makeRetryDispatcher(DEFAULT_AGENT_OPTIONS, RETRY_AGENT_OPTIONS));
   return _dispatcher;
 }
-function getDefaultEventsDispatcher() {
-  _eventsDispatcher ?? (_eventsDispatcher = createEventsDispatcher());
-  return _eventsDispatcher;
-}
 function getDefaultStreamDispatcher() {
   _streamDispatcher ?? (_streamDispatcher = createStreamDispatcher(STREAM_RETRY_OPTIONS));
   return _streamDispatcher;
@@ -136512,6 +136911,13 @@ function parseRetryAfter(value) {
   const parsed = parseInt(value, 10);
   return Number.isNaN(parsed) ? void 0 : parsed;
 }
+function headersToRecord(headers2) {
+  const out = {};
+  headers2.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}
 function errorForResponse(status, message2, opts = {}) {
   const { retryAfter, code: code2, url: url2, mitigated, details } = opts;
   if (status === 409)
@@ -136566,7 +136972,7 @@ function httpClientSpanAttributes(args) {
   };
 }
 async function instrumentedFetch(opts) {
-  const { method, url: url2, headers: headers2, body: body2, dispatcher: dispatcher2, peerService = "workflow-server", timeoutMs = getRequestTimeoutMs(), signal: callerSignal, injectTraceContext: injectTraceContext2 = true, cacheBust = true, logLabel, buildError, spanName, attributes, durationAttribute } = opts;
+  const { method, url: url2, headers: headers2, body: body2, dispatcher: dispatcher2, peerService = "workflow-server", timeoutMs = getRequestTimeoutMs(), signal: callerSignal, injectTraceContext: injectTraceContext2 = true, cacheBust = true, logLabel, buildError, spanName, attributes, durationAttribute, onTransportOutcome } = opts;
   const label = logLabel ?? url2;
   return trace(spanName ?? `http ${method}`, { kind: await getSpanKind("CLIENT") }, async (span) => {
     var _a3, _b2, _c2;
@@ -136601,6 +137007,7 @@ async function instrumentedFetch(opts) {
       });
     } catch (error2) {
       const elapsed = Date.now() - start2;
+      onTransportOutcome == null ? void 0 : onTransportOutcome(error2);
       if (error2 instanceof Error && (error2.name === "TimeoutError" || error2.name === "AbortError")) {
         const timeoutError = new WorkflowWorldError(`${method} ${label} timed out after ${elapsed}ms`, { url: url2, cause: error2 });
         span == null ? void 0 : span.setAttributes({ ...ErrorType("TIMEOUT") });
@@ -136610,6 +137017,7 @@ async function instrumentedFetch(opts) {
       throw error2;
     }
     const ms2 = Date.now() - start2;
+    onTransportOutcome == null ? void 0 : onTransportOutcome();
     httpLog(method, label, response2, ms2);
     span == null ? void 0 : span.setAttributes({ ...HttpResponseStatusCode(response2.status) });
     if (durationAttribute)
@@ -136633,7 +137041,7 @@ async function instrumentedFetch(opts) {
     return response2;
   });
 }
-const version = "5.0.0-beta.36";
+const version = "5.0.0-beta.37";
 const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
 const MAX_BODY_PARSE_RETRIES = 2;
 const BODY_PARSE_RETRY_BASE_MS = 100;
@@ -137377,7 +137785,7 @@ function createGetEncryptionKeyForRun(projectId, teamId, token, dispatcher2) {
   };
 }
 async function getDeadline() {
-  const { getDeadline: getDeadline2 } = await import("./index-7-uV1dU1.js").then((n) => n.i);
+  const { getDeadline: getDeadline2 } = await import("./index-DTci39F3.js").then((n) => n.i);
   return getDeadline2();
 }
 const WORKFLOW_SERVER_SERVICE = {
@@ -142194,6 +142602,9 @@ var QueueClient = class {
 function missingDeploymentIdMessage(operation) {
   return `${operation} requires VERCEL_DEPLOYMENT_ID, which Vercel sets in every deployment, so this process is not running inside one. The Vercel world is only selected automatically when that variable is set, so it was requested explicitly here — most often by WORKFLOW_TARGET_WORLD=vercel in a process that is not a deployment, such as a production server started locally or in CI. To use the local filesystem world instead, set WORKFLOW_TARGET_WORLD=local or unset it.`;
 }
+function isWsEventsTransportEnabled() {
+  return process.env.WORKFLOW_EVENTS_TRANSPORT === "ws";
+}
 class CborTransport {
   constructor() {
     __publicField(this, "contentType", "application/cbor");
@@ -142288,6 +142699,37 @@ function getRunIdFromPayload(payload) {
   }
   return void 0;
 }
+const wsEventsChannelForInvocation = (runId, config2) => {
+  let claim;
+  return {
+    /**
+     * Unawaited and failure-proof: callers treat the handshake as free. The
+     * refcount therefore rises a microtask late, so a write racing the import
+     * finds no channel and goes over HTTP — one frame, not the invocation,
+     * since `close` awaits this same promise and so cannot release ahead of
+     * the claim it is releasing.
+     */
+    open() {
+      if (!runId || !isWsEventsTransportEnabled())
+        return;
+      claim = import("./ws-transport-2gJL6hC2.js").then(({ openWsChannel }) => openWsChannel(runId, config2)).catch(() => void 0);
+    },
+    /**
+     * Awaited, unlike the open: work scheduled after the handler returns is not
+     * guaranteed to run, and an open socket is not `unref`'d, so skipping this
+     * stops the process exiting and keeps a server invocation pinned.
+     *
+     * Releases the claim the open returned rather than re-resolving the run,
+     * which is what keeps a channel this invocation never opened — a later
+     * invocation's, registered under the same URL after ours was evicted — out
+     * of reach of our release.
+     */
+    async close() {
+      const release = await claim;
+      release == null ? void 0 : release();
+    }
+  };
+};
 const RUN_ID_PREFIX = "wrun_";
 function regionFromTaggedRunId(runId) {
   if (!runId)
@@ -142432,15 +142874,21 @@ function createQueue$1(config2) {
       }
       const requestId = requestIdStorage.getStore();
       const { payload, queueName, deploymentId } = MessageWrapper.parse(message2);
-      const result = await handler(payload, {
-        queueName,
-        messageId: MessageId.parse(metadata.messageId),
-        attempt: metadata.deliveryCount,
-        requestId
-      });
-      if (typeof (result == null ? void 0 : result.timeoutSeconds) === "number") {
-        const delaySeconds = result.timeoutSeconds > 0 ? Math.min(result.timeoutSeconds, MAX_DELAY_SECONDS) : void 0;
-        await queue(queueName, payload, { deploymentId, delaySeconds });
+      const wsEvents = wsEventsChannelForInvocation(getRunIdFromPayload(payload), config2);
+      wsEvents.open();
+      try {
+        const result = await handler(payload, {
+          queueName,
+          messageId: MessageId.parse(metadata.messageId),
+          attempt: metadata.deliveryCount,
+          requestId
+        });
+        if (typeof (result == null ? void 0 : result.timeoutSeconds) === "number") {
+          const delaySeconds = result.timeoutSeconds > 0 ? Math.min(result.timeoutSeconds, MAX_DELAY_SECONDS) : void 0;
+          await queue(queueName, payload, { deploymentId, delaySeconds });
+        }
+      } finally {
+        await wsEvents.close();
       }
     }, {
       // Without an explicit retry directive, @vercel/queue leaves failed
@@ -142517,15 +142965,6 @@ function createResolveLatestDeploymentId(config2) {
     return result.data.id;
   };
 }
-function coerceEventDates(raw2) {
-  const parsed = EventSchema.safeParse(raw2);
-  if (parsed.success)
-    return parsed.data;
-  if (EventTypeSchema.safeParse(raw2.eventType).success) {
-    console.debug(`[workflow:world-vercel] v4 event ${raw2.eventId} failed EventSchema parse for known eventType '${raw2.eventType}'; passing through unparsed: ${parsed.error.message}`);
-  }
-  return raw2;
-}
 const EVENT_RETRY_ELIGIBILITY = {
   // Creates: conditional create → 409 EntityConflictError if it already exists.
   run_created: {
@@ -142651,6 +143090,8 @@ function isRetryableEventPostError(err) {
   if (WorkflowWorldError.is(err)) {
     if (err.code === "PARSE_ERROR")
       return true;
+    if (err.code === "TRANSPORT")
+      return true;
     if (typeof err.status === "number") {
       return err.status >= 500 && err.status <= 599;
     }
@@ -142702,6 +143143,7 @@ async function withEventPostRetry(fn2, eventType, options) {
   }
 }
 const V4_FRAME_CONTENT_TYPE = "application/vnd.workflow.v4-frames";
+const CborObjectSchema = record(string$3(), unknown$1());
 function encodeFrame(meta2, body2) {
   const metaBytes = new Uint8Array(encode$1(meta2));
   const out = new Uint8Array(4 + metaBytes.byteLength + 4 + body2.byteLength);
@@ -142743,7 +143185,7 @@ async function* decodeFrames(source) {
       if (!await refill(metaLen)) {
         throw new Error("decodeFrames: truncated meta block");
       }
-      const meta2 = decode$1(take(metaLen));
+      const meta2 = CborObjectSchema.parse(decode$1(take(metaLen)));
       if (!await refill(4)) {
         throw new Error("decodeFrames: truncated body length");
       }
@@ -142784,35 +143226,260 @@ async function* readerToIterator(reader) {
     closeQuietly(() => reader.cancel());
   }
 }
+const FORMAT_PREFIX_LENGTH = 4;
+const DEVALUE_FORMAT_PREFIX = "devl";
+const ENCRYPTED_FORMAT_PREFIX = "encr";
+const GZIP_FORMAT_PREFIX = "gzip";
+const ZSTD_FORMAT_PREFIX = "zstd";
+const formatDecoder = new TextDecoder();
+const SERIALIZED_DATA_FORMAT_PREFIXES = /* @__PURE__ */ new Set([
+  DEVALUE_FORMAT_PREFIX,
+  ENCRYPTED_FORMAT_PREFIX,
+  GZIP_FORMAT_PREFIX,
+  ZSTD_FORMAT_PREFIX
+]);
+function getNodeZlib() {
+  var _a3, _b2;
+  try {
+    return (_b2 = (_a3 = globalThis.process) == null ? void 0 : _a3.getBuiltinModule) == null ? void 0 : _b2.call(_a3, "node:zlib");
+  } catch {
+    return void 0;
+  }
+}
+function peekFormatPrefix(value) {
+  if (!(value instanceof Uint8Array) || value.byteLength < FORMAT_PREFIX_LENGTH) {
+    return null;
+  }
+  return formatDecoder.decode(value.subarray(0, FORMAT_PREFIX_LENGTH));
+}
+function hasSerializedDataFormatPrefix(value) {
+  const format2 = peekFormatPrefix(value);
+  return format2 !== null && SERIALIZED_DATA_FORMAT_PREFIXES.has(format2);
+}
+function decompress(format2, payload) {
+  const zlib = getNodeZlib();
+  const decompress2 = format2 === ZSTD_FORMAT_PREFIX ? zlib == null ? void 0 : zlib.zstdDecompressSync : zlib == null ? void 0 : zlib.gunzipSync;
+  if (!decompress2) {
+    throw new WorkflowWorldError(`Received ${format2}-compressed workflow data, but this Node.js runtime does not support ${format2} decompression. Use a compatible Node.js runtime or request unresolved data.`);
+  }
+  return new Uint8Array(decompress2(payload));
+}
+function normalizeSerializedData(value) {
+  const format2 = peekFormatPrefix(value);
+  if (format2 !== ZSTD_FORMAT_PREFIX && format2 !== GZIP_FORMAT_PREFIX) {
+    return value;
+  }
+  const bytes = value;
+  return decompress(format2, bytes.subarray(FORMAT_PREFIX_LENGTH));
+}
+function normalizeWorkflowRunData(run2) {
+  return {
+    ...run2,
+    input: normalizeSerializedData(run2.input),
+    output: normalizeSerializedData(run2.output),
+    error: normalizeSerializedData(run2.error)
+  };
+}
+function normalizeStepData(step) {
+  return {
+    ...step,
+    input: normalizeSerializedData(step.input),
+    output: normalizeSerializedData(step.output),
+    error: normalizeSerializedData(step.error)
+  };
+}
+function normalizeHookData(hook) {
+  return {
+    ...hook,
+    metadata: normalizeSerializedData(hook.metadata)
+  };
+}
+const StepWireSchema = StepSchema.omit({
+  error: true
+}).extend({
+  error: union([SerializedDataSchema, any()]).optional(),
+  errorRef: any().optional()
+});
+const StepWireWithRefsSchema = StepWireSchema.omit({
+  input: true,
+  output: true
+}).extend({
+  // We discard the results of the refs, so we don't care about the type here
+  inputRef: any().optional(),
+  outputRef: any().optional(),
+  input: _instanceof(Uint8Array).optional(),
+  output: _instanceof(Uint8Array).optional()
+});
+function deserializeStep(wireStep) {
+  const { error: error2, errorRef, ...rest } = wireStep;
+  const result = { ...rest };
+  const errorSource = error2 ?? errorRef;
+  if (errorSource !== void 0 && errorSource !== null) {
+    result.error = errorSource;
+  }
+  return result;
+}
+function filterStepData(step, resolveData) {
+  if (resolveData === "none") {
+    const { inputRef: _inputRef, outputRef: _outputRef, ...rest } = step;
+    const deserialized = normalizeStepData(deserializeStep(rest));
+    return {
+      ...deserialized,
+      input: void 0,
+      output: void 0
+    };
+  }
+  return normalizeStepData(deserializeStep(step));
+}
+async function listWorkflowRunSteps(params, config2) {
+  const { runId, pagination, resolveData = DEFAULT_RESOLVE_DATA_OPTION } = params;
+  const searchParams = new URLSearchParams();
+  if (pagination == null ? void 0 : pagination.cursor)
+    searchParams.set("cursor", pagination.cursor);
+  if (pagination == null ? void 0 : pagination.limit)
+    searchParams.set("limit", pagination.limit.toString());
+  if (pagination == null ? void 0 : pagination.sortOrder)
+    searchParams.set("sortOrder", pagination.sortOrder);
+  const remoteRefBehavior = resolveData === "none" ? "lazy" : "resolve";
+  searchParams.set("remoteRefBehavior", remoteRefBehavior);
+  const queryString = searchParams.toString();
+  const endpoint = `/v2/runs/${encodeURIComponent(runId)}/steps${queryString ? `?${queryString}` : ""}`;
+  const response2 = await makeRequest({
+    endpoint,
+    options: { method: "GET" },
+    config: config2,
+    schema: PaginatedResponseSchema(remoteRefBehavior === "lazy" ? StepWireWithRefsSchema : StepWireSchema)
+  });
+  return {
+    ...response2,
+    data: response2.data.map((step) => filterStepData(step, resolveData))
+  };
+}
+async function getStep(runId, stepId, params, config2) {
+  const resolveData = (params == null ? void 0 : params.resolveData) ?? DEFAULT_RESOLVE_DATA_OPTION;
+  const remoteRefBehavior = resolveData === "none" ? "lazy" : "resolve";
+  const searchParams = new URLSearchParams();
+  searchParams.set("remoteRefBehavior", remoteRefBehavior);
+  const queryString = searchParams.toString();
+  const endpoint = `/v2/runs/${encodeURIComponent(runId)}/steps/${encodeURIComponent(stepId)}${queryString ? `?${queryString}` : ""}`;
+  const step = await makeRequest({
+    endpoint,
+    options: { method: "GET" },
+    config: config2,
+    schema: remoteRefBehavior === "lazy" ? StepWireWithRefsSchema : StepWireSchema
+  });
+  return filterStepData(step, resolveData);
+}
 async function fetchV4(url2, init2, config2, opName) {
+  const dispatcher2 = getEventsDispatcher(config2);
   return instrumentedFetch({
     method: init2.method,
     url: url2,
     headers: init2.headers,
     body: init2.body,
-    dispatcher: getEventsDispatcher(config2),
+    dispatcher: dispatcher2,
+    // Repeated transport failures retire the shared events pool and the next
+    // request builds a fresh one. undici keeps a black-holed HTTP/2 session in
+    // service indefinitely, so without this every request routed onto it fails
+    // until the compute instance is recycled — see noteEventsTransportOutcome.
+    onTransportOutcome: (error2) => noteEventsTransportOutcome(dispatcher2, error2),
     timeoutMs: null,
     logLabel: opName,
-    buildError: async (response2) => errorFromV4Response(response2.status, headersToRecord(response2.headers), await response2.text(), opName, url2)
+    // Read the body as bytes, not text: a CBOR error body (the fence 412
+    // carries event payloads back) does not survive a UTF-8 decode.
+    buildError: async (response2) => errorFromV4Response(response2.status, headersToRecord(response2.headers), new Uint8Array(await response2.arrayBuffer()), opName, url2)
   });
 }
-function headersToRecord(headers2) {
-  const out = {};
-  headers2.forEach((value, key) => {
-    out[key] = value;
+const EVENT_ID_HEADER = "x-wf-event-id";
+const MAX_EVENTS_HEADER = "x-wf-max-events";
+const CreateEventV4BodyBaseSchema = object$1({
+  event: EventSchema,
+  run: WorkflowRunSchema.optional(),
+  step: StepWireSchema.transform(deserializeStep).optional(),
+  hook: HookSchema.optional(),
+  wait: WaitSchema.optional(),
+  stepCreated: literal(true).optional(),
+  maxEvents: number$3().int().positive().optional()
+});
+const CreateEventV4PageSchema = union([
+  object$1({
+    events: array$1(EventSchema),
+    cursor: string$3().nullable(),
+    hasMore: boolean$3()
+  }),
+  object$1({
+    events: _undefined(),
+    cursor: _undefined(),
+    hasMore: _undefined()
+  })
+]);
+const CreateEventV4BodySchema = CreateEventV4BodyBaseSchema.and(CreateEventV4PageSchema);
+const CreateEventV4BodySchemas = {
+  run_created: CreateEventV4BodyBaseSchema.extend({
+    run: WorkflowRunSchema
+  }).and(CreateEventV4PageSchema),
+  run_started: CreateEventV4BodyBaseSchema.extend({
+    run: WorkflowRunSchema.and(object$1({ startedAt: date$2() }))
+  }).and(CreateEventV4PageSchema),
+  step_started: CreateEventV4BodyBaseSchema.extend({
+    step: StepWireSchema.extend({
+      startedAt: date$2()
+    }).transform((step) => ({
+      ...deserializeStep(step),
+      startedAt: step.startedAt
+    }))
+  }).and(CreateEventV4PageSchema),
+  run_completed: CreateEventV4BodySchema,
+  run_failed: CreateEventV4BodySchema,
+  run_cancelled: CreateEventV4BodySchema,
+  attr_set: CreateEventV4BodySchema,
+  step_created: CreateEventV4BodySchema,
+  step_completed: CreateEventV4BodySchema,
+  step_failed: CreateEventV4BodySchema,
+  step_retrying: CreateEventV4BodySchema,
+  hook_created: CreateEventV4BodySchema,
+  hook_received: CreateEventV4BodySchema,
+  hook_disposed: CreateEventV4BodySchema,
+  hook_conflict: CreateEventV4BodySchema,
+  wait_created: CreateEventV4BodySchema,
+  wait_completed: CreateEventV4BodySchema
+};
+const MaxEventsHeaderSchema = number$2().int().positive();
+const EventStreamEndSchema = object$1({
+  _end: literal(1),
+  next: string$3().optional(),
+  hasMore: boolean$3()
+});
+const legacyStructuredErrorEventTypes = /* @__PURE__ */ new Set([
+  "run_failed",
+  "step_failed",
+  "step_retrying"
+]);
+function decodeLegacyStructuredError(payload) {
+  if (hasSerializedDataFormatPrefix(payload))
+    return payload;
+  try {
+    const parsed = StructuredErrorSchema.safeParse(decode$1(payload.slice()));
+    return parsed.success ? parsed.data : payload;
+  } catch {
+    return payload;
+  }
+}
+function decodeEventFrame({ meta: meta2, body: body2 }) {
+  const eventType = EventTypeSchema.parse(meta2.eventType);
+  if (body2.byteLength === 0)
+    return EventSchema.parse(meta2);
+  const payloadField = getEventDataPayloadField(eventType);
+  assert$1(payloadField, `Event type ${eventType} cannot carry a payload body`);
+  assert$1(meta2.eventData && typeof meta2.eventData === "object");
+  return EventSchema.parse({
+    ...meta2,
+    eventData: {
+      ...meta2.eventData,
+      [payloadField]: legacyStructuredErrorEventTypes.has(eventType) ? decodeLegacyStructuredError(body2) : body2
+    }
   });
-  return out;
 }
-const V4_RESPONSE_HEADERS = {
-  eventId: "x-wf-event-id",
-  runId: "x-wf-run-id",
-  createdAt: "x-wf-created-at",
-  /**
-   * Server-owned per-run event ceiling. Set on streamed replay-log
-   * responses, where there is no CBOR body to carry `maxEvents`.
-   */
-  maxEvents: "x-wf-max-events"
-};
 function buildPostFrameMeta(input) {
   const meta2 = {
     eventType: input.eventType,
@@ -142892,8 +143559,8 @@ function buildPostFrameMeta(input) {
   }
   if (input.sinceCursor !== void 0)
     meta2.sinceCursor = input.sinceCursor;
-  if (input.skipPreload !== void 0)
-    meta2.skipPreload = input.skipPreload;
+  if (input.skipPreload)
+    meta2.skipPreload = true;
   if (input.stateUpdatedAt !== void 0) {
     meta2.stateUpdatedAt = input.stateUpdatedAt;
   }
@@ -142902,6 +143569,8 @@ function buildPostFrameMeta(input) {
   }
   if (input.stateCursor !== void 0)
     meta2.stateCursor = input.stateCursor;
+  if (input.maxSlot !== void 0)
+    meta2.maxSlot = input.maxSlot;
   if (input.replayDivergenceCount !== void 0) {
     meta2.replayDivergenceCount = input.replayDivergenceCount;
   }
@@ -142914,17 +143583,16 @@ function errorFromV4Response(statusCode, responseHeaders, errorBody, opName, url
   let message2 = `v4 ${opName} failed: HTTP ${statusCode}`;
   let code2;
   let details;
-  try {
-    const json2 = JSON.parse(errorBody);
-    if (typeof json2.message === "string")
-      message2 = json2.message;
-    if (typeof json2.code === "string")
-      code2 = json2.code;
+  const { record: record2, text: text2 } = parseV4ErrorBody(errorBody, readHeader(responseHeaders, "content-type"));
+  if (record2) {
+    if (typeof record2.message === "string")
+      message2 = record2.message;
+    if (typeof record2.code === "string")
+      code2 = record2.code;
     if (statusCode === 412)
-      details = decodePreconditionDetails(json2);
-  } catch {
-    if (errorBody)
-      message2 += ` ${errorBody}`;
+      details = decodePreconditionDetails(record2);
+  } else if (text2) {
+    message2 += ` ${text2}`;
   }
   const retryAfter = parseRetryAfter(readHeader(responseHeaders, "retry-after"));
   return errorForResponse(statusCode, message2, {
@@ -142935,6 +143603,27 @@ function errorFromV4Response(statusCode, responseHeaders, errorBody, opName, url
     ...details !== void 0 ? { details } : {}
   });
 }
+function parseV4ErrorBody(body2, contentType) {
+  if (typeof body2 !== "string" && (contentType == null ? void 0 : contentType.includes("application/cbor"))) {
+    try {
+      const decoded = decode$1(body2.slice());
+      if (typeof decoded === "object" && decoded !== null) {
+        return { record: decoded };
+      }
+    } catch {
+    }
+    return {};
+  }
+  const text2 = typeof body2 === "string" ? body2 : new TextDecoder().decode(body2);
+  try {
+    const json2 = JSON.parse(text2);
+    if (typeof json2 === "object" && json2 !== null) {
+      return { record: json2 };
+    }
+  } catch {
+  }
+  return { text: text2 };
+}
 function decodePreconditionDetails(json2) {
   if (!Array.isArray(json2.events) || json2.events.length === 0)
     return void 0;
@@ -142947,7 +143636,10 @@ function decodePreconditionDetails(json2) {
       return void 0;
     if (hasUnusablePayload(candidate))
       return void 0;
-    events2.push(coerceEventDates(candidate));
+    const event = EventSchema.safeParse(candidate);
+    if (!event.success)
+      return void 0;
+    events2.push(event.data);
   }
   return {
     events: events2,
@@ -142969,49 +143661,118 @@ function hasUnusablePayload(candidate) {
     return false;
   return !(value instanceof Uint8Array);
 }
-async function createWorkflowRunEventV4(input, config2) {
+async function postWorkflowRunEventV4(input, responseType, config2) {
   const { baseUrl, headers: baseHeaders } = await getHttpConfig(config2);
   const headers2 = new Headers(baseHeaders);
   headers2.set("Content-Type", "application/octet-stream");
+  if (responseType === "event-stream") {
+    headers2.set("Accept", V4_FRAME_CONTENT_TYPE);
+  }
   const frame2 = encodeFrame(buildPostFrameMeta(input), input.payload ?? new Uint8Array(0));
   const url2 = `${baseUrl}/v4/runs/${encodeURIComponent(input.runId)}/events/${encodeURIComponent(input.eventType)}`;
-  const response2 = await fetchV4(url2, { method: "POST", headers: headers2, body: frame2 }, config2, "createEvent");
-  return decodeMaterializedCreateEventResponse(response2);
+  return fetchV4(url2, { method: "POST", headers: headers2, body: frame2 }, config2, "createEvent");
 }
-async function decodeMaterializedCreateEventResponse(response2) {
-  const eventId = response2.headers.get(V4_RESPONSE_HEADERS.eventId);
-  const runId = response2.headers.get(V4_RESPONSE_HEADERS.runId);
-  const createdAt = response2.headers.get(V4_RESPONSE_HEADERS.createdAt);
-  if (typeof eventId !== "string" || typeof runId !== "string" || typeof createdAt !== "string") {
-    throw new Error("v4 createEvent: response missing required x-wf-* headers");
+async function createWorkflowRunEventV4(input, config2) {
+  if (isWsEventsTransportEnabled()) {
+    const reply = await postEventFrameOverWs(input, config2);
+    if (reply)
+      return decodeCreateEventResponse(reply, input.eventType);
   }
+  const response2 = await postWorkflowRunEventV4(input, "materialized", config2);
+  const contentType = response2.headers.get("content-type");
+  if (contentType == null ? void 0 : contentType.startsWith(V4_FRAME_CONTENT_TYPE)) {
+    throw new Error("v4 createEvent: unexpected event page");
+  }
+  return decodeCreateEventResponse(response2, input.eventType);
+}
+async function decodeCreateEventResponse(response2, eventType) {
   const bodyBytes = new Uint8Array(await response2.arrayBuffer());
-  const body2 = bodyBytes.byteLength > 0 ? decode$1(bodyBytes) : {};
-  return { eventId, runId, createdAt, body: body2 };
+  if (bodyBytes.byteLength === 0) {
+    throw new Error("v4 createEvent: empty response body");
+  }
+  const schema = CreateEventV4BodySchemas[eventType].refine(({ event }) => event.eventType === eventType || eventType === "hook_created" && event.eventType === "hook_conflict", { path: ["event", "eventType"] });
+  const parsedBody = schema.safeParse(decode$1(bodyBytes));
+  if (!parsedBody.success) {
+    throw new WorkflowWorldError("v4 createEvent: invalid response body", {
+      code: "SCHEMA_VALIDATION",
+      cause: parsedBody.error
+    });
+  }
+  return parsedBody.data;
+}
+async function createWorkflowRunStartedEventV4(input, config2) {
+  const response2 = await postWorkflowRunEventV4({ ...input, eventType: "run_started" }, "event-stream", config2);
+  const events2 = [];
+  const page = await consumeEventFrameStream(response2, "createEvent", events2);
+  assert$1(page.cursor, "v4 createEvent: event stream missing cursor");
+  const maxEvents = MaxEventsHeaderSchema.safeParse(response2.headers.get(MAX_EVENTS_HEADER));
+  if (!maxEvents.success) {
+    throw new WorkflowWorldError("v4 createEvent: invalid max-events header", {
+      code: "SCHEMA_VALIDATION",
+      cause: maxEvents.error
+    });
+  }
+  return { events: events2, ...page, maxEvents: maxEvents.data };
+}
+function replyMetaToHeaderRecord(meta2) {
+  const out = {};
+  if (typeof meta2.eventId === "string")
+    out[EVENT_ID_HEADER] = meta2.eventId;
+  if (typeof meta2.retryAfter === "string")
+    out["retry-after"] = meta2.retryAfter;
+  if (typeof meta2.mitigated === "string")
+    out["x-vercel-mitigated"] = meta2.mitigated;
+  return out;
+}
+function wsReplyStatus(reply, endpoint) {
+  const { status } = reply.meta;
+  if (typeof status !== "number") {
+    throw new WorkflowWorldError(`Failed to parse response body for POST ${endpoint}: reply frame carried no numeric status (type: ${String(reply.meta.type ?? "absent")}). Refusing to treat an unrecognized reply as success — the write may or may not have been applied.`, { url: endpoint, code: "PARSE_ERROR" });
+  }
+  return status;
+}
+async function postEventFrameOverWs(input, config2) {
+  const { resolveWsTransport } = await import("./ws-transport-2gJL6hC2.js");
+  const { runId } = input;
+  const resolved = resolveWsTransport(runId, config2);
+  if (!resolved)
+    return void 0;
+  const { transport, wsUrl } = resolved;
+  const endpoint = `${wsUrl}#runs/${encodeURIComponent(runId)}/events`;
+  let reply;
+  try {
+    reply = await transport.request((reqId) => encodeFrame({ reqId, type: "event", event: buildPostFrameMeta(input) }, input.payload ?? new Uint8Array(0)));
+  } catch (err) {
+    throw new WorkflowWorldError(`POST ${endpoint} transport failure: ${err instanceof Error ? err.message : String(err)}`, { url: wsUrl, code: "TRANSPORT", cause: err });
+  }
+  const status = wsReplyStatus(reply, endpoint);
+  const headerRecord = replyMetaToHeaderRecord(reply.meta);
+  if (status < 200 || status >= 300) {
+    throw errorFromV4Response(status, headerRecord, new TextDecoder().decode(reply.body), "createEvent", endpoint);
+  }
+  return {
+    headers: { get: (name2) => headerRecord[name2.toLowerCase()] ?? null },
+    arrayBuffer: async () => reply.body.slice().buffer
+  };
 }
 async function createHookReceivedPreloadEventV4(input, config2) {
-  const { baseUrl, headers: baseHeaders } = await getHttpConfig(config2);
-  const headers2 = new Headers(baseHeaders);
-  headers2.set("Content-Type", "application/octet-stream");
-  headers2.set("Accept", V4_FRAME_CONTENT_TYPE);
-  const frame2 = encodeFrame(buildPostFrameMeta(input), input.payload ?? new Uint8Array(0));
-  const url2 = `${baseUrl}/v4/runs/${encodeURIComponent(input.runId)}/events/${encodeURIComponent(input.eventType)}`;
-  const response2 = await fetchV4(url2, { method: "POST", headers: headers2, body: frame2 }, config2, "createEvent");
+  const response2 = await postWorkflowRunEventV4({ ...input, eventType: "hook_received" }, "event-stream", config2);
   const contentType = response2.headers.get("content-type");
   if (!(contentType == null ? void 0 : contentType.startsWith(V4_FRAME_CONTENT_TYPE))) {
     return {
       kind: "materialized",
-      result: await decodeMaterializedCreateEventResponse(response2)
+      result: await decodeCreateEventResponse(response2, "hook_received")
     };
   }
-  const page = await decodeListFrameResponse(response2, "createEvent");
-  const maxEventsRaw = response2.headers.get(V4_RESPONSE_HEADERS.maxEvents);
-  const maxEventsParsed = maxEventsRaw === null ? Number.NaN : Number(maxEventsRaw);
+  const events2 = [];
+  const page = await consumeEventFrameStream(response2, "createEvent", events2);
+  const maxEvents = MaxEventsHeaderSchema.safeParse(response2.headers.get(MAX_EVENTS_HEADER));
   return {
     kind: "stream",
+    events: events2,
     ...page,
-    canonicalEventId: response2.headers.get(V4_RESPONSE_HEADERS.eventId) ?? void 0,
-    maxEvents: Number.isInteger(maxEventsParsed) && maxEventsParsed > 0 ? maxEventsParsed : void 0
+    canonicalEventId: response2.headers.get(EVENT_ID_HEADER) ?? void 0,
+    maxEvents: maxEvents.success ? maxEvents.data : void 0
   };
 }
 function readHeader(responseHeaders, name2) {
@@ -143022,9 +143783,9 @@ function readHeader(responseHeaders, name2) {
     return value[0];
   return void 0;
 }
-async function getEventV4(runId, eventId, config2) {
+async function getEventV4(runId, eventId, remoteRefBehavior, config2) {
   const { baseUrl, headers: headers2 } = await getHttpConfig(config2);
-  const url2 = `${baseUrl}/v4/runs/${encodeURIComponent(runId)}/events/${encodeURIComponent(eventId)}`;
+  const url2 = `${baseUrl}/v4/runs/${encodeURIComponent(runId)}/events/${encodeURIComponent(eventId)}?remoteRefBehavior=${remoteRefBehavior}`;
   const response2 = await fetchV4(url2, { method: "GET", headers: headers2 }, config2, "getEvent");
   const contentType = response2.headers.get("content-type");
   if (!(contentType == null ? void 0 : contentType.startsWith(V4_FRAME_CONTENT_TYPE))) {
@@ -143032,46 +143793,31 @@ async function getEventV4(runId, eventId, config2) {
   }
   const chunks = response2.body;
   for await (const frame2 of decodeFrames(chunks)) {
-    return { event: frame2.meta, body: frame2.body };
+    return decodeEventFrame(frame2);
   }
   throw new Error(`v4 getEvent: empty frame stream for ${eventId}`);
 }
-async function consumeListFrameStream(url2, headers2, config2, opName) {
-  const response2 = await fetchV4(url2, { method: "GET", headers: headers2 }, config2, opName);
-  return decodeListFrameResponse(response2, opName);
-}
-async function decodeListFrameResponse(response2, opName) {
+async function consumeEventFrameStream(response2, opName, events2) {
   const contentType = response2.headers.get("content-type");
   if (!(contentType == null ? void 0 : contentType.startsWith(V4_FRAME_CONTENT_TYPE))) {
     throw new Error(`v4 ${opName}: expected ${V4_FRAME_CONTENT_TYPE}, got ${contentType ?? "(none)"}`);
   }
   const chunks = response2.body;
-  const events2 = [];
-  let next2;
-  let hasMore;
-  let sawEndSentinel = false;
   for await (const frame2 of decodeFrames(chunks)) {
     if (frame2.meta._end === 1) {
-      if (typeof frame2.meta.next === "string")
-        next2 = frame2.meta.next;
-      if (typeof frame2.meta.hasMore === "boolean")
-        hasMore = frame2.meta.hasMore;
-      sawEndSentinel = true;
-      break;
+      const end = EventStreamEndSchema.parse(frame2.meta);
+      return { cursor: end.next ?? null, hasMore: end.hasMore };
     }
-    events2.push({
-      event: frame2.meta,
-      body: frame2.body
-    });
-  }
-  if (!sawEndSentinel) {
-    throw new Error(`v4 ${opName}: frame stream ended without the end-of-stream sentinel (${events2.length} events read) — truncated response?`);
+    if (Object.keys(frame2.meta).some((key) => key.startsWith("_"))) {
+      throw new Error(`v4 ${opName}: unexpected control frame`);
+    }
+    events2.push(decodeEventFrame(frame2));
   }
-  return {
-    events: events2,
-    ...next2 ? { next: next2 } : {},
-    ...hasMore !== void 0 ? { hasMore } : {}
-  };
+  throw new Error(`v4 ${opName}: frame stream ended without the end-of-stream sentinel (${events2.length} events read) — truncated response?`);
+}
+async function consumeListFrameStream(url2, headers2, config2, opName, events2) {
+  const response2 = await fetchV4(url2, { method: "GET", headers: headers2 }, config2, opName);
+  return consumeEventFrameStream(response2, opName, events2);
 }
 function appendListParams(sp, params) {
   if (params.cursor)
@@ -143086,14 +143832,28 @@ function appendListParams(sp, params) {
 }
 function paginationToQuery(params) {
   const sp = new URLSearchParams();
+  if (params.limit === void 0)
+    sp.set("returnAll", "true");
   appendListParams(sp, params);
-  const qs = sp.toString();
-  return qs ? `?${qs}` : "";
+  return `?${sp.toString()}`;
 }
 async function getWorkflowRunEventsV4(runId, params = {}, config2) {
   const { baseUrl, headers: headers2 } = await getHttpConfig(config2);
-  const url2 = `${baseUrl}/v4/runs/${encodeURIComponent(runId)}/events` + paginationToQuery(params);
-  return consumeListFrameStream(url2, headers2, config2, "listEvents");
+  const events2 = [];
+  let cursor = params.cursor;
+  while (true) {
+    const url2 = `${baseUrl}/v4/runs/${encodeURIComponent(runId)}/events` + paginationToQuery({ ...params, cursor });
+    try {
+      const page = await consumeListFrameStream(url2, headers2, config2, "listEvents", events2);
+      return { events: events2, ...page };
+    } catch (error2) {
+      const lastEvent = events2.at(-1);
+      if (params.limit !== void 0 || !lastEvent || `eid:${lastEvent.eventId}` === cursor) {
+        throw error2;
+      }
+      cursor = `eid:${lastEvent.eventId}`;
+    }
+  }
 }
 async function getEventsByCorrelationIdV4(correlationId, runId, params = {}, config2) {
   const { baseUrl, headers: headers2 } = await getHttpConfig(config2);
@@ -143102,100 +143862,9 @@ async function getEventsByCorrelationIdV4(correlationId, runId, params = {}, con
   sp.set("runId", runId);
   appendListParams(sp, params);
   const url2 = `${baseUrl}/v4/events?${sp.toString()}`;
-  return consumeListFrameStream(url2, headers2, config2, "listEventsByCorrelationId");
-}
-const FORMAT_PREFIX_LENGTH = 4;
-const DEVALUE_FORMAT_PREFIX = "devl";
-const ENCRYPTED_FORMAT_PREFIX = "encr";
-const GZIP_FORMAT_PREFIX = "gzip";
-const ZSTD_FORMAT_PREFIX = "zstd";
-const formatDecoder = new TextDecoder();
-const SERIALIZED_DATA_FORMAT_PREFIXES = /* @__PURE__ */ new Set([
-  DEVALUE_FORMAT_PREFIX,
-  ENCRYPTED_FORMAT_PREFIX,
-  GZIP_FORMAT_PREFIX,
-  ZSTD_FORMAT_PREFIX
-]);
-function getNodeZlib() {
-  var _a3, _b2;
-  try {
-    return (_b2 = (_a3 = globalThis.process) == null ? void 0 : _a3.getBuiltinModule) == null ? void 0 : _b2.call(_a3, "node:zlib");
-  } catch {
-    return void 0;
-  }
-}
-function peekFormatPrefix(value) {
-  if (!(value instanceof Uint8Array) || value.byteLength < FORMAT_PREFIX_LENGTH) {
-    return null;
-  }
-  return formatDecoder.decode(value.subarray(0, FORMAT_PREFIX_LENGTH));
-}
-function hasSerializedDataFormatPrefix(value) {
-  const format2 = peekFormatPrefix(value);
-  return format2 !== null && SERIALIZED_DATA_FORMAT_PREFIXES.has(format2);
-}
-function decompress(format2, payload) {
-  const zlib = getNodeZlib();
-  const decompress2 = format2 === ZSTD_FORMAT_PREFIX ? zlib == null ? void 0 : zlib.zstdDecompressSync : zlib == null ? void 0 : zlib.gunzipSync;
-  if (!decompress2) {
-    throw new WorkflowWorldError(`Received ${format2}-compressed workflow data, but this Node.js runtime does not support ${format2} decompression. Use a compatible Node.js runtime or request unresolved data.`);
-  }
-  return new Uint8Array(decompress2(payload));
-}
-function normalizeSerializedData(value) {
-  const format2 = peekFormatPrefix(value);
-  if (format2 !== ZSTD_FORMAT_PREFIX && format2 !== GZIP_FORMAT_PREFIX) {
-    return value;
-  }
-  const bytes = value;
-  return decompress(format2, bytes.subarray(FORMAT_PREFIX_LENGTH));
-}
-function normalizeWorkflowRunData(run2) {
-  return {
-    ...run2,
-    input: normalizeSerializedData(run2.input),
-    output: normalizeSerializedData(run2.output),
-    error: normalizeSerializedData(run2.error)
-  };
-}
-function normalizeStepData(step) {
-  return {
-    ...step,
-    input: normalizeSerializedData(step.input),
-    output: normalizeSerializedData(step.output),
-    error: normalizeSerializedData(step.error)
-  };
-}
-function normalizeHookData(hook) {
-  return {
-    ...hook,
-    metadata: normalizeSerializedData(hook.metadata)
-  };
-}
-function normalizeEventData(event) {
-  const eventData = event.eventData;
-  if (!eventData || typeof eventData !== "object") {
-    return event;
-  }
-  const eventType = typeof event.eventType === "string" ? event.eventType : "";
-  const refFields = getEventDataRefFields(eventType);
-  if (refFields.length === 0) {
-    return event;
-  }
-  const normalizedEventData = { ...eventData };
-  let changed = false;
-  for (const field of refFields) {
-    if (!(field in normalizedEventData)) {
-      continue;
-    }
-    const before = normalizedEventData[field];
-    const after = normalizeSerializedData(before);
-    if (after !== before) {
-      normalizedEventData[field] = after;
-      changed = true;
-    }
-  }
-  return changed ? { ...event, eventData: normalizedEventData } : event;
+  const events2 = [];
+  const page = await consumeListFrameStream(url2, headers2, config2, "listEventsByCorrelationId", events2);
+  return { events: events2, ...page };
 }
 const WorkflowRunWireBaseSchema = WorkflowRunBaseSchema.omit({
   error: true,
@@ -143366,82 +144035,6 @@ async function experimentalSetAttributes(runId, changes, options, config2) {
     throw error2;
   }
 }
-const StepWireSchema = StepSchema.omit({
-  error: true
-}).extend({
-  error: union([SerializedDataSchema, any()]).optional(),
-  errorRef: any().optional()
-});
-const StepWireWithRefsSchema = StepWireSchema.omit({
-  input: true,
-  output: true
-}).extend({
-  // We discard the results of the refs, so we don't care about the type here
-  inputRef: any().optional(),
-  outputRef: any().optional(),
-  input: _instanceof(Uint8Array).optional(),
-  output: _instanceof(Uint8Array).optional()
-});
-function deserializeStep(wireStep) {
-  const { error: error2, errorRef, ...rest } = wireStep;
-  const result = { ...rest };
-  const errorSource = error2 ?? errorRef;
-  if (errorSource !== void 0 && errorSource !== null) {
-    result.error = errorSource;
-  }
-  return result;
-}
-function filterStepData(step, resolveData) {
-  if (resolveData === "none") {
-    const { inputRef: _inputRef, outputRef: _outputRef, ...rest } = step;
-    const deserialized = normalizeStepData(deserializeStep(rest));
-    return {
-      ...deserialized,
-      input: void 0,
-      output: void 0
-    };
-  }
-  return normalizeStepData(deserializeStep(step));
-}
-async function listWorkflowRunSteps(params, config2) {
-  const { runId, pagination, resolveData = DEFAULT_RESOLVE_DATA_OPTION } = params;
-  const searchParams = new URLSearchParams();
-  if (pagination == null ? void 0 : pagination.cursor)
-    searchParams.set("cursor", pagination.cursor);
-  if (pagination == null ? void 0 : pagination.limit)
-    searchParams.set("limit", pagination.limit.toString());
-  if (pagination == null ? void 0 : pagination.sortOrder)
-    searchParams.set("sortOrder", pagination.sortOrder);
-  const remoteRefBehavior = resolveData === "none" ? "lazy" : "resolve";
-  searchParams.set("remoteRefBehavior", remoteRefBehavior);
-  const queryString = searchParams.toString();
-  const endpoint = `/v2/runs/${encodeURIComponent(runId)}/steps${queryString ? `?${queryString}` : ""}`;
-  const response2 = await makeRequest({
-    endpoint,
-    options: { method: "GET" },
-    config: config2,
-    schema: PaginatedResponseSchema(remoteRefBehavior === "lazy" ? StepWireWithRefsSchema : StepWireSchema)
-  });
-  return {
-    ...response2,
-    data: response2.data.map((step) => filterStepData(step, resolveData))
-  };
-}
-async function getStep(runId, stepId, params, config2) {
-  const resolveData = (params == null ? void 0 : params.resolveData) ?? DEFAULT_RESOLVE_DATA_OPTION;
-  const remoteRefBehavior = resolveData === "none" ? "lazy" : "resolve";
-  const searchParams = new URLSearchParams();
-  searchParams.set("remoteRefBehavior", remoteRefBehavior);
-  const queryString = searchParams.toString();
-  const endpoint = `/v2/runs/${encodeURIComponent(runId)}/steps/${encodeURIComponent(stepId)}${queryString ? `?${queryString}` : ""}`;
-  const step = await makeRequest({
-    endpoint,
-    options: { method: "GET" },
-    config: config2,
-    schema: remoteRefBehavior === "lazy" ? StepWireWithRefsSchema : StepWireSchema
-  });
-  return filterStepData(step, resolveData);
-}
 function validateWorkflowRunIdTimestamp(id2) {
   const raw2 = id2.startsWith("wrun_") ? id2.slice("wrun_".length) : id2;
   try {
@@ -143458,11 +144051,6 @@ const eventsNeedingResolve = /* @__PURE__ */ new Set([
   "step_started"
   // runtime reads result.step (checks attempt, state)
 ]);
-const legacyStructuredErrorEventTypes = /* @__PURE__ */ new Set([
-  "run_failed",
-  "step_failed",
-  "step_retrying"
-]);
 function splitEventDataForV4(data) {
   var _a3;
   const eventData = data.eventData ?? {};
@@ -143566,83 +144154,43 @@ function splitEventDataForV4(data) {
   }
   return { payload, meta: meta2 };
 }
-function coerceNormalizedEvent(raw2) {
-  return coerceEventDates(normalizeEventData(raw2));
-}
-function decodeLegacyStructuredError(payload) {
-  if (hasSerializedDataFormatPrefix(payload)) {
-    return payload;
-  }
-  try {
-    const parsed = StructuredErrorSchema.safeParse(decode$1(payload.slice()));
-    return parsed.success ? parsed.data : payload;
-  } catch {
-    return payload;
-  }
-}
-function buildEventFromV4(decoded, payloadBody, resolveData) {
-  const eventData = decoded.eventData ?? {};
-  if (payloadBody.byteLength > 0) {
-    const payloadField = getEventDataPayloadField(decoded.eventType);
-    const normalizedPayload = normalizeSerializedData(payloadBody);
-    if (payloadField && normalizedPayload instanceof Uint8Array) {
-      eventData[payloadField] = legacyStructuredErrorEventTypes.has(decoded.eventType) ? decodeLegacyStructuredError(normalizedPayload) : normalizedPayload;
-    }
-  }
-  const raw2 = {
-    eventId: decoded.eventId,
-    runId: decoded.runId,
-    eventType: decoded.eventType,
-    createdAt: decoded.createdAt instanceof Date ? decoded.createdAt : new Date(decoded.createdAt),
-    ...decoded.occurredAt !== void 0 ? {
-      occurredAt: decoded.occurredAt instanceof Date ? decoded.occurredAt : new Date(decoded.occurredAt)
-    } : {},
-    ...decoded.correlationId ? { correlationId: decoded.correlationId } : {},
-    eventData,
-    ...decoded.specVersion !== void 0 ? { specVersion: decoded.specVersion } : {},
-    // The persisted lazy-resume idempotency key. The runtime matches it
-    // against the queue message's hookInput.resumeId to recognize its own
-    // resume in a preloaded log — dropping it here would silently disable
-    // that check for frame-decoded events.
-    ...decoded.resumeId ? { resumeId: decoded.resumeId } : {}
-  };
-  const event = coerceNormalizedEvent(raw2);
-  return resolveData === "none" ? stripEventDataRefs(event, "none") : event;
-}
 async function getEvent(runId, eventId, params, config2) {
-  const resolveData = (params == null ? void 0 : params.resolveData) ?? DEFAULT_RESOLVE_DATA_OPTION;
-  const { event, body: body2 } = await getEventV4(runId, eventId, config2);
-  return buildEventFromV4(event, body2, resolveData);
+  return getEventV4(runId, eventId, (params == null ? void 0 : params.resolveData) === "none" ? "lazy" : "resolve", config2);
 }
 async function getWorkflowRunEvents(params, config2) {
   const { pagination, resolveData = DEFAULT_RESOLVE_DATA_OPTION } = params;
-  const wirePagination = {
-    cursor: (pagination == null ? void 0 : pagination.cursor) ?? void 0,
-    limit: pagination == null ? void 0 : pagination.limit,
-    sortOrder: pagination == null ? void 0 : pagination.sortOrder,
+  const listParams = {
+    ...pagination,
     remoteRefBehavior: resolveData === "none" ? "lazy" : "resolve"
   };
-  const result = await ("correlationId" in params ? getEventsByCorrelationIdV4(params.correlationId, params.runId, wirePagination, config2) : getWorkflowRunEventsV4(params.runId, wirePagination, config2));
-  const events2 = result.events.map((listed) => buildEventFromV4(listed.event, listed.body, resolveData));
-  const runScoped = "correlationId" in params ? events2.filter((event) => event.runId === params.runId) : events2;
+  const result = await ("correlationId" in params ? getEventsByCorrelationIdV4(params.correlationId, params.runId, listParams, config2) : getWorkflowRunEventsV4(params.runId, listParams, config2));
   return {
-    data: runScoped,
-    // `next` is present even on the final page (it's the incremental-load
-    // resume cursor), so prefer the server's explicit `hasMore`. The
-    // `Boolean(next)` fallback covers older servers that don't emit it —
-    // at the cost of one extra empty-page request per load.
-    cursor: result.next ?? null,
-    hasMore: typeof result.hasMore === "boolean" ? result.hasMore : Boolean(result.next)
+    data: "correlationId" in params ? result.events.filter((event) => event.runId === params.runId) : result.events,
+    // The cursor is present even on the final page because it is also the
+    // incremental-load resume point. `hasMore` is the pagination signal.
+    cursor: result.cursor,
+    hasMore: result.hasMore
   };
 }
 async function createWorkflowRunEvent(id2, data, params, config2) {
+  var _a3, _b2;
   try {
-    return await withEventPostRetry(() => createWorkflowRunEventInner(id2, data, params, config2), data.eventType, {
+    const result = await withEventPostRetry(() => createWorkflowRunEventInner(id2, data, params, config2), data.eventType, {
       // The atomic lazy-resume shape is deduplicated server-side by the
       // (runId, resumeId) claim, so its POST is idempotent-on-retry even
       // though plain hook_received is not — see EVENT_RETRY_ELIGIBILITY.
       idempotentHookResume: data.eventType === "hook_received" && (params == null ? void 0 : params.resumeId) !== void 0 && (params == null ? void 0 : params.resumePayloadDigest) !== void 0
     });
+    if (data.eventType === "run_created" && !result.run) {
+      throw new WorkflowWorldError(`${data.eventType} response is missing the run entity`, { code: "SCHEMA_VALIDATION" });
+    }
+    if (data.eventType === "run_started" && !((_a3 = result.run) == null ? void 0 : _a3.startedAt)) {
+      throw new WorkflowWorldError("run_started response is missing run.startedAt", { code: "SCHEMA_VALIDATION" });
+    }
+    if (data.eventType === "step_started" && !((_b2 = result.step) == null ? void 0 : _b2.startedAt)) {
+      throw new WorkflowWorldError("step_started response is missing step.startedAt", { code: "SCHEMA_VALIDATION" });
+    }
+    return result;
   } catch (err) {
     if (isHookEventRequiringExistence(data.eventType) && WorkflowWorldError.is(err) && err.status === 404 && data.correlationId) {
       throw new HookNotFoundError(data.correlationId);
@@ -143683,88 +144231,94 @@ async function createWorkflowRunEventInner(id2, data, params, config2) {
   }
   const remoteRefBehavior = eventsNeedingResolve.has(data.eventType) ? "resolve" : "lazy";
   const { payload, meta: meta2 } = splitEventDataForV4(data);
-  const resolveData = (params == null ? void 0 : params.resolveData) ?? DEFAULT_RESOLVE_DATA_OPTION;
-  const v4Input = {
+  const input = {
     runId: id2,
-    eventType: data.eventType,
     specVersion: data.specVersion ?? 2,
     ...data.correlationId ? { correlationId: data.correlationId } : {},
     ...(params == null ? void 0 : params.requestId) ? { vercelId: params.requestId } : {},
     ...(params == null ? void 0 : params.computeInstanceId) ? { computeInstanceId: params.computeInstanceId } : {},
-    // Precondition snapshot. The three fields describe one snapshot and the
-    // runtime always sends them together (or not at all); each is spread
-    // independently only so an older server that knows one but not the
-    // others still gets what it understands.
-    ...(params == null ? void 0 : params.stateUpdatedAt) !== void 0 ? { stateUpdatedAt: params.stateUpdatedAt } : {},
-    ...(params == null ? void 0 : params.stateEventCount) !== void 0 ? { stateEventCount: params.stateEventCount } : {},
+    stateUpdatedAt: params == null ? void 0 : params.stateUpdatedAt,
+    stateEventCount: params == null ? void 0 : params.stateEventCount,
     ...(params == null ? void 0 : params.stateCursor) ? { stateCursor: params.stateCursor } : {},
-    ...(params == null ? void 0 : params.replayDivergenceCount) !== void 0 ? { replayDivergenceCount: params.replayDivergenceCount } : {},
+    // Slot-identity snapshot. The runtime sends `eventCount` instead of the
+    // watermark triple once the run's own ids are slot-shaped; it rides as
+    // `maxSlot` because the v4 meta already has an unrelated telemetry
+    // `eventCount`.
+    ...(params == null ? void 0 : params.eventCount) !== void 0 ? { maxSlot: params.eventCount } : {},
+    replayDivergenceCount: params == null ? void 0 : params.replayDivergenceCount,
     occurredAt: (params == null ? void 0 : params.occurredAt) ?? /* @__PURE__ */ new Date(),
     // Opt-in inline-delta: forward the cursor the runtime held before
     // this write so the server can return the authoritative event-log
-    // delta on the response (events/cursor/hasMore), letting the inline
-    // loop skip a follow-up events.list. The server only acts on it for
-    // step_completed/step_failed; older servers ignore it and the runtime
-    // falls back to events.list.
+    // delta on the response (events/cursor/hasMore), letting the caller
+    // skip a follow-up events.list. Outside turbo the runtime sends this on
+    // every write, but a server may act on only some event types (or none);
+    // a response without a delta just means the runtime keeps its cursor
+    // and fetches when it next needs to.
     ...(params == null ? void 0 : params.sinceCursor) ? { sinceCursor: params.sinceCursor } : {},
-    // Run-started preload opt-out: turbo backgrounds run_started as a write
-    // barrier only and never reads the preloaded log, so tell the server to
-    // skip the list+resolve. The server only acts on it for run_started;
-    // older servers ignore it and simply preload as before.
-    ...(params == null ? void 0 : params.skipPreload) ? { skipPreload: true } : {},
-    // Lazy hook resume idempotency key (hook_received only). Routes the
-    // write through the server's (runId, resumeId) constraint so a
-    // concurrent queue-consumer re-ensure deduplicates to one event.
     ...(params == null ? void 0 : params.resumeId) ? { resumeId: params.resumeId } : {},
-    // Content digest forwarded alongside resumeId so the direct write and the
-    // queue re-ensure record an identical digest on the server constraint.
     ...(params == null ? void 0 : params.resumePayloadDigest) ? { resumePayloadDigest: params.resumePayloadDigest } : {},
     remoteRefBehavior,
     payload,
     ...meta2
   };
+  if (data.eventType === "run_started" && !(params == null ? void 0 : params.skipPreload)) {
+    const result = await createWorkflowRunStartedEventV4(input, config2);
+    const runCreated = result.events.find((event) => event.eventType === "run_created");
+    const runStarted = result.events.find((event) => event.eventType === "run_started");
+    if (!runCreated) {
+      throw new Error("v4 createEvent: run_started stream is missing run_created");
+    }
+    if (!runStarted) {
+      throw new Error("v4 createEvent: run_started stream is missing run_started");
+    }
+    let attributes = runCreated.eventData.attributes ?? {};
+    let updatedAt = runStarted.createdAt;
+    for (const event of result.events) {
+      if (event.eventType === "attr_set") {
+        attributes = applyAttributeChanges(attributes, event.eventData.changes);
+        updatedAt = event.createdAt;
+      }
+    }
+    return {
+      event: runStarted,
+      run: {
+        runId: runCreated.runId,
+        status: "running",
+        deploymentId: runCreated.eventData.deploymentId,
+        workflowName: runCreated.eventData.workflowName,
+        specVersion: runCreated.specVersion,
+        executionContext: runCreated.eventData.executionContext,
+        input: runCreated.eventData.input,
+        attributes,
+        encryptionPublicKey: runCreated.eventData.encryptionPublicKey,
+        startedAt: runStarted.createdAt,
+        createdAt: runCreated.createdAt,
+        updatedAt
+      },
+      events: result.events,
+      cursor: result.cursor,
+      hasMore: result.hasMore,
+      maxEvents: result.maxEvents
+    };
+  }
   if (data.eventType === "hook_received" && (params == null ? void 0 : params.preloadEvents) === true && params.resumeId !== void 0 && params.resumePayloadDigest !== void 0) {
-    const outcome = await createHookReceivedPreloadEventV4({ ...v4Input, remoteRefBehavior: "lazy" }, config2);
+    const outcome = await createHookReceivedPreloadEventV4({ ...input, remoteRefBehavior: "lazy" }, config2);
     if (outcome.kind === "materialized") {
-      return materializedV4ToEventResult(outcome.result, resolveData);
+      return outcome.result;
     }
-    const { canonicalEventId, maxEvents, next: next2, hasMore } = outcome;
-    const events2 = outcome.events.map((listed) => buildEventFromV4(listed.event, listed.body, "all"));
+    const { canonicalEventId, maxEvents, events: events2, cursor, hasMore } = outcome;
     const canonicalEvent = events2.find((event) => event.eventId === canonicalEventId);
     const run2 = reconstructRunFromReplayEvents(events2);
     return {
       ...canonicalEvent ? { event: canonicalEvent } : {},
       ...run2 ? { run: run2 } : {},
       events: events2,
-      cursor: next2 ?? null,
-      // Our streaming server always stamps hasMore on the sentinel; treat a
-      // missing flag as "not the complete log" so the runtime falls back
-      // rather than replaying a possibly-truncated prefix.
-      hasMore: hasMore ?? true,
+      cursor,
+      hasMore,
       ...maxEvents !== void 0 ? { maxEvents } : {}
     };
   }
-  const result = await createWorkflowRunEventV4(v4Input, config2);
-  return materializedV4ToEventResult(result, resolveData);
-}
-function materializedV4ToEventResult(result, resolveData) {
-  const body2 = result.body;
-  return {
-    event: body2.event ? stripEventDataRefs(coerceEventDates(body2.event), resolveData) : void 0,
-    run: body2.run ? deserializeError(body2.run) : void 0,
-    step: body2.step ? deserializeStep(body2.step) : void 0,
-    hook: body2.hook,
-    wait: body2.wait,
-    events: body2.events ? body2.events.map(coerceEventDates) : void 0,
-    cursor: body2.cursor ?? void 0,
-    hasMore: body2.hasMore,
-    // Lazy step start: thread the server's "I created the step on this call"
-    // signal through so the owned-inline runtime path can gate body execution
-    // on it. Absent from older servers → undefined → safe default.
-    ...body2.stepCreated ? { stepCreated: true } : {},
-    // Server-supplied per-run event ceiling; absent from older servers.
-    ...typeof body2.maxEvents === "number" ? { maxEvents: body2.maxEvents } : {}
-  };
+  return createWorkflowRunEventV4(data.eventType === "run_started" ? { ...input, eventType: "run_started", skipPreload: true } : { ...input, eventType: data.eventType }, config2);
 }
 function reconstructRunFromReplayEvents(events2) {
   const runCreated = events2.find((event) => event.eventType === "run_created");
@@ -144109,10 +144663,14 @@ function createWorld$1(config2) {
   var _a3, _b2;
   const projectId = ((_a3 = config2 == null ? void 0 : config2.projectConfig) == null ? void 0 : _a3.projectId) || process.env.VERCEL_PROJECT_ID;
   return {
-    // Spec v5 adds client-side zstd/gzip payload compression. The server stores
-    // those payloads opaquely, and v5 remains a superset of v4 attributes.
-    specVersion: SPEC_VERSION_SUPPORTS_COMPRESSION,
+    // Spec v6 adds slot-numbered event ids on top of v5's client-side
+    // zstd/gzip payload compression. The version is what tells the backend
+    // which id scheme a run uses: it is stamped on `run_created` and read back
+    // on every later write, so a run created before v6 keeps its ULIDs even
+    // though this adapter now asks for slots.
+    specVersion: SPEC_VERSION_SUPPORTS_SLOT_IDENTITY,
     capabilities: {
+      hookRetention: { active: true },
       // workflow-server enforces the `stateUpdatedAt` optimistic-concurrency
       // guard: creations carrying a stale snapshot are rejected with 412
       // (PreconditionFailedError) when the run's outside-event marker is
@@ -144124,7 +144682,12 @@ function createWorld$1(config2) {
       maxConcurrency: true,
       // Vercel deployments are atomic and immutable, so a deployment id names
       // one fixed build for its whole lifetime.
-      deploymentAffinity: true
+      deploymentAffinity: true,
+      // New runs get dense per-run slot event ids. Runs created before the
+      // backend adopted them keep their ULIDs; the scheme is pinned by the
+      // spec version stamped on each run, not by this flag, which only says
+      // what new runs get.
+      slotEventIds: true
       // NOTE: the backend half of resumeHook()'s parallel fast path — that
       // the server enforces the `(runId, resumeId)` dedup constraint — is
       // NO LONGER a static world capability here. It is attested per-lookup by
@@ -144133,12 +144696,6 @@ function createWorld$1(config2) {
       // rollback or kill switch drop new resumes to the sequential path
       // immediately, without a redeploy of this adapter.
     },
-    // On Vercel the platform fails the function invocation when the
-    // process exits non-zero, and VQS redelivers the queue message via a
-    // fresh invocation. The core runtime uses this to decide whether
-    // `process.exit(1)` is an acceptable response to an exhausted replay
-    // budget.
-    processExitTriggersQueueRedelivery: true,
     getRuntimeDeadline: getDeadline,
     ...createQueue$1(config2),
     ...createStorage(config2),
@@ -144281,7 +144838,7 @@ const getWorld = async () => {
 const GetWorldFnKey = Symbol.for("@workflow/world//getWorldFn");
 globalThis[GetWorldFnKey] ?? (globalThis[GetWorldFnKey] = getWorld);
 function waitUntil(promise2) {
-  void import("./index-7-uV1dU1.js").then((n) => n.i).then(({ waitUntil: waitUntil2 }) => {
+  void import("./index-DTci39F3.js").then((n) => n.i).then(({ waitUntil: waitUntil2 }) => {
     waitUntil2(promise2);
   });
 }
@@ -147172,7 +147729,11 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
               hookId: hook.hookId,
               token: hook.token,
               payload: dehydratedPayload,
-              payloadDigest
+              payloadDigest,
+              // Deployment affinity for the consumer's cheap pre-write
+              // check: lets a misrouted delivery re-route before its
+              // hoisted hook_received write instead of after.
+              deploymentId: resumeContext.deploymentId
             }
           }, queueOptions)
         ]);
@@ -147472,9 +148033,6 @@ async function start$1(workflow, argsOrOptions, options) {
         }
       } else {
         const result = runCreatedResult.value;
-        if (!result.run) {
-          throw new WorkflowRuntimeError("Missing 'run' in server response for 'run_created' event");
-        }
         if (!v1Compat && result.run.runId !== runId) {
           throw new WorkflowRuntimeError(`Server returned different runId than requested: expected ${runId}, got ${result.run.runId}`);
         }
@@ -147488,7 +148046,7 @@ async function start$1(workflow, argsOrOptions, options) {
       span == null ? void 0 : span.setAttributes({
         ...WorkflowRunId$2(runId),
         ...DeploymentId(deploymentId),
-        ...runCreatedResult.status === "fulfilled" && runCreatedResult.value.run ? WorkflowRunStatus(runCreatedResult.value.run.status) : {}
+        ...runCreatedResult.status === "fulfilled" ? WorkflowRunStatus(runCreatedResult.value.run.status) : {}
       });
       return new Run(runId, { resilientStart });
     });
@@ -147624,7 +148182,7 @@ async function wakeUpRun$2(world, runId, options) {
     do {
       const eventsResult = await world.events.list({
         runId,
-        pagination: { limit: 1e3, ...cursor ? { cursor } : {} },
+        pagination: { sortOrder: "asc", ...cursor ? { cursor } : {} },
         resolveData: "none"
       });
       allEvents.push(...eventsResult.data);
@@ -171135,7 +171693,7 @@ const route4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   __proto__: null,
   loader
 }, Symbol.toStringTag, { value: "Module" }));
-const serverManifest = { "entry": { "module": "/assets/entry.client-LwI3HNYl.js", "imports": ["/assets/index-PFjW8YjQ.js"], "css": [] }, "routes": { "root": { "id": "root", "parentId": void 0, "path": "", "index": void 0, "caseSensitive": void 0, "hasAction": true, "hasLoader": true, "hasClientAction": false, "hasClientLoader": false, "hasClientMiddleware": false, "hasDefaultExport": true, "hasErrorBoundary": true, "module": "/assets/root-n7Zz0dTX.js", "imports": ["/assets/index-PFjW8YjQ.js", "/assets/mermaid-3ZIDBTTL-qqUSEahK.js", "/assets/loader-circle-3PJSFf84.js", "/assets/arrow-up-right-Br49goey.js"], "css": ["/assets/root-ZRjqDhEN.css", "/assets/mermaid-3ZIDBTTL-D8CjRQta.css"], "clientActionModule": void 0, "clientLoaderModule": void 0, "clientMiddlewareModule": void 0, "hydrateFallbackModule": void 0 }, "routes/home": { "id": "routes/home", "parentId": "root", "path": void 0, "index": true, "caseSensitive": void 0, "hasAction": false, "hasLoader": false, "hasClientAction": false, "hasClientLoader": false, "hasClientMiddleware": false, "hasDefaultExport": true, "hasErrorBoundary": false, "module": "/assets/home-DrXIdsG5.js", "imports": ["/assets/index-PFjW8YjQ.js", "/assets/workflow-graph-viewer-DWdsfF3d.js", "/assets/mermaid-3ZIDBTTL-qqUSEahK.js", "/assets/loader-circle-3PJSFf84.js"], "css": ["/assets/workflow-graph-viewer-DnlNuQQH.css", "/assets/mermaid-3ZIDBTTL-D8CjRQta.css"], "clientActionModule": void 0, "clientLoaderModule": void 0, "clientMiddlewareModule": void 0, "hydrateFallbackModule": void 0 }, "routes/run-detail": { "id": "routes/run-detail", "parentId": "root", "path": "run/:runId", "index": void 0, "caseSensitive": void 0, "hasAction": false, "hasLoader": false, "hasClientAction": false, "hasClientLoader": false, "hasClientMiddleware": false, "hasDefaultExport": true, "hasErrorBoundary": false, "module": "/assets/run-detail-DHeMEsdg.js", "imports": ["/assets/index-PFjW8YjQ.js", "/assets/workflow-graph-viewer-DWdsfF3d.js", "/assets/mermaid-3ZIDBTTL-qqUSEahK.js", "/assets/arrow-up-right-Br49goey.js"], "css": ["/assets/run-detail-CWoGxu_0.css", "/assets/workflow-graph-viewer-DnlNuQQH.css", "/assets/mermaid-3ZIDBTTL-D8CjRQta.css"], "clientActionModule": void 0, "clientLoaderModule": void 0, "clientMiddlewareModule": void 0, "hydrateFallbackModule": void 0 }, "routes/api.rpc": { "id": "routes/api.rpc", "parentId": "root", "path": "api/rpc", "index": void 0, "caseSensitive": void 0, "hasAction": true, "hasLoader": true, "hasClientAction": false, "hasClientLoader": false, "hasClientMiddleware": false, "hasDefaultExport": false, "hasErrorBoundary": false, "module": "/assets/api.rpc-l0sNRNKZ.js", "imports": [], "css": [], "clientActionModule": void 0, "clientLoaderModule": void 0, "clientMiddlewareModule": void 0, "hydrateFallbackModule": void 0 }, "routes/api.stream.$streamId": { "id": "routes/api.stream.$streamId", "parentId": "root", "path": "api/stream/:streamId", "index": void 0, "caseSensitive": void 0, "hasAction": false, "hasLoader": true, "hasClientAction": false, "hasClientLoader": false, "hasClientMiddleware": false, "hasDefaultExport": false, "hasErrorBoundary": false, "module": "/assets/api.stream._streamId-l0sNRNKZ.js", "imports": [], "css": [], "clientActionModule": void 0, "clientLoaderModule": void 0, "clientMiddlewareModule": void 0, "hydrateFallbackModule": void 0 } }, "url": "/assets/manifest-0c933230.js", "version": "0c933230", "sri": void 0 };
+const serverManifest = { "entry": { "module": "/assets/entry.client-LwI3HNYl.js", "imports": ["/assets/index-PFjW8YjQ.js"], "css": [] }, "routes": { "root": { "id": "root", "parentId": void 0, "path": "", "index": void 0, "caseSensitive": void 0, "hasAction": true, "hasLoader": true, "hasClientAction": false, "hasClientLoader": false, "hasClientMiddleware": false, "hasDefaultExport": true, "hasErrorBoundary": true, "module": "/assets/root-D6p4Hb4F.js", "imports": ["/assets/index-PFjW8YjQ.js", "/assets/mermaid-3ZIDBTTL-DchhEfRL.js", "/assets/loader-circle-fFQM94Ej.js", "/assets/arrow-up-right-jWH-UQH9.js"], "css": ["/assets/root-ZRjqDhEN.css", "/assets/mermaid-3ZIDBTTL-D8CjRQta.css"], "clientActionModule": void 0, "clientLoaderModule": void 0, "clientMiddlewareModule": void 0, "hydrateFallbackModule": void 0 }, "routes/home": { "id": "routes/home", "parentId": "root", "path": void 0, "index": true, "caseSensitive": void 0, "hasAction": false, "hasLoader": false, "hasClientAction": false, "hasClientLoader": false, "hasClientMiddleware": false, "hasDefaultExport": true, "hasErrorBoundary": false, "module": "/assets/home-BwYHJJJr.js", "imports": ["/assets/index-PFjW8YjQ.js", "/assets/workflow-graph-viewer-t_fSwuwz.js", "/assets/mermaid-3ZIDBTTL-DchhEfRL.js", "/assets/loader-circle-fFQM94Ej.js"], "css": ["/assets/workflow-graph-viewer-DnlNuQQH.css", "/assets/mermaid-3ZIDBTTL-D8CjRQta.css"], "clientActionModule": void 0, "clientLoaderModule": void 0, "clientMiddlewareModule": void 0, "hydrateFallbackModule": void 0 }, "routes/run-detail": { "id": "routes/run-detail", "parentId": "root", "path": "run/:runId", "index": void 0, "caseSensitive": void 0, "hasAction": false, "hasLoader": false, "hasClientAction": false, "hasClientLoader": false, "hasClientMiddleware": false, "hasDefaultExport": true, "hasErrorBoundary": false, "module": "/assets/run-detail-vPCbZIXx.js", "imports": ["/assets/index-PFjW8YjQ.js", "/assets/workflow-graph-viewer-t_fSwuwz.js", "/assets/mermaid-3ZIDBTTL-DchhEfRL.js", "/assets/arrow-up-right-jWH-UQH9.js"], "css": ["/assets/run-detail-CWoGxu_0.css", "/assets/workflow-graph-viewer-DnlNuQQH.css", "/assets/mermaid-3ZIDBTTL-D8CjRQta.css"], "clientActionModule": void 0, "clientLoaderModule": void 0, "clientMiddlewareModule": void 0, "hydrateFallbackModule": void 0 }, "routes/api.rpc": { "id": "routes/api.rpc", "parentId": "root", "path": "api/rpc", "index": void 0, "caseSensitive": void 0, "hasAction": true, "hasLoader": true, "hasClientAction": false, "hasClientLoader": false, "hasClientMiddleware": false, "hasDefaultExport": false, "hasErrorBoundary": false, "module": "/assets/api.rpc-l0sNRNKZ.js", "imports": [], "css": [], "clientActionModule": void 0, "clientLoaderModule": void 0, "clientMiddlewareModule": void 0, "hydrateFallbackModule": void 0 }, "routes/api.stream.$streamId": { "id": "routes/api.stream.$streamId", "parentId": "root", "path": "api/stream/:streamId", "index": void 0, "caseSensitive": void 0, "hasAction": false, "hasLoader": true, "hasClientAction": false, "hasClientLoader": false, "hasClientMiddleware": false, "hasDefaultExport": false, "hasErrorBoundary": false, "module": "/assets/api.stream._streamId-l0sNRNKZ.js", "imports": [], "css": [], "clientActionModule": void 0, "clientLoaderModule": void 0, "clientMiddlewareModule": void 0, "hydrateFallbackModule": void 0 } }, "url": "/assets/manifest-f6a9dca2.js", "version": "f6a9dca2", "sri": void 0 };
 const assetsBuildDirectory = "build/client";
 const basename = "/";
 const future = { "unstable_optimizeDeps": false, "unstable_subResourceIntegrity": false, "unstable_trailingSlashAwareDataRequests": false, "unstable_previewServerPrerendering": false, "v8_middleware": false, "v8_splitRouteModules": false, "v8_viteEnvironmentApi": false };
@@ -171344,88 +171902,106 @@ function createFetchHandler(basename2 = "/") {
   return (request2) => handler(request2, loadContext);
 }
 export {
-  TERMINAL_STEP_EVENT_TYPES as $,
+  SerializedDataSchema as $,
   ATTRIBUTE_KEY_MAX_LENGTH as A,
   BULK_CANCEL_MAX_RUN_IDS as B,
   CHILD_ENTITY_CREATION_EVENT_TYPES as C,
   DEFAULT_TIMESTAMP_THRESHOLD_FUTURE_MS as D,
   EVENT_DATA_PAYLOAD_FIELD_BY_EVENT_TYPE as E,
-  PaginatedResponseSchema as F,
-  QueuePrefix as G,
+  FIRST_EVENT_SLOT as F,
+  HookCreatedEventSchema as G,
   HookSchema as H,
-  ROOT_RUN_ID_ATTRIBUTE as I,
-  RunInputSchema as J,
-  SPEC_VERSION_LEGACY as K,
+  HookResumeCapabilitiesSchema as I,
+  PaginatedResponseSchema as J,
+  QueuePrefix as K,
   LegacySerializedDataSchemaV1 as L,
   MessageId as M,
   Nt as N,
-  SPEC_VERSION_SUPPORTS_ATTRIBUTES as O,
+  ROOT_RUN_ID_ATTRIBUTE as O,
   PARENT_RUN_ID_ATTRIBUTE as P,
   QueuePayloadSchema as Q,
   RESERVED_ATTRIBUTE_KEY_PREFIX as R,
-  SPEC_VERSION_CURRENT as S,
-  SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT as T,
-  SPEC_VERSION_SUPPORTS_COMPRESSION as U,
-  STEP_EVENT_TYPES as V,
-  SerializedDataSchema as W,
-  StepSchema as X,
-  StepStatusSchema as Y,
-  StructuredErrorSchema as Z,
-  TERMINAL_RUN_EVENT_TYPES as _,
+  RunInputSchema as S,
+  SPEC_VERSION_CURRENT as T,
+  SPEC_VERSION_LEGACY as U,
+  SPEC_VERSION_MAX_SUPPORTED as V,
+  SPEC_VERSION_SUPPORTS_ATTRIBUTES as W,
+  SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT as X,
+  SPEC_VERSION_SUPPORTS_COMPRESSION as Y,
+  SPEC_VERSION_SUPPORTS_SLOT_IDENTITY as Z,
+  STEP_EVENT_TYPES as _,
   ATTRIBUTE_MAX_PER_RUN as a,
-  TERMINAL_STEP_STATUSES as a0,
-  TERMINAL_WORKFLOW_RUN_STATUSES as a1,
-  TerminalRunEventTypeSchema as a2,
-  TerminalStepStatusSchema as a3,
-  TerminalWorkflowRunStatusSchema as a4,
-  ValidQueueName as a5,
-  WAIT_EVENT_TYPES as a6,
-  WaitSchema as a7,
-  WaitStatusSchema as a8,
-  WorkflowInvokePayloadSchema as a9,
-  validateAttributeKey as aA,
-  validateAttributeValue as aB,
-  validateUlidTimestamp as aC,
-  workflowRunIdSchema as aD,
-  reactExports as aE,
-  R as aF,
-  Ks as aG,
-  jsxRuntimeExports as aH,
-  Qe as aI,
-  registerZstdDecoder as aJ,
-  getDefaultExportFromCjs as aK,
-  requireTokenUtil as aL,
-  requireTokenError as aM,
-  getAugmentedNamespace as aN,
-  app as aO,
-  createFetchHandler as aP,
-  WorkflowRunBaseSchema as aa,
-  WorkflowRunSchema as ab,
-  WorkflowRunStatusSchema as ac,
-  applyAttributeChanges as ad,
-  envNumber as ae,
-  getEventDataPayloadField as af,
-  getEventDataRefFields as ag,
-  getQueueTopicPrefix as ah,
-  isChildEntityCreationEvent as ai,
-  isChildEntityCreationEventType as aj,
-  isHookEventRequiringExistence as ak,
-  isHookLifecycleEventType as al,
-  isLegacySpecVersion as am,
-  isStepEventType as an,
-  isTerminalRunEventType as ao,
-  isTerminalStepEventType as ap,
-  isTerminalStepStatus as aq,
-  isTerminalWorkflowRunStatus as ar,
-  isWaitEventType as as,
-  parseQueueName as at,
-  reenqueueActiveRuns as au,
-  requiresNewerWorld as av,
-  resolveQueueNamespace as aw,
-  stripEventDataRefs as ax,
-  ulidToDate as ay,
-  validateAttributeChanges as az,
+  decodeFrames as a$,
+  StepSchema as a0,
+  StepStatusSchema as a1,
+  StructuredErrorSchema as a2,
+  TERMINAL_RUN_EVENT_TYPES as a3,
+  TERMINAL_STEP_EVENT_TYPES as a4,
+  TERMINAL_STEP_STATUSES as a5,
+  TERMINAL_WORKFLOW_RUN_STATUSES as a6,
+  TerminalRunEventTypeSchema as a7,
+  TerminalStepStatusSchema as a8,
+  TerminalWorkflowRunStatusSchema as a9,
+  isTerminalWorkflowRunStatus as aA,
+  isWaitEventType as aB,
+  parseQueueName as aC,
+  reenqueueActiveRuns as aD,
+  requiresNewerWorld as aE,
+  resolveQueueNamespace as aF,
+  slotToEventId as aG,
+  stripEventDataRefs as aH,
+  ulidToDate as aI,
+  validateAttributeChanges as aJ,
+  validateAttributeKey as aK,
+  validateAttributeValue as aL,
+  validateUlidTimestamp as aM,
+  workflowRunIdSchema as aN,
+  reactExports as aO,
+  R as aP,
+  Ks as aQ,
+  jsxRuntimeExports as aR,
+  Qe as aS,
+  registerZstdDecoder as aT,
+  isWsEventsTransportEnabled as aU,
+  getHttpUrl as aV,
+  getHttpConfig as aW,
+  headersToRecord as aX,
+  getRequestTimeoutMs as aY,
+  injectTraceContextIntoHeaders as aZ,
+  distExports as a_,
+  ValidQueueName as aa,
+  WAIT_EVENT_TYPES as ab,
+  WaitSchema as ac,
+  WaitStatusSchema as ad,
+  WorkflowInvokePayloadSchema as ae,
+  WorkflowRunBaseSchema as af,
+  WorkflowRunSchema as ag,
+  WorkflowRunStatusSchema as ah,
+  applyAttributeChanges as ai,
+  envNumber as aj,
+  eventIdToSlot as ak,
+  getEventDataPayloadField as al,
+  getEventDataRefFields as am,
+  getMaxEventsPerRun as an,
+  getQueueTopicPrefix as ao,
+  isChildEntityCreationEvent as ap,
+  isChildEntityCreationEventType as aq,
+  isHookEventRequiringExistence as ar,
+  isHookLifecycleEventType as as,
+  isLegacySpecVersion as at,
+  isSlotBody as au,
+  isSlotEventId as av,
+  isStepEventType as aw,
+  isTerminalRunEventType as ax,
+  isTerminalStepEventType as ay,
+  isTerminalStepStatus as az,
   ATTRIBUTE_VALUE_MAX_BYTES as b,
+  getDefaultExportFromCjs as b0,
+  requireTokenUtil as b1,
+  requireTokenError as b2,
+  getAugmentedNamespace as b3,
+  app as b4,
+  createFetchHandler as b5,
   AnalyticsAttributeKeySchema as c,
   AnalyticsEventSchema as d,
   AnalyticsHookSchema as e,
@@ -171441,13 +172017,13 @@ export {
   BulkCancelWorkflowRunsResultSchema as o,
   DEFAULT_TIMESTAMP_THRESHOLD_PAST_MS as p,
   EVENT_DATA_REF_FIELDS as q,
-  EventSchema as r,
-  EventTypeSchema as s,
-  HOOK_EVENTS_REQUIRING_EXISTENCE as t,
-  HOOK_LIFECYCLE_EVENT_TYPES as u,
-  HOOK_RESUME_DEDUP_VERSION as v,
-  HOOK_RESUME_INPUT_VERSION as w,
-  HealthCheckPayloadSchema as x,
-  HookCreatedEventSchema as y,
-  HookResumeCapabilitiesSchema as z
+  EVENT_ID_BODY_LENGTH as r,
+  EVENT_ID_PREFIX as s,
+  EventSchema as t,
+  EventTypeSchema as u,
+  HOOK_EVENTS_REQUIRING_EXISTENCE as v,
+  HOOK_LIFECYCLE_EVENT_TYPES as w,
+  HOOK_RESUME_DEDUP_VERSION as x,
+  HOOK_RESUME_INPUT_VERSION as y,
+  HealthCheckPayloadSchema as z
 };