@workflow/web 5.0.0-beta.25 → 5.0.0-beta.26

package/build/server/assets/{server-build-D7EgG_DH.js → server-build-0CazaFkH.js}

@@ -18,7 +18,7 @@ import { createRequire as __wkfCreateRequire } from "node:module";
 if (typeof 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-e2FYIgWU.js";
+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-DQ35jFT1.js";
 import require$$0$4, { PassThrough } from "node:stream";
 import require$$0 from "util";
 import require$$1 from "crypto";
@@ -49912,7 +49912,7 @@ function replaceEncryptedAndExpiredWithMarkers(resource) {
 async function hydrateResourceIOWithKey(resource, key) {
   const { hydrateDataWithKey: hydrateDataWithKey2 } = await Promise.resolve().then(() => serializationFormat);
   const { importKey: importKey2 } = await Promise.resolve().then(() => encryption);
-  const { ensureZstdDecoderRegistered } = await import("./zstd-browser-decoder-CcinVfMP.js");
+  const { ensureZstdDecoderRegistered } = await import("./zstd-browser-decoder-pCjqxVHM.js");
   ensureZstdDecoderRegistered();
   const cryptoKey = await importKey2(key);
   const revivers = getRevivers();
@@ -82803,7 +82803,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-B7xcG7gl.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-DUlvgLoF.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 }) })] }) });
@@ -83125,7 +83125,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-DQqBhQ9Y.js").then((e) => ({ default: e.Mermaid }))), Kn = /language-([^\s]+)/;
+var Jn = reactExports.lazy(() => import("./mermaid-3ZIDBTTL-BdnRYE9a.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;
@@ -90698,6 +90698,19 @@ if (typeof globalThis !== "undefined") {
     });
   }
 }
+const RETRYABLE_WORLD_ERROR_CODES = /* @__PURE__ */ new Set(["TRANSPORT", "TIMEOUT"]);
+function isRetryableWorldError(err) {
+  if (ThrottleError.is(err)) {
+    return true;
+  }
+  if (!WorkflowWorldError.is(err)) {
+    return false;
+  }
+  if (err.status !== void 0 && err.status >= 500) {
+    return true;
+  }
+  return err.code !== void 0 && RETRYABLE_WORLD_ERROR_CODES.has(err.code);
+}
 const colorEnabled = (() => {
   var _a3;
   const p2 = globalThis.process;
@@ -91238,7 +91251,7 @@ const encryption = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   encrypt: encrypt$1,
   importKey
 }, Symbol.toStringTag, { value: "Module" }));
-const version$1 = "5.0.0-beta.25";
+const version$1 = "5.0.0-beta.26";
 const WorldCacheKey = Symbol.for("@workflow/world//cache");
 const WorldCachePromiseKey = Symbol.for("@workflow/world//cachePromise");
 const GetWorldFnKey$1 = Symbol.for("@workflow/world//getWorldFn");
@@ -122224,7 +122237,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-BELZxbAO.js");
+        const { HookSchema: HookSchema2 } = await import("./index-BgRt1-Z6.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) {
@@ -122259,6 +122272,67 @@ function createLocalWorld(args) {
     }
   };
 }
