@workflow/world-testing 5.0.0-beta.46 → 5.0.0-beta.47

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

@@ -1,7 +1,11 @@
 // biome-ignore-all lint: generated file
 /* eslint-disable */
 import { createRequire as __createRequire } from "node:module";
+import { fileURLToPath as __fileURLToPath } from "node:url";
+import { dirname as __pathDirname } from "node:path";
 var require = __createRequire(import.meta.url);
+var __filename = __fileURLToPath(import.meta.url);
+var __dirname = __pathDirname(__filename);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -52,6 +56,26 @@ var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__
   mod
 ));
 
+// ../utils/dist/debug-log.js
+function isWorkflowDebugEnabled() {
+  const debug = typeof process !== "undefined" ? process.env.DEBUG : void 0;
+  if (typeof debug !== "string")
+    return false;
+  return debug.includes("workflow:") || debug === "*";
+}
+function debugLog(...args) {
+  if (!isWorkflowDebugEnabled())
+    return;
+  console.debug(...args);
+}
+var init_debug_log = __esm({
+  "../utils/dist/debug-log.js"() {
+    "use strict";
+    __name(isWorkflowDebugEnabled, "isWorkflowDebugEnabled");
+    __name(debugLog, "debugLog");
+  }
+});
+
 // ../utils/dist/global-singleton.js
 function globalSingleton2(name, shapeVersion, create) {
   const key = /* @__PURE__ */ Symbol.for(`${name}/v${shapeVersion}`);
@@ -409,6 +433,7 @@ var init_world_target = __esm({
 var init_dist5 = __esm({
   "../utils/dist/index.js"() {
     "use strict";
+    init_debug_log();
     init_global_singleton2();
     init_parse_name2();
     init_pluralize2();
@@ -15315,19 +15340,30 @@ function isSealedNoopEvent(event) {
 function entityEventClass(eventType) {
   return getOwnProperty(ENTITY_EVENT_CLASS_BY_TYPE, eventType);
 }
+function classifyEntityEvent(event) {
+  const eventClass = entityEventClass(event.eventType);
+  if (eventClass === void 0) {
+    return void 0;
+  }
+  if (eventClass === "run_started") {
+    return { eventClass, entity: RUN_ENTITY_KEY };
+  }
+  return event.correlationId ? { eventClass, entity: event.correlationId } : void 0;
+}
 function getEventDataRefFields(eventType) {
   return getOwnProperty(EVENT_DATA_REF_FIELDS_BY_EVENT_TYPE, eventType) ?? NO_EVENT_DATA_REF_FIELDS;
 }
 function getEventDataPayloadField(eventType) {
   return getEventDataRefFields(eventType)[0];
 }
-var ENTITY_EVENT_CLASS_BY_TYPE, EVENT_DATA_REF_FIELDS_BY_EVENT_TYPE, NO_EVENT_DATA_REF_FIELDS;
+var ENTITY_EVENT_CLASS_BY_TYPE, RUN_ENTITY_KEY, TERMINAL_EVENT_CLASSES, EVENT_DATA_REF_FIELDS_BY_EVENT_TYPE, NO_EVENT_DATA_REF_FIELDS;
 var init_event_metadata2 = __esm({
   "../world/dist/event-metadata.js"() {
     "use strict";
     __name(getOwnProperty, "getOwnProperty");
     __name(isSealedNoopEvent, "isSealedNoopEvent");
     ENTITY_EVENT_CLASS_BY_TYPE = {
+      attr_set: "attr_set",
       step_created: "step_created",
       step_started: "step_started",
       step_retrying: "step_retrying",
@@ -15340,6 +15376,14 @@ var init_event_metadata2 = __esm({
       run_started: "run_started"
     };
     __name(entityEventClass, "entityEventClass");
+    RUN_ENTITY_KEY = "";
+    TERMINAL_EVENT_CLASSES = /* @__PURE__ */ new Set([
+      "attr_set",
+      "step_terminal",
+      "wait_completed",
+      "hook_disposed"
+    ]);
+    __name(classifyEntityEvent, "classifyEntityEvent");
     EVENT_DATA_REF_FIELDS_BY_EVENT_TYPE = {
       run_created: ["input"],
       run_started: ["input"],
@@ -16426,8 +16470,9 @@ var init_queue2 = __esm({
       /** Epoch ms immediately before the queue publish was requested. */
       queuePublishRequestedAtMs: external_exports2.number(),
       /**
-       * Which `resumeHook()` dispatch path ran: `lazy` or `sequential` (`parallel`
-       * from producers predating lazy-only resume).
+       * Which `resumeHook()` dispatch path ran. Current producers always report
+       * `sequential` (durable write, then wake); older producers may report
+       * `lazy` or `parallel`.
        */
       strategy: external_exports2.string().optional(),
       /** Epoch ms the final consumer's queue handler was entered. */
@@ -16499,9 +16544,9 @@ var init_queue2 = __esm({
       /** Run creation data, only present on the first queue delivery from start() */
       runInput: RunInputSchema2.optional(),
       /**
-       * Lazy hook resume data, only present when `resumeHook()` takes the parallel
-       * fast path. A consumer that understands this field idempotently ensures the
-       * `hook_received` event exists (keyed by `resumeId`) before replaying.
+       * Legacy lazy hook resume data. A consumer that understands this field
+       * idempotently ensures the `hook_received` event exists (keyed by `resumeId`)
+       * before replaying.
        */
       hookInput: HookResumeInputSchema2.optional(),
       /**
@@ -16513,7 +16558,7 @@ var init_queue2 = __esm({
       stepInput: StepDispatchInputSchema2.optional(),
       /**
        * Hook-resume TTR timing. Present on both `resumeHook()` dispatch paths
-       * (unlike `hookInput`, which only rides the lazy path), and
+       * (unlike legacy `hookInput`), and
        * forwarded onto a dispatched step message when the resuming invocation
        * hands the next durable step to another invocation. Purely observational.
        * See {@link HookResumeTimingSchema}.
@@ -16571,12 +16616,14 @@ var init_hooks2 = __esm({
       encryptionPublicKey: external_exports2.string().optional(),
       // Feature marker: the version of the lazy-hook-resume consumer protocol the
       // run's creating deployment supports. Present (>= 1) means that deployment's
-      // `@workflow/core` re-ensures the `hook_received` event from the queue
-      // message's `hookInput` on replay, so `resumeHook()`'s lazy path is safe to
-      // use. Because a run is pinned to its creating deployment, this
-      // marker is a reliable per-run attestation, unlike inferring support from a
-      // version compare against a predicted release cutoff. Absent on runs created
-      // before the marker existed (fall back to the sequential path).
+      // `@workflow/core` re-ensures the `hook_received` event from a queue
+      // message's `hookInput` on replay. Current producers no longer send
+      // `hookInput` (the durable write happens before the wake is published), so
+      // they never read this marker; it remains stamped so OLDER producers, which
+      // still gate their lazy path on it, keep working against new runs. Because a
+      // run is pinned to its creating deployment, this marker is a reliable
+      // per-run attestation, unlike inferring support from a version compare
+      // against a predicted release cutoff.
       hookResumeInputVersion: external_exports2.number().optional()
     });
     HOOK_RESUME_INPUT_VERSION2 = 1;
@@ -16661,15 +16708,22 @@ async function reenqueueActiveRuns(runs, enqueue, label, namespace) {
       cursor = page.cursor ?? void 0;
     }
   }
-  if (reenqueued > 0) {
-    console.log(`[${label}] Re-enqueued ${reenqueued} active run(s) on startup`);
+  if (reenqueued > 0 && isDebugEnabled()) {
+    console.debug(`[${label}] Re-enqueued ${reenqueued} active run(s) on startup`);
   }
 }
+function isDebugEnabled() {
+  const debug = typeof process !== "undefined" ? process.env.DEBUG : void 0;
+  if (typeof debug !== "string")
+    return false;
+  return debug.includes("workflow:") || debug === "*";
+}
 var init_recovery2 = __esm({
   "../world/dist/recovery.js"() {
     "use strict";
     init_queue2();
     __name(reenqueueActiveRuns, "reenqueueActiveRuns");
+    __name(isDebugEnabled, "isDebugEnabled");
   }
 });
 
@@ -17074,6 +17128,7 @@ __export(dist_exports, {
   QueuePrefix: () => QueuePrefix2,
   RESERVED_ATTRIBUTE_KEY_PREFIX: () => RESERVED_ATTRIBUTE_KEY_PREFIX2,
   ROOT_RUN_ID_ATTRIBUTE: () => ROOT_RUN_ID_ATTRIBUTE2,
+  RUN_ENTITY_KEY: () => RUN_ENTITY_KEY,
   RUN_EVENT_TYPES: () => RUN_EVENT_TYPES2,
   RunInputSchema: () => RunInputSchema2,
   SEALED_LOG_ENV_VAR: () => SEALED_LOG_ENV_VAR,
@@ -17091,6 +17146,7 @@ __export(dist_exports, {
   StepSchema: () => StepSchema2,
   StepStatusSchema: () => StepStatusSchema2,
   StructuredErrorSchema: () => StructuredErrorSchema2,
+  TERMINAL_EVENT_CLASSES: () => TERMINAL_EVENT_CLASSES,
   TERMINAL_RUN_EVENT_TYPES: () => TERMINAL_RUN_EVENT_TYPES2,
   TERMINAL_STEP_EVENT_TYPES: () => TERMINAL_STEP_EVENT_TYPES2,
   TERMINAL_STEP_STATUSES: () => TERMINAL_STEP_STATUSES2,
@@ -17108,6 +17164,7 @@ __export(dist_exports, {
   WorkflowRunStatusSchema: () => WorkflowRunStatusSchema2,
   _resetEnvWarnCacheForTests: () => _resetEnvWarnCacheForTests,
   applyAttributeChanges: () => applyAttributeChanges,
+  classifyEntityEvent: () => classifyEntityEvent,
   entityEventClass: () => entityEventClass,
   envFlag: () => envFlag,
   envNumber: () => envNumber2,
@@ -17956,9 +18013,7 @@ async function getAllPorts() {
         return [];
     }
   } catch (error95) {
-    if (process.env.NODE_ENV === "development") {
-      console.debug("[getAllPorts] Detection failed:", error95);
-    }
+    debugLog("[getAllPorts] Detection failed:", error95);
     return [];
   }
 }
@@ -17994,15 +18049,14 @@ async function getWorkflowPort(options) {
   if (workflowPort) {
     return workflowPort.port;
   }
-  if (process.env.NODE_ENV === "development") {
-    console.debug("[getWorkflowPort] Probing failed, falling back to first port:", ports[0]);
-  }
+  debugLog("[getWorkflowPort] Probing failed, falling back to first port:", ports[0]);
   return ports[0];
 }
 var execFileAsync, join, PROC_ROOT, PROBE_TIMEOUT_MS, PROBE_ENDPOINT;
 var init_get_port = __esm({
   "../utils/dist/get-port.js"() {
     "use strict";
+    init_debug_log();
     init_get_port_internals();
     init_workflow_routes();
     execFileAsync = promisify(execFile);
@@ -23078,7 +23132,7 @@ var require_diagnostics = __commonJS({
       proxyConnected: diagnosticsChannel.channel("undici:proxy:connected")
     };
     var isTrackingClientEvents = false;
-    function trackClientEvents(debugLog = undiciDebugLog) {
+    function trackClientEvents(debugLog2 = undiciDebugLog) {
       if (isTrackingClientEvents) {
         return;
       }
@@ -23093,7 +23147,7 @@ var require_diagnostics = __commonJS({
           const {
             connectParams: { version: version6, protocol, port, host }
           } = evt;
-          debugLog(
+          debugLog2(
             "connecting to %s%s using %s%s",
             host,
             port ? `:${port}` : "",
@@ -23108,7 +23162,7 @@ var require_diagnostics = __commonJS({
           const {
             connectParams: { version: version6, protocol, port, host }
           } = evt;
-          debugLog(
+          debugLog2(
             "connected to %s%s using %s%s",
             host,
             port ? `:${port}` : "",
@@ -23124,7 +23178,7 @@ var require_diagnostics = __commonJS({
             connectParams: { version: version6, protocol, port, host },
             error: error95
           } = evt;
-          debugLog(
+          debugLog2(
             "connection to %s%s using %s%s errored - %s",
             host,
             port ? `:${port}` : "",
@@ -23140,13 +23194,13 @@ var require_diagnostics = __commonJS({
           const {
             request: { method, path: path14, origin }
           } = evt;
-          debugLog("sending request to %s %s%s", method, origin, path14);
+          debugLog2("sending request to %s %s%s", method, origin, path14);
         }
       );
     }
     __name(trackClientEvents, "trackClientEvents");
     var isTrackingRequestEvents = false;
-    function trackRequestEvents(debugLog = undiciDebugLog) {
+    function trackRequestEvents(debugLog2 = undiciDebugLog) {
       if (isTrackingRequestEvents) {
         return;
       }
@@ -23162,7 +23216,7 @@ var require_diagnostics = __commonJS({
             request: { method, path: path14, origin },
             response: { statusCode }
           } = evt;
-          debugLog(
+          debugLog2(
             "received response to %s %s%s - HTTP %d",
             method,
             origin,
@@ -23177,7 +23231,7 @@ var require_diagnostics = __commonJS({
           const {
             request: { method, path: path14, origin }
           } = evt;
-          debugLog("trailers received from %s %s%s", method, origin, path14);
+          debugLog2("trailers received from %s %s%s", method, origin, path14);
         }
       );
       diagnosticsChannel.subscribe(
@@ -23187,7 +23241,7 @@ var require_diagnostics = __commonJS({
             request: { method, path: path14, origin },
             error: error95
           } = evt;
-          debugLog(
+          debugLog2(
             "request to %s %s%s errored - %s",
             method,
             origin,
@@ -23199,7 +23253,7 @@ var require_diagnostics = __commonJS({
     }
     __name(trackRequestEvents, "trackRequestEvents");
     var isTrackingWebSocketEvents = false;
-    function trackWebSocketEvents(debugLog = websocketDebuglog) {
+    function trackWebSocketEvents(debugLog2 = websocketDebuglog) {
       if (isTrackingWebSocketEvents) {
         return;
       }
@@ -23213,9 +23267,9 @@ var require_diagnostics = __commonJS({
         (evt) => {
           if (evt.address != null) {
             const { address, port } = evt.address;
-            debugLog("connection opened %s%s", address, port ? `:${port}` : "");
+            debugLog2("connection opened %s%s", address, port ? `:${port}` : "");
           } else {
-            debugLog("connection opened");
+            debugLog2("connection opened");
           }
         }
       );
@@ -23223,7 +23277,7 @@ var require_diagnostics = __commonJS({
         "undici:websocket:close",
         (evt) => {
           const { websocket, code: code3, reason } = evt;
-          debugLog(
+          debugLog2(
             "closed connection to %s - %s %s",
             websocket.url,
             code3,
@@ -23234,19 +23288,19 @@ var require_diagnostics = __commonJS({
       diagnosticsChannel.subscribe(
         "undici:websocket:socket_error",
         (err) => {
-          debugLog("connection errored - %s", err.message);
+          debugLog2("connection errored - %s", err.message);
         }
       );
       diagnosticsChannel.subscribe(
         "undici:websocket:ping",
         (evt) => {
-          debugLog("ping received");
+          debugLog2("ping received");
         }
       );
       diagnosticsChannel.subscribe(
         "undici:websocket:pong",
         (evt) => {
-          debugLog("pong received");
+          debugLog2("pong received");
         }
       );
     }
@@ -47490,7 +47544,7 @@ function createQueue(config4) {
       }
       const token = semaphore.tryAcquire();
       if (!token) {
-        console.warn(`[world-local]: concurrency limit (${WORKFLOW_LOCAL_QUEUE_CONCURRENCY}) reached, waiting for queue to free up`);
+        debugLog(`[world-local]: concurrency limit (${WORKFLOW_LOCAL_QUEUE_CONCURRENCY}) reached, waiting for queue to free up`);
         await semaphore.acquire();
       }
       const MAX_LOCAL_SAFETY_LIMIT = 256;
@@ -47521,6 +47575,7 @@ function createQueue(config4) {
                 headers: new Headers(headers),
                 body,
                 agents: nodeHttpAgents,
+                signal: closeSignal,
                 headersTimeoutMs: agentOptions.headersTimeout,
                 bodyTimeoutMs: agentOptions.bodyTimeout
               }) : (
@@ -47530,7 +47585,8 @@ function createQueue(config4) {
                   duplex: "half",
                   dispatcher: httpAgent,
                   headers,
-                  body
+                  body,
+                  signal: closeSignal
                 })
               );
             }
@@ -52817,7 +52873,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(() => getVercelOidcToken7, "getVercelOidcToken"),
       getVercelToken: /* @__PURE__ */ __name(() => getVercelToken2, "getVercelToken"),
       isExpired: /* @__PURE__ */ __name(() => isExpired, "isExpired"),
       loadToken: /* @__PURE__ */ __name(() => loadToken, "loadToken"),
@@ -52879,7 +52935,7 @@ var require_token_util = __commonJS({
       }
     }
     __name(getVercelToken2, "getVercelToken");
-    async function getVercelOidcToken6(authToken, projectId, teamId) {
+    async function getVercelOidcToken7(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",
@@ -52896,7 +52952,7 @@ var require_token_util = __commonJS({
       assertVercelOidcTokenResponse(tokenRes);
       return tokenRes;
     }
-    __name(getVercelOidcToken6, "getVercelOidcToken");
+    __name(getVercelOidcToken7, "getVercelOidcToken");
     function assertVercelOidcTokenResponse(res) {
       if (!res || typeof res !== "object") {
         throw new TypeError(
@@ -53071,13 +53127,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(() => getVercelOidcToken7, "getVercelOidcToken"),
       getVercelOidcTokenSync: /* @__PURE__ */ __name(() => getVercelOidcTokenSync2, "getVercelOidcTokenSync")
     });
     module.exports = __toCommonJS(get_vercel_oidc_token_exports);
     var import_get_context = require_get_context2();
     var import_token_error = require_token_error();
-    async function getVercelOidcToken6(options) {
+    async function getVercelOidcToken7(options) {
       let token = "";
       let err;
       try {
@@ -53107,7 +53163,7 @@ ${error95.message}`;
       }
       return token;
     }
-    __name(getVercelOidcToken6, "getVercelOidcToken");
+    __name(getVercelOidcToken7, "getVercelOidcToken");
     function getVercelOidcTokenSync2() {
       const token = (0, import_get_context.getContext)().headers?.["x-vercel-oidc-token"] ?? process.env.VERCEL_OIDC_TOKEN;
       if (!token) {
@@ -56099,7 +56155,7 @@ var version4;
 var init_version3 = __esm({
   "../world-vercel/dist/version.js"() {
     "use strict";
-    version4 = "5.0.0-beta.42";
+    version4 = "5.0.0-beta.43";
   }
 });
 
@@ -66213,7 +66269,7 @@ function headersToCarrier(headers) {
   }
   return carrier;
 }
-function isDebugEnabled() {
+function isDebugEnabled2() {
   return process.env.VERCEL_QUEUE_DEBUG === "1" || process.env.VERCEL_QUEUE_DEBUG === "true";
 }
 async function consumeStream(stream) {
@@ -66987,7 +67043,7 @@ var init_dist10 = __esm({
     __name(withConsumerSpan, "withConsumerSpan");
     __name(extractProducerLink, "extractProducerLink");
     __name(headersToCarrier, "headersToCarrier");
-    __name(isDebugEnabled, "isDebugEnabled");
+    __name(isDebugEnabled2, "isDebugEnabled");
     __name(consumeStream, "consumeStream");
     __name(parseRetryAfterSeconds, "parseRetryAfterSeconds");
     __name(throwCommonHttpError, "throwCommonHttpError");
@@ -67113,7 +67169,7 @@ Cause: ${cause}`
       }
       async fetch(url3, init) {
         const method = init.method || "GET";
-        if (isDebugEnabled()) {
+        if (isDebugEnabled2()) {
           const logData = {
             method,
             url: url3,
@@ -67137,7 +67193,7 @@ Cause: ${cause}`
         init.headers.set("Vqs-Client-Ts", (/* @__PURE__ */ new Date()).toISOString());
         const fetchInit = this.dispatcher ? { ...init, dispatcher: this.dispatcher } : init;
         const response = await fetch(url3, fetchInit);
-        if (isDebugEnabled()) {
+        if (isDebugEnabled2()) {
           const logData = {
             method,
             url: url3,
@@ -67713,7 +67769,14 @@ async function* decodeFrames(source) {
     const parts = [buffer3];
     let byteLength = buffer3.byteLength;
     while (byteLength < needed) {
-      const chunk = await chunks.next();
+      let chunk;
+      try {
+        chunk = await chunks.next();
+      } catch (cause) {
+        throw new IncompleteFrameError("decodeFrames: source stream failed", {
+          cause
+        });
+      }
       if (chunk.done)
         return false;
       if (chunk.value.byteLength === 0)
@@ -67741,16 +67804,16 @@ async function* decodeFrames(source) {
       const metaLen = new DataView(buffer3.buffer, buffer3.byteOffset, 4).getUint32(0, false);
       take(4);
       if (!await refill(metaLen)) {
-        throw new Error("decodeFrames: truncated meta block");
+        throw new IncompleteFrameError("decodeFrames: truncated meta block");
       }
       const meta5 = CborObjectSchema.parse(decode5(take(metaLen)));
       if (!await refill(4)) {
-        throw new Error("decodeFrames: truncated body length");
+        throw new IncompleteFrameError("decodeFrames: truncated body length");
       }
       const bodyLen = new DataView(buffer3.buffer, buffer3.byteOffset, 4).getUint32(0, false);
       take(4);
       if (bodyLen > 0 && !await refill(bodyLen)) {
-        throw new Error("decodeFrames: truncated body bytes");
+        throw new IncompleteFrameError("decodeFrames: truncated body bytes");
       }
       yield { meta: meta5, body: buffer3.slice(0, bodyLen) };
       take(bodyLen);
@@ -67781,13 +67844,18 @@ async function* readerToIterator(reader) {
     closeQuietly(() => reader.cancel());
   }
 }
-var V4_FRAME_CONTENT_TYPE, CborObjectSchema;
+var V4_FRAME_CONTENT_TYPE, IncompleteFrameError, CborObjectSchema;
 var init_frames = __esm({
   "../world-vercel/dist/frames.js"() {
     "use strict";
     init_node_index();
     init_zod2();
     V4_FRAME_CONTENT_TYPE = "application/vnd.workflow.v4-frames";
+    IncompleteFrameError = class extends Error {
+      static {
+        __name(this, "IncompleteFrameError");
+      }
+    };
     CborObjectSchema = external_exports2.record(external_exports2.string(), external_exports2.unknown());
     __name(encodeFrame, "encodeFrame");
     __name(decodeFrames, "decodeFrames");
@@ -67867,7 +67935,7 @@ function openWsChannel(runId, config4) {
     return void 0;
   if (!wsState.loggedWsInUse) {
     wsState.loggedWsInUse = true;
-    console.log(`world-vercel: using ws events transport (${resolved}).`);
+    debugLog(`world-vercel: using ws events transport (${resolved}).`);
   }
   const transport = getWsEventsTransport(resolved, async ({ forceRefresh }) => {
     if (forceRefresh)
@@ -67897,7 +67965,7 @@ function resolveChannelUrl(runId, config4) {
   if (usingProxy) {
     if (!wsState.loggedWsProxyFallback) {
       wsState.loggedWsProxyFallback = true;
-      console.warn(`world-vercel: ws events transport requested but a World with projectConfig (api-workflow proxy, resolved baseUrl: ${baseUrl}) is active \u2014 falling back.`);
+      debugLog(`world-vercel: ws events transport unavailable for a World with projectConfig (api-workflow proxy, resolved baseUrl: ${baseUrl}) \u2014 falling back to HTTP.`);
     }
     return null;
   }
@@ -68250,7 +68318,7 @@ var init_ws_transport = __esm({
         if (decoded.meta.type === "drain") {
           const reason = decoded.meta.reason === "auth_expiry" ? "auth_expiry" : "max_duration";
           this.lastDrainReason = reason;
-          console.log(`world-vercel: ws events transport received a drain notice (reason: ${reason}, graceMs: ${decoded.meta.graceMs ?? "unspecified"}); connection will close soon.`);
+          debugLog(`world-vercel: ws events transport received a drain notice (reason: ${reason}, graceMs: ${decoded.meta.graceMs ?? "unspecified"}); connection will close soon.`);
           return;
         }
         const reqId = decoded.meta.reqId;
@@ -68670,17 +68738,29 @@ var init_queue4 = __esm({
 });
 
 // ../world-vercel/dist/resolve-latest-deployment.js
+async function resolveDeploymentIdentityToken(config4) {
+  if (config4?.token)
+    return config4.token;
+  if (process.env.VERCEL === "1") {
+    const oidcToken = await (0, import_oidc5.getVercelOidcToken)().catch(() => null);
+    if (oidcToken)
+      return oidcToken;
+  }
+  return resolveVercelApiToken(config4);
+}
 function createResolveLatestDeploymentId(config4) {
   return /* @__PURE__ */ __name(async function resolveLatestDeploymentId() {
     const currentDeploymentId = process.env.VERCEL_DEPLOYMENT_ID;
     if (!currentDeploymentId) {
       throw new Error(missingDeploymentIdMessage("Resolving the latest deployment for deploymentId: 'latest'"));
     }
-    const token = await resolveVercelApiToken(config4);
+    const token = await resolveDeploymentIdentityToken(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 teamId = config4?.projectConfig?.teamId;
+    const query = teamId ? `?${new URLSearchParams({ teamId })}` : "";
+    const url3 = `https://api.vercel.com/v1/workflow/resolve-latest-deployment/${encodeURIComponent(currentDeploymentId)}${query}`;
     const response = await instrumentedFetch({
       method: "GET",
       url: url3,
@@ -68697,7 +68777,8 @@ function createResolveLatestDeploymentId(config4) {
         } 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}` : ""}`);
+        const hint3 = res.status === 404 ? ". The deployment exists but was not visible to the identity this request authenticated as, which means the request resolved to a different team. Set the World's `projectConfig.teamId` to scope it explicitly." : "";
+        return new Error(`Failed to resolve latest deployment for ${currentDeploymentId}: HTTP ${res.status} ${res.statusText}${body ? ` \u2014 ${body}` : ""}${hint3}`);
       }, "buildError")
     });
     const data = await response.json();
@@ -68708,10 +68789,11 @@ function createResolveLatestDeploymentId(config4) {
     return result2.data.id;
   }, "resolveLatestDeploymentId");
 }
-var ResolveLatestDeploymentResponseSchema;
+var import_oidc5, ResolveLatestDeploymentResponseSchema;
 var init_resolve_latest_deployment = __esm({
   "../world-vercel/dist/resolve-latest-deployment.js"() {
     "use strict";
+    import_oidc5 = __toESM(require_dist(), 1);
     init_zod2();
     init_deployment_id();
     init_http_client();
@@ -68719,6 +68801,7 @@ var init_resolve_latest_deployment = __esm({
     ResolveLatestDeploymentResponseSchema = object2({
       id: string5()
     });
+    __name(resolveDeploymentIdentityToken, "resolveDeploymentIdentityToken");
     __name(createResolveLatestDeploymentId, "createResolveLatestDeploymentId");
   }
 });
@@ -68738,6 +68821,8 @@ function collectErrorMarkers(err, depth = 0) {
   return markers;
 }
 function isRetryableEventPostError(err) {
+  if (err instanceof ReplayEventObserverError)
+    return false;
   if (EntityConflictError2.is(err) || RunExpiredError2.is(err) || TooEarlyError.is(err) || ThrottleError2.is(err)) {
     return false;
   }
@@ -68821,11 +68906,22 @@ async function withEventPostRetry(fn, eventType, options) {
     }
   }
 }
-var EVENT_RETRY_ELIGIBILITY, MAX_EVENT_POST_RETRIES, THROTTLE_RETRY_BUDGET_MS, DEFAULT_THROTTLE_RETRY_AFTER_SECONDS, EVENT_POST_RETRY_BASE_MS, EVENT_POST_RETRY_JITTER_MS, TRANSIENT_CODES, sleep, RETRY_DEBUG_ENABLED;
+var ReplayEventObserverError, EVENT_RETRY_ELIGIBILITY, MAX_EVENT_POST_RETRIES, THROTTLE_RETRY_BUDGET_MS, DEFAULT_THROTTLE_RETRY_AFTER_SECONDS, EVENT_POST_RETRY_BASE_MS, EVENT_POST_RETRY_JITTER_MS, TRANSIENT_CODES, sleep, RETRY_DEBUG_ENABLED;
 var init_event_retry = __esm({
   "../world-vercel/dist/event-retry.js"() {
     "use strict";
     init_dist7();
+    ReplayEventObserverError = class extends Error {
+      static {
+        __name(this, "ReplayEventObserverError");
+      }
+      error;
+      constructor(error95) {
+        super("Replay event observer failed", { cause: error95 });
+        this.error = error95;
+        this.name = "ReplayEventObserverError";
+      }
+    };
     EVENT_RETRY_ELIGIBILITY = {
       // Creates: conditional create → 409 EntityConflictError if it already exists.
       run_created: {
@@ -69388,17 +69484,35 @@ async function createWorkflowRunEventV4(input, config4) {
   const response = await postWorkflowRunEventV4(input, "materialized", config4);
   const contentType = response.headers.get("content-type");
   if (contentType?.startsWith(V4_FRAME_CONTENT_TYPE)) {
-    throw new Error("v4 createEvent: unexpected event page");
+    throw new WorkflowWorldError2("v4 createEvent: unexpected event page", {
+      code: "SCHEMA_VALIDATION"
+    });
   }
   return decodeCreateEventResponse(response, input.eventType);
 }
 async function decodeCreateEventResponse(response, eventType) {
-  const bodyBytes = new Uint8Array(await response.arrayBuffer());
+  let bodyBytes;
+  try {
+    bodyBytes = new Uint8Array(await response.arrayBuffer());
+  } catch (cause) {
+    throw new WorkflowWorldError2("v4 createEvent: failed to read response body", { code: "TRANSPORT", cause });
+  }
   if (bodyBytes.byteLength === 0) {
-    throw new Error("v4 createEvent: empty response body");
+    throw new WorkflowWorldError2("v4 createEvent: empty response body", {
+      code: "PARSE_ERROR"
+    });
   }
   const schema = CreateEventV4BodySchemas[eventType].refine(({ event }) => event.eventType === eventType || eventType === "hook_created" && event.eventType === "hook_conflict", { path: ["event", "eventType"] });
-  const parsedBody = schema.safeParse(decode5(bodyBytes));
+  let decoded;
+  try {
+    decoded = decode5(bodyBytes);
+  } catch (cause) {
+    throw new WorkflowWorldError2("v4 createEvent: invalid CBOR response body", {
+      code: "PARSE_ERROR",
+      cause
+    });
+  }
+  const parsedBody = schema.safeParse(decoded);
   if (!parsedBody.success) {
     throw new WorkflowWorldError2("v4 createEvent: invalid response body", {
       code: "SCHEMA_VALIDATION",
@@ -69407,11 +69521,12 @@ async function decodeCreateEventResponse(response, eventType) {
   }
   return parsedBody.data;
 }
-async function createWorkflowRunStartedEventV4(input, config4) {
+async function createWorkflowRunStartedEventV4(input, config4, replayEventObserver) {
   const response = await postWorkflowRunEventV4({ ...input, eventType: "run_started" }, "event-stream", config4);
-  const events = [];
-  const page = await consumeEventFrameStream(response, "createEvent", events);
-  assert4(page.cursor, "v4 createEvent: event stream missing cursor");
+  const page = await consumeReplayLogResponse(response, input.runId, config4, replayEventObserver);
+  if (!page.cursor) {
+    throw new WorkflowWorldError2("v4 createEvent: event stream missing cursor", { code: "SCHEMA_VALIDATION" });
+  }
   const maxEvents = MaxEventsHeaderSchema.safeParse(response.headers.get(MAX_EVENTS_HEADER));
   if (!maxEvents.success) {
     throw new WorkflowWorldError2("v4 createEvent: invalid max-events header", {
@@ -69419,7 +69534,7 @@ async function createWorkflowRunStartedEventV4(input, config4) {
       cause: maxEvents.error
     });
   }
-  return { events, ...page, maxEvents: maxEvents.data };
+  return { ...page, maxEvents: maxEvents.data };
 }
 async function createWorkflowRunEventsBatchV4(input, config4) {
   assert4(input.events.length > 0, "v4 createEventBatch: empty batch");
@@ -69537,7 +69652,7 @@ async function postEventFrameOverWs(input, config4) {
     };
   });
 }
-async function createHookReceivedPreloadEventV4(input, config4) {
+async function createHookReceivedPreloadEventV4(input, config4, replayEventObserver) {
   const response = await postWorkflowRunEventV4({ ...input, eventType: "hook_received" }, "event-stream", config4);
   const contentType = response.headers.get("content-type");
   if (!contentType?.startsWith(V4_FRAME_CONTENT_TYPE)) {
@@ -69546,12 +69661,10 @@ async function createHookReceivedPreloadEventV4(input, config4) {
       result: await decodeCreateEventResponse(response, "hook_received")
     };
   }
-  const events = [];
-  const page = await consumeEventFrameStream(response, "createEvent", events);
+  const page = await consumeReplayLogResponse(response, input.runId, config4, replayEventObserver);
   const maxEvents = MaxEventsHeaderSchema.safeParse(response.headers.get(MAX_EVENTS_HEADER));
   return {
     kind: "stream",
-    events,
     ...page,
     canonicalEventId: response.headers.get(EVENT_ID_HEADER) ?? void 0,
     maxEvents: maxEvents.success ? maxEvents.data : void 0
@@ -69575,31 +69688,115 @@ async function getEventV4(runId, eventId, remoteRefBehavior, config4) {
   }
   const chunks = response.body;
   for await (const frame3 of decodeFrames(chunks)) {
+    if (frame3.meta._error === 1) {
+      throw streamErrorFrameToError(frame3.meta, "getEvent");
+    }
+    if (Object.keys(frame3.meta).some((key) => key.startsWith("_"))) {
+      throw new Error("v4 getEvent: unexpected control frame");
+    }
     return decodeEventFrame(frame3);
   }
   throw new Error(`v4 getEvent: empty frame stream for ${eventId}`);
 }
-async function consumeEventFrameStream(response, opName, events) {
+function streamErrorFrameToError(meta5, opName) {
+  const parsed = EventStreamErrorSchema.safeParse(meta5);
+  if (!parsed.success) {
+    return new WorkflowWorldError2(`v4 ${opName}: malformed terminal error frame`, { code: "SCHEMA_VALIDATION", cause: parsed.error });
+  }
+  const { code: code3, message } = parsed.data;
+  const detail = message ?? "(no detail)";
+  if (code3 === PAYLOAD_MISSING_ERROR_CODE) {
+    return new CorruptedEventLogError(`the event log references a payload that no longer exists in storage: ${detail}`);
+  }
+  return new WorkflowWorldError2(`v4 ${opName}: stream ended with terminal error "${code3}": ${detail}`, { code: "WORLD_CONTRACT_ERROR" });
+}
+function partialEventFrameStream(events, error95) {
+  const eventId = events.at(-1)?.eventId;
+  if (!eventId)
+    throw error95;
+  return {
+    kind: "partial",
+    events,
+    cursor: `eid:${eventId}`,
+    hasMore: true,
+    error: error95
+  };
+}
+async function consumeEventFrameStream(response, opName, replayEventObserver) {
   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)"}`);
+    throw new WorkflowWorldError2(`v4 ${opName}: expected ${V4_FRAME_CONTENT_TYPE}, got ${contentType ?? "(none)"}`, { code: "SCHEMA_VALIDATION" });
   }
-  const chunks = response.body;
-  for await (const frame3 of decodeFrames(chunks)) {
-    if (frame3.meta._end === 1) {
-      const end = EventStreamEndSchema.parse(frame3.meta);
-      return { cursor: end.next ?? null, hasMore: end.hasMore };
+  if (!response.body) {
+    throw new WorkflowWorldError2(`v4 ${opName}: response body is missing`, {
+      code: "TRANSPORT"
+    });
+  }
+  const events = [];
+  try {
+    for await (const frame3 of decodeFrames(response.body)) {
+      if (frame3.meta._end === 1) {
+        const end = EventStreamEndSchema.parse(frame3.meta);
+        return {
+          kind: "complete",
+          events,
+          cursor: end.next ?? null,
+          hasMore: end.hasMore
+        };
+      }
+      if (frame3.meta._error === 1) {
+        throw streamErrorFrameToError(frame3.meta, opName);
+      }
+      if (Object.keys(frame3.meta).some((key) => key.startsWith("_"))) {
+        throw new Error(`v4 ${opName}: unexpected control frame`);
+      }
+      const event = decodeEventFrame(frame3);
+      events.push(event);
+      try {
+        replayEventObserver?.(event);
+      } catch (error95) {
+        throw new ReplayEventObserverError(error95);
+      }
     }
-    if (Object.keys(frame3.meta).some((key) => key.startsWith("_"))) {
-      throw new Error(`v4 ${opName}: unexpected control frame`);
+  } catch (cause) {
+    if (cause instanceof ReplayEventObserverError || CorruptedEventLogError.is(cause) || WorkflowWorldError2.is(cause)) {
+      throw cause;
     }
-    events.push(decodeEventFrame(frame3));
+    if (!(cause instanceof IncompleteFrameError)) {
+      throw new WorkflowWorldError2(`v4 ${opName}: invalid event frame stream`, {
+        code: "SCHEMA_VALIDATION",
+        cause
+      });
+    }
+    return partialEventFrameStream(events, new WorkflowWorldError2(`v4 ${opName}: incomplete event frame stream`, {
+      code: "TRANSPORT",
+      cause
+    }));
+  }
+  return partialEventFrameStream(events, new WorkflowWorldError2(`v4 ${opName}: frame stream ended without the end-of-stream sentinel (${events.length} events read)`, { code: "TRANSPORT" }));
+}
+async function consumeReplayLogResponse(response, runId, config4, replayEventObserver) {
+  const page = await consumeEventFrameStream(response, "createEvent", replayEventObserver);
+  if (!page.hasMore) {
+    return {
+      events: page.events,
+      cursor: page.cursor,
+      hasMore: false
+    };
   }
-  throw new Error(`v4 ${opName}: frame stream ended without the end-of-stream sentinel (${events.length} events read) \u2014 truncated response?`);
+  if (!page.cursor) {
+    throw new WorkflowWorldError2("v4 createEvent: partial event stream missing cursor", { code: "SCHEMA_VALIDATION" });
+  }
+  const suffix = await getWorkflowRunEventsV4(runId, { cursor: page.cursor, remoteRefBehavior: "resolve" }, config4, replayEventObserver);
+  return {
+    events: [...page.events, ...suffix.events],
+    cursor: suffix.cursor ?? page.cursor,
+    hasMore: suffix.hasMore
+  };
 }
-async function consumeListFrameStream(url3, headers, config4, opName, events) {
+async function consumeListFrameStream(url3, headers, config4, opName, replayEventObserver) {
   const response = await fetchV4(url3, { method: "GET", headers }, config4, opName);
-  return consumeEventFrameStream(response, opName, events);
+  return consumeEventFrameStream(response, opName, replayEventObserver);
 }
 function appendListParams(sp, params) {
   if (params.cursor)
@@ -69619,23 +69816,34 @@ function paginationToQuery(params) {
   appendListParams(sp, params);
   return `?${sp.toString()}`;
 }
-async function getWorkflowRunEventsV4(runId, params = {}, config4) {
+async function getWorkflowRunEventsV4(runId, params = {}, config4, replayEventObserver) {
   const { baseUrl, headers } = await getHttpConfig(config4);
   const events = [];
-  let cursor = params.cursor;
-  while (true) {
-    const url3 = `${baseUrl}/v4/runs/${encodeURIComponent(runId)}/events` + paginationToQuery({ ...params, cursor });
-    try {
-      const page = await consumeListFrameStream(url3, headers, config4, "listEvents", events);
-      return { events, ...page };
-    } catch (error95) {
-      const lastEvent = events.at(-1);
-      if (params.limit !== void 0 || !lastEvent || `eid:${lastEvent.eventId}` === cursor) {
-        throw error95;
-      }
-      cursor = `eid:${lastEvent.eventId}`;
-    }
-  }
+  let cursor = params.cursor ?? null;
+  let partialStreamRetries = 0;
+  let consumed;
+  do {
+    const url3 = `${baseUrl}/v4/runs/${encodeURIComponent(runId)}/events` + paginationToQuery({ ...params, cursor: cursor ?? void 0 });
+    consumed = await consumeListFrameStream(url3, headers, config4, "listEvents", replayEventObserver);
+    const cursorAdvanced = !!consumed.cursor && consumed.cursor !== cursor;
+    if (consumed.kind === "partial") {
+      if (params.limit !== void 0 || !cursorAdvanced || partialStreamRetries === MAX_PARTIAL_STREAM_RETRIES) {
+        throw consumed.error;
+      }
+      partialStreamRetries++;
+      cursor = consumed.cursor;
+    } else if (!cursorAdvanced && (consumed.events.length > 0 || consumed.hasMore)) {
+      throw new WorkflowWorldError2("v4 listEvents: response did not advance cursor", { code: "SCHEMA_VALIDATION" });
+    }
+    for (const event of consumed.events) {
+      events.push(event);
+    }
+  } while (consumed.kind === "partial");
+  return {
+    events,
+    cursor: consumed.cursor || (partialStreamRetries > 0 ? cursor : null),
+    hasMore: consumed.hasMore
+  };
 }
 async function getEventsByCorrelationIdV4(correlationId, runId, params = {}, config4) {
   const { baseUrl, headers } = await getHttpConfig(config4);
@@ -69644,11 +69852,16 @@ async function getEventsByCorrelationIdV4(correlationId, runId, params = {}, con
   sp.set("runId", runId);
   appendListParams(sp, params);
   const url3 = `${baseUrl}/v4/events?${sp.toString()}`;
-  const events = [];
-  const page = await consumeListFrameStream(url3, headers, config4, "listEventsByCorrelationId", events);
-  return { events, ...page };
+  const consumed = await consumeListFrameStream(url3, headers, config4, "listEventsByCorrelationId");
+  if (consumed.kind === "partial")
+    throw consumed.error;
+  return {
+    events: consumed.events,
+    cursor: consumed.cursor,
+    hasMore: consumed.hasMore
+  };
 }
-var EVENT_ID_HEADER, MAX_EVENTS_HEADER, CreateEventV4BodyBaseSchema, CreateEventV4PageSchema, CreateEventV4BodySchema, CreateEventV4BodySchemas, MaxEventsHeaderSchema, EventStreamEndSchema, legacyStructuredErrorEventTypes, STRICT_WS_EVENT_TYPES, BatchItemFailureSchema;
+var EVENT_ID_HEADER, MAX_EVENTS_HEADER, CreateEventV4BodyBaseSchema, CreateEventV4PageSchema, CreateEventV4BodySchema, CreateEventV4BodySchemas, MaxEventsHeaderSchema, EventStreamEndSchema, EventStreamErrorSchema, PAYLOAD_MISSING_ERROR_CODE, legacyStructuredErrorEventTypes, STRICT_WS_EVENT_TYPES, BatchItemFailureSchema, MAX_PARTIAL_STREAM_RETRIES;
 var init_events_v4 = __esm({
   "../world-vercel/dist/events-v4.js"() {
     "use strict";
@@ -69656,6 +69869,7 @@ var init_events_v4 = __esm({
     init_dist6();
     init_node_index();
     init_zod2();
+    init_event_retry();
     init_frames();
     init_http_client();
     init_http_core();
@@ -69730,6 +69944,12 @@ var init_events_v4 = __esm({
       next: external_exports2.string().optional(),
       hasMore: external_exports2.boolean()
     });
+    EventStreamErrorSchema = external_exports2.object({
+      _error: external_exports2.literal(1),
+      code: external_exports2.string(),
+      message: external_exports2.string().optional()
+    });
+    PAYLOAD_MISSING_ERROR_CODE = "payload-missing";
     legacyStructuredErrorEventTypes = /* @__PURE__ */ new Set([
       "run_failed",
       "step_failed",
@@ -69760,7 +69980,11 @@ var init_events_v4 = __esm({
     __name(createHookReceivedPreloadEventV4, "createHookReceivedPreloadEventV4");
     __name(readHeader, "readHeader");
     __name(getEventV4, "getEventV4");
+    __name(streamErrorFrameToError, "streamErrorFrameToError");
+    MAX_PARTIAL_STREAM_RETRIES = 2;
+    __name(partialEventFrameStream, "partialEventFrameStream");
     __name(consumeEventFrameStream, "consumeEventFrameStream");
+    __name(consumeReplayLogResponse, "consumeReplayLogResponse");
     __name(consumeListFrameStream, "consumeListFrameStream");
     __name(appendListParams, "appendListParams");
     __name(paginationToQuery, "paginationToQuery");
@@ -70211,6 +70435,8 @@ async function createWorkflowRunEvent(id, data, params, config4) {
     }
     return result2;
   } catch (err) {
+    if (err instanceof ReplayEventObserverError)
+      throw err.error;
     if (isHookEventRequiringExistence(data.eventType) && WorkflowWorldError2.is(err) && err.status === 404 && data.correlationId) {
       throw new HookNotFoundError2(data.correlationId);
     }
@@ -70282,39 +70508,14 @@ async function createWorkflowRunEventInner(id, data, params, config4) {
     ...meta5
   };
   if (data.eventType === "run_started" && !params?.skipPreload) {
-    const result2 = await createWorkflowRunStartedEventV4(input, config4);
-    const runCreated = result2.events.find((event) => event.eventType === "run_created");
-    const runStarted = result2.events.find((event) => event.eventType === "run_started");
-    if (!runCreated) {
-      throw new Error("v4 createEvent: run_started stream is missing run_created");
-    }
-    if (!runStarted) {
-      throw new Error("v4 createEvent: run_started stream is missing run_started");
-    }
-    let attributes = runCreated.eventData.attributes ?? {};
-    let updatedAt = runStarted.createdAt;
-    for (const event of result2.events) {
-      if (event.eventType === "attr_set") {
-        attributes = applyAttributeChanges(attributes, event.eventData.changes);
-        updatedAt = event.createdAt;
-      }
+    const result2 = await createWorkflowRunStartedEventV4(input, config4, params?.replayEventObserver);
+    const replayRun = reconstructRunFromReplayEvents(result2.events);
+    if (!replayRun) {
+      throw new WorkflowWorldError2("v4 createEvent: run_started stream is missing lifecycle events", { code: "SCHEMA_VALIDATION" });
     }
     return {
-      event: runStarted,
-      run: {
-        runId: runCreated.runId,
-        status: "running",
-        deploymentId: runCreated.eventData.deploymentId,
-        workflowName: runCreated.eventData.workflowName,
-        specVersion: runCreated.specVersion,
-        executionContext: runCreated.eventData.executionContext,
-        input: runCreated.eventData.input,
-        attributes,
-        encryptionPublicKey: runCreated.eventData.encryptionPublicKey,
-        startedAt: runStarted.createdAt,
-        createdAt: runCreated.createdAt,
-        updatedAt
-      },
+      event: replayRun.event,
+      run: replayRun.run,
       events: result2.events,
       cursor: result2.cursor,
       hasMore: result2.hasMore,
@@ -70322,16 +70523,16 @@ async function createWorkflowRunEventInner(id, data, params, config4) {
     };
   }
   if (data.eventType === "hook_received" && params?.preloadEvents === true && params.resumeId !== void 0 && params.resumePayloadDigest !== void 0) {
-    const outcome = await createHookReceivedPreloadEventV4({ ...input, remoteRefBehavior: "lazy" }, config4);
+    const outcome = await createHookReceivedPreloadEventV4({ ...input, remoteRefBehavior: "lazy" }, config4, params.replayEventObserver);
     if (outcome.kind === "materialized") {
       return outcome.result;
     }
     const { canonicalEventId, maxEvents, events, cursor, hasMore } = outcome;
     const canonicalEvent = events.find((event) => event.eventId === canonicalEventId);
-    const run3 = reconstructRunFromReplayEvents(events);
+    const replayRun = reconstructRunFromReplayEvents(events);
     return {
       ...canonicalEvent ? { event: canonicalEvent } : {},
-      ...run3 ? { run: run3 } : {},
+      ...replayRun ? { run: replayRun.run } : {},
       events,
       cursor,
       hasMore,
@@ -70343,9 +70544,8 @@ async function createWorkflowRunEventInner(id, data, params, config4) {
 function reconstructRunFromReplayEvents(events) {
   const runCreated = events.find((event) => event.eventType === "run_created");
   const runStarted = events.find((event) => event.eventType === "run_started");
-  if (!runCreated || !runStarted) {
-    return void 0;
-  }
+  if (!runCreated || !runStarted)
+    return;
   let attributes = runCreated.eventData.attributes ?? {};
   let updatedAt = runStarted.createdAt;
   for (const event of events) {
@@ -70355,18 +70555,21 @@ function reconstructRunFromReplayEvents(events) {
     }
   }
   return {
-    runId: runCreated.runId,
-    status: "running",
-    deploymentId: runCreated.eventData.deploymentId,
-    workflowName: runCreated.eventData.workflowName,
-    specVersion: runCreated.specVersion,
-    executionContext: runCreated.eventData.executionContext,
-    input: runCreated.eventData.input,
-    attributes,
-    encryptionPublicKey: runCreated.eventData.encryptionPublicKey,
-    startedAt: runStarted.createdAt,
-    createdAt: runCreated.createdAt,
-    updatedAt
+    event: runStarted,
+    run: {
+      runId: runCreated.runId,
+      status: "running",
+      deploymentId: runCreated.eventData.deploymentId,
+      workflowName: runCreated.eventData.workflowName,
+      specVersion: runCreated.specVersion,
+      executionContext: runCreated.eventData.executionContext,
+      input: runCreated.eventData.input,
+      attributes,
+      encryptionPublicKey: runCreated.eventData.encryptionPublicKey,
+      startedAt: runStarted.createdAt,
+      createdAt: runCreated.createdAt,
+      updatedAt
+    }
   };
 }
 var eventsNeedingResolve;
@@ -71757,7 +71960,7 @@ var init_log_format2 = __esm({
 function SemanticConvention4(...names) {
   return (value) => Object.fromEntries(names.map((name) => [name, value]));
 }
-var WorkflowName2, WorkflowOperation2, WorkflowRunId4, WorkflowRunStatus2, WorkflowStartedAt2, WorkflowEventsCount2, WorkflowExecutionMode2, WorkflowParkedEventsCount2, WorkflowParkedEventId2, WorkflowParkedEventType2, WorkflowArgumentsCount2, WorkflowResultType2, WorkflowTracePropagated2, WorkflowVm2, QuickJSOutcome2, QuickJSEventsPreloaded2, QuickJSEventsFetchedCount2, QuickJSEventsFetchedPages2, QuickJSPendingOpsCount2, QuickJSInlineSteps2, WorkflowTraceMode2, WorkflowTurbo2, WorkflowErrorName2, WorkflowErrorMessage2, WorkflowErrorCode2, WorkflowStepsCreated2, WorkflowHooksCreated2, WorkflowWaitsCreated2, WorkflowStepsFailedSerialization2, WorkflowOwnedRecoverySteps2, WorkflowBackstopWakesArmed2, WorkflowRouteType2, WorkflowRouteHandlerCached2, WorkflowRouteInvocationCount2, WorkflowRouteEntrypointAgeMs2, WorkflowRouteModuleBodyInitMs2, FaasInstance2, StepName2, StepId4, StepAttempt2, StepStatus2, StepMaxRetries2, StepTracePropagated2, StepTtfsMs2, StepStsoMs3, StepRsfsMs2, StepFinalSchedulingReplayMs2, StepLatencyOptimizations3, StepSkipped2, StepSkipReason2, StepArgumentsCount2, StepResultType2, StepErrorName2, StepErrorMessage2, StepFatalError2, StepRetryExhausted2, StepRetryTimeoutSeconds2, StepRetryWillRetry2, MessagingSystem2, MessagingDestinationName2, MessagingMessageId2, MessagingOperationType2, QueueOverheadMs2, DeploymentId2, WorkflowRunPinnedDeploymentId2, WorkflowDeploymentMismatchRetryCount2, WorkflowDeploymentMismatchRecovered2, HookToken2, HookId2, HookFound2, HookResilientResume2, HookResilientResumeMaterialized2, HookResumeSetupSource2, StepResilientDispatchRecovered2, StepResilientDispatchMaterialized2, ResumeTotalMs2, ResumeProducerPrepMs2, ResumeQueueDeliveryMs2, ResumeSetupMs2, ResumeReplayMs2, ResumeStepDispatchMs2, ResumeStepClaimMs2, ResumeStepPrepareMs2, ResumeTrigger2, ResumeStrategy2, ResumeSetupSource2, ResumeStepExecution2, WebhookHandlersTriggered2, WorkflowSuspensionState2, WorkflowSuspensionHookCount2, WorkflowSuspensionStepCount2, WorkflowSuspensionWaitCount2, HttpRequestMethod3, HttpRoute2, UrlFull3, ServerAddress3, ServerPort3, HttpResponseStatusCode3, ErrorType3, WorldParseFormat3, WorkflowEventsPagesLoaded2, QueueDeserializeTimeMs2, QueueExecutionTimeMs2, QueueSerializeTimeMs2, SerializationOperation2, SerializationCompressed2, SerializationCodec2, SerializationUncompressedBytes2, SerializationStoredBytes2, SerializationCompressionRatio2, SerializationGuestCodeExecutions2, SerializationGuestCodeDetails2, PeerService4, RpcSystem4, RpcService4, RpcMethod4, ErrorRetryable2, ErrorCategory2;
+var WorkflowName2, WorkflowOperation2, WorkflowRunId4, WorkflowRunStatus2, WorkflowStartedAt2, WorkflowEventsCount2, WorkflowExecutionMode2, WorkflowBundleCompileCacheHit2, WorkflowReplayLoadSource2, WorkflowParkedEventsCount2, WorkflowParkedEventId2, WorkflowParkedEventType2, WorkflowArgumentsCount2, WorkflowResultType2, WorkflowTracePropagated2, WorkflowVm2, QuickJSOutcome2, QuickJSEventsPreloaded2, QuickJSEventsFetchedCount2, QuickJSEventsFetchedPages2, QuickJSPendingOpsCount2, QuickJSInlineSteps2, WorkflowTraceMode2, WorkflowTurbo2, WorkflowErrorName2, WorkflowErrorMessage2, WorkflowErrorCode2, WorkflowStepsCreated2, WorkflowHooksCreated2, WorkflowWaitsCreated2, WorkflowStepsFailedSerialization2, WorkflowOwnedRecoverySteps2, WorkflowBackstopWakesArmed2, WorkflowRouteType2, WorkflowRouteHandlerCached2, WorkflowRouteInvocationCount2, WorkflowRouteEntrypointAgeMs2, WorkflowRouteModuleBodyInitMs2, FaasInstance2, StepName2, StepId4, StepAttempt2, StepStatus2, StepMaxRetries2, StepTracePropagated2, StepTtfsMs2, StepStsoMs3, StepRsfsMs2, StepFinalSchedulingReplayMs2, StepLatencyOptimizations3, StepSkipped2, StepSkipReason2, StepArgumentsCount2, StepResultType2, StepErrorName2, StepErrorMessage2, StepFatalError2, StepRetryExhausted2, StepRetryTimeoutSeconds2, StepRetryWillRetry2, MessagingSystem2, MessagingDestinationName2, MessagingMessageId2, MessagingOperationType2, QueueOverheadMs2, DeploymentId2, WorkflowRunPinnedDeploymentId2, WorkflowDeploymentMismatchRetryCount2, WorkflowDeploymentMismatchRecovered2, HookToken2, HookId2, HookFound2, HookResilientResume2, HookResumeCommitted2, HookWakePublished2, HookResilientResumeMaterialized2, HookResumeSetupSource2, StepResilientDispatchRecovered2, StepResilientDispatchMaterialized2, ResumeTotalMs2, ResumeProducerPrepMs2, ResumeQueueDeliveryMs2, ResumeSetupMs2, ResumeReplayMs2, ResumeStepDispatchMs2, ResumeStepClaimMs2, ResumeStepPrepareMs2, ResumeTrigger2, ResumeStrategy2, ResumeSetupSource2, ResumeStepExecution2, WebhookHandlersTriggered2, WorkflowSuspensionState2, WorkflowSuspensionHookCount2, WorkflowSuspensionStepCount2, WorkflowSuspensionWaitCount2, HttpRequestMethod3, HttpRoute2, UrlFull3, ServerAddress3, ServerPort3, HttpResponseStatusCode3, ErrorType3, WorldParseFormat3, WorkflowEventsPagesLoaded2, QueueDeserializeTimeMs2, QueueExecutionTimeMs2, QueueSerializeTimeMs2, SerializationOperation2, SerializationCompressed2, SerializationCodec2, SerializationUncompressedBytes2, SerializationStoredBytes2, SerializationCompressionRatio2, SerializationGuestCodeExecutions2, SerializationGuestCodeDetails2, PeerService4, RpcSystem4, RpcService4, RpcMethod4, ErrorRetryable2, ErrorCategory2;
 var init_semantic_conventions2 = __esm({
   "../core/dist/telemetry/semantic-conventions.js"() {
     "use strict";
@@ -71769,6 +71972,8 @@ var init_semantic_conventions2 = __esm({
     WorkflowStartedAt2 = SemanticConvention4("workflow.started_at");
     WorkflowEventsCount2 = SemanticConvention4("workflow.events.count");
     WorkflowExecutionMode2 = SemanticConvention4("workflow.execution.mode");
+    WorkflowBundleCompileCacheHit2 = SemanticConvention4("workflow.bundle.compile.cache_hit");
+    WorkflowReplayLoadSource2 = SemanticConvention4("workflow.replay.load.source");
     WorkflowParkedEventsCount2 = SemanticConvention4("workflow.events.parked.count");
     WorkflowParkedEventId2 = SemanticConvention4("workflow.events.parked.event_id");
     WorkflowParkedEventType2 = SemanticConvention4("workflow.events.parked.event_type");
@@ -71833,6 +72038,8 @@ var init_semantic_conventions2 = __esm({
     HookId2 = SemanticConvention4("workflow.hook.id");
     HookFound2 = SemanticConvention4("workflow.hook.found");
     HookResilientResume2 = SemanticConvention4("workflow.hook.resilient_resume");
+    HookResumeCommitted2 = SemanticConvention4("workflow.hook.resume_committed");
+    HookWakePublished2 = SemanticConvention4("workflow.hook.wake_published");
     HookResilientResumeMaterialized2 = SemanticConvention4("workflow.hook.resilient_resume_materialized");
     HookResumeSetupSource2 = SemanticConvention4("workflow.resume_setup_source");
     StepResilientDispatchRecovered2 = SemanticConvention4("workflow.step.resilient_dispatch_recovered");
@@ -71933,6 +72140,16 @@ async function withTraceContext(traceCarrier, fn) {
   }
   return otel3.context.with(extractedContext, async () => await fn());
 }
+function describeThrownValue2(value) {
+  try {
+    if (typeof value === "object" && value !== null && "message" in value && typeof value.message === "string") {
+      return value.message;
+    }
+    return String(value);
+  } catch {
+    return "Unknown error";
+  }
+}
 function logOtelDiagnosticOnce3(otel3, tracer) {
   const debugEnabled = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
   if (otelDiagLogged3 || !debugEnabled)
@@ -71976,7 +72193,7 @@ async function trace5(spanName, ...args) {
       } else {
         span.setStatus({
           code: otel3.SpanStatusCode.ERROR,
-          message: e.message
+          message: describeThrownValue2(e)
         });
       }
       throw e;
@@ -71985,6 +72202,52 @@ async function trace5(spanName, ...args) {
     }
   });
 }
+async function startTraceSpan(spanName) {
+  const [tracer, otel3] = await Promise.all([Tracer2.value, OtelApi2.value]);
+  if (!tracer || !otel3)
+    return { end() {
+    }, fail() {
+    } };
+  const span = tracer.startSpan(spanName);
+  let ended = false;
+  const finish = /* @__PURE__ */ __name((status) => {
+    if (ended)
+      return;
+    ended = true;
+    span.setStatus(status);
+    span.end();
+  }, "finish");
+  return {
+    end: /* @__PURE__ */ __name(() => finish({ code: otel3.SpanStatusCode.OK }), "end"),
+    fail: /* @__PURE__ */ __name((error95) => finish({
+      code: otel3.SpanStatusCode.ERROR,
+      message: describeThrownValue2(error95)
+    }), "fail")
+  };
+}
+async function bindActiveTraceContext(fn) {
+  const otel3 = await OtelApi2.value;
+  return otel3 ? otel3.context.bind(otel3.context.active(), fn) : fn;
+}
+async function createRefreshableTraceContext() {
+  const otel3 = await OtelApi2.value;
+  if (!otel3) {
+    return { refresh() {
+    }, run: /* @__PURE__ */ __name((fn) => fn(), "run") };
+  }
+  let current = otel3.context.active();
+  const context2 = {
+    getValue: /* @__PURE__ */ __name((key) => current.getValue(key), "getValue"),
+    setValue: /* @__PURE__ */ __name((key, value) => current.setValue(key, value), "setValue"),
+    deleteValue: /* @__PURE__ */ __name((key) => current.deleteValue(key), "deleteValue")
+  };
+  return {
+    refresh: /* @__PURE__ */ __name(() => {
+      current = otel3.context.active();
+    }, "refresh"),
+    run: /* @__PURE__ */ __name((fn) => otel3.context.with(context2, fn), "run")
+  };
+}
 async function recordElapsedSpan2(spanName, startEpochMs, opts) {
   const tracer = await Tracer2.value;
   if (!tracer)
@@ -72098,8 +72361,12 @@ var init_telemetry4 = __esm({
       });
     });
     otelDiagLogged3 = false;
+    __name(describeThrownValue2, "describeThrownValue");
     __name(logOtelDiagnosticOnce3, "logOtelDiagnosticOnce");
     __name(trace5, "trace");
+    __name(startTraceSpan, "startTraceSpan");
+    __name(bindActiveTraceContext, "bindActiveTraceContext");
+    __name(createRefreshableTraceContext, "createRefreshableTraceContext");
     __name(recordElapsedSpan2, "recordElapsedSpan");
     __name(recordStepExecutionDuration, "recordStepExecutionDuration");
     __name(applyWorkflowSuspensionToSpan2, "applyWorkflowSuspensionToSpan");
@@ -72317,7 +72584,7 @@ async function awaitEarlierDeliveries(ctx, eventIndex, kind) {
     if (!gatesOn(kind, eventIndex, index, entry)) {
       continue;
     }
-    earlier.push(entry.delivered);
+    earlier.push(entry.released);
   }
   if (earlier.length > 0) {
     await Promise.all(earlier);
@@ -72337,29 +72604,52 @@ function registerDeliveryBarrier(ctx, eventIndex, kind, options = {}) {
     }, "markDelivered"), arm: /* @__PURE__ */ __name(() => {
     }, "arm") };
   }
-  let done = false;
-  const { promise: promise3, resolve: resolve3 } = withResolvers2();
-  const finish = /* @__PURE__ */ __name(() => {
-    if (done) {
-      return;
-    }
-    done = true;
-    if (barriers.get(eventIndex) === entry) {
-      barriers.delete(eventIndex);
+  const install = /* @__PURE__ */ __name((armed) => {
+    if (barriers.has(eventIndex)) {
+      throw new WorkflowRuntimeError2(`Delivery barrier already registered at event index ${eventIndex}`);
     }
-    resolve3();
-  }, "finish");
-  const entry = {
-    kind,
-    delivered: promise3,
-    armed: options.armed ?? true,
-    retire: finish
-  };
-  barriers.set(eventIndex, entry);
-  ensureBarrierSafetyNet(ctx);
+    const { promise: promise3, resolve: resolve3 } = withResolvers2();
+    const entry2 = {
+      kind,
+      released: promise3,
+      armed,
+      retired: false,
+      retire: /* @__PURE__ */ __name(() => {
+        if (entry2.retired) {
+          return;
+        }
+        entry2.retired = true;
+        if (barriers.get(eventIndex) === entry2) {
+          barriers.delete(eventIndex);
+        }
+        resolve3();
+      }, "retire")
+    };
+    barriers.set(eventIndex, entry2);
+    ensureBarrierSafetyNet(ctx);
+    return entry2;
+  }, "install");
+  let entry = install(options.armed ?? true);
+  let deliveredToWorkflow = false;
   return {
-    markDelivered: finish,
+    markDelivered: /* @__PURE__ */ __name(() => {
+      if (deliveredToWorkflow) {
+        return;
+      }
+      deliveredToWorkflow = true;
+      entry.retire();
+    }, "markDelivered"),
     arm: /* @__PURE__ */ __name(() => {
+      if (deliveredToWorkflow) {
+        return;
+      }
+      if (entry.retired) {
+        entry = install(true);
+        return;
+      }
+      if (barriers.get(eventIndex) !== entry) {
+        throw new WorkflowRuntimeError2(`Delivery barrier lost ownership of event index ${eventIndex}`);
+      }
       entry.armed = true;
     }, "arm")
   };
@@ -72443,6 +72733,7 @@ var RegisteredStepsKey2, globalSymbols3, registeredSteps2, BUILTIN_RESPONSE_STEP
 var init_private2 = __esm({
   "../core/dist/private.js"() {
     "use strict";
+    init_dist7();
     init_dist5();
     init_global2();
     RegisteredStepsKey2 = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps");
@@ -75697,6 +75988,7 @@ var init_events_consumer2 = __esm({
         let progressed = this.parked.length > 0;
         while (progressed) {
           progressed = false;
+          this.dropParkedDuplicates();
           for (let i = 0; i < this.parked.length; i++) {
             const entry = this.parked[i];
             const walkIndex = this.eventIndex;
@@ -75715,6 +76007,49 @@ var init_events_consumer2 = __esm({
           }
         }
       }
+      /**
+       * Release anything parked whose class a consumption has since recorded for
+       * the same entity, on the same terms as {@link skipDuplicateEvent}.
+       *
+       * The ordered walk decides a straggler at the event, but only for one of the
+       * two orders the copies can arrive in. When neither copy has a consumer yet,
+       * both park — the walk steps over the first and re-enters immediately, so
+       * the second is offered in the same tick, with no class recorded because
+       * nothing has been *consumed*. The drain then claims the first and the
+       * second is left held by a consumer list that will never grow the callback
+       * it needs, which the workflow function returning reports through
+       * {@link strandedEvent} as a replay divergence.
+       *
+       * Run before each offer pass rather than once, because the consumption that
+       * records the class happens inside the drain itself.
+       *
+       * Not specific to `attr_set`: `wait_completed` reaches the same state, and
+       * {@link ONE_SHOT_EVENT_TYPES} only covers it in the order where the
+       * consumption came first.
+       */
+      dropParkedDuplicates() {
+        for (let i = this.parked.length - 1; i >= 0; i--) {
+          const event = this.parked[i].event;
+          const firstType = this.firstEventTypeOfClass(event);
+          if (firstType === void 0) {
+            continue;
+          }
+          this.parked.splice(i, 1);
+          eventsLogger2.debug("Releasing a parked event that repeats a class already in the log", {
+            eventId: event.eventId,
+            eventType: event.eventType,
+            firstEventType: firstType,
+            correlationId: event.correlationId
+          });
+          try {
+            this.onDuplicateEvent?.(event, firstType);
+          } catch (error95) {
+            eventsLogger2.error("onDuplicateEvent callback threw an error", {
+              error: error95
+            });
+          }
+        }
+      }
       /**
        * Step the ordered walk over an event nobody claimed, holding on to it for a
        * later consumer. Returns false when the event's type makes its position a
@@ -75739,16 +76074,17 @@ var init_events_consumer2 = __esm({
         return true;
       }
       /**
-       * The key `event`'s class is tracked under, or `undefined` for the event
-       * types that belong to no class (`hook_received`, `hook_conflict`,
-       * `attr_set`, `run_created`) and are therefore never skipped.
+       * The key `event`'s class is tracked under, or `undefined` for the events
+       * that belong to no class and are therefore never skipped: the types with no
+       * entry at all (`hook_received`, `hook_conflict`, `run_created`), and a
+       * classed type carrying no entity to track it under.
        *
-       * Run events carry no correlation id. They are classes of the run itself, so
-       * they all key off the same bucket.
+       * {@link classifyEntityEvent} owns that rule, because the observability UI
+       * decides the same question about the same log and the two must not drift.
        */
       eventClassKey(event) {
-        const eventClass = entityEventClass(event.eventType);
-        return eventClass === void 0 ? void 0 : `${eventClass}:${event.correlationId}`;
+        const classification = classifyEntityEvent(event);
+        return classification === void 0 ? void 0 : `${classification.eventClass}:${classification.entity}`;
       }
       /**
        * Remembers that `event`'s class is now decided for its entity, if the type
@@ -75893,7 +76229,8 @@ var init_events_consumer2 = __esm({
        * recorded while the check was in flight can only have been recorded by a
        * consumption inside {@link consume}, whose next pass re-offers this event
        * and steps over it there, leaving the identity guard above to drop the
-       * in-flight check.
+       * in-flight check. One that parks before any consumption records its class
+       * is released later by {@link dropParkedDuplicates} instead.
        */
       resolveUnconsumedEvent(currentEvent, mayPark) {
         if (mayPark) {
@@ -78188,12 +78525,13 @@ var init_capabilities2 = __esm({
       // consumers that cannot unframe them (silent corruption); too-high merely
       // delays the optimization (safe).
       { capability: "framedByteStreams", minVersion: "5.0.0-beta.15" }
-      // NOTE: lazy hook resume ("does the consumer re-ensure `hook_received` from
-      // the queue message's `hookInput`?") is intentionally NOT gated here. A
-      // version-compare against a predicted release cutoff is a guess; instead the
-      // run's creating deployment stamps an explicit `hookResumeInputVersion`
-      // marker into its execution context, which the server mirrors onto the hook's
-      // resumeContext. `resumeHook()` gates the lazy path on that marker.
+      // NOTE: the hook-resume consumer protocol ("does the consumer re-ensure
+      // `hook_received` from the queue message's `hookInput`?") is intentionally
+      // NOT gated here. A version-compare against a predicted release cutoff is a
+      // guess; instead the run's creating deployment stamps an explicit
+      // `hookResumeInputVersion` marker into its execution context, which the
+      // server mirrors onto the hook's resumeContext. Older producers gate their
+      // lazy path on that marker.
     ];
     BASELINE_FORMATS2 = /* @__PURE__ */ new Set([
       SerializationFormat2.DEVALUE_V1
@@ -78207,7 +78545,7 @@ var version5;
 var init_version4 = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version5 = "5.0.0-beta.46";
+    version5 = "5.0.0-beta.47";
   }
 });
 
@@ -78320,9 +78658,10 @@ function shouldRetryWithoutEventCursor(error95, cursor, alreadyRetried) {
 }
 async function loadWorkflowRunEvents(runId, afterCursor) {
   const incremental = afterCursor !== void 0;
-  return trace5(incremental ? "workflow.loadNewEvents" : "workflow.loadEvents", async (span) => {
+  return trace5("workflow.replay.load", async (span) => {
     span?.setAttributes({
-      ...WorkflowRunId4(runId)
+      ...WorkflowRunId4(runId),
+      ...WorkflowReplayLoadSource2(incremental ? "events_list_incremental" : "events_list")
     });
     const loadedEvents = [];
     const loadedEventIds = /* @__PURE__ */ new Set();
@@ -78558,14 +78897,15 @@ function getQueueOverhead(message) {
     return;
   }
 }
+async function resolveRunEncryptionKey(world, runOrId, context2) {
+  const rawKey = typeof runOrId === "string" ? await world.getEncryptionKeyForRun?.(runOrId, context2) : await world.getEncryptionKeyForRun?.(runOrId);
+  return rawKey ? await deriveRunPayloadKeys2(rawKey) : void 0;
+}
 function memoizeEncryptionKey(world, runOrId) {
   let cached3;
   return () => {
     if (!cached3) {
-      cached3 = (async () => {
-        const rawKey = typeof runOrId === "string" ? await world.getEncryptionKeyForRun?.(runOrId) : await world.getEncryptionKeyForRun?.(runOrId);
-        return rawKey ? await deriveRunPayloadKeys2(rawKey) : void 0;
-      })();
+      cached3 = resolveRunEncryptionKey(world, runOrId);
     }
     return cached3;
   };
@@ -78618,6 +78958,7 @@ var init_helpers3 = __esm({
     __name(stepDispatchIdempotencyKey, "stepDispatchIdempotencyKey");
     __name(queueMessage, "queueMessage");
     __name(getQueueOverhead, "getQueueOverhead");
+    __name(resolveRunEncryptionKey, "resolveRunEncryptionKey");
     __name(memoizeEncryptionKey, "memoizeEncryptionKey");
   }
 });
@@ -78659,7 +79000,6 @@ var resume_hook_exports2 = {};
 __export(resume_hook_exports2, {
   getHookByToken: () => getHookByToken3,
   resumeHook: () => resumeHook2,
-  resumeHookDurable: () => resumeHookDurable2,
   resumeWebhook: () => resumeWebhook2
 });
 async function computeResumePayloadDigest2(bytes) {
@@ -78671,6 +79011,38 @@ async function computeResumePayloadDigest2(bytes) {
   }
   return hex5;
 }
+function isRetryableWakeError2(error95, isDeploymentUnavailableError) {
+  if (isDeploymentUnavailableError?.(error95))
+    return false;
+  const status = error95 ?? {};
+  const code3 = status.status ?? status.statusCode;
+  if (typeof code3 === "number") {
+    return code3 >= 500 || code3 === 408 || code3 === 429;
+  }
+  const name = error95?.name;
+  return name !== "BadRequestError" && name !== "UnauthorizedError" && name !== "ForbiddenError";
+}
+async function publishHookWakeWithRetry2(publish, isDeploymentUnavailableError) {
+  let lastError;
+  for (let attempt = 0; attempt <= HOOK_WAKE_RETRY_DELAYS_MS2.length; attempt++) {
+    try {
+      await publish();
+      return;
+    } catch (error95) {
+      lastError = error95;
+      if (!isRetryableWakeError2(error95, isDeploymentUnavailableError))
+        break;
+      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS2[attempt];
+      if (delayMs !== void 0) {
+        await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+      }
+    }
+  }
+  if (HookNotFoundError2.is(lastError)) {
+    throw new WorkflowRuntimeError2("The hook resume was committed, but its workflow wake could not be published", { cause: lastError });
+  }
+  throw lastError;
+}
 function resumeContextFromRun2(run3) {
   const coreVersion = run3.executionContext?.workflowCoreVersion;
   const traceCarrier = run3.executionContext?.traceCarrier;
@@ -78722,12 +79094,9 @@ async function getHookByToken3(token) {
   return hook;
 }
 async function resumeHook2(tokenOrHook, payload, encryptionKeyOverride) {
-  return resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, false, Date.now(), false);
-}
-async function resumeHookDurable2(tokenOrHook, payload, encryptionKeyOverride) {
-  return resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, false, Date.now(), true);
+  return resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, false, Date.now());
 }
-async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs, requireDurableWrite) {
+async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs) {
   return await waitedUntil2(() => {
     return trace5("hook.resume", async (span) => {
       const world = await getWorldLazy2();
@@ -78765,12 +79134,17 @@ async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hook
         }
         const compression = (resumeContext.runSpecVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2 && capabilities.supportedFormats.has(SerializationFormat2.GZIP);
         const ops = [];
+        const readbackOps = [];
         const v1Compat = isLegacySpecVersion2(hook.specVersion);
-        const dehydratedPayload = await dehydrateStepReturnValue2(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression);
-        safeWaitUntil2(Promise.all(ops), (err) => {
+        const dehydratedPayload = await dehydrateStepReturnValue2(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression, void 0, readbackOps);
+        await Promise.all(ops.map((op) => op.catch((error95) => {
+          if (error95 !== void 0)
+            throw error95;
+        })));
+        safeWaitUntil2(Promise.all(readbackOps), (err) => {
           if (err === void 0)
             return;
-          runtimeLogger2.warn("Background flush of hook payload ops failed", {
+          runtimeLogger2.warn("Background readback of hook payload failed", {
             workflowRunId: hook.runId,
             hookId: hook.hookId,
             error: err instanceof Error ? err.message : String(err)
@@ -78788,74 +79162,57 @@ async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hook
           deploymentId: resumeContext.deploymentId,
           specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY2
         };
-        const lazyResumeDisabled = process.env.WORKFLOW_DISABLE_LAZY_HOOK_RESUME === "1";
         const backendDedupSupported = (hookResumeCapabilitiesAreFresh ? hook.resumeCapabilities?.hookResumeDedupVersion ?? 0 : 0) >= HOOK_RESUME_DEDUP_VERSION2 || world.capabilities?.hookResumeDedup === true;
-        const fallbackReason = requireDurableWrite ? (
-          // An internal caller needs the event committed before this
-          // resolves (an ordering barrier), which only the eager write
-          // provides. Checked first so the span names the real reason
-          // rather than whichever gate happens to fail alongside it.
-          "durable_required"
-        ) : lazyResumeDisabled ? "disabled" : !backendDedupSupported ? "backend_unsupported" : (resumeContext.hookResumeInputVersion ?? 0) < HOOK_RESUME_INPUT_VERSION2 ? "consumer_unsupported" : v1Compat ? "legacy" : (resumeContext.runSpecVersion ?? 0) < SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT2 ? "non_cbor_transport" : !(dehydratedPayload instanceof Uint8Array) ? "non_bytes" : dehydratedPayload.byteLength > MAX_INLINE_RESUME_PAYLOAD_BYTES2 ? "oversized" : null;
-        const useLazyResume = fallbackReason === null;
+        const canClaimResume = backendDedupSupported && !v1Compat && dehydratedPayload instanceof Uint8Array;
         span?.setAttributes({
-          "workflow.hook.resume_strategy": useLazyResume ? "lazy" : "sequential",
-          ...fallbackReason ? { "workflow.hook.resume_fallback_reason": fallbackReason } : {}
+          "workflow.hook.resume_strategy": "sequential"
         });
-        if (!useLazyResume) {
-          const isHookGoneError = /* @__PURE__ */ __name((err) => HookNotFoundError2.is(err) || EntityConflictError2.is(err) || RunExpiredError2.is(err), "isHookGoneError");
-          try {
-            await world.events.create(hook.runId, {
-              eventType: "hook_received",
-              specVersion: SPEC_VERSION_CURRENT2,
-              correlationId: hook.hookId,
-              eventData: {
-                ...v1Compat ? {} : { token: hook.token },
-                payload: dehydratedPayload
-              }
-            }, { v1Compat });
-          } catch (err) {
-            if (isHookGoneError(err)) {
-              throw new HookNotFoundError2(hook.token);
+        const resumeId = canClaimResume ? generateResumeId2() : void 0;
+        const payloadDigest = canClaimResume ? await computeResumePayloadDigest2(dehydratedPayload) : void 0;
+        if (resumeId) {
+          span?.setAttributes({ "workflow.hook.resume_id": resumeId });
+        }
+        const isHookGoneError = /* @__PURE__ */ __name((err) => HookNotFoundError2.is(err) || RunExpiredError2.is(err), "isHookGoneError");
+        try {
+          await world.events.create(hook.runId, {
+            eventType: "hook_received",
+            specVersion: SPEC_VERSION_CURRENT2,
+            correlationId: hook.hookId,
+            eventData: {
+              ...v1Compat ? {} : { token: hook.token },
+              payload: dehydratedPayload
             }
-            throw err;
+          }, {
+            v1Compat,
+            ...resumeId && payloadDigest ? { resumeId, resumePayloadDigest: payloadDigest } : {}
+          });
+        } catch (err) {
+          if (isHookGoneError(err)) {
+            throw new HookNotFoundError2(hook.token);
           }
-          const queuePublishRequestedAtMs2 = Date.now();
-          await world.queue(queueName, {
-            runId: hook.runId,
-            traceCarrier: resumeContext.traceCarrier ?? void 0,
-            hookResumeTiming: {
-              resumeRequestedAtMs,
-              queuePublishRequestedAtMs: queuePublishRequestedAtMs2,
-              strategy: "sequential"
-            }
-          }, queueOptions);
-          return hook;
-        }
-        const resumeId = generateResumeId2();
-        const payloadDigest = await computeResumePayloadDigest2(dehydratedPayload);
-        span?.setAttributes({ "workflow.hook.resume_id": resumeId });
+          throw err;
+        }
+        span?.setAttributes(HookResumeCommitted2(true));
         const queuePublishRequestedAtMs = Date.now();
-        await world.queue(queueName, {
+        await publishHookWakeWithRetry2(() => world.queue(queueName, {
           runId: hook.runId,
           traceCarrier: resumeContext.traceCarrier ?? void 0,
-          hookInput: {
-            resumeId,
-            hookId: hook.hookId,
-            token: hook.token,
-            payload: dehydratedPayload,
-            payloadDigest,
-            // Deployment affinity for the consumer's cheap pre-write
-            // check: lets a misrouted delivery re-route before its
-            // hoisted hook_received write instead of after.
-            deploymentId: resumeContext.deploymentId
-          },
           hookResumeTiming: {
             resumeRequestedAtMs,
             queuePublishRequestedAtMs,
-            strategy: "lazy"
+            strategy: "sequential"
           }
-        }, queueOptions);
+        }, {
+          ...queueOptions,
+          // Dedup retried publishes whose response was lost: a
+          // duplicate wake is harmless for correctness (deterministic
+          // replay) but costs a full replay of the run, and the queue
+          // accepts a repeated idempotency key by delivering only one
+          // of the messages. Claim-less writes have no resumeId and
+          // keep the previous behavior.
+          ...resumeId ? { idempotencyKey: `hook-${resumeId}` } : {}
+        }), world.isDeploymentUnavailableError?.bind(world));
+        span?.setAttributes(HookWakePublished2(true));
         return hook;
       } catch (err) {
         span?.setAttributes({
@@ -78888,7 +79245,7 @@ async function resumeWebhook2(token, request) {
   } else {
     response = new Response(null, { status: 202 });
   }
-  await resumeHookImpl2(hook, request, encryptionKey, true, resumeRequestedAtMs, false);
+  await resumeHookImpl2(hook, request, encryptionKey, true, resumeRequestedAtMs);
   if (responseReadable) {
     const reader = responseReadable.getReader();
     const chunk = await reader.read();
@@ -78904,7 +79261,7 @@ async function resumeWebhook2(token, request) {
   }
   return response;
 }
-var generateResumeId2, MAX_INLINE_RESUME_PAYLOAD_BYTES2;
+var generateResumeId2, HOOK_WAKE_RETRY_DELAYS_MS2;
 var init_resume_hook2 = __esm({
   "../core/dist/runtime/resume-hook.js"() {
     "use strict";
@@ -78924,15 +79281,16 @@ var init_resume_hook2 = __esm({
     init_helpers3();
     init_wait_until2();
     generateResumeId2 = monotonicFactory2();
-    MAX_INLINE_RESUME_PAYLOAD_BYTES2 = 128 * 1024;
     __name(computeResumePayloadDigest2, "computeResumePayloadDigest");
+    HOOK_WAKE_RETRY_DELAYS_MS2 = [25, 100];
+    __name(isRetryableWakeError2, "isRetryableWakeError");
+    __name(publishHookWakeWithRetry2, "publishHookWakeWithRetry");
     __name(resumeContextFromRun2, "resumeContextFromRun");
     __name(resolveHookResumeInfo2, "resolveHookResumeInfo");
     __name(resolveHookEncryptionKey2, "resolveHookEncryptionKey");
     __name(getHookByTokenWithKey2, "getHookByTokenWithKey");
     __name(getHookByToken3, "getHookByToken");
     __name(resumeHook2, "resumeHook");
-    __name(resumeHookDurable2, "resumeHookDurable");
     __name(resumeHookImpl2, "resumeHookImpl");
     __name(resumeWebhook2, "resumeWebhook");
   }
@@ -79488,7 +79846,7 @@ function attachAbortListenerOnce2(signal, streamName, runId, cryptoKey, ops) {
     })());
   }, { once: true });
 }
-function getExternalReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier) {
+function getExternalReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier, readbackOps = ops) {
   return {
     ...getAllBaseReducers2(global2),
     ReadableStream: /* @__PURE__ */ __name((value) => {
@@ -79510,7 +79868,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, runReadyBarrier), cryptoKey)).pipeTo(writable));
+        ops.push(value.pipeThrough(getSerializeStream2(getExternalReducers2(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier, readbackOps), cryptoKey)).pipeTo(writable));
       }
       const s = { name };
       if (type)
@@ -79542,7 +79900,7 @@ function getExternalReducers2(global2 = globalThis, ops, runId, cryptoKey, frame
       const streamId = (global2[STABLE_ULID2] || defaultUlid2)();
       const name = `strm_${streamId}`;
       const readable = new WorkflowServerReadableStream2(runId, name);
-      ops.push(readable.pipeTo(value));
+      readbackOps.push(readable.pipeTo(value));
       return { name };
     }, "WritableStream"),
     AbortController: /* @__PURE__ */ __name((value) => {
@@ -79645,7 +80003,7 @@ function getWorkflowReducers2(global2 = globalThis) {
     }, "AbortSignal")
   };
 }
-function getStepReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier) {
+function getStepReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier, readbackOps = ops) {
   return {
     ...getAllBaseReducers2(global2),
     ReadableStream: /* @__PURE__ */ __name((value) => {
@@ -79672,7 +80030,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, runReadyBarrier), cryptoKey)).pipeTo(writable));
+          ops.push(value.pipeThrough(getSerializeStream2(getStepReducers2(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier, readbackOps), cryptoKey)).pipeTo(writable));
         }
       }
       const s = { name };
@@ -79690,7 +80048,7 @@ function getStepReducers2(global2 = globalThis, ops, runId, cryptoKey, framedByt
       if (!name) {
         const streamId = (global2[STABLE_ULID2] || defaultUlid2)();
         name = `strm_${streamId}`;
-        ops.push(new WorkflowServerReadableStream2(runId, name).pipeThrough(getDeserializeStream2(getStepRevivers2(global2, ops, runId, cryptoKey), cryptoKey)).pipeTo(value));
+        readbackOps.push(new WorkflowServerReadableStream2(runId, name).pipeThrough(getDeserializeStream2(getStepRevivers2(global2, readbackOps, runId, cryptoKey), cryptoKey)).pipeTo(value));
       }
       const s = { name };
       if (typeof foreignRunId === "string")
@@ -79860,8 +80218,8 @@ function reviveAbortController2(value, ops, runId) {
       if (value.hookToken) {
         const hookResume = (async () => {
           try {
-            const { resumeHookDurable: resumeHookDurable3 } = await Promise.resolve().then(() => (init_resume_hook2(), resume_hook_exports2));
-            await resumeHookDurable3(value.hookToken, {
+            const { resumeHook: resumeHook3 } = await Promise.resolve().then(() => (init_resume_hook2(), resume_hook_exports2));
+            await resumeHook3(value.hookToken, {
               aborted: true,
               reason
             });
@@ -80393,16 +80751,16 @@ async function hydrateStepArguments2(value, runId, key, ops = [], global2 = glob
   await recordCompression2(compressionStats, "deserialize");
   return result2;
 }
-async function dehydrateStepReturnValue2(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false, runReadyBarrier) {
+async function dehydrateStepReturnValue2(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false, runReadyBarrier, readbackOps = ops) {
   if (v1Compat) {
-    const str = stringify2(value, getStepReducers2(global2, ops, runId, key, framedByteStreams, runReadyBarrier));
+    const str = stringify2(value, getStepReducers2(global2, ops, runId, key, framedByteStreams, runReadyBarrier, readbackOps));
     return revive2(str);
   }
   try {
     const compressionStats = {};
     const result2 = await serialize3(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers2(getStepReducers2(global2, ops, runId, key, framedByteStreams, runReadyBarrier)),
+      extraReducers: getStreamAndRequestReducers2(getStepReducers2(global2, ops, runId, key, framedByteStreams, runReadyBarrier, readbackOps)),
       compression,
       compressionStats
     });
@@ -94550,6 +94908,7 @@ var BUILTIN_RESPONSE_STEP_NAMES;
 var init_private = __esm2({
   "../core/dist/private.js"() {
     "use strict";
+    init_dist2();
     init_global();
     RegisteredStepsKey = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps");
     globalSymbols = globalThis;
@@ -111939,8 +112298,9 @@ var init_queue = __esm2({
       /** Epoch ms immediately before the queue publish was requested. */
       queuePublishRequestedAtMs: external_exports.number(),
       /**
-       * Which `resumeHook()` dispatch path ran: `lazy` or `sequential` (`parallel`
-       * from producers predating lazy-only resume).
+       * Which `resumeHook()` dispatch path ran. Current producers always report
+       * `sequential` (durable write, then wake); older producers may report
+       * `lazy` or `parallel`.
        */
       strategy: external_exports.string().optional(),
       /** Epoch ms the final consumer's queue handler was entered. */
@@ -112012,9 +112372,9 @@ var init_queue = __esm2({
       /** Run creation data, only present on the first queue delivery from start() */
       runInput: RunInputSchema.optional(),
       /**
-       * Lazy hook resume data, only present when `resumeHook()` takes the parallel
-       * fast path. A consumer that understands this field idempotently ensures the
-       * `hook_received` event exists (keyed by `resumeId`) before replaying.
+       * Legacy lazy hook resume data. A consumer that understands this field
+       * idempotently ensures the `hook_received` event exists (keyed by `resumeId`)
+       * before replaying.
        */
       hookInput: HookResumeInputSchema.optional(),
       /**
@@ -112026,7 +112386,7 @@ var init_queue = __esm2({
       stepInput: StepDispatchInputSchema.optional(),
       /**
        * Hook-resume TTR timing. Present on both `resumeHook()` dispatch paths
-       * (unlike `hookInput`, which only rides the lazy path), and
+       * (unlike legacy `hookInput`), and
        * forwarded onto a dispatched step message when the resuming invocation
        * hands the next durable step to another invocation. Purely observational.
        * See {@link HookResumeTimingSchema}.
@@ -112086,12 +112446,14 @@ var init_hooks = __esm2({
       encryptionPublicKey: external_exports.string().optional(),
       // Feature marker: the version of the lazy-hook-resume consumer protocol the
       // run's creating deployment supports. Present (>= 1) means that deployment's
-      // `@workflow/core` re-ensures the `hook_received` event from the queue
-      // message's `hookInput` on replay, so `resumeHook()`'s lazy path is safe to
-      // use. Because a run is pinned to its creating deployment, this
-      // marker is a reliable per-run attestation, unlike inferring support from a
-      // version compare against a predicted release cutoff. Absent on runs created
-      // before the marker existed (fall back to the sequential path).
+      // `@workflow/core` re-ensures the `hook_received` event from a queue
+      // message's `hookInput` on replay. Current producers no longer send
+      // `hookInput` (the durable write happens before the wake is published), so
+      // they never read this marker; it remains stamped so OLDER producers, which
+      // still gate their lazy path on it, keep working against new runs. Because a
+      // run is pinned to its creating deployment, this marker is a reliable
+      // per-run attestation, unlike inferring support from a version compare
+      // against a predicted release cutoff.
       hookResumeInputVersion: external_exports.number().optional()
     });
     HOOK_RESUME_INPUT_VERSION = 1;
@@ -113745,6 +114107,8 @@ var WorkflowRunStatus;
 var WorkflowStartedAt;
 var WorkflowEventsCount;
 var WorkflowExecutionMode;
+var WorkflowBundleCompileCacheHit;
+var WorkflowReplayLoadSource;
 var WorkflowParkedEventsCount;
 var WorkflowParkedEventId;
 var WorkflowParkedEventType;
@@ -113809,6 +114173,8 @@ var HookToken;
 var HookId;
 var HookFound;
 var HookResilientResume;
+var HookResumeCommitted;
+var HookWakePublished;
 var HookResilientResumeMaterialized;
 var HookResumeSetupSource;
 var StepResilientDispatchRecovered;
@@ -113867,6 +114233,8 @@ var init_semantic_conventions = __esm2({
     WorkflowStartedAt = SemanticConvention("workflow.started_at");
     WorkflowEventsCount = SemanticConvention("workflow.events.count");
     WorkflowExecutionMode = SemanticConvention("workflow.execution.mode");
+    WorkflowBundleCompileCacheHit = SemanticConvention("workflow.bundle.compile.cache_hit");
+    WorkflowReplayLoadSource = SemanticConvention("workflow.replay.load.source");
     WorkflowParkedEventsCount = SemanticConvention("workflow.events.parked.count");
     WorkflowParkedEventId = SemanticConvention("workflow.events.parked.event_id");
     WorkflowParkedEventType = SemanticConvention("workflow.events.parked.event_type");
@@ -113931,6 +114299,8 @@ var init_semantic_conventions = __esm2({
     HookId = SemanticConvention("workflow.hook.id");
     HookFound = SemanticConvention("workflow.hook.found");
     HookResilientResume = SemanticConvention("workflow.hook.resilient_resume");
+    HookResumeCommitted = SemanticConvention("workflow.hook.resume_committed");
+    HookWakePublished = SemanticConvention("workflow.hook.wake_published");
     HookResilientResumeMaterialized = SemanticConvention("workflow.hook.resilient_resume_materialized");
     HookResumeSetupSource = SemanticConvention("workflow.resume_setup_source");
     StepResilientDispatchRecovered = SemanticConvention("workflow.step.resilient_dispatch_recovered");
@@ -116063,6 +116433,17 @@ async function deserializeTraceCarrier(traceCarrier) {
   return otel3.propagation.extract(otel3.context.active(), traceCarrier);
 }
 __name(deserializeTraceCarrier, "deserializeTraceCarrier");
+function describeThrownValue(value) {
+  try {
+    if (typeof value === "object" && value !== null && "message" in value && typeof value.message === "string") {
+      return value.message;
+    }
+    return String(value);
+  } catch {
+    return "Unknown error";
+  }
+}
+__name(describeThrownValue, "describeThrownValue");
 function logOtelDiagnosticOnce(otel3, tracer) {
   const debugEnabled = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
   if (otelDiagLogged || !debugEnabled) return;
@@ -116118,7 +116499,7 @@ async function trace(spanName, ...args) {
       } else {
         span.setStatus({
           code: otel3.SpanStatusCode.ERROR,
-          message: e.message
+          message: describeThrownValue(e)
         });
       }
       throw e;
@@ -116223,6 +116604,7 @@ var init_telemetry = __esm2({
       });
     });
     otelDiagLogged = false;
+    __name2(describeThrownValue, "describeThrownValue");
     __name2(logOtelDiagnosticOnce, "logOtelDiagnosticOnce");
     __name2(trace, "trace");
     __name2(recordElapsedSpan, "recordElapsedSpan");
@@ -118556,7 +118938,7 @@ var version2;
 var init_version = __esm2({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.46";
+    version2 = "5.0.0-beta.47";
   }
 });
 function getWorkflowQueueName(workflowName, namespace) {
@@ -123749,7 +124131,6 @@ var resume_hook_exports = {};
 __export2(resume_hook_exports, {
   getHookByToken: /* @__PURE__ */ __name(() => getHookByToken, "getHookByToken"),
   resumeHook: /* @__PURE__ */ __name(() => resumeHook, "resumeHook"),
-  resumeHookDurable: /* @__PURE__ */ __name(() => resumeHookDurable, "resumeHookDurable"),
   resumeWebhook: /* @__PURE__ */ __name(() => resumeWebhook, "resumeWebhook")
 });
 async function computeResumePayloadDigest(bytes) {
@@ -123762,6 +124143,40 @@ async function computeResumePayloadDigest(bytes) {
   return hex32;
 }
 __name(computeResumePayloadDigest, "computeResumePayloadDigest");
+function isRetryableWakeError(error482, isDeploymentUnavailableError) {
+  if (isDeploymentUnavailableError?.(error482)) return false;
+  const status = error482 ?? {};
+  const code22 = status.status ?? status.statusCode;
+  if (typeof code22 === "number") {
+    return code22 >= 500 || code22 === 408 || code22 === 429;
+  }
+  const name = error482?.name;
+  return name !== "BadRequestError" && name !== "UnauthorizedError" && name !== "ForbiddenError";
+}
+__name(isRetryableWakeError, "isRetryableWakeError");
+async function publishHookWakeWithRetry(publish, isDeploymentUnavailableError) {
+  let lastError;
+  for (let attempt = 0; attempt <= HOOK_WAKE_RETRY_DELAYS_MS.length; attempt++) {
+    try {
+      await publish();
+      return;
+    } catch (error482) {
+      lastError = error482;
+      if (!isRetryableWakeError(error482, isDeploymentUnavailableError)) break;
+      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS[attempt];
+      if (delayMs !== void 0) {
+        await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+      }
+    }
+  }
+  if (HookNotFoundError.is(lastError)) {
+    throw new WorkflowRuntimeError("The hook resume was committed, but its workflow wake could not be published", {
+      cause: lastError
+    });
+  }
+  throw lastError;
+}
+__name(publishHookWakeWithRetry, "publishHookWakeWithRetry");
 function resumeContextFromRun(run22) {
   const coreVersion = run22.executionContext?.workflowCoreVersion;
   const traceCarrier = run22.executionContext?.traceCarrier;
@@ -123824,14 +124239,10 @@ async function getHookByToken(token) {
 }
 __name(getHookByToken, "getHookByToken");
 async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
-  return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false, Date.now(), false);
+  return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false, Date.now());
 }
 __name(resumeHook, "resumeHook");
-async function resumeHookDurable(tokenOrHook, payload, encryptionKeyOverride) {
-  return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false, Date.now(), true);
-}
-__name(resumeHookDurable, "resumeHookDurable");
-async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs, requireDurableWrite) {
+async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs) {
   return await waitedUntil(() => {
     return trace("hook.resume", async (span) => {
       const world = await getWorldLazy();
@@ -123868,11 +124279,15 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
         }
         const compression = (resumeContext.runSpecVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION && capabilities.supportedFormats.has(SerializationFormat.GZIP);
         const ops = [];
+        const readbackOps = [];
         const v1Compat = isLegacySpecVersion(hook.specVersion);
-        const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression);
-        safeWaitUntil(Promise.all(ops), (err) => {
+        const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression, void 0, readbackOps);
+        await Promise.all(ops.map((op) => op.catch((error482) => {
+          if (error482 !== void 0) throw error482;
+        })));
+        safeWaitUntil(Promise.all(readbackOps), (err) => {
           if (err === void 0) return;
-          runtimeLogger.warn("Background flush of hook payload ops failed", {
+          runtimeLogger.warn("Background readback of hook payload failed", {
             workflowRunId: hook.runId,
             hookId: hook.hookId,
             error: err instanceof Error ? err.message : String(err)
@@ -123890,81 +124305,66 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
           deploymentId: resumeContext.deploymentId,
           specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY
         };
-        const lazyResumeDisabled = process.env.WORKFLOW_DISABLE_LAZY_HOOK_RESUME === "1";
         const backendDedupSupported = (hookResumeCapabilitiesAreFresh ? hook.resumeCapabilities?.hookResumeDedupVersion ?? 0 : 0) >= HOOK_RESUME_DEDUP_VERSION || world.capabilities?.hookResumeDedup === true;
-        const fallbackReason = requireDurableWrite ? (
-          // resolves (an ordering barrier), which only the eager write
-          // provides. Checked first so the span names the real reason
-          // rather than whichever gate happens to fail alongside it.
-          "durable_required"
-        ) : lazyResumeDisabled ? "disabled" : !backendDedupSupported ? "backend_unsupported" : (resumeContext.hookResumeInputVersion ?? 0) < HOOK_RESUME_INPUT_VERSION ? "consumer_unsupported" : v1Compat ? "legacy" : (resumeContext.runSpecVersion ?? 0) < SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT ? "non_cbor_transport" : !(dehydratedPayload instanceof Uint8Array) ? "non_bytes" : dehydratedPayload.byteLength > MAX_INLINE_RESUME_PAYLOAD_BYTES ? "oversized" : null;
-        const useLazyResume = fallbackReason === null;
+        const canClaimResume = backendDedupSupported && !v1Compat && dehydratedPayload instanceof Uint8Array;
         span?.setAttributes({
-          "workflow.hook.resume_strategy": useLazyResume ? "lazy" : "sequential",
-          ...fallbackReason ? {
-            "workflow.hook.resume_fallback_reason": fallbackReason
-          } : {}
+          "workflow.hook.resume_strategy": "sequential"
         });
-        if (!useLazyResume) {
-          const isHookGoneError = /* @__PURE__ */ __name2((err) => HookNotFoundError.is(err) || EntityConflictError.is(err) || RunExpiredError.is(err), "isHookGoneError");
-          try {
-            await world.events.create(hook.runId, {
-              eventType: "hook_received",
-              specVersion: SPEC_VERSION_CURRENT,
-              correlationId: hook.hookId,
-              eventData: {
-                ...v1Compat ? {} : {
-                  token: hook.token
-                },
-                payload: dehydratedPayload
-              }
-            }, {
-              v1Compat
-            });
-          } catch (err) {
-            if (isHookGoneError(err)) {
-              throw new HookNotFoundError(hook.token);
+        const resumeId = canClaimResume ? generateResumeId() : void 0;
+        const payloadDigest = canClaimResume ? await computeResumePayloadDigest(dehydratedPayload) : void 0;
+        if (resumeId) {
+          span?.setAttributes({
+            "workflow.hook.resume_id": resumeId
+          });
+        }
+        const isHookGoneError = /* @__PURE__ */ __name2((err) => HookNotFoundError.is(err) || RunExpiredError.is(err), "isHookGoneError");
+        try {
+          await world.events.create(hook.runId, {
+            eventType: "hook_received",
+            specVersion: SPEC_VERSION_CURRENT,
+            correlationId: hook.hookId,
+            eventData: {
+              ...v1Compat ? {} : {
+                token: hook.token
+              },
+              payload: dehydratedPayload
             }
-            throw err;
+          }, {
+            v1Compat,
+            ...resumeId && payloadDigest ? {
+              resumeId,
+              resumePayloadDigest: payloadDigest
+            } : {}
+          });
+        } catch (err) {
+          if (isHookGoneError(err)) {
+            throw new HookNotFoundError(hook.token);
           }
-          const queuePublishRequestedAtMs2 = Date.now();
-          await world.queue(queueName, {
-            runId: hook.runId,
-            traceCarrier: resumeContext.traceCarrier ?? void 0,
-            hookResumeTiming: {
-              resumeRequestedAtMs,
-              queuePublishRequestedAtMs: queuePublishRequestedAtMs2,
-              strategy: "sequential"
-            }
-          }, queueOptions);
-          return hook;
+          throw err;
         }
-        const resumeId = generateResumeId();
-        const payloadDigest = await computeResumePayloadDigest(dehydratedPayload);
-        span?.setAttributes({
-          "workflow.hook.resume_id": resumeId
-        });
+        span?.setAttributes(HookResumeCommitted(true));
         const queuePublishRequestedAtMs = Date.now();
-        await world.queue(queueName, {
+        await publishHookWakeWithRetry(() => world.queue(queueName, {
           runId: hook.runId,
           traceCarrier: resumeContext.traceCarrier ?? void 0,
-          hookInput: {
-            resumeId,
-            hookId: hook.hookId,
-            token: hook.token,
-            payload: dehydratedPayload,
-            payloadDigest,
-            // Deployment affinity for the consumer's cheap pre-write
-            // check: lets a misrouted delivery re-route before its
-            // hoisted hook_received write instead of after.
-            deploymentId: resumeContext.deploymentId
-          },
           hookResumeTiming: {
             resumeRequestedAtMs,
             queuePublishRequestedAtMs,
-            strategy: "lazy"
+            strategy: "sequential"
           }
-        }, queueOptions);
+        }, {
+          ...queueOptions,
+          // Dedup retried publishes whose response was lost: a
+          // duplicate wake is harmless for correctness (deterministic
+          // replay) but costs a full replay of the run, and the queue
+          // accepts a repeated idempotency key by delivering only one
+          // of the messages. Claim-less writes have no resumeId and
+          // keep the previous behavior.
+          ...resumeId ? {
+            idempotencyKey: `hook-${resumeId}`
+          } : {}
+        }), world.isDeploymentUnavailableError?.bind(world));
+        span?.setAttributes(HookWakePublished(true));
         return hook;
       } catch (err) {
         span?.setAttributes({
@@ -124002,7 +124402,7 @@ async function resumeWebhook(token, request) {
       status: 202
     });
   }
-  await resumeHookImpl(hook, request, encryptionKey, true, resumeRequestedAtMs, false);
+  await resumeHookImpl(hook, request, encryptionKey, true, resumeRequestedAtMs);
   if (responseReadable) {
     const reader = responseReadable.getReader();
     const chunk = await reader.read();
@@ -124020,7 +124420,7 @@ async function resumeWebhook(token, request) {
 }
 __name(resumeWebhook, "resumeWebhook");
 var generateResumeId;
-var MAX_INLINE_RESUME_PAYLOAD_BYTES;
+var HOOK_WAKE_RETRY_DELAYS_MS;
 var init_resume_hook = __esm2({
   "../core/dist/runtime/resume-hook.js"() {
     "use strict";
@@ -124040,15 +124440,19 @@ var init_resume_hook = __esm2({
     init_helpers();
     init_wait_until();
     generateResumeId = monotonicFactory();
-    MAX_INLINE_RESUME_PAYLOAD_BYTES = 128 * 1024;
     __name2(computeResumePayloadDigest, "computeResumePayloadDigest");
+    HOOK_WAKE_RETRY_DELAYS_MS = [
+      25,
+      100
+    ];
+    __name2(isRetryableWakeError, "isRetryableWakeError");
+    __name2(publishHookWakeWithRetry, "publishHookWakeWithRetry");
     __name2(resumeContextFromRun, "resumeContextFromRun");
     __name2(resolveHookResumeInfo, "resolveHookResumeInfo");
     __name2(resolveHookEncryptionKey, "resolveHookEncryptionKey");
     __name2(getHookByTokenWithKey, "getHookByTokenWithKey");
     __name2(getHookByToken, "getHookByToken");
     __name2(resumeHook, "resumeHook");
-    __name2(resumeHookDurable, "resumeHookDurable");
     __name2(resumeHookImpl, "resumeHookImpl");
     __name2(resumeWebhook, "resumeWebhook");
   }
@@ -124632,7 +125036,7 @@ function attachAbortListenerOnce(signal, streamName, runId, cryptoKey, ops) {
   });
 }
 __name(attachAbortListenerOnce, "attachAbortListenerOnce");
-function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier) {
+function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier, readbackOps = ops) {
   return {
     ...getAllBaseReducers(global2),
     ReadableStream: /* @__PURE__ */ __name2((value) => {
@@ -124653,7 +125057,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, runReadyBarrier), cryptoKey)).pipeTo(writable));
+        ops.push(value.pipeThrough(getSerializeStream(getExternalReducers(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier, readbackOps), cryptoKey)).pipeTo(writable));
       }
       const s = {
         name
@@ -124684,7 +125088,7 @@ function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framed
       const streamId = (global2[STABLE_ULID] || defaultUlid)();
       const name = `strm_${streamId}`;
       const readable = new WorkflowServerReadableStream(runId, name);
-      ops.push(readable.pipeTo(value));
+      readbackOps.push(readable.pipeTo(value));
       return {
         name
       };
@@ -124786,7 +125190,7 @@ function getWorkflowReducers(global2 = globalThis) {
   };
 }
 __name(getWorkflowReducers, "getWorkflowReducers");
-function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier) {
+function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier, readbackOps = ops) {
   return {
     ...getAllBaseReducers(global2),
     ReadableStream: /* @__PURE__ */ __name2((value) => {
@@ -124812,7 +125216,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, runReadyBarrier), cryptoKey)).pipeTo(writable));
+          ops.push(value.pipeThrough(getSerializeStream(getStepReducers(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier, readbackOps), cryptoKey)).pipeTo(writable));
         }
       }
       const s = {
@@ -124829,7 +125233,7 @@ function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByte
       if (!name) {
         const streamId = (global2[STABLE_ULID] || defaultUlid)();
         name = `strm_${streamId}`;
-        ops.push(new WorkflowServerReadableStream(runId, name).pipeThrough(getDeserializeStream(getStepRevivers(global2, ops, runId, cryptoKey), cryptoKey)).pipeTo(value));
+        readbackOps.push(new WorkflowServerReadableStream(runId, name).pipeThrough(getDeserializeStream(getStepRevivers(global2, readbackOps, runId, cryptoKey), cryptoKey)).pipeTo(value));
       }
       const s = {
         name
@@ -124962,8 +125366,8 @@ function reviveAbortController(value, ops, runId) {
       if (value.hookToken) {
         const hookResume = (async () => {
           try {
-            const { resumeHookDurable: resumeHookDurable22 } = await Promise.resolve().then(() => (init_resume_hook(), resume_hook_exports));
-            await resumeHookDurable22(value.hookToken, {
+            const { resumeHook: resumeHook22 } = await Promise.resolve().then(() => (init_resume_hook(), resume_hook_exports));
+            await resumeHook22(value.hookToken, {
               aborted: true,
               reason
             });
@@ -125281,16 +125685,16 @@ function getStepRevivers(global2 = globalThis, ops, runId, cryptoKey, deployment
   };
 }
 __name(getStepRevivers, "getStepRevivers");
-async function dehydrateWorkflowArguments(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false) {
+async function dehydrateWorkflowArguments(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false, readbackOps = ops) {
   if (v1Compat) {
-    const str = stringify(value, getExternalReducers(global2, ops, runId, key, framedByteStreams));
+    const str = stringify(value, getExternalReducers(global2, ops, runId, key, framedByteStreams, void 0, readbackOps));
     return revive(str);
   }
   try {
     const compressionStats = {};
     const result2 = await serialize(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers(getExternalReducers(global2, ops, runId, key, framedByteStreams)),
+      extraReducers: getStreamAndRequestReducers(getExternalReducers(global2, ops, runId, key, framedByteStreams, void 0, readbackOps)),
       compression,
       compressionStats
     });
@@ -125364,16 +125768,16 @@ async function hydrateStepArguments(value, runId, key, ops = [], global2 = globa
   return result2;
 }
 __name(hydrateStepArguments, "hydrateStepArguments");
-async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false, runReadyBarrier) {
+async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false, runReadyBarrier, readbackOps = ops) {
   if (v1Compat) {
-    const str = stringify(value, getStepReducers(global2, ops, runId, key, framedByteStreams, runReadyBarrier));
+    const str = stringify(value, getStepReducers(global2, ops, runId, key, framedByteStreams, runReadyBarrier, readbackOps));
     return revive(str);
   }
   try {
     const compressionStats = {};
     const result2 = await serialize2(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers(getStepReducers(global2, ops, runId, key, framedByteStreams, runReadyBarrier)),
+      extraReducers: getStreamAndRequestReducers(getStepReducers(global2, ops, runId, key, framedByteStreams, runReadyBarrier, readbackOps)),
       compression,
       compressionStats
     });
@@ -126174,9 +126578,9 @@ async function start(workflow, argsOrOptions, options) {
         },
         // Attest that the *consumer* deployment's runtime re-ensures a
         // `hook_received` event from a queue message's `hookInput` on replay.
-        // A resume of this run reads the marker (mirrored onto the hook's
-        // resumeContext by the server) to decide whether the parallel fast
-        // path is safe. For a cross-deployment start the consumer is the
+        // An OLDER producer resuming this run reads the marker (mirrored onto
+        // the hook's resumeContext by the server) to decide whether its lazy
+        // fast path is safe. For a cross-deployment start the consumer is the
         // target deployment, so we stamp the *target's* value carried back on
         // the health-check probe, never the caller's. Omitted when we could
         // not attest the target (older target, timeout, or no probe channel),
@@ -126288,7 +126692,7 @@ __name2(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.46//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.47//start");
 async function wakeUpRun(world, runId, options) {
   try {
     const run22 = await world.runs.get(runId, {
@@ -126691,7 +127095,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.47//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);
@@ -126700,7 +127104,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.47//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);
@@ -126709,7 +127113,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.47//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);
@@ -126718,7 +127122,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.47//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);
@@ -126727,7 +127131,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.47//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);
@@ -126736,7 +127140,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.47//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);
@@ -126745,7 +127149,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.47//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);
@@ -126754,7 +127158,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.47//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);
@@ -126763,7 +127167,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.47//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);
@@ -126772,7 +127176,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.47//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);
@@ -126782,7 +127186,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.46//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.47//Run");
 async function fetch2(...args) {
   return globalThis.fetch(...args);
 }
@@ -127342,19 +127746,12 @@ import { types as types9 } from "node:util";
 
 // ../core/dist/replay-payload-cache.js
 init_serialization4();
-var MAX_MEMOIZED_PRIMITIVE_LENGTH = 4096;
 function isMemoizablePrimitive(value) {
   if (value === null)
     return true;
   const type = typeof value;
   if (type === "object" || type === "function")
     return false;
-  if (type === "string") {
-    return value.length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;
-  }
-  if (type === "bigint") {
-    return value.toString().length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;
-  }
   return true;
 }
 __name(isMemoizablePrimitive, "isMemoizablePrimitive");
@@ -127362,14 +127759,20 @@ var ReplayPayloadCache = class {
   static {
     __name(this, "ReplayPayloadCache");
   }
-  encryptionKey;
   preparer;
   preparedPayloads = /* @__PURE__ */ new Map();
   primitiveStepResults = /* @__PURE__ */ new Map();
+  encryptionKey;
   nextUnscannedEventIndex = 0;
   constructor(encryptionKey, preparer = prepareReplayPayload) {
-    this.encryptionKey = encryptionKey;
     this.preparer = preparer;
+    this.encryptionKey = Promise.resolve(encryptionKey);
+  }
+  /** Start preparing an event payload as soon as its frame is decoded. */
+  prepareEvent(event) {
+    const preparation = this.prepareEventIfMissing(event);
+    void preparation?.catch(() => {
+    });
   }
   /**
    * Start every missing binary preparation before workflow execution. Failures
@@ -127378,41 +127781,19 @@ var ReplayPayloadCache = class {
    */
   async prewarm(workflowRun, events) {
     const preparations = [];
-    const start3 = /* @__PURE__ */ __name((cacheKey, value) => {
-      if (!(value instanceof Uint8Array))
-        return;
-      if (this.preparedPayloads.has(cacheKey))
-        return;
-      preparations.push(this.ensurePreparation(cacheKey, value));
-    }, "start");
-    start3(this.workflowInputKey(workflowRun.runId), workflowRun.input);
+    const workflowInput = this.startPreparation(this.workflowInputKey(workflowRun.runId), workflowRun.input);
+    if (workflowInput)
+      preparations.push(workflowInput);
     for (let index = this.nextUnscannedEventIndex; index < events.length; index++) {
       const event = events[index];
-      switch (event.eventType) {
-        case "step_completed":
-          start3(this.eventPayloadKey(event.eventId, "result"), event.eventData?.result);
-          break;
-        case "step_failed":
-          start3(this.eventPayloadKey(event.eventId, "error"), event.eventData?.error);
-          break;
-        case "hook_received":
-          start3(this.eventPayloadKey(event.eventId, "payload"), event.eventData?.payload);
-          break;
-      }
+      const preparation = this.prepareEventIfMissing(event);
+      if (preparation)
+        preparations.push(preparation);
     }
     this.nextUnscannedEventIndex = events.length;
     await Promise.allSettled(preparations);
   }
-  /**
-   * Forget how much of the event log has been scanned, so the next
-   * {@link prewarm} walks it from the start again.
-   *
-   * Required before a replay whose event log was reloaded rather than extended:
-   * a corrected log inserts the events the previous load was missing, which
-   * shifts every later position, so a positional resume would skip exactly the
-   * events the reload was for. Already-prepared payloads are kept: they are
-   * keyed by event id, so re-scanning re-observes them for free.
-   */
+  /** Rescan the next event log after an authoritative replacement. */
   resetScan() {
     this.nextUnscannedEventIndex = 0;
   }
@@ -127430,8 +127811,8 @@ var ReplayPayloadCache = class {
   }
   /**
    * Reuse final step values only when sharing them across VMs is unobservable.
-   * Objects and large strings/bigints always run `hydrate` again, producing a
-   * fresh VM-specific value from the separately cached prepared payload.
+   * Objects always run `hydrate` again to produce a fresh VM-specific value;
+   * every primitive is safe to reuse directly.
    */
   async getStepResult(eventId, hydrate) {
     if (this.primitiveStepResults.has(eventId)) {
@@ -127469,7 +127850,39 @@ var ReplayPayloadCache = class {
   }
   /** Normalize synchronous and asynchronous preparers to one promise contract. */
   async runPreparation(value) {
-    return this.preparer(value, this.encryptionKey);
+    return this.preparer(value, await this.encryptionKey);
+  }
+  /** Start one event's binary payload unless another path already did. */
+  prepareEventIfMissing(event) {
+    let field;
+    let value;
+    switch (event.eventType) {
+      case "run_created":
+        return this.startPreparation(this.workflowInputKey(event.runId), event.eventData.input);
+      case "run_started":
+        return this.startPreparation(this.workflowInputKey(event.runId), event.eventData?.input);
+      case "step_completed":
+        field = "result";
+        value = event.eventData?.result;
+        break;
+      case "step_failed":
+        field = "error";
+        value = event.eventData?.error;
+        break;
+      case "hook_received":
+        field = "payload";
+        value = event.eventData?.payload;
+        break;
+      default:
+        return void 0;
+    }
+    return this.startPreparation(this.eventPayloadKey(event.eventId, field), value);
+  }
+  startPreparation(cacheKey, value) {
+    if (!(value instanceof Uint8Array) || this.preparedPayloads.has(cacheKey)) {
+      return void 0;
+    }
+    return this.ensurePreparation(cacheKey, value);
   }
   workflowInputKey(runId) {
     return `run:${runId}:input`;
@@ -129304,8 +129717,8 @@ import { Script } from "node:vm";
 var scripts = globalSingleton2("@workflow/core//vmScriptCache", 1, () => ({
   byCode: /* @__PURE__ */ new Map()
 }));
-var MAX_BUNDLES = 8;
-function touchBundle(code3) {
+var MAX_SCRIPT_SOURCES = 8;
+function touchScriptSource(code3) {
   const byFilename = scripts.byCode.get(code3);
   if (byFilename === void 0) {
     return void 0;
@@ -129314,13 +129727,13 @@ function touchBundle(code3) {
   scripts.byCode.set(code3, byFilename);
   return byFilename;
 }
-__name(touchBundle, "touchBundle");
+__name(touchScriptSource, "touchScriptSource");
 function getCachedWorkflowScript(code3, filename) {
-  let byFilename = touchBundle(code3);
+  let byFilename = touchScriptSource(code3);
   if (byFilename === void 0) {
     byFilename = /* @__PURE__ */ new Map();
     scripts.byCode.set(code3, byFilename);
-    while (scripts.byCode.size > MAX_BUNDLES) {
+    while (scripts.byCode.size > MAX_SCRIPT_SOURCES) {
       const oldest = scripts.byCode.keys().next().value;
       if (oldest === void 0) {
         break;
@@ -129329,17 +129742,14 @@ function getCachedWorkflowScript(code3, filename) {
     }
   }
   let script = byFilename.get(filename);
+  const cacheHit = script !== void 0;
   if (script === void 0) {
     script = new Script(code3, { filename });
     byFilename.set(filename, script);
   }
-  return script;
+  return { script, cacheHit };
 }
 __name(getCachedWorkflowScript, "getCachedWorkflowScript");
-function runCachedWorkflowScript(code3, filename, context2) {
-  return getCachedWorkflowScript(code3, filename).runInContext(context2);
-}
-__name(runCachedWorkflowScript, "runCachedWorkflowScript");
 
 // ../core/dist/workflow.js
 init_abort_controller2();
@@ -129776,6 +130186,26 @@ async function drainPendingQueueItems(runId, pendingQueue, vmGlobalThis, workflo
   }
 }
 __name(drainPendingQueueItems, "drainPendingQueueItems");
+function compileWorkflowBundle(workflowCode2, workflowName) {
+  const parsedName = parseWorkflowName2(workflowName);
+  const filename = parsedName?.moduleSpecifier || workflowName;
+  const workflowLookupCode = `globalThis.__private_workflows?.get(${JSON.stringify(workflowName)})`;
+  return trace5("workflow.bundle.compile", async (span) => {
+    const bundle = getCachedWorkflowScript(workflowCode2, filename);
+    const lookup = getCachedWorkflowScript(workflowLookupCode, filename);
+    span?.setAttributes({
+      // This attribute intentionally describes the workflow bundle. The tiny
+      // lookup script may miss when another workflow from the same source file
+      // runs, but that does not mean V8 recompiled the application bundle.
+      ...WorkflowBundleCompileCacheHit2(bundle.cacheHit)
+    });
+    return {
+      bundleScript: bundle.script,
+      workflowLookupScript: lookup.script
+    };
+  });
+}
+__name(compileWorkflowBundle, "compileWorkflowBundle");
 function replayWorkflow(options) {
   return traceExecution("replay", options.workflowRun, options.events, async (span) => {
     const { session, execution } = await createWorkflowSession(options);
@@ -129827,7 +130257,15 @@ function recordResult(result2, span) {
   return result2;
 }
 __name(recordResult, "recordResult");
-async function createWorkflowSession({ workflowCode: workflowCode2, workflowRun, events, encryptionKey, replayPayloadCache, runReadyBarrier, worldCapabilities }) {
+async function createWorkflowSession(options) {
+  const vmTrace = await startTraceSpan("workflow.vm.create_context");
+  return createWorkflowSessionInner(options, vmTrace.end).catch((error95) => {
+    vmTrace.fail(error95);
+    throw error95;
+  });
+}
+__name(createWorkflowSession, "createWorkflowSession");
+async function createWorkflowSessionInner({ workflowCode: workflowCode2, workflowRun, events, encryptionKey, replayPayloadCache, compiledWorkflowScripts, runReadyBarrier, worldCapabilities }, endVmTrace) {
   const startedAt = workflowRun.startedAt;
   if (!startedAt) {
     throw new WorkflowRuntimeError2(`Workflow run "${workflowRun.runId}" has no "startedAt" timestamp (should not happen)`);
@@ -130355,22 +130793,23 @@ Learn more: https://workflow-sdk.dev/err/${ERROR_SLUGS2.FETCH_IN_WORKFLOW_FUNCTI
   vmGlobalThis.console = globalThis.console;
   const SYMBOL_FOR_REQ_CONTEXT = /* @__PURE__ */ Symbol.for("@vercel/request-context");
   vmGlobalThis[SYMBOL_FOR_REQ_CONTEXT] = globalThis[SYMBOL_FOR_REQ_CONTEXT];
-  const parsedName = parseWorkflowName2(workflowRun.workflowName);
-  const filename = parsedName?.moduleSpecifier || workflowRun.workflowName;
-  runCachedWorkflowScript(workflowCode2, filename, context2);
-  const workflowFn = runCachedWorkflowScript(`globalThis.__private_workflows?.get(${JSON.stringify(workflowRun.workflowName)})`, filename, context2);
+  endVmTrace();
+  const { bundleScript, workflowLookupScript } = compiledWorkflowScripts ?? await compileWorkflowBundle(workflowCode2, workflowRun.workflowName);
+  const workflowFn = await trace5("workflow.bundle.evaluate", async () => {
+    bundleScript.runInContext(context2);
+    return workflowLookupScript.runInContext(context2);
+  });
   if (typeof workflowFn !== "function") {
     throw new WorkflowNotRegisteredError2(workflowRun.workflowName);
   }
   let args = [];
   workflowContext.promiseQueue = workflowContext.promiseQueue.then(async () => {
-    const prepared = await replayPayloadCache.prepareWorkflowInput(workflowRun);
-    args = await hydrateWorkflowArguments(workflowRun.input, workflowRun.runId, encryptionKey, vmGlobalThis, {}, prepared);
+    args = await trace5("workflow.input.hydrate", async () => {
+      const prepared = await replayPayloadCache.prepareWorkflowInput(workflowRun);
+      return hydrateWorkflowArguments(workflowRun.input, workflowRun.runId, encryptionKey, vmGlobalThis, {}, prepared);
+    });
   });
   await workflowContext.promiseQueue;
-  const workflowBody = (async () => {
-    return await workflowFn(...args);
-  })();
   const failWorkflow = /* @__PURE__ */ __name(async (error95) => {
     if (WorkflowSuspension2.is(error95) || ReplayDivergenceError.is(error95)) {
       if (state.type === "running")
@@ -130381,10 +130820,10 @@ Learn more: https://workflow-sdk.dev/err/${ERROR_SLUGS2.FETCH_IN_WORKFLOW_FUNCTI
     await drainPendingQueueItems(workflowRun.runId, workflowContext.invocationsQueue, vmGlobalThis, workflowRun, "failed", runReadyBarrier);
     throw error95;
   }, "failWorkflow");
-  const waitForExecution = /* @__PURE__ */ __name(async (interruption) => {
+  const waitForExecution = /* @__PURE__ */ __name(async (workflowBody2, interruption) => {
     let result2;
     try {
-      result2 = await Promise.race([workflowBody, interruption.promise]);
+      result2 = await Promise.race([workflowBody2, interruption.promise]);
     } catch (error95) {
       if (state.type === "suspended" && error95 === state.suspension) {
         return {
@@ -130421,6 +130860,9 @@ Learn more: https://workflow-sdk.dev/err/${ERROR_SLUGS2.FETCH_IN_WORKFLOW_FUNCTI
       return failWorkflow(error95);
     }
   }, "waitForExecution");
+  const workflowTraceContext = await createRefreshableTraceContext();
+  const replayTrace = await startTraceSpan("workflow.replay.execute");
+  const workflowBody = workflowTraceContext.run(async () => workflowFn(...args));
   const session = {
     workflowRun,
     argumentCount: args.length,
@@ -130436,8 +130878,9 @@ Learn more: https://workflow-sdk.dev/err/${ERROR_SLUGS2.FETCH_IN_WORKFLOW_FUNCTI
           const interruption = withResolvers2();
           state = { type: "running", interruption };
           workflowContext.suspensionGeneration++;
+          workflowTraceContext.refresh();
           eventsConsumer.append(nextEvents.slice(knownEvents.length));
-          return waitForExecution(interruption);
+          return waitForExecution(workflowBody, interruption);
         }
         case "replay":
           return { type: "replay" };
@@ -130448,12 +130891,14 @@ Learn more: https://workflow-sdk.dev/err/${ERROR_SLUGS2.FETCH_IN_WORKFLOW_FUNCTI
       state;
     }
   };
+  const execution = waitForExecution(workflowBody, initialInterruption);
+  void execution.then(replayTrace.end, replayTrace.fail);
   return {
     session,
-    execution: waitForExecution(initialInterruption)
+    execution
   };
 }
-__name(createWorkflowSession, "createWorkflowSession");
+__name(createWorkflowSessionInner, "createWorkflowSessionInner");
 
 // ../core/dist/runtime.js
 init_global2();
@@ -130966,8 +131411,12 @@ async function recordFatalRunError({ world, workflowRun, runId, requestId, err,
   }
 }
 __name(recordFatalRunError, "recordFatalRunError");
+function findRecordedTerminalRunEvent(events, runId) {
+  return events.find((e) => e.runId === runId && (e.eventType === "run_completed" || e.eventType === "run_failed" || e.eventType === "run_cancelled"));
+}
+__name(findRecordedTerminalRunEvent, "findRecordedTerminalRunEvent");
 function hasRecordedTerminalRunEvent(events, runId) {
-  const terminalRunEvent = events.find((e) => e.runId === runId && (e.eventType === "run_completed" || e.eventType === "run_failed" || e.eventType === "run_cancelled"));
+  const terminalRunEvent = findRecordedTerminalRunEvent(events, runId);
   if (!terminalRunEvent) {
     return false;
   }
@@ -131198,6 +131647,41 @@ function workflowEntrypoint(workflowCode2, options) {
           const noInlineReplayAfterMs = await getMaxInlineDurationMs(world, invocationStartTime);
           let loopIteration = 0;
           const replayRecoveryReporter = replayDivergence ? new ReplayRecoveryReporter(replayDivergence.count) : ReplayRecoveryReporter.inert();
+          let compiledWorkflowScripts;
+          let compiledWorkflowName;
+          const startWorkflowCompile = await bindActiveTraceContext((workflow) => {
+            if (!workflow || useQuickJSVm(workflow))
+              return;
+            if (compiledWorkflowName !== workflow.workflowName) {
+              compiledWorkflowName = workflow.workflowName;
+              compiledWorkflowScripts = compileWorkflowBundle(workflowCode2, workflow.workflowName);
+              void compiledWorkflowScripts.catch(() => {
+              });
+            }
+            return compiledWorkflowScripts;
+          });
+          const encryptionKey = once2(() => {
+            const result2 = resolveRunEncryptionKey(world, runId);
+            void result2.catch(() => {
+            });
+            return result2;
+          });
+          let replayPayloadCache;
+          const startReplayPayloadCache = /* @__PURE__ */ __name((workflow) => {
+            if (!workflow || useQuickJSVm(workflow))
+              return;
+            if (!replayPayloadCache) {
+              replayPayloadCache = new ReplayPayloadCache(encryptionKey.value);
+            }
+            return replayPayloadCache;
+          }, "startReplayPayloadCache");
+          const prepareReplayEvent = /* @__PURE__ */ __name((event) => {
+            if (event.eventType === "run_created") {
+              startReplayPayloadCache(event.eventData);
+              startWorkflowCompile(event.eventData);
+            }
+            replayPayloadCache?.prepareEvent(event);
+          }, "prepareReplayEvent");
           const createEvent = /* @__PURE__ */ __name(async (data, params) => {
             const sinceCursor = deltaRequestCursor(data, params);
             const withSnapshot = { ...slotSnapshot(), ...params };
@@ -131207,6 +131691,23 @@ function workflowEntrypoint(workflowCode2, options) {
             }
             return result2;
           }, "createEvent");
+          const traceReplayLoad = /* @__PURE__ */ __name((source, load) => trace5("workflow.replay.load", async (loadSpan) => {
+            let eventsCount = 0;
+            loadSpan?.setAttributes({
+              ...WorkflowRunId4(runId),
+              ...WorkflowReplayLoadSource2(source)
+            });
+            try {
+              const result2 = await load((event) => {
+                eventsCount++;
+                prepareReplayEvent(event);
+              });
+              eventsCount = result2.events?.length ?? eventsCount;
+              return result2;
+            } finally {
+              loadSpan?.setAttributes(WorkflowEventsCount2(eventsCount));
+            }
+          }), "traceReplayLoad");
           const slotSnapshot = /* @__PURE__ */ __name(() => eventLog.type === "loadAll" ? {} : slotSnapshotParams(eventLog.events), "slotSnapshot");
           const deltaRequestCursor = /* @__PURE__ */ __name((data, params) => {
             if (turbo || eventLog.type !== "ready" || params?.sinceCursor !== void 0 || params?.preloadEvents === true || isTerminalRunEventType(data.eventType)) {
@@ -131242,6 +131743,21 @@ function workflowEntrypoint(workflowCode2, options) {
               }
             }
           }, "awaitRunReady");
+          const recordWorkflowSetupFailure = /* @__PURE__ */ __name(async (err) => {
+            const errorCode = getWorkflowSetupErrorCode(err);
+            if (!errorCode)
+              return false;
+            await recordFatalRunError({
+              world,
+              workflowRun,
+              runId,
+              requestId,
+              err,
+              errorCode,
+              logMessage: "Fatal runtime error during workflow setup"
+            });
+            return true;
+          }, "recordWorkflowSetupFailure");
           const inFlightOwnedSteps = /* @__PURE__ */ new Set();
           const assertNoInFlightOwnedSteps = /* @__PURE__ */ __name((ackPath) => {
             if (inFlightOwnedSteps.size > 0) {
@@ -131307,7 +131823,7 @@ function workflowEntrypoint(workflowCode2, options) {
               eventLog = { ...eventLog, type: "ready" };
             } else {
               eventLog = { type: "loadAll" };
-              replayPayloadCache.resetScan();
+              replayPayloadCache?.resetScan();
             }
             runtimeLogger2.warn("Event creation rejected as stale; restarting replay in-process", {
               workflowRunId: runId,
@@ -131518,6 +132034,7 @@ function workflowEntrypoint(workflowCode2, options) {
                     return;
                   }
                 }
+                startWorkflowCompile(bgRun);
                 runtimeLogger2.debug("All parallel steps done, replaying inline after background step", { workflowRunId: runId });
                 const runCreatedEvent = loaded.events.find((event) => event.eventType === "run_created");
                 let replayInput;
@@ -131606,7 +132123,7 @@ function workflowEntrypoint(workflowCode2, options) {
               span?.addEvent("workflow.hook_received.create.start", {
                 "workflow.hook_received.preload_events": true
               });
-              const result2 = await createEvent({
+              const replayLoad = traceReplayLoad("hook_preload", (replayEventObserver) => createEvent({
                 eventType: "hook_received",
                 specVersion: SPEC_VERSION_CURRENT2,
                 correlationId: hookResumeInput.hookId,
@@ -131619,8 +132136,10 @@ function workflowEntrypoint(workflowCode2, options) {
                 occurredAt,
                 resumeId: hookResumeInput.resumeId,
                 resumePayloadDigest: hookResumeInput.payloadDigest,
-                preloadEvents: true
-              });
+                preloadEvents: true,
+                replayEventObserver
+              }));
+              const result2 = await replayLoad;
               hookEnsured = true;
               const usableReplayPreload = result2.run !== void 0 && result2.run.startedAt !== void 0 && result2.event !== void 0 && result2.events !== void 0 && result2.events.length > 0 && result2.cursor != null && result2.hasMore === false && typeof result2.maxEvents === "number" && result2.events.some((e) => e.eventType === "run_created") && result2.events.some((e) => e.eventType === "run_started") && result2.events.some((e) => e.eventType === "hook_received" && e.resumeId === hookResumeInput.resumeId);
               if (usableReplayPreload && result2.run?.startedAt && result2.events) {
@@ -131637,6 +132156,7 @@ function workflowEntrypoint(workflowCode2, options) {
                   return;
                 }
                 workflowRun = result2.run;
+                startWorkflowCompile(workflowRun);
                 maxEventsLimit = clampMaxEvents(result2.maxEvents);
                 runStartedReceivedAtMs = Date.now();
                 if (resumeTracking) {
@@ -131661,6 +132181,8 @@ function workflowEntrypoint(workflowCode2, options) {
                 runtimeLogger2.info("Run already finished during lazy hook setup, skipping", { workflowRunId: runId, message: err.message });
                 return;
               }
+              if (await recordWorkflowSetupFailure(err))
+                return;
               throw err;
             }
           }
@@ -131701,6 +132223,16 @@ function workflowEntrypoint(workflowCode2, options) {
                 { requestId, skipPreload: true }
               );
               runReadyBarrier = startedPromise;
+              try {
+                startWorkflowCompile(runInput);
+                startReplayPayloadCache(runInput);
+              } catch (err) {
+                await awaitRunReady();
+                if (!await recordWorkflowSetupFailure(err)) {
+                  throw err;
+                }
+                return;
+              }
               void startedPromise.then((r) => {
                 const limit = clampMaxEvents(r.maxEvents);
                 if (limit !== void 0)
@@ -131749,9 +132281,21 @@ function workflowEntrypoint(workflowCode2, options) {
                 span?.addEvent("workflow.run_started.create.start", {
                   "workflow.run_started.skip_preload": false
                 });
-                const result2 = await createEvent(runStartedEvent, {
-                  requestId
-                });
+                const replayLoad = traceReplayLoad("run_started", (replayEventObserver) => createEvent(runStartedEvent, {
+                  requestId,
+                  replayEventObserver
+                }));
+                try {
+                  startWorkflowCompile(runInput);
+                  startReplayPayloadCache(runInput);
+                } catch (setupError) {
+                  try {
+                    await replayLoad;
+                  } catch {
+                  }
+                  throw setupError;
+                }
+                const result2 = await replayLoad;
                 workflowRun = result2.run;
                 maxEventsLimit = clampMaxEvents(result2.maxEvents);
                 runStartedReceivedAtMs = Date.now();
@@ -131777,24 +132321,15 @@ function workflowEntrypoint(workflowCode2, options) {
                   });
                   return;
                 }
+                startWorkflowCompile(workflowRun);
               } catch (err) {
                 if (EntityConflictError2.is(err) || RunExpiredError2.is(err)) {
                   runtimeLogger2.info("Run already finished during setup, skipping", { workflowRunId: runId, message: err.message });
                   return;
                 } else {
-                  const errorCode = getWorkflowSetupErrorCode(err);
-                  if (!errorCode) {
+                  if (!await recordWorkflowSetupFailure(err)) {
                     throw err;
                   }
-                  await recordFatalRunError({
-                    world,
-                    workflowRun,
-                    runId,
-                    requestId,
-                    err,
-                    errorCode,
-                    logMessage: "Fatal runtime error during workflow setup"
-                  });
                   return;
                 }
               }
@@ -131856,14 +132391,12 @@ function workflowEntrypoint(workflowCode2, options) {
               }
               if (eventLog.type !== "loadAll" && ensuredEvent) {
                 insertEventByEventId(eventLog.events, ensuredEvent);
+                prepareReplayEvent(ensuredEvent);
               } else {
                 eventLog = { type: "loadAll" };
               }
             }
           }
-          const getEncryptionKey = memoizeEncryptionKey(world, workflowRun);
-          const encryptionKey = await getEncryptionKey();
-          const replayPayloadCache = new ReplayPayloadCache(encryptionKey);
           let retainedSession = null;
           while (true) {
             loopIteration++;
@@ -131944,7 +132477,10 @@ function workflowEntrypoint(workflowCode2, options) {
                   appendEventLog(eventLog, page);
                   eventLog = { ...eventLog, type: "ready" };
                 } else {
-                  eventLog = { ...page, type: "ready" };
+                  eventLog = {
+                    ...page,
+                    type: "ready"
+                  };
                 }
               }
               assert6(eventLog.type === "ready");
@@ -132007,7 +132543,10 @@ function workflowEntrypoint(workflowCode2, options) {
                   events: eventLog.events,
                   cursor: eventLog.cursor
                 });
-                eventLog = { ...settled.log, type: "ready" };
+                eventLog = {
+                  ...settled.log,
+                  type: "ready"
+                };
                 if (settled.gap !== void 0) {
                   throw new CorruptedEventLogError(`Event log for run ${runId} has a hole at slot ${settled.gap.firstMissingSlot}: ${settled.gap.missingCount} of the ${settled.gap.maxSlot} slots up to the log's maximum hold no event.`);
                 }
@@ -132032,17 +132571,22 @@ function workflowEntrypoint(workflowCode2, options) {
               if (resumeTracking) {
                 resumeTracking.replayStartedAtMs ??= replayStart;
               }
-              const payloadPrewarm = replayPayloadCache.prewarm(workflowRun, eventLog.events);
+              const replayPayloadCache2 = startReplayPayloadCache(workflowRun);
+              assert6(replayPayloadCache2, "Node workflow replay requires payload preparation");
+              const payloadPrewarm = replayPayloadCache2.prewarm(workflowRun, eventLog.events);
               let workflowResult = retainedSession ? await resumeWorkflow(retainedSession, eventLog.events) : { type: "replay" };
               servedByRetainedSession = retainedSession !== null && workflowResult.type !== "replay";
               if (workflowResult.type === "replay") {
                 retainedSession = null;
+                const compiled = startWorkflowCompile(workflowRun);
+                assert6(compiled, "Node workflow replay requires compiled scripts");
                 workflowResult = await replayWorkflow({
                   workflowCode: workflowCode2,
                   workflowRun,
                   events: eventLog.events,
-                  encryptionKey,
-                  replayPayloadCache,
+                  encryptionKey: await encryptionKey.value,
+                  replayPayloadCache: replayPayloadCache2,
+                  compiledWorkflowScripts: await compiled,
                   // Turbo: the end-of-run drain inside workflow
                   // execution commits fire-and-forget `*_created`
                   // events before the terminal `awaitRunReady()` below.
@@ -132166,7 +132710,7 @@ function workflowEntrypoint(workflowCode2, options) {
                       eventType: "run_failed",
                       specVersion: SPEC_VERSION_CURRENT2,
                       eventData: {
-                        error: await dehydrateRunError(suspensionError, runId, encryptionKey, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
+                        error: await dehydrateRunError(suspensionError, runId, await encryptionKey.value, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
                         errorCode
                       }
                     }, { requestId });
@@ -132189,9 +132733,6 @@ function workflowEntrypoint(workflowCode2, options) {
                   });
                   return;
                 }
-                if (suspensionResult.reportedEventCount > 0) {
-                  replayPayloadCache.resetScan();
-                }
                 const openHookWait = once2(() => {
                   assert6(eventLog.type === "ready");
                   return openHookAndWaitState(eventLog.events);
@@ -132653,7 +133194,7 @@ function workflowEntrypoint(workflowCode2, options) {
                     eventType: "run_failed",
                     specVersion: SPEC_VERSION_CURRENT2,
                     eventData: {
-                      error: await dehydrateRunError(terminalError, runId, encryptionKey, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
+                      error: await dehydrateRunError(terminalError, runId, await encryptionKey.value, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
                       errorCode
                     }
                   }, {
@@ -133497,10 +134038,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.46//Run#wakeUp");
-Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.46//Run#cancel");
-Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.46//Run#getReadable");
-var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.46//Run#exists");
+Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.47//Run#wakeUp");
+Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.47//Run#cancel");
+Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.47//Run#getReadable");
+var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.47//Run#exists");
 Object.defineProperty(Run.prototype, "exists", {
   get() {
     return __step_Run$exists.call(this);
@@ -133508,7 +134049,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.46//Run#status");
+var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.47//Run#status");
 Object.defineProperty(Run.prototype, "status", {
   get() {
     return __step_Run$status.call(this);
@@ -133516,7 +134057,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.46//Run#returnValue");
+var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.47//Run#returnValue");
 Object.defineProperty(Run.prototype, "returnValue", {
   get() {
     return __step_Run$returnValue.call(this);
@@ -133524,7 +134065,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.46//Run#workflowName");
+var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.47//Run#workflowName");
 Object.defineProperty(Run.prototype, "workflowName", {
   get() {
     return __step_Run$workflowName.call(this);
@@ -133532,7 +134073,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.46//Run#createdAt");
+var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.47//Run#createdAt");
 Object.defineProperty(Run.prototype, "createdAt", {
   get() {
     return __step_Run$createdAt.call(this);
@@ -133540,7 +134081,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.46//Run#startedAt");
+var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.47//Run#startedAt");
 Object.defineProperty(Run.prototype, "startedAt", {
   get() {
     return __step_Run$startedAt.call(this);
@@ -133548,7 +134089,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.46//Run#completedAt");
+var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.47//Run#completedAt");
 Object.defineProperty(Run.prototype, "completedAt", {
   get() {
     return __step_Run$completedAt.call(this);
@@ -133565,7 +134106,7 @@ Object.defineProperty(Run.prototype, "completedAt", {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.46//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.47//Run");
 
 // ../core/dist/workflow/create-hook.js
 aliasSerializationClass(RUN_CLASS_ID, Run);
@@ -138195,7 +138736,7 @@ globalThis.__private_workflows.set("workflow//./workflows/inline-execution//hook
 var latestNoOpWarning = globalSingleton("@workflow/core//latestNoOpWarning", 1, () => ({
   warned: false
 }));
-var start = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/start@5.0.0-beta.46//start");
+var start = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/start@5.0.0-beta.47//start");
 
 // workflows/lineage.ts
 var noop = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//./workflows/lineage//noop");