@workflow/web 4.1.14 → 4.1.16

package/build/server/assets/{server-build-CAufQfpc.js → server-build-BXSdchZI.js}

@@ -14,7 +14,11 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
 var _a2, _b, _root, _hasMagic, _uflag, _parts, _parent, _parentIndex, _negs, _filledNegs, _options, _toString, _emptyExt, _AST_instances, fillNegs_fn, _AST_static, parseAST_fn, canAdoptWithSpace_fn, canAdopt_fn, canAdoptType_fn, adoptWithSpace_fn, adopt_fn, canUsurpType_fn, canUsurp_fn, usurp_fn, flatten_fn, partsToRegExp_fn, parseGlob_fn, _Minimatch_instances, matchGlobstar_fn, matchGlobStarBodySections_fn, matchOne_fn, _reader;
-import { a as requireReact, S as ServerRouter, c as createReadableStreamFromReadable, r as reactExports, g as getDefaultExportFromCjs, R as React, b as ReactExports, w as withComponentProps, d as withErrorBoundaryProps, M as Meta, L as Links, e as ScrollRestoration, f as Scripts, O as Outlet, u as useNavigate, h as useSearchParams, i as Link$1, j as useRouteError, k as isRouteErrorResponse, l as useLocation, m as useParams } from "./app-B2hObQJu.js";
+import { createRequire as __wkfCreateRequire } from "node:module";
+if (typeof globalThis.require === "undefined") {
+  globalThis.require = __wkfCreateRequire(import.meta.url);
+}
+import { a as requireReact, S as ServerRouter, c as createReadableStreamFromReadable, r as reactExports, g as getDefaultExportFromCjs, R as React, b as ReactExports, w as withComponentProps, d as withErrorBoundaryProps, M as Meta, L as Links, e as ScrollRestoration, f as Scripts, O as Outlet, u as useNavigate, h as useSearchParams, i as Link$1, j as useRouteError, k as isRouteErrorResponse, l as useLocation, m as useParams } from "./app-GbUkc_Xp.js";
 import require$$0$5, { PassThrough } from "node:stream";
 import require$$0 from "util";
 import require$$1 from "crypto";
