@workflow/world-testing 5.0.0-beta.24 → 5.0.0-beta.26

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

@@ -350,11 +350,11 @@ var init_dist5 = __esm({
 });
 
 // ../errors/dist/error-codes.js
-var RUN_ERROR_CODES;
+var RUN_ERROR_CODES2;
 var init_error_codes2 = __esm({
   "../errors/dist/error-codes.js"() {
     "use strict";
-    RUN_ERROR_CODES = {
+    RUN_ERROR_CODES2 = {
       /** Error thrown in user workflow or step code */
       USER_ERROR: "USER_ERROR",
       /** Internal runtime error (missing timestamps, runtime invariant failures) */
@@ -398,7 +398,7 @@ function buildFramedDetails2(hint3, slug) {
     out.push({ label: "docs", value: `${BASE_URL2}/${slug}` });
   return out;
 }
-var BASE_URL2, ERROR_SLUGS2, WorkflowError2, WorkflowWorldError2, WorkflowRunFailedError2, WorkflowRunNotCompletedError2, WorkflowRuntimeError2, CorruptedEventLogError, ReplayDivergenceError, RuntimeDecryptionError2, SerializationError2, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRunNotFoundError2, HookConflictError2, HookNotFoundError2, EntityConflictError2, RunExpiredError, TooEarlyError, ThrottleError2, WorkflowRunCancelledError2, RunNotSupportedError, FatalError2, RetryableError2, FATAL_ERROR_KEY2, RETRYABLE_ERROR_KEY2, HOOK_CONFLICT_ERROR_KEY2, RUNTIME_DECRYPTION_ERROR_KEY2;
+var BASE_URL2, ERROR_SLUGS2, WorkflowError2, WorkflowWorldError2, WorkflowRunFailedError2, WorkflowRunNotCompletedError2, WorkflowRuntimeError2, CorruptedEventLogError, ReplayDivergenceError, RuntimeDecryptionError2, SerializationError2, StepNotRegisteredError2, WorkflowNotRegisteredError2, WorkflowRunNotFoundError2, HookConflictError2, HookNotFoundError2, EntityConflictError2, RunExpiredError, TooEarlyError, ThrottleError2, WorkflowRunCancelledError2, RunNotSupportedError, FatalError2, RetryableError2, FATAL_ERROR_KEY2, RETRYABLE_ERROR_KEY2, HOOK_CONFLICT_ERROR_KEY2, RUNTIME_DECRYPTION_ERROR_KEY2;
 var init_dist6 = __esm({
   "../errors/dist/index.js"() {
     "use strict";
@@ -597,7 +597,7 @@ Caused by: ${options.cause.stack}`;
         return isError2(value) && value.name === "SerializationError";
       }
     };
-    StepNotRegisteredError = class extends WorkflowRuntimeError2 {
+    StepNotRegisteredError2 = class extends WorkflowRuntimeError2 {
       static {
         __name(this, "StepNotRegisteredError");
       }
@@ -611,7 +611,7 @@ Caused by: ${options.cause.stack}`;
         return isError2(value) && value.name === "StepNotRegisteredError";
       }
     };
-    WorkflowNotRegisteredError = class extends WorkflowRuntimeError2 {
+    WorkflowNotRegisteredError2 = class extends WorkflowRuntimeError2 {
       static {
         __name(this, "WorkflowNotRegisteredError");
       }
@@ -19204,7 +19204,7 @@ var version4;
 var init_version3 = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version4 = "5.0.0-beta.24";
+    version4 = "5.0.0-beta.26";
   }
 });
 
@@ -19272,7 +19272,7 @@ async function handleHealthCheckMessage(healthCheck3, endpoint, worldSpecVersion
   await world.streams.close(fakeRunId, streamName);
 }
 function eventPaginationContractError(runId, message) {
-  return new WorkflowWorldError2(`Event pagination ${message} for workflow run "${runId}".`, { code: RUN_ERROR_CODES.WORLD_CONTRACT_ERROR });
+  return new WorkflowWorldError2(`Event pagination ${message} for workflow run "${runId}".`, { code: RUN_ERROR_CODES2.WORLD_CONTRACT_ERROR });
 }
 function recordRequestedEventCursor(runId, cursor, requestedCursors) {
   if (!cursor) {
@@ -25537,7 +25537,7 @@ function attachAbortListenerOnce2(signal, streamName, runId, cryptoKey, ops) {
     })());
   }, { once: true });
 }
-function getExternalReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false) {
+function getExternalReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier) {
   return {
     ...getAllBaseReducers2(global2),
     ReadableStream: /* @__PURE__ */ __name((value) => {
@@ -25551,7 +25551,7 @@ function getExternalReducers2(global2 = globalThis, ops, runId, cryptoKey, frame
       const streamId = (global2[STABLE_ULID2] || defaultUlid2)();
       const name = `strm_${streamId}`;
       const type = getStreamType2(value);
-      const writable = new WorkflowServerWritableStream2(runId, name);
+      const writable = new WorkflowServerWritableStream2(runId, name, runReadyBarrier);
       if (type === "bytes") {
         if (framedByteStreams) {
           ops.push(value.pipeThrough(getByteFramingStream2()).pipeTo(writable));
@@ -25559,7 +25559,7 @@ function getExternalReducers2(global2 = globalThis, ops, runId, cryptoKey, frame
           ops.push(value.pipeTo(writable));
         }
       } else {
-        ops.push(value.pipeThrough(getSerializeStream2(getExternalReducers2(global2, ops, runId, cryptoKey, framedByteStreams), cryptoKey)).pipeTo(writable));
+        ops.push(value.pipeThrough(getSerializeStream2(getExternalReducers2(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier), cryptoKey)).pipeTo(writable));
       }
       const s = { name };
       if (type)
@@ -25668,7 +25668,7 @@ function getWorkflowReducers2(global2 = globalThis) {
     }, "AbortSignal")
   };
 }
-function getStepReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false) {
+function getStepReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier) {
   return {
     ...getAllBaseReducers2(global2),
     ReadableStream: /* @__PURE__ */ __name((value) => {
@@ -25687,7 +25687,7 @@ function getStepReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByt
         name = `strm_${streamId}`;
         type = getStreamType2(value);
         framing = type === "bytes" && framedByteStreams ? "framed-v1" : framing;
-        const writable = new WorkflowServerWritableStream2(runId, name);
+        const writable = new WorkflowServerWritableStream2(runId, name, runReadyBarrier);
         if (type === "bytes") {
           if (framing === "framed-v1") {
             ops.push(value.pipeThrough(getByteFramingStream2()).pipeTo(writable));
@@ -25695,7 +25695,7 @@ function getStepReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByt
             ops.push(value.pipeTo(writable));
           }
         } else {
-          ops.push(value.pipeThrough(getSerializeStream2(getStepReducers2(global2, ops, runId, cryptoKey, framedByteStreams), cryptoKey)).pipeTo(writable));
+          ops.push(value.pipeThrough(getSerializeStream2(getStepReducers2(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier), cryptoKey)).pipeTo(writable));
         }
       }
       const s = { name };
@@ -26304,16 +26304,16 @@ async function hydrateStepArguments2(value, runId, key, ops = [], global2 = glob
   await recordCompression2(compressionStats, "deserialize");
   return result;
 }
-async function dehydrateStepReturnValue2(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false) {
+async function dehydrateStepReturnValue2(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false, runReadyBarrier) {
   if (v1Compat) {
-    const str = stringify2(value, getStepReducers2(global2, ops, runId, key, framedByteStreams));
+    const str = stringify2(value, getStepReducers2(global2, ops, runId, key, framedByteStreams, runReadyBarrier));
     return revive2(str);
   }
   try {
     const compressionStats = {};
     const result = await serialize3(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers2(getStepReducers2(global2, ops, runId, key, framedByteStreams)),
+      extraReducers: getStreamAndRequestReducers2(getStepReducers2(global2, ops, runId, key, framedByteStreams, runReadyBarrier)),
       compression,
       compressionStats
     });
@@ -26514,7 +26514,16 @@ var init_serialization4 = __esm({
       static {
         __name(this, "WorkflowServerWritableStream");
       }
-      constructor(runId, name) {
+      /**
+       * @param runReadyBarrier Turbo mode only: a promise that resolves once the
+       * backgrounded `run_started` has landed. When the step body runs
+       * optimistically (before `run_started` is durable), the first chunk write to
+       * a brand-new stream would otherwise reach the World before the run exists
+       * and be rejected as run-not-found. Awaiting this once before the first
+       * flush/close orders the write after the run's creation. `undefined` outside
+       * turbo and on the await path, where the run was already durable.
+       */
+      constructor(runId, name, runReadyBarrier) {
         if (typeof runId !== "string") {
           throw new WorkflowRuntimeError2(`"runId" must be a string, got "${typeof runId}"`);
         }
@@ -26522,6 +26531,16 @@ var init_serialization4 = __esm({
           throw new WorkflowRuntimeError2(`"name" is required, got "${name}"`);
         }
         const worldPromise = getWorldLazy2();
+        let pendingRunReady = runReadyBarrier;
+        const ensureRunReady = /* @__PURE__ */ __name(async () => {
+          if (pendingRunReady) {
+            try {
+              await pendingRunReady;
+            } catch {
+            }
+            pendingRunReady = void 0;
+          }
+        }, "ensureRunReady");
         let buffer3 = [];
         let flushTimer = null;
         let flushPromise = null;
@@ -26533,6 +26552,7 @@ var init_serialization4 = __esm({
           }
           if (buffer3.length === 0)
             return;
+          await ensureRunReady();
           const chunksToFlush = buffer3.slice();
           const world = await worldPromise;
           if (resolvedFlushIntervalMs === void 0) {
@@ -26582,6 +26602,7 @@ var init_serialization4 = __esm({
               flushPromise = null;
             }
             await flush();
+            await ensureRunReady();
             const world = await worldPromise;
             await world.streams.close(runId, name);
           },
@@ -53042,7 +53063,7 @@ var require_token_util = __commonJS({
       findProjectInfo: /* @__PURE__ */ __name(() => findProjectInfo, "findProjectInfo"),
       getTokenPayload: /* @__PURE__ */ __name(() => getTokenPayload, "getTokenPayload"),
       getVercelDataDir: /* @__PURE__ */ __name(() => getVercelDataDir, "getVercelDataDir"),
-      getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken6, "getVercelOidcToken"),
+      getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken5, "getVercelOidcToken"),
       getVercelToken: /* @__PURE__ */ __name(() => getVercelToken2, "getVercelToken"),
       isExpired: /* @__PURE__ */ __name(() => isExpired, "isExpired"),
       loadToken: /* @__PURE__ */ __name(() => loadToken, "loadToken"),
@@ -53104,7 +53125,7 @@ var require_token_util = __commonJS({
       }
     }
     __name(getVercelToken2, "getVercelToken");
-    async function getVercelOidcToken6(authToken, projectId, teamId) {
+    async function getVercelOidcToken5(authToken, projectId, teamId) {
       const url3 = `https://api.vercel.com/v1/projects/${projectId}/token?source=vercel-oidc-refresh${teamId ? `&teamId=${teamId}` : ""}`;
       const res = await fetch(url3, {
         method: "POST",
@@ -53121,7 +53142,7 @@ var require_token_util = __commonJS({
       assertVercelOidcTokenResponse(tokenRes);
       return tokenRes;
     }
-    __name(getVercelOidcToken6, "getVercelOidcToken");
+    __name(getVercelOidcToken5, "getVercelOidcToken");
     function assertVercelOidcTokenResponse(res) {
       if (!res || typeof res !== "object") {
         throw new TypeError(
@@ -53296,13 +53317,13 @@ var require_get_vercel_oidc_token = __commonJS({
     var __toCommonJS = /* @__PURE__ */ __name((mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod), "__toCommonJS");
     var get_vercel_oidc_token_exports = {};
     __export3(get_vercel_oidc_token_exports, {
-      getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken6, "getVercelOidcToken"),
+      getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken5, "getVercelOidcToken"),
       getVercelOidcTokenSync: /* @__PURE__ */ __name(() => getVercelOidcTokenSync2, "getVercelOidcTokenSync")
     });
     module.exports = __toCommonJS(get_vercel_oidc_token_exports);
     var import_get_context = require_get_context3();
     var import_token_error = require_token_error();
-    async function getVercelOidcToken6(options) {
+    async function getVercelOidcToken5(options) {
       let token = "";
       let err;
       try {
@@ -53332,7 +53353,7 @@ ${error95.message}`;
       }
       return token;
     }
-    __name(getVercelOidcToken6, "getVercelOidcToken");
+    __name(getVercelOidcToken5, "getVercelOidcToken");
     function getVercelOidcTokenSync2() {
       const token = (0, import_get_context.getContext)().headers?.["x-vercel-oidc-token"] ?? process.env.VERCEL_OIDC_TOKEN;
       if (!token) {
@@ -55074,9 +55095,26 @@ var init_dist = __esm2({
     init_world_target();
   }
 });
+var RUN_ERROR_CODES;
 var init_error_codes = __esm2({
   "../errors/dist/error-codes.js"() {
     "use strict";
+    RUN_ERROR_CODES = {
+      /** Error thrown in user workflow or step code */
+      USER_ERROR: "USER_ERROR",
+      /** Internal runtime error (missing timestamps, runtime invariant failures) */
+      RUNTIME_ERROR: "RUNTIME_ERROR",
+      /** Event log contains orphaned or mismatched events and cannot be replayed */
+      CORRUPTED_EVENT_LOG: "CORRUPTED_EVENT_LOG",
+      /** One replay could not consume the event log deterministically; retryable */
+      REPLAY_DIVERGENCE: "REPLAY_DIVERGENCE",
+      /** Run exceeded the maximum number of queue deliveries */
+      MAX_DELIVERIES_EXCEEDED: "MAX_DELIVERIES_EXCEEDED",
+      /** Workflow replay exceeded the maximum allowed duration */
+      REPLAY_TIMEOUT: "REPLAY_TIMEOUT",
+      /** World response violated the SDK contract and cannot be retried safely */
+      WORLD_CONTRACT_ERROR: "WORLD_CONTRACT_ERROR"
+    };
   }
 });
 function isError(value) {
@@ -55120,6 +55158,8 @@ var WorkflowRunNotCompletedError;
 var WorkflowRuntimeError;
 var RuntimeDecryptionError;
 var SerializationError;
+var StepNotRegisteredError;
+var WorkflowNotRegisteredError;
 var WorkflowRunNotFoundError;
 var HookConflictError;
 var HookNotFoundError;
@@ -55323,6 +55363,44 @@ Caused by: ${options.cause.stack}`;
         return isError(value) && value.name === "SerializationError";
       }
     };
+    StepNotRegisteredError = class extends WorkflowRuntimeError {
+      static {
+        __name(this, "StepNotRegisteredError");
+      }
+      static {
+        __name2(this, "StepNotRegisteredError");
+      }
+      stepName;
+      constructor(stepName) {
+        super(`Step "${stepName}" is not registered in the current deployment. This usually indicates a build or bundling issue that caused the step to not be included in the deployment.`, {
+          slug: ERROR_SLUGS.STEP_NOT_REGISTERED
+        });
+        this.name = "StepNotRegisteredError";
+        this.stepName = stepName;
+      }
+      static is(value) {
+        return isError(value) && value.name === "StepNotRegisteredError";
+      }
+    };
+    WorkflowNotRegisteredError = class extends WorkflowRuntimeError {
+      static {
+        __name(this, "WorkflowNotRegisteredError");
+      }
+      static {
+        __name2(this, "WorkflowNotRegisteredError");
+      }
+      workflowName;
+      constructor(workflowName) {
+        super(`Workflow "${workflowName}" is not registered in the current deployment. This usually means a run was started against a deployment that does not have this workflow, or there was a build/bundling issue.`, {
+          slug: ERROR_SLUGS.WORKFLOW_NOT_REGISTERED
+        });
+        this.name = "WorkflowNotRegisteredError";
+        this.workflowName = workflowName;
+      }
+      static is(value) {
+        return isError(value) && value.name === "WorkflowNotRegisteredError";
+      }
+    };
     WorkflowRunNotFoundError = class extends WorkflowError {
       static {
         __name(this, "WorkflowRunNotFoundError");
@@ -79586,7 +79664,7 @@ var version2;
 var init_version = __esm2({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.24";
+    version2 = "5.0.0-beta.26";
   }
 });
 function getWorkflowQueueName(workflowName, namespace) {
@@ -81524,7 +81602,7 @@ function attachAbortListenerOnce(signal, streamName, runId, cryptoKey, ops) {
   });
 }
 __name(attachAbortListenerOnce, "attachAbortListenerOnce");
-function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false) {
+function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier) {
   return {
     ...getAllBaseReducers(global2),
     ReadableStream: /* @__PURE__ */ __name2((value) => {
@@ -81537,7 +81615,7 @@ function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framed
       const streamId = (global2[STABLE_ULID] || defaultUlid)();
       const name = `strm_${streamId}`;
       const type = getStreamType(value);
-      const writable = new WorkflowServerWritableStream(runId, name);
+      const writable = new WorkflowServerWritableStream(runId, name, runReadyBarrier);
       if (type === "bytes") {
         if (framedByteStreams) {
           ops.push(value.pipeThrough(getByteFramingStream()).pipeTo(writable));
@@ -81545,7 +81623,7 @@ function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framed
           ops.push(value.pipeTo(writable));
         }
       } else {
-        ops.push(value.pipeThrough(getSerializeStream(getExternalReducers(global2, ops, runId, cryptoKey, framedByteStreams), cryptoKey)).pipeTo(writable));
+        ops.push(value.pipeThrough(getSerializeStream(getExternalReducers(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier), cryptoKey)).pipeTo(writable));
       }
       const s = {
         name
@@ -81653,7 +81731,7 @@ function getWorkflowReducers(global2 = globalThis) {
   };
 }
 __name(getWorkflowReducers, "getWorkflowReducers");
-function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false) {
+function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier) {
   return {
     ...getAllBaseReducers(global2),
     ReadableStream: /* @__PURE__ */ __name2((value) => {
@@ -81671,7 +81749,7 @@ function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByte
         name = `strm_${streamId}`;
         type = getStreamType(value);
         framing = type === "bytes" && framedByteStreams ? "framed-v1" : framing;
-        const writable = new WorkflowServerWritableStream(runId, name);
+        const writable = new WorkflowServerWritableStream(runId, name, runReadyBarrier);
         if (type === "bytes") {
           if (framing === "framed-v1") {
             ops.push(value.pipeThrough(getByteFramingStream()).pipeTo(writable));
@@ -81679,7 +81757,7 @@ function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByte
             ops.push(value.pipeTo(writable));
           }
         } else {
-          ops.push(value.pipeThrough(getSerializeStream(getStepReducers(global2, ops, runId, cryptoKey, framedByteStreams), cryptoKey)).pipeTo(writable));
+          ops.push(value.pipeThrough(getSerializeStream(getStepReducers(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier), cryptoKey)).pipeTo(writable));
         }
       }
       const s = {
@@ -82200,16 +82278,16 @@ async function hydrateStepArguments(value, runId, key, ops = [], global2 = globa
   return result;
 }
 __name(hydrateStepArguments, "hydrateStepArguments");
-async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false) {
+async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false, runReadyBarrier) {
   if (v1Compat) {
-    const str = stringify(value, getStepReducers(global2, ops, runId, key, framedByteStreams));
+    const str = stringify(value, getStepReducers(global2, ops, runId, key, framedByteStreams, runReadyBarrier));
     return revive(str);
   }
   try {
     const compressionStats = {};
     const result = await serialize2(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers(getStepReducers(global2, ops, runId, key, framedByteStreams)),
+      extraReducers: getStreamAndRequestReducers(getStepReducers(global2, ops, runId, key, framedByteStreams, runReadyBarrier)),
       compression,
       compressionStats
     });
@@ -82367,7 +82445,16 @@ var init_serialization2 = __esm2({
       static {
         __name2(this, "WorkflowServerWritableStream");
       }
-      constructor(runId, name) {
+      /**
+       * @param runReadyBarrier Turbo mode only: a promise that resolves once the
+       * backgrounded `run_started` has landed. When the step body runs
+       * optimistically (before `run_started` is durable), the first chunk write to
+       * a brand-new stream would otherwise reach the World before the run exists
+       * and be rejected as run-not-found. Awaiting this once before the first
+       * flush/close orders the write after the run's creation. `undefined` outside
+       * turbo and on the await path, where the run was already durable.
+       */
+      constructor(runId, name, runReadyBarrier) {
         if (typeof runId !== "string") {
           throw new WorkflowRuntimeError(`"runId" must be a string, got "${typeof runId}"`);
         }
@@ -82375,6 +82462,16 @@ var init_serialization2 = __esm2({
           throw new WorkflowRuntimeError(`"name" is required, got "${name}"`);
         }
         const worldPromise = getWorldLazy();
+        let pendingRunReady = runReadyBarrier;
+        const ensureRunReady = /* @__PURE__ */ __name2(async () => {
+          if (pendingRunReady) {
+            try {
+              await pendingRunReady;
+            } catch {
+            }
+            pendingRunReady = void 0;
+          }
+        }, "ensureRunReady");
         let buffer22 = [];
         let flushTimer = null;
         let flushPromise = null;
@@ -82385,6 +82482,7 @@ var init_serialization2 = __esm2({
             flushTimer = null;
           }
           if (buffer22.length === 0) return;
+          await ensureRunReady();
           const chunksToFlush = buffer22.slice();
           const world = await worldPromise;
           if (resolvedFlushIntervalMs === void 0) {
@@ -82434,6 +82532,7 @@ var init_serialization2 = __esm2({
               flushPromise = null;
             }
             await flush();
+            await ensureRunReady();
             const world = await worldPromise;
             await world.streams.close(runId, name);
           },
@@ -82626,6 +82725,40 @@ function normalizeAttributeChanges(attrs, options = {}) {
 __name(normalizeAttributeChanges, "normalizeAttributeChanges");
 __name2(normalizeAttributeChanges, "normalizeAttributeChanges");
 init_capabilities();
+init_dist2();
+var WORLD_CONTRACT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "PARSE_ERROR",
+  "SCHEMA_VALIDATION",
+  RUN_ERROR_CODES.WORLD_CONTRACT_ERROR
+]);
+var RETRYABLE_WORLD_ERROR_CODES = /* @__PURE__ */ new Set([
+  "TRANSPORT",
+  "TIMEOUT"
+]);
+var RUNTIME_ERROR_CHECKS = [
+  WorkflowRuntimeError.is,
+  StepNotRegisteredError.is,
+  WorkflowNotRegisteredError.is,
+  // SDK-level encryption failures (most notably AES-GCM auth-tag
+  // mismatches surfacing as a native `OperationError` from
+  // `AESCipherJob.onDone`) are wrapped in `RuntimeDecryptionError` at
+  // the encryption module boundary.
+  RuntimeDecryptionError.is
+];
+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);
+}
+__name(isRetryableWorldError, "isRetryableWorldError");
+__name2(isRetryableWorldError, "isRetryableWorldError");
 init_encryption();
 init_logger();
 init_serialization2();
@@ -82778,7 +82911,7 @@ async function start(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,
@@ -82823,14 +82956,7 @@ __name2(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.24//start");
-function isRetryableStartError(err) {
-  if (ThrottleError.is(err)) return true;
-  if (WorkflowWorldError.is(err) && err.status && err.status >= 500) return true;
-  return false;
-}
-__name(isRetryableStartError, "isRetryableStartError");
-__name2(isRetryableStartError, "isRetryableStartError");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.26//start");
 async function wakeUpRun(world, runId, options) {
   try {
     const run22 = await world.runs.get(runId, {
@@ -83157,7 +83283,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.24//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.26//Run#wakeUp");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -83166,7 +83292,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.24//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.26//Run#cancel");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -83175,7 +83301,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.24//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.26//Run#getReadable");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -83184,7 +83310,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.24//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.26//Run#exists");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -83193,7 +83319,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.24//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.26//Run#status");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -83202,7 +83328,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.24//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.26//Run#returnValue");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -83211,7 +83337,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.24//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.26//Run#workflowName");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -83220,7 +83346,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.24//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.26//Run#createdAt");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -83229,7 +83355,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.24//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.26//Run#startedAt");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -83238,7 +83364,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.24//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.26//Run#completedAt");
 (function(__wf_cls, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("workflow-class-registry"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_cls);
@@ -83248,7 +83374,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.24//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.26//Run");
 async function fetch2(...args) {
   return globalThis.fetch(...args);
 }
@@ -83710,15 +83836,16 @@ import { types as types6 } from "node:util";
 
 // ../core/dist/classify-error.js
 init_dist6();
-var WORLD_CONTRACT_ERROR_CODES = /* @__PURE__ */ new Set([
+var WORLD_CONTRACT_ERROR_CODES2 = /* @__PURE__ */ new Set([
   "PARSE_ERROR",
   "SCHEMA_VALIDATION",
-  RUN_ERROR_CODES.WORLD_CONTRACT_ERROR
+  RUN_ERROR_CODES2.WORLD_CONTRACT_ERROR
 ]);
-var RUNTIME_ERROR_CHECKS = [
+var RETRYABLE_WORLD_ERROR_CODES2 = /* @__PURE__ */ new Set(["TRANSPORT", "TIMEOUT"]);
+var RUNTIME_ERROR_CHECKS2 = [
   WorkflowRuntimeError2.is,
-  StepNotRegisteredError.is,
-  WorkflowNotRegisteredError.is,
+  StepNotRegisteredError2.is,
+  WorkflowNotRegisteredError2.is,
   // SDK-level encryption failures (most notably AES-GCM auth-tag
   // mismatches surfacing as a native `OperationError` from
   // `AESCipherJob.onDone`) are wrapped in `RuntimeDecryptionError` at
@@ -83730,25 +83857,38 @@ function isWorldContractError(err) {
     return false;
   }
   const cause = "cause" in err ? err.cause : void 0;
-  return err.code !== void 0 && WORLD_CONTRACT_ERROR_CODES.has(err.code) || err.message.startsWith("Failed to parse response body for ") || err.message.startsWith("Schema validation failed for ") || typeof cause === "object" && cause !== null && "name" in cause && cause.name === "ZodError";
+  return err.code !== void 0 && WORLD_CONTRACT_ERROR_CODES2.has(err.code) || err.message.startsWith("Failed to parse response body for ") || err.message.startsWith("Schema validation failed for ") || typeof cause === "object" && cause !== null && "name" in cause && cause.name === "ZodError";
 }
 __name(isWorldContractError, "isWorldContractError");
+function isRetryableWorldError2(err) {
+  if (ThrottleError2.is(err)) {
+    return true;
+  }
+  if (!WorkflowWorldError2.is(err)) {
+    return false;
+  }
+  if (err.status !== void 0 && err.status >= 500) {
+    return true;
+  }
+  return err.code !== void 0 && RETRYABLE_WORLD_ERROR_CODES2.has(err.code);
+}
+__name(isRetryableWorldError2, "isRetryableWorldError");
 function classifyRunError(err) {
   if (ReplayDivergenceError.is(err)) {
-    return RUN_ERROR_CODES.REPLAY_DIVERGENCE;
+    return RUN_ERROR_CODES2.REPLAY_DIVERGENCE;
   }
   if (CorruptedEventLogError.is(err)) {
-    return RUN_ERROR_CODES.CORRUPTED_EVENT_LOG;
+    return RUN_ERROR_CODES2.CORRUPTED_EVENT_LOG;
   }
-  if (isWorldContractError(err)) {
-    return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;
+  if (isWorldContractError(err) || isRetryableWorldError2(err)) {
+    return RUN_ERROR_CODES2.WORLD_CONTRACT_ERROR;
   }
-  for (const isMatch of RUNTIME_ERROR_CHECKS) {
+  for (const isMatch of RUNTIME_ERROR_CHECKS2) {
     if (isMatch(err)) {
-      return RUN_ERROR_CODES.RUNTIME_ERROR;
+      return RUN_ERROR_CODES2.RUNTIME_ERROR;
     }
   }
-  return RUN_ERROR_CODES.USER_ERROR;
+  return RUN_ERROR_CODES2.USER_ERROR;
 }
 __name(classifyRunError, "classifyRunError");
 
@@ -83972,28 +84112,28 @@ function describeError(err, errorCode) {
       hint: RUNTIME_ERROR_HINT
     };
   }
-  if (effectiveCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {
+  if (effectiveCode === RUN_ERROR_CODES2.REPLAY_TIMEOUT) {
     return {
       attribution: "sdk",
       errorCode: effectiveCode,
       hint: REPLAY_TIMEOUT_HINT
     };
   }
-  if (effectiveCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {
+  if (effectiveCode === RUN_ERROR_CODES2.MAX_DELIVERIES_EXCEEDED) {
     return {
       attribution: "sdk",
       errorCode: effectiveCode,
       hint: MAX_DELIVERIES_HINT
     };
   }
-  if (effectiveCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {
+  if (effectiveCode === RUN_ERROR_CODES2.CORRUPTED_EVENT_LOG) {
     return {
       attribution: "sdk",
       errorCode: effectiveCode,
       hint: CORRUPTED_EVENT_LOG_HINT
     };
   }
-  if (effectiveCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {
+  if (effectiveCode === RUN_ERROR_CODES2.WORLD_CONTRACT_ERROR) {
     return {
       attribution: "sdk",
       errorCode: effectiveCode,
@@ -84458,6 +84598,10 @@ function hasTag(fileId, tag) {
   return fileId.endsWith(`.${tag}`);
 }
 __name(hasTag, "hasTag");
+function isUntagged(fileId) {
+  return !TAG_PATTERN.test(fileId);
+}
+__name(isUntagged, "isUntagged");
 function taggedPath(basedir, entityDir, fileId, tag) {
   assertSafeEntityId("fileId", fileId);
   if (tag !== void 0)
@@ -85199,34 +85343,54 @@ function createQueue(config4) {
         await semaphore.acquire();
       }
       const MAX_LOCAL_SAFETY_LIMIT = 256;
+      let delivery = 0;
       try {
-        for (let attempt = 0; attempt < MAX_LOCAL_SAFETY_LIMIT; attempt++) {
+        for (let loop = 0; loop < MAX_LOCAL_SAFETY_LIMIT; loop++) {
           const headers = {
             ...opts?.headers,
             "content-type": "application/json",
             "x-vqs-queue-name": queueName,
             "x-vqs-message-id": messageId,
-            "x-vqs-message-attempt": String(attempt + 1)
+            "x-vqs-message-attempt": String(delivery + 1)
           };
           const directHandler = directHandlers.get(prefix);
           let response;
-          if (directHandler) {
-            const req = new Request(`http://localhost/.well-known/workflow/v1/${pathname}`, {
-              method: "POST",
-              headers,
-              body
-            });
-            response = await directHandler(req);
-          } else {
-            const baseUrl = await resolveBaseUrl(config4);
-            response = await fetch(`${baseUrl}/.well-known/workflow/v1/${pathname}`, {
-              method: "POST",
-              duplex: "half",
-              dispatcher: httpAgent,
-              headers,
-              body
+          try {
+            if (directHandler) {
+              const req = new Request(`http://localhost/.well-known/workflow/v1/${pathname}`, {
+                method: "POST",
+                headers,
+                body
+              });
+              response = await directHandler(req);
+            } else {
+              const baseUrl = await resolveBaseUrl(config4);
+              response = await fetch(`${baseUrl}/.well-known/workflow/v1/${pathname}`, {
+                method: "POST",
+                duplex: "half",
+                dispatcher: httpAgent,
+                headers,
+                body
+              });
+            }
+          } catch (err) {
+            const name = err?.name;
+            if (closeSignal.aborted || name === "AbortError" || name === "ResponseAborted") {
+              return;
+            }
+            if (isDetachedArrayBufferQueueError(err))
+              throw err;
+            console.error(`[world-local] Queue delivery failed at the transport (loop ${loop + 1}), retrying`, {
+              queueName,
+              messageId,
+              ...runId && { runId },
+              ...stepId && { stepId },
+              error: String(err)
             });
+            await setTimeout2(5e3, void 0, { signal: closeSignal });
+            continue;
           }
+          delivery++;
           const text = await response.text();
           if (response.ok) {
             try {
@@ -85244,7 +85408,7 @@ function createQueue(config4) {
             }
             return;
           }
-          console.error(`[world-local] Queue message failed (attempt ${attempt + 1}, HTTP ${response.status})`, {
+          console.error(`[world-local] Queue message failed (attempt ${delivery}, HTTP ${response.status})`, {
             queueName,
             messageId,
             ...runId && { runId },
@@ -87031,13 +87195,14 @@ function createLocalWorld(args) {
       if (!recoverActiveRuns) {
         return;
       }
-      const recoveryRuns = tag ? {
+      const fileIdFilter = tag ? (fileId) => hasTag(fileId, tag) : isUntagged;
+      const recoveryRuns = {
         ...storage.runs,
         list: /* @__PURE__ */ __name(((params) => storage.runs.list({
           ...params,
-          fileIdFilter: /* @__PURE__ */ __name((fileId) => hasTag(fileId, tag), "fileIdFilter")
+          fileIdFilter
         })), "list")
-      } : storage.runs;
+      };
       await reenqueueActiveRuns(recoveryRuns, queue.queue, "world-local");
     },
     async close() {
@@ -87089,41 +87254,316 @@ __name(createLocalWorld, "createLocalWorld");
 init_dist7();
 
 // ../world-vercel/dist/encryption.js
-var import_oidc = __toESM(require_dist(), 1);
 init_zod2();
 import { webcrypto } from "node:crypto";
 
 // ../world-vercel/dist/http-client.js
 var import_undici2 = __toESM(require_undici(), 1);
 var _dispatcher;
+var _eventsDispatcher;
+var _streamDispatcher;
+var 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
+};
+var DEFAULT_AGENT_OPTIONS = {
+  ...BASE_AGENT_OPTIONS,
+  allowH2: false
+};
+var EVENTS_AGENT_OPTIONS = {
+  ...BASE_AGENT_OPTIONS,
+  allowH2: true
+};
+var 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]
+};
+var STREAM_RETRY_OPTIONS = {
+  retryAfter: true,
+  methods: ["PUT"],
+  statusCodes: [429]
+};
 function getDispatcher(config4) {
   return config4?.dispatcher ?? getDefaultDispatcher();
 }
 __name(getDispatcher, "getDispatcher");
+function getEventsDispatcher(config4) {
+  return config4?.dispatcher ?? getDefaultEventsDispatcher();
+}
+__name(getEventsDispatcher, "getEventsDispatcher");
+function getStreamDispatcher(config4) {
+  return config4?.dispatcher ?? getDefaultStreamDispatcher();
+}
+__name(getStreamDispatcher, "getStreamDispatcher");
+function makeRetryDispatcher(agentOptions, retryOptions) {
+  return new import_undici2.RetryAgent(new import_undici2.Agent(agentOptions), retryOptions);
+}
+__name(makeRetryDispatcher, "makeRetryDispatcher");
 function getDefaultDispatcher() {
-  if (!_dispatcher) {
-    _dispatcher = new import_undici2.RetryAgent(new import_undici2.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
-      // 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.
-    });
-  }
+  _dispatcher ??= makeRetryDispatcher(DEFAULT_AGENT_OPTIONS, RETRY_AGENT_OPTIONS);
   return _dispatcher;
 }
 __name(getDefaultDispatcher, "getDefaultDispatcher");
+function getDefaultEventsDispatcher() {
+  _eventsDispatcher ??= makeRetryDispatcher(EVENTS_AGENT_OPTIONS, RETRY_AGENT_OPTIONS);
+  return _eventsDispatcher;
+}
+__name(getDefaultEventsDispatcher, "getDefaultEventsDispatcher");
+function getDefaultStreamDispatcher() {
+  _streamDispatcher ??= makeRetryDispatcher(EVENTS_AGENT_OPTIONS, STREAM_RETRY_OPTIONS);
+  return _streamDispatcher;
+}
+__name(getDefaultStreamDispatcher, "getDefaultStreamDispatcher");
+
+// ../world-vercel/dist/http-core.js
+var import_oidc = __toESM(require_dist(), 1);
+init_dist6();
+
+// ../world-vercel/dist/telemetry.js
+var otelApiPromise2 = null;
+async function getOtelApi2() {
+  if (!otelApiPromise2) {
+    otelApiPromise2 = Promise.resolve().then(() => (init_esm(), esm_exports)).catch(() => null);
+  }
+  return otelApiPromise2;
+}
+__name(getOtelApi2, "getOtelApi");
+var tracerPromise2 = null;
+async function getTracer2() {
+  if (!tracerPromise2) {
+    tracerPromise2 = getOtelApi2().then((otel) => otel ? otel.trace.getTracer("workflow") : null);
+  }
+  return tracerPromise2;
+}
+__name(getTracer2, "getTracer");
+async function trace5(spanName, ...args) {
+  const [tracer, otel] = await Promise.all([getTracer2(), getOtelApi2()]);
+  const { fn, opts } = typeof args[0] === "function" ? { fn: args[0], opts: {} } : { fn: args[1], opts: args[0] };
+  if (!fn)
+    throw new Error("Function to trace must be provided");
+  if (!tracer || !otel) {
+    return await fn();
+  }
+  return tracer.startActiveSpan(spanName, opts, async (span) => {
+    try {
+      const result = await fn(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();
+    }
+  });
+}
+__name(trace5, "trace");
+async function getSpanKind3(field) {
+  const otel = await getOtelApi2();
+  if (!otel)
+    return void 0;
+  return otel.SpanKind[field];
+}
+__name(getSpanKind3, "getSpanKind");
+async function injectTraceContextIntoHeaders(headers) {
+  const otel = await getOtelApi2();
+  if (!otel)
+    return;
+  const carrier = {};
+  otel.propagation.inject(otel.context.active(), carrier);
+  for (const [key, value] of Object.entries(carrier)) {
+    headers.set(key, value);
+  }
+}
+__name(injectTraceContextIntoHeaders, "injectTraceContextIntoHeaders");
+function SemanticConvention4(...names) {
+  return (value) => Object.fromEntries(names.map((name) => [name, value]));
+}
+__name(SemanticConvention4, "SemanticConvention");
+var HttpRequestMethod3 = SemanticConvention4("http.request.method");
+var UrlFull3 = SemanticConvention4("url.full");
+var ServerAddress3 = SemanticConvention4("server.address");
+var ServerPort3 = SemanticConvention4("server.port");
+var HttpResponseStatusCode3 = SemanticConvention4("http.response.status_code");
+var ErrorType3 = SemanticConvention4("error.type");
+var WorldParseFormat3 = SemanticConvention4("workflow.world.parse.format");
+var PeerService4 = SemanticConvention4("peer.service");
+var RpcSystem4 = SemanticConvention4("rpc.system");
+var RpcService4 = SemanticConvention4("rpc.service");
+var RpcMethod4 = SemanticConvention4("rpc.method");
+var WorkflowRunId4 = SemanticConvention4("workflow.run.id");
+var StepId4 = SemanticConvention4("step.id");
+
+// ../world-vercel/dist/http-core.js
+var REQUEST_TIMEOUT_MS = 6e4;
+var HTTP_DEBUG_ENABLED = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
+var DIAGNOSTIC_HEADERS = [
+  "x-vercel-id",
+  "x-vercel-error",
+  "x-vercel-mitigated"
+];
+function getVercelDiagnostics(headers) {
+  return DIAGNOSTIC_HEADERS.flatMap((header) => {
+    const value = headers.get(header);
+    return value ? [`${header}=${value}`] : [];
+  });
+}
+__name(getVercelDiagnostics, "getVercelDiagnostics");
+function formatVercelDiagnostics(headers) {
+  const diagnostics = getVercelDiagnostics(headers);
+  return diagnostics.length > 0 ? ` (${diagnostics.join("; ")})` : "";
+}
+__name(formatVercelDiagnostics, "formatVercelDiagnostics");
+function httpLog(method, label, response, ms2) {
+  if (!HTTP_DEBUG_ENABLED)
+    return;
+  const diagnostics = getVercelDiagnostics(response.headers);
+  const suffix = diagnostics.length > 0 ? `; ${diagnostics.join("; ")}` : "";
+  console.debug(`[workflow:world-vercel:http] ${method} ${label} -> ${response.status} (${ms2}ms${suffix})`);
+}
+__name(httpLog, "httpLog");
+function logCurlRepro(method, url3, headers) {
+  if (!process.env.DEBUG)
+    return;
+  const stringifiedHeaders = Array.from(headers.entries()).filter(([key]) => key.toLowerCase() !== "authorization").map(([key, value]) => `-H "${key}: ${value}"`).join(" ");
+  console.error(`Failed to fetch, reproduce with:
+curl -X ${method} ${stringifiedHeaders} "${url3}"`);
+}
+__name(logCurlRepro, "logCurlRepro");
+function parseRetryAfter(value) {
+  if (!value)
+    return void 0;
+  const parsed = parseInt(value, 10);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+__name(parseRetryAfter, "parseRetryAfter");
+function errorForResponse(status, message, opts = {}) {
+  const { retryAfter, code: code3, url: url3, mitigated } = opts;
+  if (status === 409)
+    return new EntityConflictError2(message);
+  if (status === 410)
+    return new RunExpiredError(message);
+  if (status === 425)
+    return new TooEarlyError(message, { retryAfter });
+  if (status === 429) {
+    if (isFirewallChallenge429(status, mitigated)) {
+      return new WorkflowWorldError2(`${message} (x-vercel-mitigated=challenge)`, {
+        url: url3,
+        status,
+        code: "TRANSPORT",
+        retryAfter
+      });
+    }
+    return new ThrottleError2(message, { retryAfter });
+  }
+  return new WorkflowWorldError2(message, { url: url3, status, code: code3, retryAfter });
+}
+__name(errorForResponse, "errorForResponse");
+function isFirewallChallenge429(status, mitigated) {
+  return status === 429 && mitigated === "challenge";
+}
+__name(isFirewallChallenge429, "isFirewallChallenge429");
+async function resolveVercelApiToken(opts) {
+  return opts?.token ?? process.env.VERCEL_TOKEN ?? await (0, import_oidc.getVercelOidcToken)().catch(() => null);
+}
+__name(resolveVercelApiToken, "resolveVercelApiToken");
+function parseServer(url3) {
+  try {
+    const parsed = new URL(url3);
+    return {
+      serverAddress: parsed.hostname,
+      serverPort: parsed.port ? parseInt(parsed.port, 10) : parsed.protocol === "https:" ? 443 : 80
+    };
+  } catch {
+    return {};
+  }
+}
+__name(parseServer, "parseServer");
+function httpClientSpanAttributes(args) {
+  const { method, url: url3, peerService } = args;
+  const { serverAddress, serverPort } = parseServer(url3);
+  return {
+    ...HttpRequestMethod3(method),
+    ...UrlFull3(url3),
+    ...serverAddress ? ServerAddress3(serverAddress) : {},
+    ...serverPort ? ServerPort3(serverPort) : {},
+    ...PeerService4(peerService),
+    ...RpcSystem4("http"),
+    ...RpcService4(peerService)
+  };
+}
+__name(httpClientSpanAttributes, "httpClientSpanAttributes");
+async function instrumentedFetch(opts) {
+  const { method, url: url3, headers, body, dispatcher, peerService = "workflow-server", timeoutMs = REQUEST_TIMEOUT_MS, signal: callerSignal, injectTraceContext = true, cacheBust = true, logLabel, buildError } = opts;
+  const label = logLabel ?? url3;
+  return trace5(`http ${method}`, { kind: await getSpanKind3("CLIENT") }, async (span) => {
+    span?.setAttributes(httpClientSpanAttributes({ method, url: url3, peerService }));
+    if (injectTraceContext)
+      await injectTraceContextIntoHeaders(headers);
+    if (cacheBust)
+      headers.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 start3 = Date.now();
+    let response;
+    try {
+      response = await fetch(url3, {
+        method,
+        headers,
+        body,
+        signal,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- undici dispatcher type doesn't match @types/node's RequestInit
+        dispatcher
+      });
+    } catch (error95) {
+      const elapsed = Date.now() - start3;
+      if (error95 instanceof Error && (error95.name === "TimeoutError" || error95.name === "AbortError")) {
+        const timeoutError = new WorkflowWorldError2(`${method} ${label} timed out after ${elapsed}ms`, { url: url3, cause: error95 });
+        span?.setAttributes({ ...ErrorType3("TIMEOUT") });
+        span?.recordException?.(timeoutError);
+        throw timeoutError;
+      }
+      throw error95;
+    }
+    const ms2 = Date.now() - start3;
+    httpLog(method, label, response, ms2);
+    span?.setAttributes({ ...HttpResponseStatusCode3(response.status) });
+    if (!response.ok) {
+      span?.setAttributes({ ...ErrorType3(`HTTP ${response.status}`) });
+      logCurlRepro(method, url3, headers);
+      if (buildError) {
+        const error96 = await buildError(response);
+        span?.recordException?.(error96);
+        throw error96;
+      }
+      const text = await response.text().catch(() => "");
+      const error95 = errorForResponse(response.status, `${method} ${label} -> HTTP ${response.status}: ${response.statusText}${text ? ` ${text}` : ""}${formatVercelDiagnostics(response.headers)}`, {
+        url: url3,
+        retryAfter: parseRetryAfter(response.headers.get("Retry-After"))
+      });
+      span?.recordException?.(error95);
+      throw error95;
+    }
+    return response;
+  });
+}
+__name(instrumentedFetch, "instrumentedFetch");
 
 // ../world-vercel/dist/encryption.js
 var KEY_BYTES = 32;
@@ -87151,7 +87591,7 @@ async function deriveRunKey(deploymentKey, projectId, runId) {
 }
 __name(deriveRunKey, "deriveRunKey");
 async function fetchRunKey(deploymentId, projectId, runId, options) {
-  const token = options?.token ?? process.env.VERCEL_TOKEN ?? await (0, import_oidc.getVercelOidcToken)().catch(() => null);
+  const token = await resolveVercelApiToken({ token: options?.token });
   if (!token) {
     throw new Error("Cannot fetch run key: no OIDC token or VERCEL_TOKEN available");
   }
@@ -87159,23 +87599,25 @@ async function fetchRunKey(deploymentId, projectId, runId, options) {
   if (options?.teamId) {
     params.set("teamId", options.teamId);
   }
-  const response = await fetch(`https://api.vercel.com/v1/workflow/run-key/${deploymentId}?${params}`, {
+  const response = 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?.dispatcher })
+    url: `https://api.vercel.com/v1/workflow/run-key/${deploymentId}?${params}`,
+    headers: new Headers({ Authorization: `Bearer ${token}` }),
+    dispatcher: getDispatcher({ dispatcher: 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: /* @__PURE__ */ __name(async (res) => {
+      let body;
+      try {
+        body = await res.text();
+      } catch {
+        body = "<unable to read response body>";
+      }
+      return new Error(`Failed to fetch run key for ${runId} (deployment ${deploymentId}): HTTP ${res.status} ${res.statusText}${body ? ` \u2014 ${body}` : ""}`);
+    }, "buildError")
   });
-  if (!response.ok) {
-    let body;
-    try {
-      body = await response.text();
-    } catch {
-      body = "<unable to read response body>";
-    }
-    throw new Error(`Failed to fetch run key for ${runId} (deployment ${deploymentId}): HTTP ${response.status} ${response.statusText}${body ? ` \u2014 ${body}` : ""}`);
-  }
   const data = await response.json();
   const result = object2({ key: string5().nullable() }).safeParse(data);
   if (!result.success) {
@@ -87224,84 +87666,6 @@ function createGetEncryptionKeyForRun(projectId, teamId, token, dispatcher) {
 }
 __name(createGetEncryptionKeyForRun, "createGetEncryptionKeyForRun");
 
-// ../world-vercel/dist/telemetry.js
-var otelApiPromise2 = null;
-async function getOtelApi2() {
-  if (!otelApiPromise2) {
-    otelApiPromise2 = Promise.resolve().then(() => (init_esm(), esm_exports)).catch(() => null);
-  }
-  return otelApiPromise2;
-}
-__name(getOtelApi2, "getOtelApi");
-var tracerPromise2 = null;
-async function getTracer2() {
-  if (!tracerPromise2) {
-    tracerPromise2 = getOtelApi2().then((otel) => otel ? otel.trace.getTracer("workflow") : null);
-  }
-  return tracerPromise2;
-}
-__name(getTracer2, "getTracer");
-async function trace5(spanName, ...args) {
-  const [tracer, otel] = await Promise.all([getTracer2(), getOtelApi2()]);
-  const { fn, opts } = typeof args[0] === "function" ? { fn: args[0], opts: {} } : { fn: args[1], opts: args[0] };
-  if (!fn)
-    throw new Error("Function to trace must be provided");
-  if (!tracer || !otel) {
-    return await fn();
-  }
-  return tracer.startActiveSpan(spanName, opts, async (span) => {
-    try {
-      const result = await fn(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();
-    }
-  });
-}
-__name(trace5, "trace");
-async function getSpanKind3(field) {
-  const otel = await getOtelApi2();
-  if (!otel)
-    return void 0;
-  return otel.SpanKind[field];
-}
-__name(getSpanKind3, "getSpanKind");
-async function injectTraceContextIntoHeaders(headers) {
-  const otel = await getOtelApi2();
-  if (!otel)
-    return;
-  const carrier = {};
-  otel.propagation.inject(otel.context.active(), carrier);
-  for (const [key, value] of Object.entries(carrier)) {
-    headers.set(key, value);
-  }
-}
-__name(injectTraceContextIntoHeaders, "injectTraceContextIntoHeaders");
-function SemanticConvention4(...names) {
-  return (value) => Object.fromEntries(names.map((name) => [name, value]));
-}
-__name(SemanticConvention4, "SemanticConvention");
-var HttpRequestMethod3 = SemanticConvention4("http.request.method");
-var UrlFull3 = SemanticConvention4("url.full");
-var ServerAddress3 = SemanticConvention4("server.address");
-var ServerPort3 = SemanticConvention4("server.port");
-var HttpResponseStatusCode3 = SemanticConvention4("http.response.status_code");
-var ErrorType3 = SemanticConvention4("error.type");
-var WorldParseFormat3 = SemanticConvention4("workflow.world.parse.format");
-var PeerService4 = SemanticConvention4("peer.service");
-var RpcSystem4 = SemanticConvention4("rpc.system");
-var RpcService4 = SemanticConvention4("rpc.service");
-var RpcMethod4 = SemanticConvention4("rpc.method");
-var WorkflowRunId4 = SemanticConvention4("workflow.run.id");
-var StepId4 = SemanticConvention4("step.id");
-
 // ../world-vercel/dist/instrumentObject.js
 var WORKFLOW_SERVER_SERVICE = {
   peerService: "workflow-server",
@@ -94331,35 +94695,41 @@ import os from "node:os";
 import { inspect } from "node:util";
 
 // ../world-vercel/dist/version.js
-var version5 = "5.0.0-beta.20";
+var version5 = "5.0.0-beta.22";
 
 // ../world-vercel/dist/utils.js
-var HTTP_DEBUG_ENABLED = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
-function httpLog(method, endpoint, response, ms2) {
-  if (HTTP_DEBUG_ENABLED) {
-    const responseContext = getResponseDiagnosticHeaders(response);
-    const diagnosticSuffix = responseContext.length > 0 ? `; ${responseContext.join("; ")}` : "";
-    console.debug(`[workflow:world-vercel:http] ${method} ${endpoint} -> ${response.status} (${ms2}ms${diagnosticSuffix})`);
-  }
-}
-__name(httpLog, "httpLog");
-function getResponseDiagnosticHeaders(response) {
-  return ["x-vercel-id", "x-vercel-error"].flatMap((header) => {
-    const value = response.headers.get(header);
-    return value ? [`${header}=${value}`] : [];
-  });
-}
-__name(getResponseDiagnosticHeaders, "getResponseDiagnosticHeaders");
-function formatResponseDiagnostics(response) {
-  const headers = getResponseDiagnosticHeaders(response);
-  return headers.length > 0 ? ` (${headers.join("; ")})` : "";
-}
-__name(formatResponseDiagnostics, "formatResponseDiagnostics");
 var WORKFLOW_SERVER_URL_OVERRIDE = "";
-var REQUEST_TIMEOUT_MS = 6e4;
 var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
 var MAX_BODY_PARSE_RETRIES = 2;
 var BODY_PARSE_RETRY_BASE_MS = 100;
+var 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(error95) {
+  let current = error95;
+  for (let depth = 0; current != null && depth < 5; depth++) {
+    if (typeof current === "object" && "code" in current) {
+      const code3 = current.code;
+      if (typeof code3 === "string" && TRANSIENT_TRANSPORT_ERROR_CODES.has(code3)) {
+        return code3;
+      }
+    }
+    current = current?.cause;
+  }
+  return void 0;
+}
+__name(getTransientTransportCode, "getTransientTransportCode");
 var getWorkflowServerUrlOverride = /* @__PURE__ */ __name(() => WORKFLOW_SERVER_URL_OVERRIDE || process.env.VERCEL_WORKFLOW_SERVER_URL || "", "getWorkflowServerUrlOverride");
 var DEFAULT_RESOLVE_DATA_OPTION2 = "all";
 function deserializeError(obj) {
@@ -94430,25 +94800,12 @@ async function makeRequest({ endpoint, options = {}, config: config4 = {}, schem
   const method = options.method || "GET";
   const { baseUrl, headers } = await getHttpConfig(config4);
   const url3 = `${baseUrl}${endpoint}`;
-  let serverAddress;
-  let serverPort;
-  try {
-    const parsedUrl = new URL(url3);
-    serverAddress = parsedUrl.hostname;
-    serverPort = parsedUrl.port ? parseInt(parsedUrl.port, 10) : parsedUrl.protocol === "https:" ? 443 : 80;
-  } catch {
-  }
   return trace5(`http ${method}`, { kind: await getSpanKind3("CLIENT") }, async (span) => {
-    span?.setAttributes({
-      ...HttpRequestMethod3(method),
-      ...UrlFull3(url3),
-      ...serverAddress && ServerAddress3(serverAddress),
-      ...serverPort && ServerPort3(serverPort),
-      // Peer service for Datadog service maps
-      ...PeerService4("workflow-server"),
-      ...RpcSystem4("http"),
-      ...RpcService4("workflow-server")
-    });
+    span?.setAttributes(httpClientSpanAttributes({
+      method,
+      url: url3,
+      peerService: "workflow-server"
+    }));
     headers.set("Accept", "application/cbor");
     await injectTraceContextIntoHeaders(headers);
     let body;
@@ -94478,60 +94835,42 @@ async function makeRequest({ endpoint, options = {}, config: config4 = {}, schem
       } catch (error95) {
         const elapsed = Date.now() - fetchStart;
         if (error95 instanceof Error && (error95.name === "TimeoutError" || error95.name === "AbortError")) {
-          const timeoutError = new WorkflowWorldError2(`${method} ${endpoint} timed out after ${elapsed}ms`, { url: url3, cause: error95 });
+          const timeoutError = new WorkflowWorldError2(`${method} ${endpoint} timed out after ${elapsed}ms`, { url: url3, code: "TIMEOUT", cause: error95 });
           span?.setAttributes({ ...ErrorType3("TIMEOUT") });
           span?.recordException?.(timeoutError);
           throw timeoutError;
         }
+        const transportCode = getTransientTransportCode(error95);
+        if (transportCode) {
+          const transportError = new WorkflowWorldError2(`${method} ${endpoint} transport failure after ${elapsed}ms (${transportCode})`, { url: url3, code: "TRANSPORT", cause: error95 });
+          span?.setAttributes({ ...ErrorType3("TRANSPORT") });
+          span?.recordException?.(transportError);
+          throw transportError;
+        }
         throw error95;
       }
       const fetchMs = Date.now() - fetchStart;
-      responseDiagnostics = formatResponseDiagnostics(response);
+      responseDiagnostics = formatVercelDiagnostics(response.headers);
       httpLog(method, endpoint, response, fetchMs);
       span?.setAttributes({
         ...HttpResponseStatusCode3(response.status)
       });
       if (!response.ok) {
         const errorData = await parseResponseBody(response).then((r) => r.data).catch(() => ({}));
-        if (process.env.DEBUG) {
-          const stringifiedHeaders = Array.from(headers.entries()).filter(([key]) => key.toLowerCase() !== "authorization").map(([key, value]) => `-H "${key}: ${value}"`).join(" ");
-          console.error(`Failed to fetch, reproduce with:
-curl -X ${request.method} ${stringifiedHeaders} "${url3}"`);
-        }
-        let retryAfter;
-        const retryAfterHeader = response.headers.get("Retry-After");
-        if (retryAfterHeader) {
-          const parsed = parseInt(retryAfterHeader, 10);
-          if (!Number.isNaN(parsed)) {
-            retryAfter = parsed;
-          }
-        }
+        logCurlRepro(request.method, url3, headers);
+        const retryAfter = parseRetryAfter(response.headers.get("Retry-After"));
         const defaultMessage = (errorData.message || `${request.method} ${endpoint} -> HTTP ${response.status}: ${response.statusText}`) + responseDiagnostics;
-        const throwWithTrace = /* @__PURE__ */ __name((error95) => {
-          span?.setAttributes({
-            ...ErrorType3(errorData.code || `HTTP ${response.status}`)
-          });
-          span?.recordException?.(error95);
-          throw error95;
-        }, "throwWithTrace");
-        if (response.status === 409) {
-          throwWithTrace(new EntityConflictError2(defaultMessage));
-        }
-        if (response.status === 410) {
-          throwWithTrace(new RunExpiredError(defaultMessage));
-        }
-        if (response.status === 425) {
-          throwWithTrace(new TooEarlyError(defaultMessage, { retryAfter }));
-        }
-        if (response.status === 429) {
-          throwWithTrace(new ThrottleError2(defaultMessage, { retryAfter }));
-        }
-        throwWithTrace(new WorkflowWorldError2(defaultMessage, {
+        const error95 = errorForResponse(response.status, defaultMessage, {
           url: url3,
-          status: response.status,
           code: errorData.code,
-          retryAfter
-        }));
+          retryAfter,
+          mitigated: response.headers.get("x-vercel-mitigated")
+        });
+        span?.setAttributes({
+          ...ErrorType3(errorData.code || `HTTP ${response.status}`)
+        });
+        span?.recordException?.(error95);
+        throw error95;
       }
       onResponse?.(response);
       try {
@@ -94688,7 +95027,7 @@ var MAX_DELAY_SECONDS = Number(
   // 23 hours - leave 1h buffer before 24h retention limit
 );
 var HANDLER_ERROR_RETRY_AFTER_SECONDS = 1;
-var HANDLER_ERROR_MAX_RETRY_AFTER_SECONDS = 60;
+var HANDLER_ERROR_MAX_RETRY_AFTER_SECONDS = 900;
 var 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);
@@ -94818,7 +95157,6 @@ function createQueue2(config4) {
 __name(createQueue2, "createQueue");
 
 // ../world-vercel/dist/resolve-latest-deployment.js
-var import_oidc4 = __toESM(require_dist(), 1);
 init_zod2();
 var ResolveLatestDeploymentResponseSchema = object2({
   id: string5()
@@ -94829,28 +95167,30 @@ function createResolveLatestDeploymentId(config4) {
     if (!currentDeploymentId) {
       throw new Error("Cannot resolve latest deployment: VERCEL_DEPLOYMENT_ID environment variable is not set");
     }
-    const token = config4?.token ?? process.env.VERCEL_TOKEN ?? await (0, import_oidc4.getVercelOidcToken)().catch(() => null);
+    const token = await resolveVercelApiToken(config4);
     if (!token) {
       throw new Error("Cannot resolve latest deployment: no OIDC token or VERCEL_TOKEN available");
     }
     const url3 = `https://api.vercel.com/v1/workflow/resolve-latest-deployment/${encodeURIComponent(currentDeploymentId)}`;
-    const response = await fetch(url3, {
+    const response = 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(config4)
+      url: url3,
+      headers: new Headers({ Authorization: `Bearer ${token}` }),
+      dispatcher: getDispatcher(config4),
+      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: /* @__PURE__ */ __name(async (res) => {
+        let body;
+        try {
+          body = await res.text();
+        } catch {
+          body = "<unable to read response body>";
+        }
+        return new Error(`Failed to resolve latest deployment for ${currentDeploymentId}: HTTP ${res.status} ${res.statusText}${body ? ` \u2014 ${body}` : ""}`);
+      }, "buildError")
     });
-    if (!response.ok) {
-      let body;
-      try {
-        body = await response.text();
-      } catch {
-        body = "<unable to read response body>";
-      }
-      throw new Error(`Failed to resolve latest deployment for ${currentDeploymentId}: HTTP ${response.status} ${response.statusText}${body ? ` \u2014 ${body}` : ""}`);
-    }
     const data = await response.json();
     const result = ResolveLatestDeploymentResponseSchema.safeParse(data);
     if (!result.success) {
@@ -94865,8 +95205,187 @@ __name(createResolveLatestDeploymentId, "createResolveLatestDeploymentId");
 init_dist6();
 init_dist7();
 
-// ../world-vercel/dist/events-v4.js
+// ../world-vercel/dist/event-retry.js
 init_dist6();
+var EVENT_RETRY_ELIGIBILITY = {
+  // Creates: conditional create → 409 EntityConflictError if it already exists.
+  run_created: {
+    retryable: true,
+    reason: "conditional create \u2192 409 if exists"
+  },
+  step_created: {
+    retryable: true,
+    reason: "conditional create \u2192 409 if exists"
+  },
+  wait_created: {
+    retryable: true,
+    reason: "conditional create \u2192 409 if exists"
+  },
+  hook_created: {
+    retryable: true,
+    reason: "transactional token uniqueness \u2192 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 \u2192 409, no duplicate row"
+  },
+  run_failed: {
+    retryable: true,
+    reason: "terminal-state guard \u2192 409, no duplicate row"
+  },
+  run_cancelled: {
+    retryable: true,
+    reason: "terminal-state guard \u2192 409, no duplicate row"
+  },
+  step_completed: {
+    retryable: true,
+    reason: "terminal-state guard \u2192 409, no duplicate row"
+  },
+  step_failed: {
+    retryable: true,
+    reason: "terminal-state guard \u2192 409, no duplicate row"
+  },
+  wait_completed: {
+    retryable: true,
+    reason: "waiting-state guard \u2192 409, no duplicate row"
+  },
+  hook_disposed: {
+    retryable: true,
+    reason: "conditional delete (exists) \u2192 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 \u2192 a retry double-counts attempts"
+  },
+  step_retrying: {
+    retryable: false,
+    reason: "no duplicate guard \u2192 a retry appends a second event row"
+  },
+  hook_received: {
+    retryable: false,
+    reason: "no server guard \u2192 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"
+  }
+};
+var MAX_EVENT_POST_RETRIES = 2;
+var EVENT_POST_RETRY_BASE_MS = 100;
+var EVENT_POST_RETRY_JITTER_MS = 50;
+var 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 markers = [];
+  const e = err;
+  if (typeof e.code === "string")
+    markers.push(e.code);
+  if (typeof e.name === "string")
+    markers.push(e.name);
+  if (e.cause)
+    markers.push(...collectErrorMarkers(e.cause, depth + 1));
+  return markers;
+}
+__name(collectErrorMarkers, "collectErrorMarkers");
+function isRetryableEventPostError(err) {
+  if (EntityConflictError2.is(err) || RunExpiredError.is(err) || TooEarlyError.is(err) || ThrottleError2.is(err)) {
+    return false;
+  }
+  if (WorkflowWorldError2.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((m) => TRANSIENT_CODES.has(m));
+}
+__name(isRetryableEventPostError, "isRetryableEventPostError");
+var sleep = /* @__PURE__ */ __name((ms2) => new Promise((resolve3) => setTimeout(resolve3, ms2)), "sleep");
+var RETRY_DEBUG_ENABLED = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
+function logRetry(message, fields) {
+  if (!RETRY_DEBUG_ENABLED)
+    return;
+  const suffix = Object.entries(fields).map(([k, v]) => `${k}=${v}`).join(" ");
+  console.debug(`[workflow:world-vercel:event-retry] ${message} ${suffix}`);
+}
+__name(logRetry, "logRetry");
+function errorMarker(err) {
+  if (WorkflowWorldError2.is(err)) {
+    return err.code ?? (err.status != null ? `status_${err.status}` : err.name);
+  }
+  return collectErrorMarkers(err)[0] ?? (err instanceof Error ? err.name : "unknown");
+}
+__name(errorMarker, "errorMarker");
+async function withEventPostRetry(fn, eventType) {
+  const retryable = EVENT_RETRY_ELIGIBILITY[eventType]?.retryable ?? false;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await fn();
+    } 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(backoff);
+        continue;
+      }
+      if (transient) {
+        logRetry("exhausted in-process retries; surfacing for queue redelivery", {
+          eventType,
+          attempts: attempt + 1,
+          error: errorMarker(err)
+        });
+      }
+      throw err;
+    }
+  }
+}
+__name(withEventPostRetry, "withEventPostRetry");
 
 // ../world-vercel/dist/frames.js
 var V4_FRAME_CONTENT_TYPE = "application/vnd.workflow.v4-frames";
@@ -94943,15 +95462,16 @@ async function* readerToIterator(reader) {
 __name(readerToIterator, "readerToIterator");
 
 // ../world-vercel/dist/events-v4.js
-async function fetchV4(url3, init, config4) {
-  init.headers.set("X-Request-Time", Date.now().toString());
-  await injectTraceContextIntoHeaders(init.headers);
-  return fetch(url3, {
+async function fetchV4(url3, init, config4, opName) {
+  return instrumentedFetch({
     method: init.method,
+    url: url3,
     headers: init.headers,
     body: init.body,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- undici dispatcher type doesn't match @types/node's RequestInit
-    dispatcher: getDispatcher(config4)
+    dispatcher: getEventsDispatcher(config4),
+    timeoutMs: null,
+    logLabel: opName,
+    buildError: /* @__PURE__ */ __name(async (response) => errorFromV4Response(response.status, headersToRecord(response.headers), await response.text(), opName, url3), "buildError")
   });
 }
 __name(fetchV4, "fetchV4");
@@ -95021,7 +95541,7 @@ function buildPostFrameMeta(input) {
   return meta5;
 }
 __name(buildPostFrameMeta, "buildPostFrameMeta");
-function throwForErrorResponse(statusCode, responseHeaders, errorBody, opName, url3) {
+function errorFromV4Response(statusCode, responseHeaders, errorBody, opName, url3) {
   let message = `v4 ${opName} failed: HTTP ${statusCode}`;
   let code3;
   try {
@@ -95034,40 +95554,22 @@ function throwForErrorResponse(statusCode, responseHeaders, errorBody, opName, u
     if (errorBody)
       message += ` ${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 EntityConflictError2(message);
-  if (statusCode === 410)
-    throw new RunExpiredError(message);
-  if (statusCode === 425)
-    throw new TooEarlyError(message, { retryAfter });
-  if (statusCode === 429)
-    throw new ThrottleError2(message, { retryAfter });
-  throw new WorkflowWorldError2(message, {
-    status: statusCode,
+  const retryAfter = parseRetryAfter(readHeader(responseHeaders, "retry-after"));
+  return errorForResponse(statusCode, message, {
+    retryAfter,
     code: code3,
     url: url3,
-    retryAfter
+    mitigated: readHeader(responseHeaders, "x-vercel-mitigated")
   });
 }
-__name(throwForErrorResponse, "throwForErrorResponse");
+__name(errorFromV4Response, "errorFromV4Response");
 async function createWorkflowRunEventV4(input, config4) {
   const { baseUrl, headers: baseHeaders } = await getHttpConfig(config4);
   const headers = new Headers(baseHeaders);
   headers.set("Content-Type", "application/octet-stream");
   const frame3 = encodeFrame(buildPostFrameMeta(input), input.payload ?? new Uint8Array(0));
   const url3 = `${baseUrl}/v4/runs/${encodeURIComponent(input.runId)}/events/${encodeURIComponent(input.eventType)}`;
-  const response = await fetchV4(url3, { method: "POST", headers, body: frame3 }, config4);
-  if (!response.ok) {
-    const errorBody = await response.text();
-    throwForErrorResponse(response.status, headersToRecord(response.headers), errorBody, "createEvent", url3);
-  }
+  const response = await fetchV4(url3, { method: "POST", headers, body: frame3 }, config4, "createEvent");
   const eventId = response.headers.get(V4_RESPONSE_HEADERS.eventId);
   const runId = response.headers.get(V4_RESPONSE_HEADERS.runId);
   const createdAt = response.headers.get(V4_RESPONSE_HEADERS.createdAt);
@@ -95091,11 +95593,7 @@ __name(readHeader, "readHeader");
 async function getEventV4(runId, eventId, config4) {
   const { baseUrl, headers } = await getHttpConfig(config4);
   const url3 = `${baseUrl}/v4/runs/${encodeURIComponent(runId)}/events/${encodeURIComponent(eventId)}`;
-  const response = await fetchV4(url3, { method: "GET", headers }, config4);
-  if (!response.ok) {
-    const errorBody = await response.text();
-    throwForErrorResponse(response.status, headersToRecord(response.headers), errorBody, "getEvent", url3);
-  }
+  const response = await fetchV4(url3, { method: "GET", headers }, config4, "getEvent");
   const contentType = response.headers.get("content-type");
   if (!contentType?.startsWith(V4_FRAME_CONTENT_TYPE)) {
     throw new Error(`v4 getEvent: expected ${V4_FRAME_CONTENT_TYPE}, got ${contentType ?? "(none)"}`);
@@ -95108,11 +95606,7 @@ async function getEventV4(runId, eventId, config4) {
 }
 __name(getEventV4, "getEventV4");
 async function consumeListFrameStream(url3, headers, config4, opName) {
-  const response = await fetchV4(url3, { method: "GET", headers }, config4);
-  if (!response.ok) {
-    const errorBody = await response.text();
-    throwForErrorResponse(response.status, headersToRecord(response.headers), errorBody, opName, url3);
-  }
+  const response = await fetchV4(url3, { method: "GET", headers }, config4, opName);
   const contentType = response.headers.get("content-type");
   if (!contentType?.startsWith(V4_FRAME_CONTENT_TYPE)) {
     throw new Error(`v4 ${opName}: expected ${V4_FRAME_CONTENT_TYPE}, got ${contentType ?? "(none)"}`);
@@ -95588,7 +96082,7 @@ async function getWorkflowRunEvents(params, config4) {
 __name(getWorkflowRunEvents, "getWorkflowRunEvents");
 async function createWorkflowRunEvent(id, data, params, config4) {
   try {
-    return await createWorkflowRunEventInner(id, data, params, config4);
+    return await withEventPostRetry(() => createWorkflowRunEventInner(id, data, params, config4), data.eventType);
   } catch (err) {
     if (hookEventsRequiringExistence.has(data.eventType) && WorkflowWorldError2.is(err) && err.status === 404 && data.correlationId) {
       throw new HookNotFoundError2(data.correlationId);
@@ -95793,13 +96287,10 @@ function getStreamReadUrl(name, runId, httpConfig) {
 }
 __name(getStreamReadUrl, "getStreamReadUrl");
 function createStreamRequestError(operation, url3, response, text) {
-  const context2 = [`PUT ${url3.origin}${url3.pathname}`];
-  for (const header of ["x-vercel-id", "x-vercel-error"]) {
-    const value = response.headers.get(header);
-    if (value) {
-      context2.push(`${header}=${value}`);
-    }
-  }
+  const context2 = [
+    `PUT ${url3.origin}${url3.pathname}`,
+    ...getVercelDiagnostics(response.headers)
+  ];
   return new Error(`Stream ${operation} failed: HTTP ${response.status} (${context2.join("; ")}): ${text}`);
 }
 __name(createStreamRequestError, "createStreamRequestError");
@@ -95844,15 +96335,17 @@ function createStreamer2(config4) {
         const resolvedRunId = await runId;
         const httpConfig = await getHttpConfig(config4);
         const url3 = getStreamUrl(name, resolvedRunId, httpConfig);
-        const response = await fetch(url3, {
+        const response = await instrumentedFetch({
           method: "PUT",
+          url: url3.toString(),
           body: chunk,
-          headers: httpConfig.headers
+          headers: httpConfig.headers,
+          dispatcher: getStreamDispatcher(config4),
+          timeoutMs: null,
+          logLabel: url3.pathname,
+          buildError: /* @__PURE__ */ __name(async (res) => createStreamRequestError("write", url3, res, await res.text()), "buildError")
         });
-        const text = await response.text();
-        if (!response.ok) {
-          throw createStreamRequestError("write", url3, response, text);
-        }
+        await response.text();
       },
       async writeMulti(runId, name, chunks) {
         if (chunks.length === 0)
@@ -95864,15 +96357,17 @@ function createStreamer2(config4) {
           const batch = chunks.slice(i, i + MAX_CHUNKS_PER_REQUEST);
           const body = encodeMultiChunks(batch);
           const url3 = getStreamUrl(name, resolvedRunId, httpConfig);
-          const response = await fetch(url3, {
+          const response = await instrumentedFetch({
             method: "PUT",
+            url: url3.toString(),
             body,
-            headers: httpConfig.headers
+            headers: httpConfig.headers,
+            dispatcher: getStreamDispatcher(config4),
+            timeoutMs: null,
+            logLabel: url3.pathname,
+            buildError: /* @__PURE__ */ __name(async (res) => createStreamRequestError("write", url3, res, await res.text()), "buildError")
           });
-          const text = await response.text();
-          if (!response.ok) {
-            throw createStreamRequestError("write", url3, response, text);
-          }
+          await response.text();
         }
       },
       async close(runId, name) {
@@ -95880,14 +96375,16 @@ function createStreamer2(config4) {
         const httpConfig = await getHttpConfig(config4);
         httpConfig.headers.set("X-Stream-Done", "true");
         const url3 = getStreamUrl(name, resolvedRunId, httpConfig);
-        const response = await fetch(url3, {
+        const response = await instrumentedFetch({
           method: "PUT",
-          headers: httpConfig.headers
+          url: url3.toString(),
+          headers: httpConfig.headers,
+          dispatcher: getStreamDispatcher(config4),
+          timeoutMs: null,
+          logLabel: url3.pathname,
+          buildError: /* @__PURE__ */ __name(async (res) => createStreamRequestError("close", url3, res, await res.text()), "buildError")
         });
-        const text = await response.text();
-        if (!response.ok) {
-          throw createStreamRequestError("close", url3, response, text);
-        }
+        await response.text();
       },
       async get(runId, name, startIndex) {
         const httpConfig = await getHttpConfig(config4);
@@ -95895,12 +96392,15 @@ function createStreamer2(config4) {
         if (typeof startIndex === "number") {
           url3.searchParams.set("startIndex", String(startIndex));
         }
-        const response = await fetch(url3, {
-          headers: httpConfig.headers
+        const response = await instrumentedFetch({
+          method: "GET",
+          url: url3.toString(),
+          headers: httpConfig.headers,
+          dispatcher: void 0,
+          timeoutMs: null,
+          logLabel: url3.pathname,
+          buildError: /* @__PURE__ */ __name((res) => new Error(`Failed to fetch stream: ${res.status}`), "buildError")
         });
-        if (!response.ok) {
-          throw new Error(`Failed to fetch stream: ${response.status}`);
-        }
         if (!response.body) {
           throw new Error("No response body for stream");
         }
@@ -95933,12 +96433,15 @@ function createStreamer2(config4) {
       async list(runId) {
         const httpConfig = await getHttpConfig(config4);
         const url3 = new URL(`${httpConfig.baseUrl}/v2/runs/${encodeURIComponent(runId)}/streams`);
-        const response = await fetch(url3, {
-          headers: httpConfig.headers
+        const response = await instrumentedFetch({
+          method: "GET",
+          url: url3.toString(),
+          headers: httpConfig.headers,
+          dispatcher: void 0,
+          timeoutMs: null,
+          logLabel: url3.pathname,
+          buildError: /* @__PURE__ */ __name((res) => new Error(`Failed to list streams: ${res.status}`), "buildError")
         });
-        if (!response.ok) {
-          throw new Error(`Failed to list streams: ${response.status}`);
-        }
         return await response.json();
       }
     }
@@ -96148,7 +96651,7 @@ async function handleReplayBudgetExhausted(args) {
         specVersion: SPEC_VERSION_CURRENT2,
         eventData: {
           error: await dehydrateRunError(timeoutErr, runId, await getEncryptionKey()),
-          errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT
+          errorCode: RUN_ERROR_CODES2.REPLAY_TIMEOUT
         }
       }, { requestId });
     } catch (err) {
@@ -96168,7 +96671,7 @@ async function handleReplayBudgetExhausted(args) {
     });
     process.exit(1);
   }
-  const replayTimeoutDescription = describeError(void 0, RUN_ERROR_CODES.REPLAY_TIMEOUT);
+  const replayTimeoutDescription = describeError(void 0, RUN_ERROR_CODES2.REPLAY_TIMEOUT);
   runLogger.error("Workflow replay exceeded timeout and max retries exceeded. Failing the run", {
     timeoutMs: limitMs,
     attempt,
@@ -96184,7 +96687,7 @@ async function handleReplayBudgetExhausted(args) {
       specVersion: SPEC_VERSION_CURRENT2,
       eventData: {
         error: await dehydrateRunError(timeoutErr, runId, await getEncryptionKey()),
-        errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT
+        errorCode: RUN_ERROR_CODES2.REPLAY_TIMEOUT
       }
     }, { requestId });
   } catch (err) {
@@ -96562,13 +97065,14 @@ async function executeStep(params) {
       return { type: "failed" };
     }
     const preCompletionOps = [];
+    const ops = [];
+    let opsSettled = true;
     try {
       const attempt = step.attempt;
       if (!step.startedAt) {
         throw new WorkflowRuntimeError2(`Step "${stepId}" has no "startedAt" timestamp`);
       }
       const stepStartedAt = step.startedAt;
-      const ops = [];
       const encryptionKey = params.encryptionKey ?? await getEncryptionKey();
       const hydratedInput = await trace3("step.hydrate", {}, async (hydrateSpan) => {
         const startTime = Date.now();
@@ -96603,7 +97107,12 @@ async function executeStep(params) {
           ops,
           preCompletionOps,
           closureVars: hydratedInput.closureVars,
-          encryptionKey
+          encryptionKey,
+          // Turbo optimistic start runs this body before `run_started` is
+          // durable. Expose the barrier so a direct step-body world write
+          // (e.g. `experimental_setAttributes`) can order itself after the
+          // run exists. Undefined on the await path (run already durable).
+          runReadyBarrier: optimisticStart ? params.runReadyBarrier : void 0
         }, () => stepFn.apply(thisVal, args));
       });
       const executionTimeMs = Date.now() - executionStartTime;
@@ -96612,7 +97121,20 @@ async function executeStep(params) {
       });
       result = await trace3("step.dehydrate", {}, async (dehydrateSpan) => {
         const startTime = Date.now();
-        const dehydrated = await dehydrateStepReturnValue2(result, workflowRunId, encryptionKey, ops, globalThis, false, false, compression);
+        const dehydrated = await dehydrateStepReturnValue2(
+          result,
+          workflowRunId,
+          encryptionKey,
+          ops,
+          globalThis,
+          false,
+          false,
+          compression,
+          // Turbo optimistic start: a returned stream is piped to the server
+          // after the body but within this same op flush, so gate its first
+          // write on the run-ready barrier. Undefined on the await path.
+          optimisticStart ? params.runReadyBarrier : void 0
+        );
         const durationMs = Date.now() - startTime;
         dehydrateSpan?.setAttributes({
           ...QueueSerializeTimeMs2(durationMs),
@@ -96620,7 +97142,6 @@ async function executeStep(params) {
         });
         return dehydrated;
       });
-      let opsSettled = true;
       if (ops.length > 0) {
         const opsPromise = Promise.all(ops);
         safeWaitUntil2(opsPromise, (err) => {
@@ -96649,45 +97170,6 @@ async function executeStep(params) {
         await Promise.all(preCompletionOps).catch(() => {
         });
       }
-      let stepCompleted409 = false;
-      const completedResult = await world.events.create(workflowRunId, {
-        eventType: "step_completed",
-        specVersion: SPEC_VERSION_CURRENT2,
-        correlationId: stepId,
-        eventData: {
-          stepName,
-          workflowName,
-          result
-        }
-      }, params.inlineDeltaSinceCursor !== void 0 ? { sinceCursor: params.inlineDeltaSinceCursor } : void 0).catch((err) => {
-        if (EntityConflictError2.is(err)) {
-          runtimeLogger2.info("Tried completing step, but step has already finished.", {
-            workflowRunId,
-            stepId,
-            stepName,
-            message: err.message
-          });
-          stepCompleted409 = true;
-          return void 0;
-        }
-        throw err;
-      });
-      if (stepCompleted409) {
-        return { type: "skipped" };
-      }
-      const inlineDelta = completedResult ? extractInlineDelta(completedResult, params.inlineDeltaSinceCursor !== void 0) : void 0;
-      span?.setAttributes({
-        ...StepStatus2("completed"),
-        ...StepResultType2(typeof result)
-      });
-      if (ops.length > 0) {
-        stepLogger2.debug("Step has pending ops", {
-          workflowRunId,
-          stepName,
-          opsCount: ops.length
-        });
-      }
-      return { type: "completed", hasPendingOps: !opsSettled, inlineDelta };
     } catch (err) {
       if (optimisticStart) {
         const reconcile = await reconcileOptimisticStart();
@@ -96848,6 +97330,51 @@ async function executeStep(params) {
       });
       return { type: "retry", timeoutSeconds };
     }
+    let completedResult;
+    try {
+      completedResult = await world.events.create(workflowRunId, {
+        eventType: "step_completed",
+        specVersion: SPEC_VERSION_CURRENT2,
+        correlationId: stepId,
+        eventData: {
+          stepName,
+          workflowName,
+          result
+        }
+      }, params.inlineDeltaSinceCursor !== void 0 ? { sinceCursor: params.inlineDeltaSinceCursor } : void 0);
+    } catch (err) {
+      if (EntityConflictError2.is(err)) {
+        runtimeLogger2.info("Tried completing step, but step has already finished.", {
+          workflowRunId,
+          stepId,
+          stepName,
+          message: err.message
+        });
+        return { type: "skipped" };
+      }
+      if (RunExpiredError.is(err)) {
+        stepLogger2.info("Workflow run already completed, skipping step", {
+          workflowRunId,
+          stepId,
+          message: err.message
+        });
+        return { type: "gone" };
+      }
+      throw err;
+    }
+    const inlineDelta = extractInlineDelta(completedResult, params.inlineDeltaSinceCursor !== void 0);
+    span?.setAttributes({
+      ...StepStatus2("completed"),
+      ...StepResultType2(typeof result)
+    });
+    if (ops.length > 0) {
+      stepLogger2.debug("Step has pending ops", {
+        workflowRunId,
+        stepName,
+        opsCount: ops.length
+      });
+    }
+    return { type: "completed", hasPendingOps: !opsSettled, inlineDelta };
   });
 }
 __name(executeStep, "executeStep");
@@ -98987,7 +99514,7 @@ function createSleep(ctx) {
 __name(createSleep, "createSleep");
 
 // ../core/dist/workflow.js
-async function drainPendingQueueItems(runId, pendingQueue, vmGlobalThis, workflowRun, outcome) {
+async function drainPendingQueueItems(runId, pendingQueue, vmGlobalThis, workflowRun, outcome, runReadyBarrier) {
   if (pendingQueue.size === 0)
     return;
   for (const item of pendingQueue.values()) {
@@ -99001,7 +99528,8 @@ async function drainPendingQueueItems(runId, pendingQueue, vmGlobalThis, workflo
     await handleSuspension({
       suspension: synthesized,
       world,
-      run: workflowRun
+      run: workflowRun,
+      runReadyBarrier
     });
   } catch (err) {
     runtimeLogger2.warn(`Failed to drain pending queue items for ${outcome} workflow run`, {
@@ -99011,7 +99539,7 @@ async function drainPendingQueueItems(runId, pendingQueue, vmGlobalThis, workflo
   }
 }
 __name(drainPendingQueueItems, "drainPendingQueueItems");
-async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, stepHydrationCache) {
+async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, stepHydrationCache, runReadyBarrier) {
   return trace3(`workflow.run ${workflowRun.workflowName}`, async (span) => {
     span?.setAttributes({
       ...WorkflowName2(workflowRun.workflowName),
@@ -99090,12 +99618,12 @@ async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, st
     });
     const useStep = createUseStep(workflowContext);
     const createHook = createCreateHook(workflowContext);
-    const sleep = createSleep(workflowContext);
+    const sleep2 = createSleep(workflowContext);
     const setAttributes = createSetAttributes(workflowContext);
     vmGlobalThis[WORKFLOW_USE_STEP] = useStep;
     vmGlobalThis[WORKFLOW_SET_ATTRIBUTES] = setAttributes;
     vmGlobalThis[WORKFLOW_CREATE_HOOK] = createHook;
-    vmGlobalThis[WORKFLOW_SLEEP] = sleep;
+    vmGlobalThis[WORKFLOW_SLEEP] = sleep2;
     vmGlobalThis[WORKFLOW_GET_STREAM_ID] = (namespace) => getWorkflowRunStreamId2(workflowRun.runId, namespace);
     const url3 = isVercel ? `https://${process.env.VERCEL_URL}` : `http://localhost:${port ?? 3e3}`;
     const ctx = {
@@ -99494,7 +100022,7 @@ Learn more: https://workflow-sdk.dev/err/${ERROR_SLUGS2.FETCH_IN_WORKFLOW_FUNCTI
     runCachedWorkflowScript(workflowCode2, filename, context2);
     const workflowFn = runCachedWorkflowScript(`globalThis.__private_workflows?.get(${JSON.stringify(workflowRun.workflowName)})`, filename, context2);
     if (typeof workflowFn !== "function") {
-      throw new WorkflowNotRegisteredError(workflowRun.workflowName);
+      throw new WorkflowNotRegisteredError2(workflowRun.workflowName);
     }
     let args = [];
     workflowContext.promiseQueue = workflowContext.promiseQueue.then(async () => {
@@ -99523,13 +100051,13 @@ Learn more: https://workflow-sdk.dev/err/${ERROR_SLUGS2.FETCH_IN_WORKFLOW_FUNCTI
       span?.setAttributes({
         ...WorkflowResultType2(typeof result)
       });
-      await drainPendingQueueItems(workflowRun.runId, workflowContext.invocationsQueue, vmGlobalThis, workflowRun, "completed");
+      await drainPendingQueueItems(workflowRun.runId, workflowContext.invocationsQueue, vmGlobalThis, workflowRun, "completed", runReadyBarrier);
       return dehydrated;
     } catch (err) {
       if (WorkflowSuspension2.is(err) || ReplayDivergenceError.is(err)) {
         throw err;
       }
-      await drainPendingQueueItems(workflowRun.runId, workflowContext.invocationsQueue, vmGlobalThis, workflowRun, "failed");
+      await drainPendingQueueItems(workflowRun.runId, workflowContext.invocationsQueue, vmGlobalThis, workflowRun, "failed", runReadyBarrier);
       throw err;
     }
   });
@@ -99889,10 +100417,10 @@ var Run2 = class _Run2 {
 // ../core/dist/runtime.js
 function getWorkflowSetupErrorCode(err) {
   if (WorkflowRuntimeError2.is(err)) {
-    return RUN_ERROR_CODES.RUNTIME_ERROR;
+    return RUN_ERROR_CODES2.RUNTIME_ERROR;
   }
   if (isWorldContractError(err)) {
-    return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;
+    return RUN_ERROR_CODES2.WORLD_CONTRACT_ERROR;
   }
   return null;
 }
@@ -99920,7 +100448,7 @@ async function recordFatalRunError({ world, workflowRun, runId, requestId, err,
     if (isWorldContractError(failErr)) {
       runtimeLogger2.error("Fatal world contract error while recording workflow failure", {
         workflowRunId: runId,
-        errorCode: RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,
+        errorCode: RUN_ERROR_CODES2.WORLD_CONTRACT_ERROR,
         error: failErr instanceof Error ? failErr.message : String(failErr)
       });
       return;
@@ -99979,7 +100507,7 @@ function workflowEntrypoint(workflowCode2, options) {
     const workflowName = metadata.queueName.slice(workflowPrefix.length);
     const runLogger = runtimeLogger2.forRun(runId, workflowName);
     if (metadata.attempt > MAX_QUEUE_DELIVERIES) {
-      const maxDeliveriesDescription = describeError(void 0, RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED);
+      const maxDeliveriesDescription = describeError(void 0, RUN_ERROR_CODES2.MAX_DELIVERIES_EXCEEDED);
       runLogger.error(`Workflow handler exceeded max deliveries (${metadata.attempt}/${MAX_QUEUE_DELIVERIES})`, {
         attempt: metadata.attempt,
         errorCode: maxDeliveriesDescription.errorCode,
@@ -99994,7 +100522,7 @@ function workflowEntrypoint(workflowCode2, options) {
           specVersion: SPEC_VERSION_CURRENT2,
           eventData: {
             error: await dehydrateRunError(err, runId, await getEncryptionKey()),
-            errorCode: RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED
+            errorCode: RUN_ERROR_CODES2.MAX_DELIVERIES_EXCEEDED
           }
         }, { requestId });
       } catch (err) {
@@ -100419,7 +100947,18 @@ function workflowEntrypoint(workflowCode2, options) {
                 eventCount: events.length
               });
               replayStart = Date.now();
-              const result = await runWorkflow(workflowCode2, workflowRun, events, encryptionKey, stepHydrationCache);
+              const result = await runWorkflow(
+                workflowCode2,
+                workflowRun,
+                events,
+                encryptionKey,
+                stepHydrationCache,
+                // Turbo: the end-of-run drain inside runWorkflow commits
+                // fire-and-forget `*_created` events before the terminal
+                // `awaitRunReady()` below, so gate those writes on the
+                // backgrounded run_started too. Undefined outside turbo.
+                runReadyBarrier
+              );
               runtimeLogger2.debug("Workflow replay completed", {
                 workflowRunId: runId,
                 loopIteration,
@@ -100665,12 +101204,20 @@ function workflowEntrypoint(workflowCode2, options) {
                   }
                 }
               } else {
+                if (isRetryableWorldError2(err)) {
+                  runLogger.warn("Transient world error during replay; redelivering via queue instead of failing the run", {
+                    errorName: err instanceof Error ? err.name : "UnknownError",
+                    errorMessage: err instanceof Error ? err.message : String(err),
+                    deliveryAttempt: metadata.attempt
+                  });
+                  throw err;
+                }
                 let terminalError = err;
                 if (ReplayDivergenceError.is(err)) {
                   const divergenceCount = (replayDivergence?.count ?? 0) + 1;
                   if (divergenceCount <= REPLAY_DIVERGENCE_MAX_RETRIES) {
                     runLogger.warn("Workflow replay diverged; queueing a recovery replay before declaring the event log corrupted", {
-                      errorCode: RUN_ERROR_CODES.REPLAY_DIVERGENCE,
+                      errorCode: RUN_ERROR_CODES2.REPLAY_DIVERGENCE,
                       divergenceEventId: err.eventId,
                       priorDivergenceEventId: replayDivergence?.eventId,
                       divergenceCount,
@@ -100734,7 +101281,7 @@ function workflowEntrypoint(workflowCode2, options) {
                   if (isWorldContractError(failErr)) {
                     runtimeLogger2.error("Fatal world contract error while recording workflow failure", {
                       workflowRunId: runId,
-                      errorCode: RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,
+                      errorCode: RUN_ERROR_CODES2.WORLD_CONTRACT_ERROR,
                       error: failErr instanceof Error ? failErr.message : String(failErr)
                     });
                     return;
@@ -117072,10 +117619,10 @@ var Run = class _Run {
     return this.getReadable();
   }
 };
-Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.24//Run#wakeUp");
-Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.24//Run#cancel");
-Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.24//Run#getReadable");
-var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.24//Run#exists");
+Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.26//Run#wakeUp");
+Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.26//Run#cancel");
+Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.26//Run#getReadable");
+var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.26//Run#exists");
 Object.defineProperty(Run.prototype, "exists", {
   get() {
     return __step_Run$exists.call(this);
@@ -117083,7 +117630,7 @@ Object.defineProperty(Run.prototype, "exists", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.24//Run#status");
+var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.26//Run#status");
 Object.defineProperty(Run.prototype, "status", {
   get() {
     return __step_Run$status.call(this);
@@ -117091,7 +117638,7 @@ Object.defineProperty(Run.prototype, "status", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.24//Run#returnValue");
+var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.26//Run#returnValue");
 Object.defineProperty(Run.prototype, "returnValue", {
   get() {
     return __step_Run$returnValue.call(this);
@@ -117099,7 +117646,7 @@ Object.defineProperty(Run.prototype, "returnValue", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.24//Run#workflowName");
+var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.26//Run#workflowName");
 Object.defineProperty(Run.prototype, "workflowName", {
   get() {
     return __step_Run$workflowName.call(this);
@@ -117107,7 +117654,7 @@ Object.defineProperty(Run.prototype, "workflowName", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.24//Run#createdAt");
+var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.26//Run#createdAt");
 Object.defineProperty(Run.prototype, "createdAt", {
   get() {
     return __step_Run$createdAt.call(this);
@@ -117115,7 +117662,7 @@ Object.defineProperty(Run.prototype, "createdAt", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.24//Run#startedAt");
+var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.26//Run#startedAt");
 Object.defineProperty(Run.prototype, "startedAt", {
   get() {
     return __step_Run$startedAt.call(this);
@@ -117123,7 +117670,7 @@ Object.defineProperty(Run.prototype, "startedAt", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.24//Run#completedAt");
+var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.26//Run#completedAt");
 Object.defineProperty(Run.prototype, "completedAt", {
   get() {
     return __step_Run$completedAt.call(this);
@@ -117140,7 +117687,7 @@ Object.defineProperty(Run.prototype, "completedAt", {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.24//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.26//Run");
 
 // ../core/dist/workflow/create-hook.js
 aliasSerializationClass(RUN_CLASS_ID, Run);