+let _dispatcher;
+let _eventsDispatcher;
+let _streamDispatcher;
+const BASE_AGENT_OPTIONS = {
+  connections: 8,
+  keepAliveTimeout: 1e4,
+  // HTTP/1.1 pipelining is disabled (pipelining: 1) because it causes
+  // head-of-line blocking that deadlocks the webhook respondWith mechanism.
+  pipelining: 1
+};
+const DEFAULT_AGENT_OPTIONS = {
+  ...BASE_AGENT_OPTIONS,
+  allowH2: false
+};
+const EVENTS_AGENT_OPTIONS = {
+  ...BASE_AGENT_OPTIONS,
+  allowH2: true
+};
+const RETRY_AGENT_OPTIONS = {
+  // 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. This is the long-standing "let 429s pass
+  // through" intent. (undici default is [500, 502, 503, 504, 429].)
+  statusCodes: [500, 502, 503, 504]
+};
+const STREAM_RETRY_OPTIONS = {
+  retryAfter: true,
+  methods: ["PUT"],
+  statusCodes: [429]
+};
+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 makeRetryDispatcher(agentOptions, retryOptions) {
+  return new undiciExports.RetryAgent(new undiciExports.Agent(agentOptions), retryOptions);
+}
+function getDefaultDispatcher() {
+  _dispatcher ?? (_dispatcher = makeRetryDispatcher(DEFAULT_AGENT_OPTIONS, RETRY_AGENT_OPTIONS));
+  return _dispatcher;
+}
+function getDefaultEventsDispatcher() {
+  _eventsDispatcher ?? (_eventsDispatcher = makeRetryDispatcher(EVENTS_AGENT_OPTIONS, RETRY_AGENT_OPTIONS));
+  return _eventsDispatcher;
+}
+function getDefaultStreamDispatcher() {
+  _streamDispatcher ?? (_streamDispatcher = makeRetryDispatcher(EVENTS_AGENT_OPTIONS, STREAM_RETRY_OPTIONS));
+  return _streamDispatcher;
+}
 var getContext_1;
 var hasRequiredGetContext;
 function requireGetContext() {
@@ -122377,8 +122451,8 @@ function requireGetVercelOidcToken() {
     }
     try {
       const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
-        await import("./token-util-CCeU4-vR.js").then((n) => n.t),
-        await import("./token-guLCf66r.js").then((n) => n.t)
+        await import("./token-util-CaJAmsYa.js").then((n) => n.t),
+        await import("./token-DK_R23fr.js").then((n) => n.t)
       ]);
       if (!token || isExpired(getTokenPayload(token), options == null ? void 0 : options.expirationBufferMs)) {
         await refreshToken(options);
@@ -122941,63 +123015,218 @@ function requireDist() {
   return dist;
 }
 var distExports = requireDist();
-let _dispatcher;
-let _eventsDispatcher;
-let _streamDispatcher;
-const BASE_AGENT_OPTIONS = {
-  connections: 8,
-  keepAliveTimeout: 1e4,
-  // HTTP/1.1 pipelining is disabled (pipelining: 1) because it causes
-  // head-of-line blocking that deadlocks the webhook respondWith mechanism.
-  pipelining: 1
-};
-const DEFAULT_AGENT_OPTIONS = {
-  ...BASE_AGENT_OPTIONS,
-  allowH2: false
-};
-const EVENTS_AGENT_OPTIONS = {
-  ...BASE_AGENT_OPTIONS,
-  allowH2: true
-};
-const RETRY_AGENT_OPTIONS = {
-  // Observe Retry-After header if received
-  retryAfter: true
-  // By default, we observe re-try headers, and also separately
-  // re-try on these status codes: 429 / 500 / 502 / 503 / 504.
-  // TODO: We might want to let 429s pass through, so that we can do
-  // runtime retry-after handling through the queue.
-};
-const STREAM_RETRY_OPTIONS = {
-  retryAfter: true,
-  methods: ["PUT"],
-  statusCodes: [429]
-};
-function getDispatcher(config2) {
-  return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultDispatcher();
+let otelApiPromise = null;
+async function getOtelApi() {
+  if (!otelApiPromise) {
+    otelApiPromise = import("./index-Dq5jTBN4.js").catch(() => null);
+  }
+  return otelApiPromise;
 }
-function getEventsDispatcher(config2) {
-  return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultEventsDispatcher();
+let tracerPromise = null;
+async function getTracer() {
+  if (!tracerPromise) {
+    tracerPromise = getOtelApi().then((otel) => otel ? otel.trace.getTracer("workflow") : null);
+  }
+  return tracerPromise;
 }
-function getStreamDispatcher(config2) {
-  return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultStreamDispatcher();
+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();
+    }
+  });
 }
-function getDefaultDispatcher() {
-  if (!_dispatcher) {
-    _dispatcher = new undiciExports.RetryAgent(new undiciExports.Agent(DEFAULT_AGENT_OPTIONS), RETRY_AGENT_OPTIONS);
+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);
   }
-  return _dispatcher;
 }