@@ -81828,7 +81832,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-c3Vtq09H.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-A5X3ZwtB.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 }) })] }) });
@@ -82150,7 +82154,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-D9FphmOZ.js").then((e) => ({ default: e.Mermaid }))), Kn = /language-([^\s]+)/;
+var Jn = reactExports.lazy(() => import("./mermaid-3ZIDBTTL-CJ4kkLUP.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;
@@ -90910,6 +90914,15 @@ class ThrottleError extends WorkflowWorldError {
     return isError(value) && value.name === "ThrottleError";
   }
 }
+class PreconditionFailedError extends WorkflowWorldError {
+  constructor(message2, options) {
+    super(message2, { status: 412, retryAfter: options == null ? void 0 : options.retryAfter });
+    this.name = "PreconditionFailedError";
+  }
+  static is(value) {
+    return isError(value) && value.name === "PreconditionFailedError";
+  }
+}
 class WorkflowRunCancelledError extends WorkflowError {
   constructor(runId) {
     super(`Workflow run "${runId}" cancelled`, {});
@@ -91888,7 +91901,7 @@ async function withTraceContext(traceCarrier, fn2) {
 }
 const OtelApi = once$1(async () => {
   try {
-    return await import("./index-meg9qk8y.js");
+    return await import("./index-hBO56emR.js");
   } catch {
     runtimeLogger.info("OpenTelemetry not available, tracing will be disabled");
     return null;
@@ -92033,7 +92046,7 @@ createLogger("build", {
   debugNamespace: "workflow:build"
 });
 const MAX_QUEUE_DELIVERIES = 48;
-const version$1 = "4.6.2";
+const version$1 = "4.8.0";
 const execFileAsync = promisify(execFile);
 function parsePort$1(value, radix = 10) {
   const port = parseInt(value, radix);
@@ -92488,7 +92501,7 @@ async function readFirstByte(filePath) {
 }
 async function deleteJSON(filePath) {
   try {
-    await promises.unlink(filePath);
+    await withWindowsRetry(() => promises.unlink(filePath));
   } catch (error2) {
     if (error2.code !== "ENOENT")
       throw error2;
@@ -92793,7 +92806,7 @@ async function initDataDir(dataDir) {
 let otelApiPromise$1 = null;
 async function getOtelApi$1() {
   if (!otelApiPromise$1) {
-    otelApiPromise$1 = import("./index-meg9qk8y.js").catch(() => null);
+    otelApiPromise$1 = import("./index-hBO56emR.js").catch(() => null);
   }
   return otelApiPromise$1;
 }
@@ -100033,8 +100046,8 @@ function requireClientH1() {
       return this.createError(ret, EMPTY_BUF);
     }
     createError(ret, data) {
-      const { llhttp, contentLength, bytesRead } = this;
-      if (contentLength && bytesRead !== parseInt(contentLength, 10)) {
+      const { llhttp, contentLength: contentLength2, bytesRead } = this;
+      if (contentLength2 && bytesRead !== parseInt(contentLength2, 10)) {
         return new ResponseContentLengthMismatchError();
       }
       const ptr = llhttp.llhttp_get_error_reason(this.ptr);
@@ -100287,7 +100300,7 @@ function requireClientH1() {
      * @returns {number}
      */
     onMessageComplete() {
-      const { client: client2, socket, statusCode, upgrade, headers: headers2, contentLength, bytesRead, shouldKeepAlive } = this;
+      const { client: client2, socket, statusCode, upgrade, headers: headers2, contentLength: contentLength2, bytesRead, shouldKeepAlive } = this;
       if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
         return -1;
       }
@@ -100309,7 +100322,7 @@ function requireClientH1() {
       if (statusCode < 200) {
         return 0;
       }
-      if (request2.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
+      if (request2.method !== "HEAD" && contentLength2 && bytesRead !== parseInt(contentLength2, 10)) {
         util2.destroy(socket, new ResponseContentLengthMismatchError());
         return -1;
       }
@@ -100564,7 +100577,7 @@ function requireClientH1() {
   }
   function writeH1(client2, request2) {
     const { method, path: path2, host, upgrade, blocking, reset } = request2;
-    let { body: body2, headers: headers2, contentLength } = request2;
+    let { body: body2, headers: headers2, contentLength: contentLength2 } = request2;
     const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
     if (util2.isFormDataLike(body2)) {
       if (!extractBody) {
@@ -100575,7 +100588,7 @@ function requireClientH1() {
         headers2.push("content-type", contentType);
       }
       body2 = bodyStream.stream;
-      contentLength = bodyStream.length;
+      contentLength2 = bodyStream.length;
     } else if (util2.isBlobLike(body2) && request2.contentType == null && body2.type) {
       headers2.push("content-type", body2.type);
     }
@@ -100583,14 +100596,14 @@ function requireClientH1() {
       body2.read(0);
     }
     const bodyLength = util2.bodyLength(body2);
-    contentLength = bodyLength ?? contentLength;
-    if (contentLength === null) {
-      contentLength = request2.contentLength;
+    contentLength2 = bodyLength ?? contentLength2;
+    if (contentLength2 === null) {
+      contentLength2 = request2.contentLength;
     }
-    if (contentLength === 0 && !expectsPayload) {
-      contentLength = null;
+    if (contentLength2 === 0 && !expectsPayload) {
+      contentLength2 = null;
     }
-    if (shouldSendContentLength(method) && contentLength > 0 && request2.contentLength !== null && request2.contentLength !== contentLength) {
+    if (shouldSendContentLength(method) && contentLength2 > 0 && request2.contentLength !== null && request2.contentLength !== contentLength2) {
       if (client2[kStrictContentLength]) {
         util2.errorRequest(client2, request2, new RequestContentLengthMismatchError());
         return false;
@@ -100669,28 +100682,28 @@ upgrade: ${upgrade}\r
       channels.sendHeaders.publish({ request: request2, headers: header, socket });
     }
     if (!body2 || bodyLength === 0) {
-      writeBuffer2(abort, null, client2, request2, socket, contentLength, header, expectsPayload);
+      writeBuffer2(abort, null, client2, request2, socket, contentLength2, header, expectsPayload);
     } else if (util2.isBuffer(body2)) {
-      writeBuffer2(abort, body2, client2, request2, socket, contentLength, header, expectsPayload);
+      writeBuffer2(abort, body2, client2, request2, socket, contentLength2, header, expectsPayload);
     } else if (util2.isBlobLike(body2)) {
       if (typeof body2.stream === "function") {
-        writeIterable(abort, body2.stream(), client2, request2, socket, contentLength, header, expectsPayload);
+        writeIterable(abort, body2.stream(), client2, request2, socket, contentLength2, header, expectsPayload);
       } else {
-        writeBlob(abort, body2, client2, request2, socket, contentLength, header, expectsPayload);
+        writeBlob(abort, body2, client2, request2, socket, contentLength2, header, expectsPayload);
       }
     } else if (util2.isStream(body2)) {
-      writeStream(abort, body2, client2, request2, socket, contentLength, header, expectsPayload);
+      writeStream(abort, body2, client2, request2, socket, contentLength2, header, expectsPayload);
     } else if (util2.isIterable(body2)) {
-      writeIterable(abort, body2, client2, request2, socket, contentLength, header, expectsPayload);
+      writeIterable(abort, body2, client2, request2, socket, contentLength2, header, expectsPayload);
     } else {
       assert2(false);
     }
     return true;
   }
-  function writeStream(abort, body2, client2, request2, socket, contentLength, header, expectsPayload) {
-    assert2(contentLength !== 0 || client2[kRunning] === 0, "stream body cannot be pipelined");
+  function writeStream(abort, body2, client2, request2, socket, contentLength2, header, expectsPayload) {
+    assert2(contentLength2 !== 0 || client2[kRunning] === 0, "stream body cannot be pipelined");
     let finished = false;
-    const writer = new AsyncWriter({ abort, socket, request: request2, contentLength, client: client2, expectsPayload, header });
+    const writer = new AsyncWriter({ abort, socket, request: request2, contentLength: contentLength2, client: client2, expectsPayload, header });
     const onData = function(chunk) {
       if (finished) {
         return;
@@ -100756,22 +100769,22 @@ upgrade: ${upgrade}\r
       setImmediate(onClose);
     }
   }
-  function writeBuffer2(abort, body2, client2, request2, socket, contentLength, header, expectsPayload) {
+  function writeBuffer2(abort, body2, client2, request2, socket, contentLength2, header, expectsPayload) {
     try {
       if (!body2) {
-        if (contentLength === 0) {
+        if (contentLength2 === 0) {
           socket.write(`${header}content-length: 0\r
 \r
 `, "latin1");
         } else {
-          assert2(contentLength === null, "no body must not have content length");
+          assert2(contentLength2 === null, "no body must not have content length");
           socket.write(`${header}\r
 `, "latin1");
         }
       } else if (util2.isBuffer(body2)) {
-        assert2(contentLength === body2.byteLength, "buffer body must have content length");
+        assert2(contentLength2 === body2.byteLength, "buffer body must have content length");
         socket.cork();
-        socket.write(`${header}content-length: ${contentLength}\r
+        socket.write(`${header}content-length: ${contentLength2}\r
 \r
 `, "latin1");
         socket.write(body2);
@@ -100787,15 +100800,15 @@ upgrade: ${upgrade}\r
       abort(err);
     }
   }
-  async function writeBlob(abort, body2, client2, request2, socket, contentLength, header, expectsPayload) {
-    assert2(contentLength === body2.size, "blob body must have content length");
+  async function writeBlob(abort, body2, client2, request2, socket, contentLength2, header, expectsPayload) {
+    assert2(contentLength2 === body2.size, "blob body must have content length");
     try {
-      if (contentLength != null && contentLength !== body2.size) {
+      if (contentLength2 != null && contentLength2 !== body2.size) {
         throw new RequestContentLengthMismatchError();
       }
       const buffer2 = Buffer.from(await body2.arrayBuffer());
       socket.cork();
-      socket.write(`${header}content-length: ${contentLength}\r
+      socket.write(`${header}content-length: ${contentLength2}\r
 \r
 `, "latin1");
       socket.write(buffer2);
@@ -100810,8 +100823,8 @@ upgrade: ${upgrade}\r
       abort(err);
     }
   }
-  async function writeIterable(abort, body2, client2, request2, socket, contentLength, header, expectsPayload) {
-    assert2(contentLength !== 0 || client2[kRunning] === 0, "iterator body cannot be pipelined");
+  async function writeIterable(abort, body2, client2, request2, socket, contentLength2, header, expectsPayload) {
+    assert2(contentLength2 !== 0 || client2[kRunning] === 0, "iterator body cannot be pipelined");
     let callback = null;
     function onDrain() {
       if (callback) {
@@ -100829,7 +100842,7 @@ upgrade: ${upgrade}\r
       }
     });
     socket.on("close", onDrain).on("drain", onDrain);
-    const writer = new AsyncWriter({ abort, socket, request: request2, contentLength, client: client2, expectsPayload, header });
+    const writer = new AsyncWriter({ abort, socket, request: request2, contentLength: contentLength2, client: client2, expectsPayload, header });
     try {
       for await (const chunk of body2) {
         if (socket[kError]) {
@@ -100858,10 +100871,10 @@ upgrade: ${upgrade}\r
      * @param {boolean} arg.expectsPayload
      * @param {string} arg.header
      */
-    constructor({ abort, socket, request: request2, contentLength, client: client2, expectsPayload, header }) {
+    constructor({ abort, socket, request: request2, contentLength: contentLength2, client: client2, expectsPayload, header }) {
       this.socket = socket;
       this.request = request2;
-      this.contentLength = contentLength;
+      this.contentLength = contentLength2;
       this.client = client2;
       this.bytesWritten = 0;
       this.expectsPayload = expectsPayload;
@@ -100874,7 +100887,7 @@ upgrade: ${upgrade}\r
      * @returns
      */
     write(chunk) {
-      const { socket, request: request2, contentLength, client: client2, bytesWritten, expectsPayload, header } = this;
+      const { socket, request: request2, contentLength: contentLength2, client: client2, bytesWritten, expectsPayload, header } = this;
       if (socket[kError]) {
         throw socket[kError];
       }
@@ -100885,7 +100898,7 @@ upgrade: ${upgrade}\r
       if (!len) {
         return true;
       }
-      if (contentLength !== null && bytesWritten + len > contentLength) {
+      if (contentLength2 !== null && bytesWritten + len > contentLength2) {
         if (client2[kStrictContentLength]) {
           throw new RequestContentLengthMismatchError();
         }
@@ -100896,16 +100909,16 @@ upgrade: ${upgrade}\r
         if (!expectsPayload && request2.reset !== false) {
           socket[kReset] = true;
         }
-        if (contentLength === null) {
+        if (contentLength2 === null) {
           socket.write(`${header}transfer-encoding: chunked\r
 `, "latin1");
         } else {
-          socket.write(`${header}content-length: ${contentLength}\r
+          socket.write(`${header}content-length: ${contentLength2}\r
 \r
 `, "latin1");
         }
       }
-      if (contentLength === null) {
+      if (contentLength2 === null) {
         socket.write(`\r
 ${len.toString(16)}\r
 `, "latin1");
@@ -100927,7 +100940,7 @@ ${len.toString(16)}\r
      * @returns {void}
      */
     end() {
-      const { socket, contentLength, client: client2, bytesWritten, expectsPayload, header, request: request2 } = this;
+      const { socket, contentLength: contentLength2, client: client2, bytesWritten, expectsPayload, header, request: request2 } = this;
       request2.onRequestSent();
       socket[kWriting] = false;
       if (socket[kError]) {
@@ -100945,10 +100958,10 @@ ${len.toString(16)}\r
           socket.write(`${header}\r
 `, "latin1");
         }
-      } else if (contentLength === null) {
+      } else if (contentLength2 === null) {
         socket.write("\r\n0\r\n\r\n", "latin1");
       }
-      if (contentLength !== null && bytesWritten !== contentLength) {
+      if (contentLength2 !== null && bytesWritten !== contentLength2) {
         if (client2[kStrictContentLength]) {
           throw new RequestContentLengthMismatchError();
         } else {
@@ -101401,30 +101414,30 @@ function requireClientH2() {
     if (body2 && typeof body2.read === "function") {
       body2.read(0);
     }
-    let contentLength = util2.bodyLength(body2);
+    let contentLength2 = util2.bodyLength(body2);
     if (util2.isFormDataLike(body2)) {
       extractBody ?? (extractBody = requireBody().extractBody);
       const [bodyStream, contentType] = extractBody(body2);
       headers2["content-type"] = contentType;
       body2 = bodyStream.stream;
-      contentLength = bodyStream.length;
+      contentLength2 = bodyStream.length;
     }
-    if (contentLength == null) {
-      contentLength = request2.contentLength;
+    if (contentLength2 == null) {
+      contentLength2 = request2.contentLength;
     }
     if (!expectsPayload) {
-      contentLength = null;
+      contentLength2 = null;
     }
-    if (shouldSendContentLength(method) && contentLength > 0 && request2.contentLength != null && request2.contentLength !== contentLength) {
+    if (shouldSendContentLength(method) && contentLength2 > 0 && request2.contentLength != null && request2.contentLength !== contentLength2) {
       if (client2[kStrictContentLength]) {
         util2.errorRequest(client2, request2, new RequestContentLengthMismatchError());
         return false;
       }
       process.emitWarning(new RequestContentLengthMismatchError());
     }
-    if (contentLength != null) {
-      assert2(body2 || contentLength === 0, "no body must not have content length");
-      headers2[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
+    if (contentLength2 != null) {
+      assert2(body2 || contentLength2 === 0, "no body must not have content length");
+      headers2[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength2}`;
     }
     session.ref();
     if (channels.sendHeaders.hasSubscribers) {
@@ -101523,7 +101536,7 @@ function requireClientH2() {
     });
     return true;
     function writeBodyH2() {
-      if (!body2 || contentLength === 0) {
+      if (!body2 || contentLength2 === 0) {
         writeBuffer2(
           abort,
           stream,
@@ -101531,7 +101544,7 @@ function requireClientH2() {
           client2,
           request2,
           client2[kSocket],
-          contentLength,
+          contentLength2,
           expectsPayload
         );
       } else if (util2.isBuffer(body2)) {
@@ -101542,7 +101555,7 @@ function requireClientH2() {
           client2,
           request2,
           client2[kSocket],
-          contentLength,
+          contentLength2,
           expectsPayload
         );
       } else if (util2.isBlobLike(body2)) {
@@ -101554,7 +101567,7 @@ function requireClientH2() {
             client2,
             request2,
             client2[kSocket],
-            contentLength,
+            contentLength2,
             expectsPayload
           );
         } else {
@@ -101565,7 +101578,7 @@ function requireClientH2() {
             client2,
             request2,
             client2[kSocket],
-            contentLength,
+            contentLength2,
             expectsPayload
           );
         }
@@ -101578,7 +101591,7 @@ function requireClientH2() {
           body2,
           client2,
           request2,
-          contentLength
+          contentLength2
         );
       } else if (util2.isIterable(body2)) {
         writeIterable(
@@ -101588,7 +101601,7 @@ function requireClientH2() {
           client2,
           request2,
           client2[kSocket],
-          contentLength,
+          contentLength2,
           expectsPayload
         );
       } else {
@@ -101596,10 +101609,10 @@ function requireClientH2() {
       }
     }
   }
-  function writeBuffer2(abort, h2stream, body2, client2, request2, socket, contentLength, expectsPayload) {
+  function writeBuffer2(abort, h2stream, body2, client2, request2, socket, contentLength2, expectsPayload) {
     try {
       if (body2 != null && util2.isBuffer(body2)) {
-        assert2(contentLength === body2.byteLength, "buffer body must have content length");
+        assert2(contentLength2 === body2.byteLength, "buffer body must have content length");
         h2stream.cork();
         h2stream.write(body2);
         h2stream.uncork();
@@ -101615,8 +101628,8 @@ function requireClientH2() {
       abort(error2);
     }
   }
-  function writeStream(abort, socket, expectsPayload, h2stream, body2, client2, request2, contentLength) {
-    assert2(contentLength !== 0 || client2[kRunning] === 0, "stream body cannot be pipelined");
+  function writeStream(abort, socket, expectsPayload, h2stream, body2, client2, request2, contentLength2) {
+    assert2(contentLength2 !== 0 || client2[kRunning] === 0, "stream body cannot be pipelined");
     const pipe2 = pipeline(
       body2,
       h2stream,
@@ -101639,10 +101652,10 @@ function requireClientH2() {
       request2.onBodySent(chunk);
     }
   }
-  async function writeBlob(abort, h2stream, body2, client2, request2, socket, contentLength, expectsPayload) {
-    assert2(contentLength === body2.size, "blob body must have content length");
+  async function writeBlob(abort, h2stream, body2, client2, request2, socket, contentLength2, expectsPayload) {
+    assert2(contentLength2 === body2.size, "blob body must have content length");
     try {
-      if (contentLength != null && contentLength !== body2.size) {
+      if (contentLength2 != null && contentLength2 !== body2.size) {
         throw new RequestContentLengthMismatchError();
       }
       const buffer2 = Buffer.from(await body2.arrayBuffer());
@@ -101660,8 +101673,8 @@ function requireClientH2() {
       abort(err);
     }
   }
-  async function writeIterable(abort, h2stream, body2, client2, request2, socket, contentLength, expectsPayload) {
-    assert2(contentLength !== 0 || client2[kRunning] === 0, "iterator body cannot be pipelined");
+  async function writeIterable(abort, h2stream, body2, client2, request2, socket, contentLength2, expectsPayload) {
+    assert2(contentLength2 !== 0 || client2[kRunning] === 0, "iterator body cannot be pipelined");
     let callback = null;
     function onDrain() {
       if (callback) {
@@ -104301,8 +104314,8 @@ function requireRetryHandler() {
           this.end = end;
         }
         if (this.end == null) {
-          const contentLength = headers2["content-length"];
-          this.end = contentLength != null ? Number(contentLength) - 1 : null;
+          const contentLength2 = headers2["content-length"];
+          this.end = contentLength2 != null ? Number(contentLength2) - 1 : null;
         }
         assert2(Number.isFinite(this.start));
         assert2(
@@ -104518,7 +104531,7 @@ function requireReadable() {
       resume,
       abort,
       contentType = "",
-      contentLength,
+      contentLength: contentLength2,
       highWaterMark = 64 * 1024
       // Same as nodejs fs streams.
     }) {
@@ -104534,7 +104547,7 @@ function requireReadable() {
       this[kBody] = null;
       this[kUsed] = false;
       this[kContentType] = contentType;
-      this[kContentLength] = Number.isFinite(contentLength) ? contentLength : null;
+      this[kContentLength] = Number.isFinite(contentLength2) ? contentLength2 : null;
       this[kReading] = false;
     }
     /**
@@ -104974,12 +104987,12 @@ function requireApiRequest() {
       }
       const parsedHeaders = responseHeaders === "raw" ? util2.parseHeaders(rawHeaders) : headers2;
       const contentType = parsedHeaders["content-type"];
-      const contentLength = parsedHeaders["content-length"];
+      const contentLength2 = parsedHeaders["content-length"];
       const res = new Readable({
         resume,
         abort,
         contentType,
-        contentLength: this.method !== "HEAD" && contentLength ? Number(contentLength) : null,
+        contentLength: this.method !== "HEAD" && contentLength2 ? Number(contentLength2) : null,
         highWaterMark
       });
       if (this.removeAbortListener) {
@@ -106199,8 +106212,8 @@ function requireMockInterceptor() {
     }
     createMockScopeDispatchData({ statusCode, data, responseOptions }) {
       const responseData = getResponseData(data);
-      const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {};
-      const headers2 = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers };
+      const contentLength2 = this[kContentLength] ? { "content-length": responseData.length } : {};
+      const headers2 = { ...this[kDefaultHeaders], ...contentLength2, ...responseOptions.headers };
       const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers };
       return { statusCode, data, headers: headers2, trailers };
     }
@@ -108043,10 +108056,10 @@ function requireDump() {
       return super.onRequestStart(controller, context);
     }
     onResponseStart(controller, statusCode, headers2, statusMessage) {
-      const contentLength = headers2["content-length"];
-      if (contentLength != null && contentLength > __privateGet(this, _maxSize2)) {
+      const contentLength2 = headers2["content-length"];
+      if (contentLength2 != null && contentLength2 > __privateGet(this, _maxSize2)) {
         throw new RequestAbortedError(
-          `Response size (${contentLength}) larger than maxSize (${__privateGet(this, _maxSize2)})`
+          `Response size (${contentLength2}) larger than maxSize (${__privateGet(this, _maxSize2)})`
         );
       }
       if (this.aborted === true) {
@@ -113865,18 +113878,18 @@ function requireFetch() {
       httpFetchParams.request = httpRequest;
     }
     const includeCredentials = request2.credentials === "include" || request2.credentials === "same-origin" && request2.responseTainting === "basic";
-    const contentLength = httpRequest.body ? httpRequest.body.length : null;
+    const contentLength2 = httpRequest.body ? httpRequest.body.length : null;
     let contentLengthHeaderValue = null;
     if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) {
       contentLengthHeaderValue = "0";
     }
-    if (contentLength != null) {
-      contentLengthHeaderValue = isomorphicEncode(`${contentLength}`);
+    if (contentLength2 != null) {
+      contentLengthHeaderValue = isomorphicEncode(`${contentLength2}`);
     }
     if (contentLengthHeaderValue != null && !httpRequest.headersList.contains("content-length", true)) {
       httpRequest.headersList.append("content-length", contentLengthHeaderValue, true);
     }
-    if (contentLength != null && httpRequest.keepalive) ;
+    if (contentLength2 != null && httpRequest.keepalive) ;
     if (webidl.is.URL(httpRequest.referrer)) {
       httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href), true);
     }
@@ -119008,6 +119021,12 @@ async function handleLegacyEvent(basedir, runId, data, currentRun, params) {
       throw new Error(`Event type '${data.eventType}' not supported for legacy runs (specVersion: ${currentRun.specVersion || "undefined"}). Please upgrade 'workflow' package.`);
   }
 }
+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 HookTokenClaimSchema = object$1({
   // The token-claim writer below has always persisted `hookId`, but
   // this read schema previously omitted it, which is the bug fixed
@@ -119239,7 +119258,8 @@ function createEventsStorage(basedir, tag) {
             const resolveData2 = (params == null ? void 0 : params.resolveData) ?? DEFAULT_RESOLVE_DATA_OPTION$1;
             return {
               event: stripEventDataRefs(event2, resolveData2),
-              run: currentRun
+              run: currentRun,
+              ...currentRun ? { maxEvents: getMaxEventsPerRun() } : {}
             };
           }
           if (data.eventType === "run_started") {
@@ -119322,7 +119342,7 @@ function createEventsStorage(basedir, tag) {
         } else if (data.eventType === "run_started") {
           if (currentRun) {
             if (currentRun.status === "running") {
-              return { run: currentRun };
+              return { run: currentRun, maxEvents: getMaxEventsPerRun() };
             }
             run2 = {
               runId: currentRun.runId,
@@ -119705,7 +119725,9 @@ function createEventsStorage(basedir, tag) {
           wait: wait2,
           events: events2,
           cursor,
-          hasMore
+          hasMore,
+          // Per-run event ceiling (mirrors the Vercel World).
+          ...run2 ? { maxEvents: getMaxEventsPerRun() } : {}
         };
       }
     },
@@ -120294,7 +120316,7 @@ function createLocalWorld(args) {
         const basedir = mergedConfig.dataDir;
         const hooksDir = path$3.join(basedir, "hooks");
         const taggedHookFiles = await listTaggedFiles(hooksDir, tag);
-        const { HookSchema: HookSchema2 } = await import("./index-ulh-Ko1q.js");
+        const { HookSchema: HookSchema2 } = await import("./index-DUMo8iW2.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) {
@@ -120329,6 +120351,175 @@ function createLocalWorld(args) {
     }
   };
 }
+let _dispatcher;
+let _eventsDispatcher;
+let _streamDispatcher;
+let _streamCloseDispatcher;
+const DEFAULT_HEADERS_TIMEOUT_MS = 3e4;
+const DEFAULT_BODY_TIMEOUT_MS = 3e4;
+function envTimeoutMs(name2, fallback) {
+  const raw2 = process.env[name2];
+  if (raw2 === void 0 || raw2 === "")
+    return fallback;
+  const parsed = Number.parseInt(raw2, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+const RETRY_ERROR_CODES = [
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "ENETDOWN",
+  "ENETUNREACH",
+  "EHOSTDOWN",
+  "EHOSTUNREACH",
+  "EPIPE",
+  "UND_ERR_SOCKET",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT"
+];
+const MAX_RETRIES = 2;
+function getBaseAgentOptions() {
+  return {
+    connections: 8,
+    keepAliveTimeout: 1e4,
+    headersTimeout: envTimeoutMs("WORKFLOW_VERCEL_HEADERS_TIMEOUT_MS", DEFAULT_HEADERS_TIMEOUT_MS),
+    bodyTimeout: envTimeoutMs("WORKFLOW_VERCEL_BODY_TIMEOUT_MS", DEFAULT_BODY_TIMEOUT_MS)
+  };
+}
+const H2_MAX_IN_FLIGHT_STREAMS = 100;
+const H2_STREAM_WINDOW_BYTES = 4 * 1024 * 1024;
+const H2_CONNECTION_WINDOW_BYTES = 16 * 1024 * 1024;
+function getAgentOptions() {
+  return {
+    ...getBaseAgentOptions(),
+    allowH2: false,
+    // HTTP/1.1 pipelining is disabled (pipelining: 1) because it causes
+    // head-of-line blocking that deadlocks the webhook respondWith mechanism.
+    pipelining: 1
+  };
+}
+function getEventsAgentOptions() {
+  return {
+    ...getBaseAgentOptions(),
+    allowH2: true,
+    pipelining: H2_MAX_IN_FLIGHT_STREAMS,
+    initialWindowSize: H2_STREAM_WINDOW_BYTES,
+    connectionWindowSize: H2_CONNECTION_WINDOW_BYTES
+  };
+}
+function getStreamAgentOptions() {
+  return {
+    ...getBaseAgentOptions(),
+    allowH2: true,
+    pipelining: 1
+  };
+}
+function getRetryAgentOptions() {
+  return {
+    // Observe Retry-After header if received
+    retryAfter: true,
+    // Retry 5xx in-process (genuine transient blips recover fast), but NOT
+    // 429. The Vercel firewall issues a challenge as a 429: our
+    // server-to-server client cannot solve a challenge, so in-process
+    // retries just re-trigger it ~5× per request and amplify load against
+    // an already-overloaded firewall during an incident. Letting 429 pass
+    // through surfaces it immediately to makeRequest — which maps it to a
+    // ThrottleError carrying the `x-vercel-mitigated` / `x-vercel-id`
+    // headers — and the queue does the (backed-off) retry instead.
+    // (undici default is [500, 502, 503, 504, 429].)
+    statusCodes: [500, 502, 503, 504],
+    errorCodes: RETRY_ERROR_CODES,
+    maxRetries: MAX_RETRIES
+  };
+}
+const STREAM_RETRY_OPTIONS = {
+  retryAfter: true,
+  methods: ["PUT"],
+  statusCodes: [429]
+};
+const STREAM_CLOSE_RETRY_OPTIONS = {
+  retryAfter: true,
+  methods: ["PUT"],
+  statusCodes: [429, 500, 502, 503, 504]
+};
+const H2_REBUFFER_MAX_BYTES = 1 << 20;
+function h2MultiplexEnabled() {
+  return process.env.WORKFLOW_H2_MULTIPLEX !== "0";
+}
+function contentLength(headers2) {
+  if (!headers2 || typeof headers2 !== "object" || Array.isArray(headers2)) {
+    return Number.NaN;
+  }
+  const record2 = headers2;
+  const raw2 = record2["content-length"] ?? record2["Content-Length"];
+  return typeof raw2 === "string" || typeof raw2 === "number" ? Number(raw2) : Number.NaN;
+}
+function h2MultiplexInterceptor(dispatch2) {
+  return (opts, handler) => {
+    const body2 = opts.body;
+    const isAsyncIterable = !!body2 && typeof body2 !== "string" && !Buffer.isBuffer(body2) && typeof body2[Symbol.asyncIterator] === "function";
+    const length = contentLength(opts.headers);
+    if (!isAsyncIterable || !(length >= 0) || length > H2_REBUFFER_MAX_BYTES) {
+      return dispatch2({ ...opts, idempotent: true }, handler);
+    }
+    void (async () => {
+      var _a3;
+      try {
+        const chunks = [];
+        for await (const chunk of body2) {
+          chunks.push(Buffer.from(chunk));
+        }
+        dispatch2({ ...opts, body: Buffer.concat(chunks), idempotent: true }, handler);
+      } catch (error2) {
+        (_a3 = handler.onError) == null ? void 0 : _a3.call(handler, error2);
+      }
+    })();
+    return true;
+  };
+}
+function getDispatcher(config2) {
+  return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultDispatcher();
+}
+function getEventsDispatcher(config2) {
+  return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultEventsDispatcher();
+}
+function getStreamDispatcher(config2) {
+  return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultStreamDispatcher();
+}
+function getStreamCloseDispatcher(config2) {
+  return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultStreamCloseDispatcher();
+}
+function createEventsDispatcher(agentOverrides) {
+  const agent2 = new undiciExports.RetryAgent(new undiciExports.Agent({ ...getEventsAgentOptions(), ...agentOverrides }), getRetryAgentOptions());
+  if (!h2MultiplexEnabled()) {
+    return agent2;
+  }
+  return withBoundLifecycle(agent2, agent2.compose(h2MultiplexInterceptor));
+}
+function withBoundLifecycle(agent2, composed) {
+  return new Proxy(composed, {
+    get: (target2, key) => key === "close" || key === "destroy" ? agent2[key].bind(agent2) : target2[key]
+  });
+}
+function createStreamDispatcher(retryOptions, agentOverrides) {
+  return new undiciExports.RetryAgent(new undiciExports.Agent({ ...getStreamAgentOptions(), ...agentOverrides }), retryOptions);
+}
+function getDefaultDispatcher() {
+  _dispatcher ?? (_dispatcher = new undiciExports.RetryAgent(new undiciExports.Agent(getAgentOptions()), getRetryAgentOptions()));
+  return _dispatcher;
+}
+function getDefaultEventsDispatcher() {
+  _eventsDispatcher ?? (_eventsDispatcher = createEventsDispatcher());
+  return _eventsDispatcher;
+}
+function getDefaultStreamDispatcher() {
+  _streamDispatcher ?? (_streamDispatcher = createStreamDispatcher(STREAM_RETRY_OPTIONS));
+  return _streamDispatcher;
+}
+function getDefaultStreamCloseDispatcher() {
+  _streamCloseDispatcher ?? (_streamCloseDispatcher = createStreamDispatcher(STREAM_CLOSE_RETRY_OPTIONS));
+  return _streamCloseDispatcher;
+}
 var getContext_1;
 var hasRequiredGetContext;
 function requireGetContext() {
@@ -120447,8 +120638,8 @@ function requireGetVercelOidcToken() {
     }
     try {
       const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
-        await import("./token-util-TwMjSZSF.js").then((n) => n.t),
-        await import("./token-COKbCOS0.js").then((n) => n.t)
+        await import("./token-util-BVCPBo_Y.js").then((n) => n.t),
+        await import("./token-BdngUnpg.js").then((n) => n.t)
       ]);
       if (!token || isExpired(getTokenPayload(token), options == null ? void 0 : options.expirationBufferMs)) {
         await refreshToken(options);
@@ -121011,38 +121202,220 @@ function requireDist() {
   return dist;
 }
 var distExports = requireDist();
-let _dispatcher;
-function getDispatcher(config2) {
-  return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultDispatcher();
+let otelApiPromise = null;
+async function getOtelApi() {
+  if (!otelApiPromise) {
+    otelApiPromise = import("./index-hBO56emR.js").catch(() => null);
+  }
+  return otelApiPromise;
 }
-function getDefaultDispatcher() {
-  if (!_dispatcher) {
-    _dispatcher = new undiciExports.RetryAgent(new undiciExports.Agent({
-      connections: 8,
-      keepAliveTimeout: 1e4,
-      // H2 is specifically incompatible with SvelteKit on Vercel prod. Everything else
-      // runs fine.
-      // TODO: Investigate/fix the failure on SvelteKit so we can re-enable H2.
-      allowH2: false,
-      // HTTP/1.1 pipelining is disabled (pipelining: 1) because it causes
-      // head-of-line blocking that deadlocks the webhook respondWith mechanism.
-      pipelining: 1
-    }), {
-      // Observe Retry-After header if received
-      retryAfter: true,
-      // Retry 5xx in-process (genuine transient blips recover fast), but NOT
-      // 429. The Vercel firewall issues a challenge as a 429: our
-      // server-to-server client cannot solve a challenge, so in-process
-      // retries just re-trigger it ~5× per request and amplify load against
-      // an already-overloaded firewall during an incident. Letting 429 pass
-      // through surfaces it immediately to makeRequest — which maps it to a
-      // ThrottleError carrying the `x-vercel-mitigated` / `x-vercel-id`
-      // headers — and the queue does the (backed-off) retry instead.
-      // (undici default is [500, 502, 503, 504, 429].)
-      statusCodes: [500, 502, 503, 504]
-    });
+let tracerPromise = null;
+async function getTracer() {
+  if (!tracerPromise) {
+    tracerPromise = getOtelApi().then((otel) => otel ? otel.trace.getTracer("workflow") : null);
   }
-  return _dispatcher;
+  return tracerPromise;
+}
+async function trace(spanName2, ...args) {
+  const [tracer, otel] = await Promise.all([getTracer(), getOtelApi()]);
+  const { fn: fn2, opts } = typeof args[0] === "function" ? { fn: args[0], opts: {} } : { fn: args[1], opts: args[0] };
+  if (!fn2)
+    throw new Error("Function to trace must be provided");
+  if (!tracer || !otel) {
+    return await fn2();
+  }
+  return tracer.startActiveSpan(spanName2, opts, async (span) => {
+    try {
+      const result = await fn2(span);
+      span.setStatus({ code: otel.SpanStatusCode.OK });
+      return result;
+    } catch (e) {
+      span.setStatus({
+        code: otel.SpanStatusCode.ERROR,
+        message: e.message
+      });
+      throw e;
+    } finally {
+      span.end();
+    }
+  });
+}
+async function getSpanKind(field) {
+  const otel = await getOtelApi();
+  if (!otel)
+    return void 0;
+  return otel.SpanKind[field];
+}
+async function injectTraceContextIntoHeaders(headers2) {
+  const otel = await getOtelApi();
+  if (!otel)
+    return;
+  const carrier = {};
+  otel.propagation.inject(otel.context.active(), carrier);
+  for (const [key, value] of Object.entries(carrier)) {
+    headers2.set(key, value);
+  }
+}
+function SemanticConvention(...names) {
+  return (value) => Object.fromEntries(names.map((name2) => [name2, value]));
+}
+const HttpRequestMethod = SemanticConvention("http.request.method");
+const UrlFull = SemanticConvention("url.full");
+const ServerAddress = SemanticConvention("server.address");
+const ServerPort = SemanticConvention("server.port");
+const HttpResponseStatusCode = SemanticConvention("http.response.status_code");
+const ErrorType = SemanticConvention("error.type");
+const WorldParseFormat = SemanticConvention("workflow.world.parse.format");
+const PeerService = SemanticConvention("peer.service");
+const RpcSystem = SemanticConvention("rpc.system");
+const RpcService = SemanticConvention("rpc.service");
+const RpcMethod = SemanticConvention("rpc.method");
+const WorkflowRunId = SemanticConvention("workflow.run.id");
+const StepId = SemanticConvention("step.id");
+const REQUEST_TIMEOUT_MS = 6e4;
+const HTTP_DEBUG_ENABLED = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
+const DIAGNOSTIC_HEADERS = [
+  "x-vercel-id",
+  "x-vercel-error",
+  "x-vercel-mitigated"
+];
+function getVercelDiagnostics(headers2) {
+  return DIAGNOSTIC_HEADERS.flatMap((header) => {
+    const value = headers2.get(header);
+    return value ? [`${header}=${value}`] : [];
+  });
+}
+function formatVercelDiagnostics(headers2) {
+  const diagnostics2 = getVercelDiagnostics(headers2);
+  return diagnostics2.length > 0 ? ` (${diagnostics2.join("; ")})` : "";
+}
+function httpLog(method, label, response2, ms2) {
+  if (!HTTP_DEBUG_ENABLED)
+    return;
+  const diagnostics2 = getVercelDiagnostics(response2.headers);
+  const suffix = diagnostics2.length > 0 ? `; ${diagnostics2.join("; ")}` : "";
+  console.debug(`[workflow:world-vercel:http] ${method} ${label} -> ${response2.status} (${ms2}ms${suffix})`);
+}
+function logCurlRepro(method, url2, headers2) {
+  if (!process.env.DEBUG)
+    return;
+  const stringifiedHeaders = Array.from(headers2.entries()).filter(([key]) => key.toLowerCase() !== "authorization").map(([key, value]) => `-H "${key}: ${value}"`).join(" ");
+  console.error(`Failed to fetch, reproduce with:
+curl -X ${method} ${stringifiedHeaders} "${url2}"`);
+}
+function parseRetryAfter(value) {
+  if (!value)
+    return void 0;
+  const parsed = parseInt(value, 10);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function errorForResponse(status, message2, opts = {}) {
+  const { retryAfter, code: code2, url: url2, mitigated } = opts;
+  if (status === 409)
+    return new EntityConflictError(message2);
+  if (status === 410)
+    return new RunExpiredError(message2);
+  if (status === 412)
+    return new PreconditionFailedError(message2, { retryAfter });
+  if (status === 425)
+    return new TooEarlyError(message2, { retryAfter });
+  if (status === 429) {
+    if (isFirewallChallenge429(status, mitigated)) {
+      return new WorkflowWorldError(`${message2} (x-vercel-mitigated=challenge)`, {
+        url: url2,
+        status,
+        code: "TRANSPORT",
+        retryAfter
+      });
+    }
+    return new ThrottleError(message2, { retryAfter });
+  }
+  return new WorkflowWorldError(message2, { url: url2, status, code: code2, retryAfter });
+}
+function isFirewallChallenge429(status, mitigated) {
+  return status === 429 && mitigated === "challenge";
+}
+async function resolveVercelApiToken(opts) {
+  return (opts == null ? void 0 : opts.token) ?? process.env.VERCEL_TOKEN ?? await distExports.getVercelOidcToken().catch(() => null);
+}
+function parseServer(url2) {
+  try {
+    const parsed = new URL(url2);
+    return {
+      serverAddress: parsed.hostname,
+      serverPort: parsed.port ? parseInt(parsed.port, 10) : parsed.protocol === "https:" ? 443 : 80
+    };
+  } catch {
+    return {};
+  }
+}
+function httpClientSpanAttributes(args) {
+  const { method, url: url2, peerService } = args;
+  const { serverAddress, serverPort } = parseServer(url2);
+  return {
+    ...HttpRequestMethod(method),
+    ...UrlFull(url2),
+    ...serverAddress ? ServerAddress(serverAddress) : {},
+    ...serverPort ? ServerPort(serverPort) : {},
+    ...PeerService(peerService),
+    ...RpcSystem("http"),
+    ...RpcService(peerService)
+  };
+}
+async function instrumentedFetch(opts) {
+  const { method, url: url2, headers: headers2, body: body2, dispatcher: dispatcher2, peerService = "workflow-server", timeoutMs = REQUEST_TIMEOUT_MS, signal: callerSignal, injectTraceContext = true, cacheBust = true, logLabel, buildError } = opts;
+  const label = logLabel ?? url2;
+  return trace(`http ${method}`, { kind: await getSpanKind("CLIENT") }, async (span) => {
+    var _a3, _b2, _c;
+    span == null ? void 0 : span.setAttributes(httpClientSpanAttributes({ method, url: url2, peerService }));
+    if (injectTraceContext)
+      await injectTraceContextIntoHeaders(headers2);
+    if (cacheBust)
+      headers2.set("X-Request-Time", Date.now().toString());
+    const timeoutSignal = timeoutMs != null ? AbortSignal.timeout(timeoutMs) : void 0;
+    const signal = callerSignal && timeoutSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : callerSignal ?? timeoutSignal;
+    const start2 = Date.now();
+    let response2;
+    try {
+      response2 = await fetch(url2, {
+        method,
+        headers: headers2,
+        body: body2,
+        signal,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- undici dispatcher type doesn't match @types/node's RequestInit
+        dispatcher: dispatcher2
+      });
+    } catch (error2) {
+      const elapsed = Date.now() - start2;
+      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") });
+        (_a3 = span == null ? void 0 : span.recordException) == null ? void 0 : _a3.call(span, timeoutError);
+        throw timeoutError;
+      }
+      throw error2;
+    }
+    const ms2 = Date.now() - start2;
+    httpLog(method, label, response2, ms2);
+    span == null ? void 0 : span.setAttributes({ ...HttpResponseStatusCode(response2.status) });
+    if (!response2.ok) {
+      span == null ? void 0 : span.setAttributes({ ...ErrorType(`HTTP ${response2.status}`) });
+      logCurlRepro(method, url2, headers2);
+      if (buildError) {
+        const error3 = await buildError(response2);
+        (_b2 = span == null ? void 0 : span.recordException) == null ? void 0 : _b2.call(span, error3);
+        throw error3;
+      }
+      const text2 = await response2.text().catch(() => "");
+      const error2 = errorForResponse(response2.status, `${method} ${label} -> HTTP ${response2.status}: ${response2.statusText}${text2 ? ` ${text2}` : ""}${formatVercelDiagnostics(response2.headers)}`, {
+        url: url2,
+        retryAfter: parseRetryAfter(response2.headers.get("Retry-After"))
+      });
+      (_c = span == null ? void 0 : span.recordException) == null ? void 0 : _c.call(span, error2);
+      throw error2;
+    }
+    return response2;
+  });
 }
 const KEY_BYTES = 32;
 async function deriveRunKey(deploymentKey, projectId, runId) {
@@ -121068,7 +121441,7 @@ async function deriveRunKey(deploymentKey, projectId, runId) {
   return new Uint8Array(derivedBits);
 }
 async function fetchRunKey(deploymentId, projectId, runId, options) {
-  const token = (options == null ? void 0 : options.token) ?? process.env.VERCEL_TOKEN ?? await distExports.getVercelOidcToken().catch(() => null);
+  const token = await resolveVercelApiToken({ token: options == null ? void 0 : options.token });
   if (!token) {
     throw new Error("Cannot fetch run key: no OIDC token or VERCEL_TOKEN available");
   }
@@ -121076,23 +121449,25 @@ async function fetchRunKey(deploymentId, projectId, runId, options) {
   if (options == null ? void 0 : options.teamId) {
     params.set("teamId", options.teamId);
   }
-  const response2 = await fetch(`https://api.vercel.com/v1/workflow/run-key/${deploymentId}?${params}`, {
+  const response2 = await instrumentedFetch({
     method: "GET",
-    headers: {
-      Authorization: `Bearer ${token}`
-    },
-    // @ts-expect-error -- undici dispatcher is accepted by Node.js fetch but not in @types/node's RequestInit
-    dispatcher: getDispatcher({ dispatcher: options == null ? void 0 : options.dispatcher })
-  });
-  if (!response2.ok) {
-    let body2;
-    try {
-      body2 = await response2.text();
-    } catch {
-      body2 = "<unable to read response body>";
+    url: `https://api.vercel.com/v1/workflow/run-key/${deploymentId}?${params}`,
+    headers: new Headers({ Authorization: `Bearer ${token}` }),
+    dispatcher: getDispatcher({ dispatcher: options == null ? void 0 : options.dispatcher }),
+    peerService: "vercel-api",
+    // Preserve the prior no-timeout behavior for this Vercel-API call; the
+    // shared RetryAgent still handles transient/5xx retries.
+    timeoutMs: null,
+    buildError: async (res) => {
+      let body2;
+      try {
+        body2 = await res.text();
+      } catch {
+        body2 = "<unable to read response body>";
+      }
+      return new Error(`Failed to fetch run key for ${runId} (deployment ${deploymentId}): HTTP ${res.status} ${res.statusText}${body2 ? ` — ${body2}` : ""}`);
     }
-    throw new Error(`Failed to fetch run key for ${runId} (deployment ${deploymentId}): HTTP ${response2.status} ${response2.statusText}${body2 ? ` — ${body2}` : ""}`);
-  }
+  });
   const data = await response2.json();
   const result = object$1({ key: string$3().nullable() }).safeParse(data);
   if (!result.success) {
@@ -121137,66 +121512,6 @@ function createGetEncryptionKeyForRun(projectId, teamId, token, dispatcher2) {
     });
   };
 }
-let otelApiPromise = null;
-async function getOtelApi() {
-  if (!otelApiPromise) {
-    otelApiPromise = import("./index-meg9qk8y.js").catch(() => null);
-  }
-  return otelApiPromise;
-}
-let tracerPromise = null;
-async function getTracer() {
-  if (!tracerPromise) {
-    tracerPromise = getOtelApi().then((otel) => otel ? otel.trace.getTracer("workflow") : null);
-  }
-  return tracerPromise;
-}
-async function trace(spanName2, ...args) {
-  const [tracer, otel] = await Promise.all([getTracer(), getOtelApi()]);
-  const { fn: fn2, opts } = typeof args[0] === "function" ? { fn: args[0], opts: {} } : { fn: args[1], opts: args[0] };
-  if (!fn2)
-    throw new Error("Function to trace must be provided");
-  if (!tracer || !otel) {
-    return await fn2();
-  }
-  return tracer.startActiveSpan(spanName2, opts, async (span) => {
-    try {
-      const result = await fn2(span);
-      span.setStatus({ code: otel.SpanStatusCode.OK });
-      return result;
-    } catch (e) {
-      span.setStatus({
-        code: otel.SpanStatusCode.ERROR,
-        message: e.message
-      });
-      throw e;
-    } finally {
-      span.end();
-    }
-  });
-}
-async function getSpanKind(field) {
-  const otel = await getOtelApi();
-  if (!otel)
-    return void 0;
-  return otel.SpanKind[field];
-}
-function SemanticConvention(...names) {
-  return (value) => Object.fromEntries(names.map((name2) => [name2, value]));
-}
-const HttpRequestMethod = SemanticConvention("http.request.method");
-const UrlFull = SemanticConvention("url.full");
-const ServerAddress = SemanticConvention("server.address");
-const ServerPort = SemanticConvention("server.port");
-const HttpResponseStatusCode = SemanticConvention("http.response.status_code");
-const ErrorType = SemanticConvention("error.type");
-const WorldParseFormat = SemanticConvention("workflow.world.parse.format");
-const PeerService = SemanticConvention("peer.service");
-const RpcSystem = SemanticConvention("rpc.system");
-const RpcService = SemanticConvention("rpc.service");
-const RpcMethod = SemanticConvention("rpc.method");
-const WorkflowRunId = SemanticConvention("workflow.run.id");
-const StepId = SemanticConvention("step.id");
 const WORKFLOW_SERVER_SERVICE = {
   peerService: "workflow-server",
   rpcSystem: "http",
@@ -125793,26 +126108,7 @@ var QueueClient = class {
     setApi(this, new ApiClient({ ...options, region }));
   }
 };
-const version = "4.5.1";
-const HTTP_DEBUG_ENABLED = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
-function httpLog(method, endpoint, response2, ms2) {
-  if (HTTP_DEBUG_ENABLED) {
-    const responseContext = getResponseDiagnosticHeaders(response2);
-    const diagnosticSuffix = responseContext.length > 0 ? `; ${responseContext.join("; ")}` : "";
-    console.debug(`[workflow:world-vercel:http] ${method} ${endpoint} -> ${response2.status} (${ms2}ms${diagnosticSuffix})`);
-  }
-}
-function getResponseDiagnosticHeaders(response2) {
-  return ["x-vercel-id", "x-vercel-error", "x-vercel-mitigated"].flatMap((header) => {
-    const value = response2.headers.get(header);
-    return value ? [`${header}=${value}`] : [];
-  });
-}
-function formatResponseDiagnostics(response2) {
-  const headers2 = getResponseDiagnosticHeaders(response2);
-  return headers2.length > 0 ? ` (${headers2.join("; ")})` : "";
-}
-const REQUEST_TIMEOUT_MS = 6e4;
+const version = "4.6.1";
 const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
 const MAX_BODY_PARSE_RETRIES = 2;
 const BODY_PARSE_RETRY_BASE_MS = 100;
@@ -125950,27 +126246,15 @@ async function makeRequest({ endpoint, options = {}, config: config2 = {}, schem
   const method = options.method || "GET";
   const { baseUrl, headers: headers2 } = await getHttpConfig(config2);
   const url2 = `${baseUrl}${endpoint}`;
-  let serverAddress;
-  let serverPort;
-  try {
-    const parsedUrl = new URL(url2);
-    serverAddress = parsedUrl.hostname;
-    serverPort = parsedUrl.port ? parseInt(parsedUrl.port, 10) : parsedUrl.protocol === "https:" ? 443 : 80;
-  } catch {
-  }
   return trace(`http ${method}`, { kind: await getSpanKind("CLIENT") }, async (span) => {
-    var _a3, _b2;
-    span == null ? void 0 : span.setAttributes({
-      ...HttpRequestMethod(method),
-      ...UrlFull(url2),
-      ...serverAddress && ServerAddress(serverAddress),
-      ...serverPort && ServerPort(serverPort),
-      // Peer service for Datadog service maps
-      ...PeerService("workflow-server"),
-      ...RpcSystem("http"),
-      ...RpcService("workflow-server")
-    });
+    var _a3, _b2, _c;
+    span == null ? void 0 : span.setAttributes(httpClientSpanAttributes({
+      method,
+      url: url2,
+      peerService: "workflow-server"
+    }));
     headers2.set("Accept", "application/cbor");
+    await injectTraceContextIntoHeaders(headers2);
     let body2;
     if (data !== void 0) {
       headers2.set("Content-Type", "application/cbor");
@@ -126017,61 +126301,27 @@ async function makeRequest({ endpoint, options = {}, config: config2 = {}, schem
         throw error2;
       }
       const fetchMs = Date.now() - fetchStart;
-      responseDiagnostics = formatResponseDiagnostics(response2);
+      responseDiagnostics = formatVercelDiagnostics(response2.headers);
       httpLog(method, endpoint, response2, fetchMs);
       span == null ? void 0 : span.setAttributes({
         ...HttpResponseStatusCode(response2.status)
       });
       if (!response2.ok) {
         const errorData = await parseResponseBody(response2).then((r2) => r2.data).catch(() => ({}));
-        if (process.env.DEBUG) {
-          const stringifiedHeaders = Array.from(headers2.entries()).filter(([key]) => key.toLowerCase() !== "authorization").map(([key, value]) => `-H "${key}: ${value}"`).join(" ");
-          console.error(`Failed to fetch, reproduce with:
-curl -X ${request2.method} ${stringifiedHeaders} "${url2}"`);
-        }
-        let retryAfter;
-        const retryAfterHeader = response2.headers.get("Retry-After");
-        if (retryAfterHeader) {
-          const parsed = parseInt(retryAfterHeader, 10);
-          if (!Number.isNaN(parsed)) {
-            retryAfter = parsed;
-          }
-        }
+        logCurlRepro(request2.method, url2, headers2);
+        const retryAfter = parseRetryAfter(response2.headers.get("Retry-After"));
         const defaultMessage = (errorData.message || `${request2.method} ${endpoint} -> HTTP ${response2.status}: ${response2.statusText}`) + responseDiagnostics;
-        const throwWithTrace = (error2) => {
-          var _a4;
-          span == null ? void 0 : span.setAttributes({
-            ...ErrorType(errorData.code || `HTTP ${response2.status}`)
-          });
-          (_a4 = span == null ? void 0 : span.recordException) == null ? void 0 : _a4.call(span, error2);
-          throw error2;
-        };
-        if (response2.status === 409) {
-          throwWithTrace(new EntityConflictError(defaultMessage));
-        }
-        if (response2.status === 410) {
-          throwWithTrace(new RunExpiredError(defaultMessage));
-        }
-        if (response2.status === 425) {
-          throwWithTrace(new TooEarlyError(defaultMessage, { retryAfter }));
-        }
-        if (response2.status === 429) {
-          if (response2.headers.get("x-vercel-mitigated") === "challenge") {
-            throwWithTrace(new WorkflowWorldError(`${defaultMessage} (x-vercel-mitigated=challenge)`, {
-              url: url2,
-              status: response2.status,
-              code: "TRANSPORT",
-              retryAfter
-            }));
-          }
-          throwWithTrace(new ThrottleError(defaultMessage, { retryAfter }));
-        }
-        throwWithTrace(new WorkflowWorldError(defaultMessage, {
+        const error2 = errorForResponse(response2.status, defaultMessage, {
           url: url2,
-          status: response2.status,
           code: errorData.code,
-          retryAfter
-        }));
+          retryAfter,
+          mitigated: response2.headers.get("x-vercel-mitigated")
+        });
+        span == null ? void 0 : span.setAttributes({
+          ...ErrorType(errorData.code || `HTTP ${response2.status}`)
+        });
+        (_c = span == null ? void 0 : span.recordException) == null ? void 0 : _c.call(span, error2);
+        throw error2;
       }
       onResponse == null ? void 0 : onResponse(response2);
       try {
@@ -126356,28 +126606,30 @@ function createResolveLatestDeploymentId(config2) {
     if (!currentDeploymentId) {
       throw new Error("Cannot resolve latest deployment: VERCEL_DEPLOYMENT_ID environment variable is not set");
     }
-    const token = (config2 == null ? void 0 : config2.token) ?? process.env.VERCEL_TOKEN ?? await distExports.getVercelOidcToken().catch(() => null);
+    const token = await resolveVercelApiToken(config2);
     if (!token) {
       throw new Error("Cannot resolve latest deployment: no OIDC token or VERCEL_TOKEN available");
     }
     const url2 = `https://api.vercel.com/v1/workflow/resolve-latest-deployment/${encodeURIComponent(currentDeploymentId)}`;
-    const response2 = await fetch(url2, {
+    const response2 = await instrumentedFetch({
       method: "GET",
-      headers: {
-        Authorization: `Bearer ${token}`
-      },
-      // @ts-expect-error -- undici dispatcher is accepted by Node.js fetch but not in @types/node's RequestInit
-      dispatcher: getDispatcher(config2)
-    });
-    if (!response2.ok) {
-      let body2;
-      try {
-        body2 = await response2.text();
-      } catch {
-        body2 = "<unable to read response body>";
+      url: url2,
+      headers: new Headers({ Authorization: `Bearer ${token}` }),
+      dispatcher: getDispatcher(config2),
+      peerService: "vercel-api",
+      // Preserve the prior no-timeout behavior for this Vercel-API call; the
+      // shared RetryAgent still handles transient/5xx retries.
+      timeoutMs: null,
+      buildError: async (res) => {
+        let body2;
+        try {
+          body2 = await res.text();
+        } catch {
+          body2 = "<unable to read response body>";
+        }
+        return new Error(`Failed to resolve latest deployment for ${currentDeploymentId}: HTTP ${res.status} ${res.statusText}${body2 ? ` — ${body2}` : ""}`);
       }
-      throw new Error(`Failed to resolve latest deployment for ${currentDeploymentId}: HTTP ${response2.status} ${response2.statusText}${body2 ? ` — ${body2}` : ""}`);
-    }
+    });
     const data = await response2.json();
     const result = ResolveLatestDeploymentResponseSchema.safeParse(data);
     if (!result.success) {
@@ -126386,6 +126638,176 @@ function createResolveLatestDeploymentId(config2) {
     return result.data.id;
   };
 }
+const EVENT_RETRY_ELIGIBILITY = {
+  // Creates: conditional create → 409 EntityConflictError if it already exists.
+  run_created: {
+    retryable: true,
+    reason: "conditional create → 409 if exists"
+  },
+  step_created: {
+    retryable: true,
+    reason: "conditional create → 409 if exists"
+  },
+  wait_created: {
+    retryable: true,
+    reason: "conditional create → 409 if exists"
+  },
+  hook_created: {
+    retryable: true,
+    reason: "transactional token uniqueness → 409 if exists"
+  },
+  // Run start: early-returns if already running, writes no duplicate row.
+  run_started: {
+    retryable: true,
+    reason: "early-returns if already running, no duplicate row"
+  },
+  // Terminal transitions: conditional `.where()` excludes terminal states →
+  // 409 before the event row is written.
+  run_completed: {
+    retryable: true,
+    reason: "terminal-state guard → 409, no duplicate row"
+  },
+  run_failed: {
+    retryable: true,
+    reason: "terminal-state guard → 409, no duplicate row"
+  },
+  run_cancelled: {
+    retryable: true,
+    reason: "terminal-state guard → 409, no duplicate row"
+  },
+  step_completed: {
+    retryable: true,
+    reason: "terminal-state guard → 409, no duplicate row"
+  },
+  step_failed: {
+    retryable: true,
+    reason: "terminal-state guard → 409, no duplicate row"
+  },
+  wait_completed: {
+    retryable: true,
+    reason: "waiting-state guard → 409, no duplicate row"
+  },
+  hook_disposed: {
+    retryable: true,
+    reason: "conditional delete (exists) → 409, no duplicate row"
+  },
+  // NOT safe to retry — see the module comment.
+  step_started: {
+    retryable: false,
+    reason: "unconditional attempt increment → a retry double-counts attempts"
+  },
+  step_retrying: {
+    retryable: false,
+    reason: "no duplicate guard → a retry appends a second event row"
+  },
+  hook_received: {
+    retryable: false,
+    reason: "no server guard → a retry duplicates the row / re-delivers payload"
+  },
+  // Server-originated; the SDK never POSTs it.
+  hook_conflict: {
+    retryable: false,
+    reason: "server-originated; never POSTed by the SDK"
+  }
+};
+const MAX_EVENT_POST_RETRIES = 2;
+const EVENT_POST_RETRY_BASE_MS = 100;
+const EVENT_POST_RETRY_JITTER_MS = 50;
+const TRANSIENT_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "ENETDOWN",
+  "ENETUNREACH",
+  "EHOSTDOWN",
+  "EHOSTUNREACH",
+  "EPIPE",
+  "ETIMEDOUT",
+  "UND_ERR_SOCKET",
+  "UND_ERR_REQ_RETRY",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  // Names (undici/Node surface these on the error or its cause).
+  // `TimeoutError` is our own per-request deadline (`AbortSignal.timeout` in
+  // makeRequest) — a genuinely ambiguous failure worth retrying. We deliberately
+  // do NOT include `AbortError`: that is how an external/caller-supplied
+  // cancellation surfaces (makeRequest composes the caller's signal via
+  // `AbortSignal.any`), and re-issuing a write the caller asked to cancel —
+  // stalling the abort by the full backoff budget — would be wrong.
+  "TimeoutError",
+  "RequestRetryError"
+]);
+function collectErrorMarkers(err, depth = 0) {
+  if (depth > 5 || err === null || typeof err !== "object")
+    return [];
+  const markers2 = [];
+  const e = err;
+  if (typeof e.code === "string")
+    markers2.push(e.code);
+  if (typeof e.name === "string")
+    markers2.push(e.name);
+  if (e.cause)
+    markers2.push(...collectErrorMarkers(e.cause, depth + 1));
+  return markers2;
+}
+function isRetryableEventPostError(err) {
+  if (EntityConflictError.is(err) || RunExpiredError.is(err) || TooEarlyError.is(err) || ThrottleError.is(err)) {
+    return false;
+  }
+  if (WorkflowWorldError.is(err)) {
+    if (err.code === "PARSE_ERROR")
+      return true;
+    if (typeof err.status === "number") {
+      return err.status >= 500 && err.status <= 599;
+    }
+  }
+  return collectErrorMarkers(err).some((m2) => TRANSIENT_CODES.has(m2));
+}
+const sleep$1 = (ms2) => new Promise((resolve2) => setTimeout(resolve2, ms2));
+const RETRY_DEBUG_ENABLED = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
+function logRetry(message2, fields) {
+  if (!RETRY_DEBUG_ENABLED)
+    return;
+  const suffix = Object.entries(fields).map(([k2, v2]) => `${k2}=${v2}`).join(" ");
+  console.debug(`[workflow:world-vercel:event-retry] ${message2} ${suffix}`);
+}
+function errorMarker(err) {
+  if (WorkflowWorldError.is(err)) {
+    return err.code ?? (err.status != null ? `status_${err.status}` : err.name);
+  }
+  return collectErrorMarkers(err)[0] ?? (err instanceof Error ? err.name : "unknown");
+}
+async function withEventPostRetry(fn2, eventType) {
+  var _a3;
+  const retryable = ((_a3 = EVENT_RETRY_ELIGIBILITY[eventType]) == null ? void 0 : _a3.retryable) ?? false;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await fn2();
+    } catch (err) {
+      const transient = retryable && isRetryableEventPostError(err);
+      if (transient && attempt < MAX_EVENT_POST_RETRIES) {
+        const backoff = EVENT_POST_RETRY_BASE_MS * 2 ** attempt + Math.floor(Math.random() * EVENT_POST_RETRY_JITTER_MS);
+        logRetry("retrying event POST after transient failure", {
+          eventType,
+          attempt: attempt + 1,
+          backoffMs: backoff,
+          error: errorMarker(err)
+        });
+        await sleep$1(backoff);
+        continue;
+      }
+      if (transient) {
+        logRetry("exhausted in-process retries; surfacing for queue redelivery", {
+          eventType,
+          attempts: attempt + 1,
+          error: errorMarker(err)
+        });
+      }
+      throw err;
+    }
+  }
+}
 const V4_FRAME_CONTENT_TYPE = "application/vnd.workflow.v4-frames";
 function encodeFrame(meta2, body2) {
   const metaBytes = new Uint8Array(encode(meta2));
@@ -126419,42 +126841,75 @@ async function* decodeFrames(source) {
     buffer2 = buffer2.subarray(n);
     return out;
   };
-  while (true) {
-    if (!await refill(4))
-      return;
-    const metaLen = new DataView(buffer2.buffer, buffer2.byteOffset, 4).getUint32(0, false);
-    take(4);
-    if (!await refill(metaLen)) {
-      throw new Error("decodeFrames: truncated meta block");
-    }
-    const meta2 = decode(take(metaLen));
-    if (!await refill(4)) {
-      throw new Error("decodeFrames: truncated body length");
-    }
-    const bodyLen = new DataView(buffer2.buffer, buffer2.byteOffset, 4).getUint32(0, false);
-    take(4);
-    if (bodyLen > 0) {
-      if (!await refill(bodyLen)) {
+  try {
+    while (true) {
+      if (!await refill(4))
+        return;
+      const metaLen = new DataView(buffer2.buffer, buffer2.byteOffset, 4).getUint32(0, false);
+      take(4);
+      if (!await refill(metaLen)) {
+        throw new Error("decodeFrames: truncated meta block");
+      }
+      const meta2 = decode(take(metaLen));
+      if (!await refill(4)) {
+        throw new Error("decodeFrames: truncated body length");
+      }
+      const bodyLen = new DataView(buffer2.buffer, buffer2.byteOffset, 4).getUint32(0, false);
+      take(4);
+      if (bodyLen > 0 && !await refill(bodyLen)) {
         throw new Error("decodeFrames: truncated body bytes");
       }
       yield { meta: meta2, body: buffer2.slice(0, bodyLen) };
       take(bodyLen);
-    } else {
-      yield { meta: meta2, body: new Uint8Array(0) };
+      if (meta2._end === 1)
+        return;
     }
-    if (meta2._end === 1)
-      return;
+  } finally {
+    closeQuietly(() => {
+      var _a3;
+      return (_a3 = chunks.return) == null ? void 0 : _a3.call(chunks);
+    });
+  }
+}
+function closeQuietly(close) {
+  try {
+    void Promise.resolve(close()).catch(() => {
+    });
+  } catch {
   }
 }
 async function* readerToIterator(reader) {
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done)
-      return;
-    if (value)
-      yield value;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        return;
+      if (value)
+        yield value;
+    }
+  } finally {
+    closeQuietly(() => reader.cancel());
   }
 }
+async function fetchV4(url2, init2, config2, opName) {
+  return instrumentedFetch({
+    method: init2.method,
+    url: url2,
+    headers: init2.headers,
+    body: init2.body,
+    dispatcher: getEventsDispatcher(config2),
+    timeoutMs: null,
+    logLabel: opName,
+    buildError: async (response2) => errorFromV4Response(response2.status, headersToRecord(response2.headers), await response2.text(), opName, url2)
+  });
+}
+function headersToRecord(headers2) {
+  const out = {};
+  headers2.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}
 const V4_RESPONSE_HEADERS = {
   eventId: "x-wf-event-id",
   runId: "x-wf-run-id",
@@ -126500,9 +126955,12 @@ function buildPostFrameMeta(input) {
   if (input.executionContext !== void 0) {
     meta2.executionContext = input.executionContext;
   }
+  if (input.stateUpdatedAt !== void 0) {
+    meta2.stateUpdatedAt = input.stateUpdatedAt;
+  }
   return meta2;
 }
-function throwForErrorResponse(statusCode, responseHeaders, errorBody, opName, url2) {
+function errorFromV4Response(statusCode, responseHeaders, errorBody, opName, url2) {
   let message2 = `v4 ${opName} failed: HTTP ${statusCode}`;
   let code2;
   try {
@@ -126515,35 +126973,12 @@ function throwForErrorResponse(statusCode, responseHeaders, errorBody, opName, u
     if (errorBody)
       message2 += ` ${errorBody}`;
   }
-  let retryAfter;
-  const retryAfterHeader = readHeader(responseHeaders, "retry-after");
-  if (retryAfterHeader) {
-    const parsed = parseInt(retryAfterHeader, 10);
-    if (!Number.isNaN(parsed))
-      retryAfter = parsed;
-  }
-  if (statusCode === 409)
-    throw new EntityConflictError(message2);
-  if (statusCode === 410)
-    throw new RunExpiredError(message2);
-  if (statusCode === 425)
-    throw new TooEarlyError(message2, { retryAfter });
-  if (statusCode === 429) {
-    if (readHeader(responseHeaders, "x-vercel-mitigated") === "challenge") {
-      throw new WorkflowWorldError(`${message2} (x-vercel-mitigated=challenge)`, {
-        status: statusCode,
-        code: "TRANSPORT",
-        url: url2,
-        retryAfter
-      });
-    }
-    throw new ThrottleError(message2, { retryAfter });
-  }
-  throw new WorkflowWorldError(message2, {
-    status: statusCode,
+  const retryAfter = parseRetryAfter(readHeader(responseHeaders, "retry-after"));
+  return errorForResponse(statusCode, message2, {
+    retryAfter,
     code: code2,
     url: url2,
-    retryAfter
+    mitigated: readHeader(responseHeaders, "x-vercel-mitigated")
   });
 }
 async function createWorkflowRunEventV4(input, config2) {
@@ -126552,26 +126987,14 @@ async function createWorkflowRunEventV4(input, config2) {
   headers2.set("Content-Type", "application/octet-stream");
   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 undiciExports.request(url2, {
-    method: "POST",
-    headers: Object.fromEntries(headers2.entries()),
-    body: frame2,
-    // getDispatcher() is typed `unknown` (undici's Dispatcher type is
-    // version-specific across @types/node majors); cast to the undici
-    // Dispatcher this module's own `request` expects.
-    dispatcher: getDispatcher(config2)
-  });
-  if (response2.statusCode < 200 || response2.statusCode >= 300) {
-    const errorBody = await response2.body.text();
-    throwForErrorResponse(response2.statusCode, response2.headers, errorBody, "createEvent", url2);
-  }
-  const eventId = response2.headers[V4_RESPONSE_HEADERS.eventId];
-  const runId = response2.headers[V4_RESPONSE_HEADERS.runId];
-  const createdAt = response2.headers[V4_RESPONSE_HEADERS.createdAt];
+  const response2 = await fetchV4(url2, { method: "POST", headers: headers2, body: frame2 }, config2, "createEvent");
+  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");
   }
-  const bodyBytes = new Uint8Array(await response2.body.arrayBuffer());
+  const bodyBytes = new Uint8Array(await response2.arrayBuffer());
   const body2 = bodyBytes.byteLength > 0 ? decode(bodyBytes) : {};
   return { eventId, runId, createdAt, body: body2 };
 }
@@ -126586,19 +127009,8 @@ function readHeader(responseHeaders, name2) {
 async function getEventV4(runId, eventId, config2) {
   const { baseUrl, headers: headers2 } = await getHttpConfig(config2);
   const url2 = `${baseUrl}/v4/runs/${encodeURIComponent(runId)}/events/${encodeURIComponent(eventId)}`;
-  const response2 = await undiciExports.request(url2, {
-    method: "GET",
-    headers: Object.fromEntries(headers2.entries()),
-    // getDispatcher() is typed `unknown` (undici's Dispatcher type is
-    // version-specific across @types/node majors); cast to the undici
-    // Dispatcher this module's own `request` expects.
-    dispatcher: getDispatcher(config2)
-  });
-  if (response2.statusCode < 200 || response2.statusCode >= 300) {
-    const errorBody = await response2.body.text();
-    throwForErrorResponse(response2.statusCode, response2.headers, errorBody, "getEvent", url2);
-  }
-  const contentType = readHeader(response2.headers, "content-type");
+  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))) {
     throw new Error(`v4 getEvent: expected ${V4_FRAME_CONTENT_TYPE}, got ${contentType ?? "(none)"}`);
   }
@@ -126609,19 +127021,8 @@ async function getEventV4(runId, eventId, config2) {
   throw new Error(`v4 getEvent: empty frame stream for ${eventId}`);
 }
 async function consumeListFrameStream(url2, headers2, config2, opName) {
-  const response2 = await undiciExports.request(url2, {
-    method: "GET",
-    headers: Object.fromEntries(headers2.entries()),
-    // getDispatcher() is typed `unknown` (undici's Dispatcher type is
-    // version-specific across @types/node majors); cast to the undici
-    // Dispatcher this module's own `request` expects.
-    dispatcher: getDispatcher(config2)
-  });
-  if (response2.statusCode < 200 || response2.statusCode >= 300) {
-    const errorBody = await response2.body.text();
-    throwForErrorResponse(response2.statusCode, response2.headers, errorBody, opName, url2);
-  }
-  const contentType = readHeader(response2.headers, "content-type");
+  const response2 = await fetchV4(url2, { method: "GET", headers: headers2 }, config2, opName);
+  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)"}`);
   }
@@ -127066,7 +127467,7 @@ async function getWorkflowRunEvents(params, config2) {
 }
 async function createWorkflowRunEvent(id2, data, params, config2) {
   try {
-    return await createWorkflowRunEventInner(id2, data, params, config2);
+    return await withEventPostRetry(() => createWorkflowRunEventInner(id2, data, params, config2), data.eventType);
   } catch (err) {
     if (hookEventsRequiringExistence.has(data.eventType) && WorkflowWorldError.is(err) && err.status === 404 && data.correlationId) {
       throw new HookNotFoundError(data.correlationId);
@@ -127113,6 +127514,7 @@ async function createWorkflowRunEventInner(id2, data, params, config2) {
     specVersion: data.specVersion ?? 2,
     ...data.correlationId ? { correlationId: data.correlationId } : {},
     ...(params == null ? void 0 : params.requestId) ? { vercelId: params.requestId } : {},
+    ...(params == null ? void 0 : params.stateUpdatedAt) !== void 0 ? { stateUpdatedAt: params.stateUpdatedAt } : {},
     occurredAt: (params == null ? void 0 : params.occurredAt) ?? /* @__PURE__ */ new Date(),
     remoteRefBehavior,
     payload,
@@ -127128,7 +127530,9 @@ async function createWorkflowRunEventInner(id2, data, params, config2) {
     wait: body2.wait,
     events: body2.events ? body2.events.map(coerceEventDates) : void 0,
     cursor: body2.cursor ?? void 0,
-    hasMore: body2.hasMore
+    hasMore: body2.hasMore,
+    // Server-supplied per-run event ceiling; absent from older servers.
+    ...typeof body2.maxEvents === "number" ? { maxEvents: body2.maxEvents } : {}
   };
 }
 function filterHookData(hook, resolveData) {
@@ -127242,30 +127646,28 @@ function getStreamMutationTimeoutMs() {
   }
   return DEFAULT_STREAM_MUTATION_TIMEOUT_MS;
 }
-async function fetchStreamMutation(url2, init2, operation) {
-  const timeoutMs = getStreamMutationTimeoutMs();
-  try {
-    return await fetch(url2, {
-      ...init2,
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-  } catch (err) {
-    if (err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError")) {
-      throw new Error(`Stream ${operation} timed out after ${timeoutMs}ms`, {
-        cause: err
-      });
-    }
-    throw err;
-  }
+async function fetchStreamMutation(url2, init2, operation, config2) {
+  const response2 = await instrumentedFetch({
+    method: init2.method,
+    url: url2.toString(),
+    headers: init2.headers,
+    body: init2.body,
+    // Stream mutations go through the dedicated H2 stream dispatchers rather
+    // than the global agent — see the note at the top of this file. Close is
+    // idempotent (unlike chunk appends), so it gets the dispatcher that
+    // retries 5xx, which the server's close-barrier protocol depends on.
+    dispatcher: operation === "close" ? getStreamCloseDispatcher(config2) : getStreamDispatcher(config2),
+    timeoutMs: getStreamMutationTimeoutMs(),
+    logLabel: url2.pathname,
+    buildError: async (res) => createStreamRequestError(operation, url2, res, await res.text())
+  });
+  await response2.text();
 }
 function createStreamRequestError(operation, url2, response2, text2) {
-  const context = [`PUT ${url2.origin}${url2.pathname}`];
-  for (const header of ["x-vercel-id", "x-vercel-error"]) {
-    const value = response2.headers.get(header);
-    if (value) {
-      context.push(`${header}=${value}`);
-    }
-  }
+  const context = [
+    `PUT ${url2.origin}${url2.pathname}`,
+    ...getVercelDiagnostics(response2.headers)
+  ];
   return new Error(`Stream ${operation} failed: HTTP ${response2.status} (${context.join("; ")}): ${text2}`);
 }
 function encodeMultiChunks(chunks) {
@@ -127307,15 +127709,11 @@ function createStreamer(config2) {
       const resolvedRunId = await runId;
       const httpConfig = await getHttpConfig(config2);
       const url2 = getStreamUrl(name2, resolvedRunId, httpConfig);
-      const response2 = await fetchStreamMutation(url2, {
+      await fetchStreamMutation(url2, {
         method: "PUT",
         body: chunk,
         headers: httpConfig.headers
-      }, "write");
-      const text2 = await response2.text();
-      if (!response2.ok) {
-        throw createStreamRequestError("write", url2, response2, text2);
-      }
+      }, "write", config2);
     },
     async writeToStreamMulti(name2, runId, chunks) {
       if (chunks.length === 0)
@@ -127327,15 +127725,11 @@ function createStreamer(config2) {
         const batch = chunks.slice(i, i + MAX_CHUNKS_PER_REQUEST);
         const body2 = encodeMultiChunks(batch);
         const url2 = getStreamUrl(name2, resolvedRunId, httpConfig);
-        const response2 = await fetchStreamMutation(url2, {
+        await fetchStreamMutation(url2, {
           method: "PUT",
           body: body2,
           headers: httpConfig.headers
-        }, "write");
-        const text2 = await response2.text();
-        if (!response2.ok) {
-          throw createStreamRequestError("write", url2, response2, text2);
-        }
+        }, "write", config2);
       }
     },
     async closeStream(name2, runId) {
@@ -127343,14 +127737,10 @@ function createStreamer(config2) {
       const httpConfig = await getHttpConfig(config2);
       httpConfig.headers.set("X-Stream-Done", "true");
       const url2 = getStreamUrl(name2, resolvedRunId, httpConfig);
-      const response2 = await fetchStreamMutation(url2, {
+      await fetchStreamMutation(url2, {
         method: "PUT",
         headers: httpConfig.headers
-      }, "close");
-      const text2 = await response2.text();
-      if (!response2.ok) {
-        throw createStreamRequestError("close", url2, response2, text2);
-      }
+      }, "close", config2);
     },
     async readFromStream(name2, startIndex) {
       const httpConfig = await getHttpConfig(config2);
@@ -127359,13 +127749,16 @@ function createStreamer(config2) {
         url2.searchParams.set("startIndex", String(startIndex));
       }
       const abortController = new AbortController();
-      const response2 = await fetch(url2, {
+      const response2 = await instrumentedFetch({
+        method: "GET",
+        url: url2.toString(),
         headers: httpConfig.headers,
-        signal: abortController.signal
+        dispatcher: void 0,
+        timeoutMs: null,
+        signal: abortController.signal,
+        logLabel: url2.pathname,
+        buildError: (res) => new Error(`Failed to fetch stream: ${res.status}`)
       });
-      if (!response2.ok) {
-        throw new Error(`Failed to fetch stream: ${response2.status}`);
-      }
       if (!response2.body) {
         throw new Error("No response body for stream");
       }
@@ -127421,12 +127814,15 @@ function createStreamer(config2) {
     async listStreamsByRunId(runId) {
       const httpConfig = await getHttpConfig(config2);
       const url2 = new URL(`${httpConfig.baseUrl}/v2/runs/${encodeURIComponent(runId)}/streams`);
-      const response2 = await fetch(url2, {
-        headers: httpConfig.headers
+      const response2 = await instrumentedFetch({
+        method: "GET",
+        url: url2.toString(),
+        headers: httpConfig.headers,
+        dispatcher: void 0,
+        timeoutMs: null,
+        logLabel: url2.pathname,
+        buildError: (res) => new Error(`Failed to list streams: ${res.status}`)
       });
-      if (!response2.ok) {
-        throw new Error(`Failed to list streams: ${response2.status}`);
-      }
       return await response2.json();
     }
   };
@@ -131953,7 +132349,7 @@ function getRunCapabilities(workflowCoreVersion) {
   return result;
 }
 function waitUntil(promise2) {
-  void import("./index-B8YoYr9f.js").then((n) => n.i).then(({ waitUntil: waitUntil2 }) => {
+  void import("./index-CMfOrLiJ.js").then((n) => n.i).then(({ waitUntil: waitUntil2 }) => {
     waitUntil2(promise2);
   });
 }