-function getDefaultEventsDispatcher() {
-  if (!_eventsDispatcher) {
-    _eventsDispatcher = new undiciExports.RetryAgent(new undiciExports.Agent(EVENTS_AGENT_OPTIONS), RETRY_AGENT_OPTIONS);
+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 === 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 _eventsDispatcher;
+  return new WorkflowWorldError(message2, { url: url2, status, code: code2, retryAfter });
 }
-function getDefaultStreamDispatcher() {
-  if (!_streamDispatcher) {
-    _streamDispatcher = new undiciExports.RetryAgent(new undiciExports.Agent(EVENTS_AGENT_OPTIONS), STREAM_RETRY_OPTIONS);
+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 {};
   }
-  return _streamDispatcher;
+}
+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, _c2;
+    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"))
+      });
+      (_c2 = span == null ? void 0 : span.recordException) == null ? void 0 : _c2.call(span, error2);
+      throw error2;
+    }
+    return response2;
+  });
 }
 const KEY_BYTES = 32;
 async function deriveRunKey(deploymentKey, projectId, runId) {
@@ -123023,7 +123252,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");
   }
@@ -123031,23 +123260,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) {
@@ -123092,76 +123323,6 @@ function createGetEncryptionKeyForRun(projectId, teamId, token, dispatcher2) {
     });
   };
 }
-let otelApiPromise = null;
-async function getOtelApi() {
-  if (!otelApiPromise) {
-    otelApiPromise = import("./index-Dq5jTBN4.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];
-}
-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 WORKFLOW_SERVER_SERVICE = {
   peerService: "workflow-server",
   rpcSystem: "http",
@@ -127758,29 +127919,37 @@ var QueueClient = class {
     setApi(this, new ApiClient({ ...options, region }));
   }
 };
-const version = "5.0.0-beta.21";
-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"].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 = "5.0.0-beta.22";
 const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
 const MAX_BODY_PARSE_RETRIES = 2;
 const BODY_PARSE_RETRY_BASE_MS = 100;
+const TRANSIENT_TRANSPORT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "UND_ERR_REQ_RETRY",
+  "UND_ERR_SOCKET",
+  "UND_ERR_CONNECT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CLOSED",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EPIPE"
+]);
+function getTransientTransportCode(error2) {
+  let current = error2;
+  for (let depth = 0; current != null && depth < 5; depth++) {
+    if (typeof current === "object" && "code" in current) {
+      const code2 = current.code;
+      if (typeof code2 === "string" && TRANSIENT_TRANSPORT_ERROR_CODES.has(code2)) {
+        return code2;
+      }
+    }
+    current = current == null ? void 0 : current.cause;
+  }
+  return void 0;
+}
 const getWorkflowServerUrlOverride = () => process.env.VERCEL_WORKFLOW_SERVER_URL || "";
 const DEFAULT_RESOLVE_DATA_OPTION = "all";
 function deserializeError(obj) {
@@ -127849,26 +128018,13 @@ 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;
-    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, _c2;
+    span == null ? void 0 : span.setAttributes(httpClientSpanAttributes({
+      method,
+      url: url2,
+      peerService: "workflow-server"
+    }));
     headers2.set("Accept", "application/cbor");
     await injectTraceContextIntoHeaders(headers2);
     let body2;
@@ -127898,61 +128054,42 @@ async function makeRequest({ endpoint, options = {}, config: config2 = {}, schem
       } catch (error2) {
         const elapsed = Date.now() - fetchStart;
         if (error2 instanceof Error && (error2.name === "TimeoutError" || error2.name === "AbortError")) {
-          const timeoutError = new WorkflowWorldError(`${method} ${endpoint} timed out after ${elapsed}ms`, { url: url2, cause: error2 });
+          const timeoutError = new WorkflowWorldError(`${method} ${endpoint} timed out after ${elapsed}ms`, { url: url2, code: "TIMEOUT", 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;
         }
+        const transportCode = getTransientTransportCode(error2);
+        if (transportCode) {
+          const transportError = new WorkflowWorldError(`${method} ${endpoint} transport failure after ${elapsed}ms (${transportCode})`, { url: url2, code: "TRANSPORT", cause: error2 });
+          span == null ? void 0 : span.setAttributes({ ...ErrorType("TRANSPORT") });
+          (_b2 = span == null ? void 0 : span.recordException) == null ? void 0 : _b2.call(span, transportError);
+          throw transportError;
+        }
         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) {
-          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}`)
+        });
+        (_c2 = span == null ? void 0 : span.recordException) == null ? void 0 : _c2.call(span, error2);
+        throw error2;
       }
       onResponse == null ? void 0 : onResponse(response2);
       try {
@@ -128101,7 +128238,7 @@ const MAX_DELAY_SECONDS = Number(
   // 23 hours - leave 1h buffer before 24h retention limit
 );
 const HANDLER_ERROR_RETRY_AFTER_SECONDS = 1;
-const HANDLER_ERROR_MAX_RETRY_AFTER_SECONDS = 60;
+const HANDLER_ERROR_MAX_RETRY_AFTER_SECONDS = 900;
 const HANDLER_ERROR_RETRY_JITTER_RATIO = 0.25;
 function getHandlerErrorRetryAfterSeconds(deliveryCount) {
   const backoffSeconds = Math.min(Math.max(HANDLER_ERROR_RETRY_AFTER_SECONDS, 2 ** (deliveryCount - 1)), HANDLER_ERROR_MAX_RETRY_AFTER_SECONDS);
@@ -128235,28 +128372,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) {
@@ -128265,6 +128404,181 @@ 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"
+  },
+  // True idempotency via a correlationId constraint that reuses the eventId.
+  attr_set: {
+    retryable: true,
+    reason: "correlationId constraint reuses eventId (idempotent replay)"
+  },
+  // 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));
@@ -128334,15 +128648,16 @@ async function* readerToIterator(reader) {
       yield value;
   }
 }
-async function fetchV4(url2, init2, config2) {
-  init2.headers.set("X-Request-Time", Date.now().toString());
-  await injectTraceContextIntoHeaders(init2.headers);
-  return fetch(url2, {
+async function fetchV4(url2, init2, config2, opName) {
+  return instrumentedFetch({
     method: init2.method,
+    url: url2,
     headers: init2.headers,
     body: init2.body,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- undici dispatcher type doesn't match @types/node's RequestInit
-    dispatcher: getEventsDispatcher(config2)
+    dispatcher: getEventsDispatcher(config2),
+    timeoutMs: null,
+    logLabel: opName,
+    buildError: async (response2) => errorFromV4Response(response2.status, headersToRecord(response2.headers), await response2.text(), opName, url2)
   });
 }
 function headersToRecord(headers2) {
@@ -128409,7 +128724,7 @@ function buildPostFrameMeta(input) {
     meta2.skipPreload = input.skipPreload;
   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 {
@@ -128422,26 +128737,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)
-    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) {
@@ -128450,11 +128751,7 @@ 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 fetchV4(url2, { method: "POST", headers: headers2, body: frame2 }, config2);
-  if (!response2.ok) {
-    const errorBody = await response2.text();
-    throwForErrorResponse(response2.status, headersToRecord(response2.headers), errorBody, "createEvent", url2);
-  }
+  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);
@@ -128476,11 +128773,7 @@ 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 fetchV4(url2, { method: "GET", headers: headers2 }, config2);
-  if (!response2.ok) {
-    const errorBody = await response2.text();
-    throwForErrorResponse(response2.status, headersToRecord(response2.headers), errorBody, "getEvent", url2);
-  }
+  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)"}`);
@@ -128492,11 +128785,7 @@ 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 fetchV4(url2, { method: "GET", headers: headers2 }, config2);
-  if (!response2.ok) {
-    const errorBody = await response2.text();
-    throwForErrorResponse(response2.status, headersToRecord(response2.headers), errorBody, opName, url2);
-  }
+  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)"}`);
@@ -128937,7 +129226,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);
@@ -129123,13 +129412,10 @@ function getStreamReadUrl(name2, runId, httpConfig) {
   return new URL(`${httpConfig.baseUrl}/v3/runs/${encodeURIComponent(runId)}/stream/${encodeURIComponent(name2)}`);
 }
 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) {
@@ -129172,17 +129458,17 @@ function createStreamer(config2) {
         const resolvedRunId = await runId;
         const httpConfig = await getHttpConfig(config2);
         const url2 = getStreamUrl(name2, resolvedRunId, httpConfig);
-        const response2 = await fetch(url2, {
+        const response2 = await instrumentedFetch({
           method: "PUT",
+          url: url2.toString(),
           body: chunk,
           headers: httpConfig.headers,
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any -- undici dispatcher type doesn't match @types/node's RequestInit
-          dispatcher: getStreamDispatcher(config2)
+          dispatcher: getStreamDispatcher(config2),
+          timeoutMs: null,
+          logLabel: url2.pathname,
+          buildError: async (res) => createStreamRequestError("write", url2, res, await res.text())
         });
-        const text2 = await response2.text();
-        if (!response2.ok) {
-          throw createStreamRequestError("write", url2, response2, text2);
-        }
+        await response2.text();
       },
       async writeMulti(runId, name2, chunks) {
         if (chunks.length === 0)
@@ -129194,17 +129480,17 @@ 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 fetch(url2, {
+          const response2 = await instrumentedFetch({
             method: "PUT",
+            url: url2.toString(),
             body: body2,
             headers: httpConfig.headers,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- undici dispatcher type doesn't match @types/node's RequestInit
-            dispatcher: getStreamDispatcher(config2)
+            dispatcher: getStreamDispatcher(config2),
+            timeoutMs: null,
+            logLabel: url2.pathname,
+            buildError: async (res) => createStreamRequestError("write", url2, res, await res.text())
           });
-          const text2 = await response2.text();
-          if (!response2.ok) {
-            throw createStreamRequestError("write", url2, response2, text2);
-          }
+          await response2.text();
         }
       },
       async close(runId, name2) {
@@ -129212,16 +129498,16 @@ function createStreamer(config2) {
         const httpConfig = await getHttpConfig(config2);
         httpConfig.headers.set("X-Stream-Done", "true");
         const url2 = getStreamUrl(name2, resolvedRunId, httpConfig);
-        const response2 = await fetch(url2, {
+        const response2 = await instrumentedFetch({
           method: "PUT",
+          url: url2.toString(),
           headers: httpConfig.headers,
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any -- undici dispatcher type doesn't match @types/node's RequestInit
-          dispatcher: getStreamDispatcher(config2)
+          dispatcher: getStreamDispatcher(config2),
+          timeoutMs: null,
+          logLabel: url2.pathname,
+          buildError: async (res) => createStreamRequestError("close", url2, res, await res.text())
         });
-        const text2 = await response2.text();
-        if (!response2.ok) {
-          throw createStreamRequestError("close", url2, response2, text2);
-        }
+        await response2.text();
       },
       async get(runId, name2, startIndex) {
         const httpConfig = await getHttpConfig(config2);
@@ -129229,12 +129515,15 @@ function createStreamer(config2) {
         if (typeof startIndex === "number") {
           url2.searchParams.set("startIndex", String(startIndex));
         }
-        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 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");
         }
@@ -129267,12 +129556,15 @@ function createStreamer(config2) {
       async list(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();
       }
     }
@@ -132361,7 +132653,7 @@ async function start$1(workflow, argsOrOptions, options) {
       if (runCreatedResult.status === "rejected") {
         const err = runCreatedResult.reason;
         if (EntityConflictError.is(err)) ;
-        else if (isRetryableStartError(err)) {
+        else if (isRetryableWorldError(err)) {
           resilientStart = true;
           runtimeLogger.warn("Run creation event failed, but the run was accepted via the queue. The run_created event will be re-tried async by the runtime.", { workflowRunId: runId, error: err.message });
         } else {
@@ -132391,13 +132683,6 @@ async function start$1(workflow, argsOrOptions, options) {
     });
   });
 }
-function isRetryableStartError(err) {
-  if (ThrottleError.is(err))
-    return true;
-  if (WorkflowWorldError.is(err) && err.status && err.status >= 500)
-    return true;
-  return false;
-}
 const normalizeWorkflowArgs = (args) => {
   return Array.isArray(args) ? args : [args];
 };