@workflow/world-testing 5.0.0-beta.41 → 5.0.0-beta.42

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

@@ -15289,6 +15289,9 @@ function isStepEventType(eventType) {
 function isTerminalStepEventType(eventType) {
   return TERMINAL_STEP_EVENT_TYPES2.includes(eventType);
 }
+function entityEventClass(eventType) {
+  return ENTITY_EVENT_CLASS_BY_TYPE[eventType];
+}
 function isHookLifecycleEventType(eventType) {
   return HOOK_LIFECYCLE_EVENT_TYPES2.includes(eventType);
 }
@@ -15335,7 +15338,7 @@ function isChildEntityCreationEvent(event) {
     return true;
   return event.eventType === "step_started" && typeof event.eventData?.stepName === "string" && event.eventData.input !== void 0;
 }
-var EventTypeSchema2, RunEventTypeSchema2, RUN_EVENT_TYPES2, TerminalRunEventTypeSchema2, TERMINAL_RUN_EVENT_TYPES2, StepEventTypeSchema2, STEP_EVENT_TYPES2, TerminalStepEventTypeSchema2, TERMINAL_STEP_EVENT_TYPES2, HookLifecycleEventTypeSchema2, HOOK_LIFECYCLE_EVENT_TYPES2, HookEventRequiringExistenceTypeSchema2, HOOK_EVENTS_REQUIRING_EXISTENCE2, WaitEventTypeSchema2, WAIT_EVENT_TYPES2, ChildEntityCreationEventTypeSchema2, CHILD_ENTITY_CREATION_EVENT_TYPES2, EVENT_DATA_PAYLOAD_FIELD_BY_EVENT_TYPE2, EVENT_DATA_REF_FIELDS2, BaseEventSchema2, stepLatencyTelemetryFields2, StepCompletedEventSchema2, StepFailedEventSchema2, StepRetryingEventSchema2, StepStartedEventSchema2, StepCreatedEventSchema2, HookCreatedEventSchema2, HookReceivedEventSchema2, HookDisposedEventSchema2, HookConflictEventSchema2, WaitCreatedEventSchema2, WaitCompletedEventSchema2, AttributeWriterSchema2, AttrSetEventSchema2, RunCreatedEventSchema2, RunStartedEventSchema2, RunCompletedEventSchema2, RunFailedEventSchema2, RunCancelledEventSchema2, CreateEventSchema2, AllEventsSchema2, EventSchema2;
+var EventTypeSchema2, RunEventTypeSchema2, RUN_EVENT_TYPES2, TerminalRunEventTypeSchema2, TERMINAL_RUN_EVENT_TYPES2, StepEventTypeSchema2, STEP_EVENT_TYPES2, TerminalStepEventTypeSchema2, TERMINAL_STEP_EVENT_TYPES2, ENTITY_EVENT_CLASS_BY_TYPE, HookLifecycleEventTypeSchema2, HOOK_LIFECYCLE_EVENT_TYPES2, HookEventRequiringExistenceTypeSchema2, HOOK_EVENTS_REQUIRING_EXISTENCE2, WaitEventTypeSchema2, WAIT_EVENT_TYPES2, ChildEntityCreationEventTypeSchema2, CHILD_ENTITY_CREATION_EVENT_TYPES2, EVENT_DATA_PAYLOAD_FIELD_BY_EVENT_TYPE2, EVENT_DATA_REF_FIELDS2, BaseEventSchema2, stepLatencyTelemetryFields2, StepCompletedEventSchema2, StepFailedEventSchema2, StepRetryingEventSchema2, StepStartedEventSchema2, StepCreatedEventSchema2, HookCreatedEventSchema2, HookReceivedEventSchema2, HookDisposedEventSchema2, HookConflictEventSchema2, WaitCreatedEventSchema2, WaitCompletedEventSchema2, AttributeWriterSchema2, AttrSetEventSchema2, RunCreatedEventSchema2, RunStartedEventSchema2, RunCompletedEventSchema2, RunFailedEventSchema2, RunCancelledEventSchema2, CreateEventSchema2, AllEventsSchema2, EventSchema2;
 var init_events2 = __esm({
   "../world/dist/events.js"() {
     "use strict";
@@ -15398,6 +15401,19 @@ var init_events2 = __esm({
     ]);
     TERMINAL_STEP_EVENT_TYPES2 = TerminalStepEventTypeSchema2.options;
     __name(isTerminalStepEventType, "isTerminalStepEventType");
+    ENTITY_EVENT_CLASS_BY_TYPE = {
+      step_created: "step_created",
+      step_started: "step_started",
+      step_retrying: "step_retrying",
+      step_completed: "step_terminal",
+      step_failed: "step_terminal",
+      wait_created: "wait_created",
+      wait_completed: "wait_completed",
+      hook_created: "hook_created",
+      hook_disposed: "hook_disposed",
+      run_started: "run_started"
+    };
+    __name(entityEventClass, "entityEventClass");
     HookLifecycleEventTypeSchema2 = EventTypeSchema2.extract([
       "hook_created",
       "hook_received",
@@ -16024,7 +16040,7 @@ var init_waits2 = __esm({
 });
 
 // ../world/dist/analytics.js
-var NAIVE_DATETIME2, UTCDateSchema2, NullableDateSchema2, NullableStringSchema2, NullableBooleanSchema2, AnalyticsRunSchema2, AnalyticsStepSchema2, AnalyticsEventSchema2, AnalyticsHookSchema2, AnalyticsWaitSchema2, AnalyticsAttributeKeySchema2;
+var NAIVE_DATETIME2, UTCDateSchema2, NullableDateSchema2, NullableStringSchema2, NullableBooleanSchema2, AnalyticsRunSchema2, AnalyticsStepSchema2, AnalyticsEventSchema2, AnalyticsHookSchema2, AnalyticsWaitSchema2, AnalyticsAttributeKeySchema2, ANALYTICS_EVENTS_GET_MANY_LIMIT;
 var init_analytics2 = __esm({
   "../world/dist/analytics.js"() {
     "use strict";
@@ -16130,6 +16146,7 @@ var init_analytics2 = __esm({
       firstSeenAt: external_exports2.coerce.date(),
       lastSeenAt: external_exports2.coerce.date()
     });
+    ANALYTICS_EVENTS_GET_MANY_LIMIT = 100;
   }
 });
 
@@ -16220,7 +16237,7 @@ function parseQueueName(name) {
     id: match2[2]
   };
 }
-var QueuePrefix2, ValidQueueName2, QueueNamespace2, MessageId2, TraceCarrierSchema2, RunInputSchema2, HookResumeInputSchema2, WorkflowInvokePayloadSchema2, HealthCheckPayloadSchema2, QueuePayloadSchema2;
+var QueuePrefix2, ValidQueueName2, QueueNamespace2, MessageId2, TraceCarrierSchema2, RunInputSchema2, StepDispatchInputSchema2, HookResumeInputSchema2, HookResumeTimingSchema2, WorkflowInvokePayloadSchema2, HealthCheckPayloadSchema2, QueuePayloadSchema2;
 var init_queue2 = __esm({
   "../world/dist/queue.js"() {
     "use strict";
@@ -16268,6 +16285,19 @@ var init_queue2 = __esm({
        */
       environment: external_exports2.string().optional()
     });
+    StepDispatchInputSchema2 = external_exports2.object({
+      /**
+       * The serialized step input, reused verbatim from the direct write. Always
+       * binary: producers only attach `stepInput` when the dehydrated input is a
+       * `Uint8Array` and the run's queue transport preserves bytes (CBOR).
+       * Validated here so a malformed or transport-mangled payload fails the
+       * message parse instead of being silently written into a `step_created` as
+       * non-binary data. `Buffer` is a `Uint8Array` subclass and passes.
+       */
+      input: external_exports2.custom((value) => value instanceof Uint8Array, {
+        message: "stepInput.input must be a Uint8Array"
+      })
+    });
     HookResumeInputSchema2 = external_exports2.object({
       /** Stable idempotency key minted once per `resumeHook()` call. */
       resumeId: external_exports2.string(),
@@ -16301,6 +16331,22 @@ var init_queue2 = __esm({
        */
       deploymentId: external_exports2.string().optional()
     });
+    HookResumeTimingSchema2 = external_exports2.object({
+      /** Epoch ms at entry into `resumeHook()` — the start of the TTR window. */
+      resumeRequestedAtMs: external_exports2.number(),
+      /** Epoch ms immediately before the queue publish was requested. */
+      queuePublishRequestedAtMs: external_exports2.number(),
+      /** Which `resumeHook()` dispatch path ran: `parallel` or `sequential`. */
+      strategy: external_exports2.string().optional(),
+      /** Epoch ms the final consumer's queue handler was entered. */
+      consumerStartedAtMs: external_exports2.number().optional(),
+      /** Epoch ms this invocation's first replay pass began. */
+      replayStartedAtMs: external_exports2.number().optional(),
+      /** Epoch ms replay first encountered a durable step after the resume. */
+      nextStepEncounteredAtMs: external_exports2.number().optional(),
+      /** How the consumer initialized replay state: see `ResumeSetupSource`. */
+      setupSource: external_exports2.string().optional()
+    });
     WorkflowInvokePayloadSchema2 = external_exports2.object({
       runId: external_exports2.string(),
       traceCarrier: TraceCarrierSchema2.optional(),
@@ -16334,7 +16380,28 @@ var init_queue2 = __esm({
        * fast path. A consumer that understands this field idempotently ensures the
        * `hook_received` event exists (keyed by `resumeId`) before replaying.
        */
-      hookInput: HookResumeInputSchema2.optional()
+      hookInput: HookResumeInputSchema2.optional(),
+      /**
+       * Resilient step dispatch data, only present alongside `stepId` when the
+       * producer parallelized the `step_created` write with this queue publish. A
+       * consumer that understands this field idempotently ensures the
+       * `step_created` event exists (keyed by `stepId`) before executing the step.
+       */
+      stepInput: StepDispatchInputSchema2.optional(),
+      /**
+       * Hook-resume TTR timing. Present on both `resumeHook()` dispatch paths
+       * (unlike `hookInput`, which only rides the parallel fast path), and
+       * forwarded onto a dispatched step message when the resuming invocation
+       * hands the next durable step to another invocation. Purely observational —
+       * see {@link HookResumeTimingSchema}.
+       *
+       * `.catch(undefined)` because this field must never be able to fail the
+       * parse of the invocation payload: a malformed value (a NaN boundary, a
+       * shape change from a future producer) would otherwise throw on every
+       * delivery of that message and burn the run's delivery budget over a
+       * telemetry field. Anything unparseable degrades to "no measurement".
+       */
+      hookResumeTiming: HookResumeTimingSchema2.optional().catch(void 0)
     });
     HealthCheckPayloadSchema2 = external_exports2.object({
       __healthCheck: external_exports2.literal(true),
@@ -16541,6 +16608,13 @@ function eventIdToSlot(eventId) {
   const slot = Number(body);
   return Number.isSafeInteger(slot) && slot >= FIRST_EVENT_SLOT ? slot : null;
 }
+function requireEventSlot(eventId) {
+  const slot = eventIdToSlot(eventId);
+  if (slot === null) {
+    throw new Error(`Event id is not slot-numbered: ${eventId}. This World allocates event positions the runtime cannot read.`);
+  }
+  return slot;
+}
 var EVENT_ID_BODY_LENGTH, SLOT_LEADING_ZEROS, FIRST_EVENT_SLOT, MAX_EVENT_SLOT2, EVENT_ID_PREFIX;
 var init_slot_identity2 = __esm({
   "../world/dist/slot-identity.js"() {
@@ -16555,6 +16629,7 @@ var init_slot_identity2 = __esm({
     __name(isSlotEventId, "isSlotEventId");
     __name(slotToEventId, "slotToEventId");
     __name(eventIdToSlot, "eventIdToSlot");
+    __name(requireEventSlot, "requireEventSlot");
   }
 });
 
@@ -16577,7 +16652,7 @@ var init_spec_version2 = __esm({
     SPEC_VERSION_SUPPORTS_ATTRIBUTES2 = 4;
     SPEC_VERSION_SUPPORTS_COMPRESSION2 = 5;
     SPEC_VERSION_SUPPORTS_SLOT_IDENTITY2 = 6;
-    SPEC_VERSION_CURRENT2 = SPEC_VERSION_SUPPORTS_COMPRESSION2;
+    SPEC_VERSION_CURRENT2 = SPEC_VERSION_SUPPORTS_SLOT_IDENTITY2;
     SPEC_VERSION_MAX_SUPPORTED2 = SPEC_VERSION_SUPPORTS_SLOT_IDENTITY2;
     __name(isLegacySpecVersion2, "isLegacySpecVersion");
     __name(requiresNewerWorld, "requiresNewerWorld");
@@ -16805,6 +16880,7 @@ var init_ulid2 = __esm({
 // ../world/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  ANALYTICS_EVENTS_GET_MANY_LIMIT: () => ANALYTICS_EVENTS_GET_MANY_LIMIT,
   ATTRIBUTE_KEY_MAX_LENGTH: () => ATTRIBUTE_KEY_MAX_LENGTH2,
   ATTRIBUTE_MAX_PER_RUN: () => ATTRIBUTE_MAX_PER_RUN2,
   ATTRIBUTE_VALUE_MAX_BYTES: () => ATTRIBUTE_VALUE_MAX_BYTES2,
@@ -16883,6 +16959,7 @@ __export(dist_exports, {
   WorkflowRunStatusSchema: () => WorkflowRunStatusSchema2,
   _resetEnvWarnCacheForTests: () => _resetEnvWarnCacheForTests,
   applyAttributeChanges: () => applyAttributeChanges,
+  entityEventClass: () => entityEventClass,
   envNumber: () => envNumber2,
   eventIdToSlot: () => eventIdToSlot,
   getEventDataPayloadField: () => getEventDataPayloadField,
@@ -16905,6 +16982,7 @@ __export(dist_exports, {
   isWaitEventType: () => isWaitEventType,
   parseQueueName: () => parseQueueName,
   reenqueueActiveRuns: () => reenqueueActiveRuns,
+  requireEventSlot: () => requireEventSlot,
   requiresNewerWorld: () => requiresNewerWorld,
   resolveQueueNamespace: () => resolveQueueNamespace2,
   slotToEventId: () => slotToEventId,
@@ -16992,7 +17070,7 @@ function buildFramedDetails2(hint3, slug) {
     out.push({ label: "docs", value: `${BASE_URL2}/${slug}` });
   return out;
 }
-var BASE_URL2, ERROR_SLUGS2, WorkflowError2, WorkflowWorldError2, WorkflowRunFailedError2, WorkflowRunNotCompletedError2, WorkflowRuntimeError2, CorruptedEventLogError, ReplayDivergenceError, MaxEventsExceededError, RuntimeDecryptionError2, SerializationError2, StepNotRegisteredError2, WorkflowNotRegisteredError2, WorkflowDeploymentMismatchError, WorkflowRunNotFoundError2, HookConflictError2, HookNotFoundError2, EntityConflictError2, RunExpiredError2, TooEarlyError, ThrottleError2, PreconditionFailedError, WorkflowRunCancelledError2, RunNotSupportedError, FatalError2, RetryableError2, FATAL_ERROR_KEY2, RETRYABLE_ERROR_KEY2, HOOK_CONFLICT_ERROR_KEY2, RUNTIME_DECRYPTION_ERROR_KEY2;
+var BASE_URL2, ERROR_SLUGS2, WorkflowError2, WorkflowWorldError2, WorkflowRunFailedError2, WorkflowRunNotCompletedError2, WorkflowRuntimeError2, CorruptedEventLogError, ReplayDivergenceError, MaxEventsExceededError, RuntimeDecryptionError2, SerializationError2, StepNotRegisteredError2, WorkflowNotRegisteredError2, WorkflowDeploymentMismatchError, WorkflowRunNotFoundError2, HookConflictError2, HookNotFoundError2, EntityConflictError2, RunExpiredError2, StreamExpiredError2, TooEarlyError, ThrottleError2, PreconditionFailedError, WorkflowRunCancelledError2, RunNotSupportedError, FatalError2, RetryableError2, FATAL_ERROR_KEY2, RETRYABLE_ERROR_KEY2, HOOK_CONFLICT_ERROR_KEY2, RUNTIME_DECRYPTION_ERROR_KEY2;
 var init_dist7 = __esm({
   "../errors/dist/index.js"() {
     "use strict";
@@ -17335,6 +17413,24 @@ Caused by: ${options.cause.stack}`;
         return isError2(value) && value.name === "RunExpiredError";
       }
     };
+    StreamExpiredError2 = class extends WorkflowWorldError2 {
+      static {
+        __name(this, "StreamExpiredError");
+      }
+      runId;
+      streamId;
+      expiredAt;
+      constructor(message, runId, streamId, expiredAt) {
+        super(message, { status: 410, code: "stream-expired" });
+        this.runId = runId;
+        this.streamId = streamId;
+        this.expiredAt = expiredAt;
+        this.name = "StreamExpiredError";
+      }
+      static is(value) {
+        return isError2(value) && value.name === "StreamExpiredError";
+      }
+    };
     TooEarlyError = class extends WorkflowWorldError2 {
       static {
         __name(this, "TooEarlyError");
@@ -49911,7 +50007,7 @@ async function writeRunUnderLifecycleLock(basedir, runId, tag, proposed) {
 function createEventsStorage(basedir, tag) {
   const hookRetentionLimitMs = getHookRetentionLimitMs();
   const maxCachedEventBytes = 4 * 1024 * 1024;
-  const maxCachedEventEntries = 1e3;
+  const maxCachedEventEntries = MAX_CACHED_EVENT_ENTRIES;
   const eventCache = /* @__PURE__ */ new Map();
   const cachedEventBytes = /* @__PURE__ */ new Map();
   const cachedPathsByRunId = /* @__PURE__ */ new Map();
@@ -50882,13 +50978,10 @@ function createEventsStorage(basedir, tag) {
             if (terminalByMarker || runNow && isTerminalWorkflowRunStatus2(runNow.status)) {
               throw new RunExpiredError2(`Workflow run "${effectiveRunId}" is already in a terminal state`);
             }
-            const stagedPath = pendingHookEventPath(basedir, effectiveRunId, eventId, tag);
+            const stagedPath = pendingHookEventPath(basedir, effectiveRunId, `${eventId}.${monotonicUlid()}`, tag);
             const staged = await writeExclusive(stagedPath, serializedEvent);
             if (!staged) {
-              if (await bumpEventSlot(attempt)) {
-                continue;
-              }
-              throw new EntityConflictError2(`Event "${eventId}" already exists for run "${effectiveRunId}"`);
+              throw new WorkflowWorldError2(`Failed to stage event "${eventId}" for run "${effectiveRunId}": staging path already exists`);
             }
             try {
               if (await isRunTerminalCommitted(basedir, effectiveRunId, tag)) {
@@ -50910,6 +51003,17 @@ function createEventsStorage(basedir, tag) {
             notePublishedSlot(effectiveRunId, eventId);
             break;
           }
+          if (data.eventType === "hook_received" && params?.resumeId) {
+            const occupant = await readJSONWithFallback(basedir, "events", `${effectiveRunId}-${eventId}`, EventSchema2, tag);
+            if (occupant && isResumeEvent(occupant, {
+              runId: effectiveRunId,
+              resumeId: params.resumeId,
+              hookId: data.correlationId,
+              eventId
+            })) {
+              return { event: occupant };
+            }
+          }
           if (!await bumpEventSlot(attempt)) {
             break;
           }
@@ -51078,7 +51182,7 @@ function createEventsStorage(basedir, tag) {
   }), "create");
   return { ...storage, create };
 }
-var DAY_MS, HookRecoveryMarkerSchema, HookResumeClaimSchema;
+var DAY_MS, MAX_CACHED_EVENT_ENTRIES, HookRecoveryMarkerSchema, HookResumeClaimSchema;
 var init_events_storage = __esm({
   "../world-local/dist/storage/events-storage.js"() {
     "use strict";
@@ -51094,6 +51198,7 @@ var init_events_storage = __esm({
     init_legacy();
     init_runs_storage();
     DAY_MS = 24 * 60 * 60 * 1e3;
+    MAX_CACHED_EVENT_ENTRIES = 1e3;
     __name(getHookRetentionLimitMs, "getHookRetentionLimitMs");
     HookRecoveryMarkerSchema = external_exports2.object({
       eventId: external_exports2.string()
@@ -51626,11 +51731,7 @@ function createWorld(args) {
       // `(runId, resumeId)` via a filesystem sidecar claim (see
       // events-storage.ts `claimHookResume`), so resumeHook()'s parallel fast
       // path converges on one event in dev exactly as it does on Vercel.
-      hookResumeDedup: true,
-      // New runs get dense per-run slot event ids. Runs created before this
-      // keep their ULIDs; the scheme is pinned by a run's own first event id,
-      // not by this flag, which only says what new runs get.
-      slotEventIds: true
+      hookResumeDedup: true
     },
     ...queue,
     ...storage,
@@ -55781,7 +55882,7 @@ async function injectTraceContextIntoHeaders(headers) {
 function SemanticConvention3(...names) {
   return (value) => Object.fromEntries(names.map((name) => [name, value]));
 }
-var otelApiPromise2, tracerPromise2, otelDiagLogged2, HttpRequestMethod2, UrlFull2, ServerAddress2, ServerPort2, HttpResponseStatusCode2, ErrorType2, WorldParseFormat2, PeerService3, RpcSystem3, RpcService3, RpcMethod3, WorkflowRunId3, StepId3, WorkflowStreamName, WorkflowStreamOperation, WorkflowStreamStartIndex;
+var otelApiPromise2, tracerPromise2, otelDiagLogged2, HttpRequestMethod2, UrlFull2, ServerAddress2, ServerPort2, HttpResponseStatusCode2, ErrorType2, NetworkProtocolName, WorldParseFormat2, PeerService3, RpcSystem3, RpcService3, RpcMethod3, WorkflowRunId3, StepId3, WorkflowStreamName, WorkflowStreamOperation, WorkflowStreamStartIndex, WorkflowEventsTransport, WorkflowEventType, WorkflowClientVersion, StepStsoMs2, StepLatencyOptimizations2, WorkflowWsUrl, WorkflowWsRequestId, WorkflowWsReconnectAttempt;
 var init_telemetry3 = __esm({
   "../world-vercel/dist/telemetry.js"() {
     "use strict";
@@ -55802,6 +55903,7 @@ var init_telemetry3 = __esm({
     ServerPort2 = SemanticConvention3("server.port");
     HttpResponseStatusCode2 = SemanticConvention3("http.response.status_code");
     ErrorType2 = SemanticConvention3("error.type");
+    NetworkProtocolName = SemanticConvention3("network.protocol.name");
     WorldParseFormat2 = SemanticConvention3("workflow.world.parse.format");
     PeerService3 = SemanticConvention3("peer.service");
     RpcSystem3 = SemanticConvention3("rpc.system");
@@ -55812,6 +55914,14 @@ var init_telemetry3 = __esm({
     WorkflowStreamName = SemanticConvention3("workflow.stream.name");
     WorkflowStreamOperation = SemanticConvention3("workflow.stream.operation");
     WorkflowStreamStartIndex = SemanticConvention3("workflow.stream.start_index");
+    WorkflowEventsTransport = SemanticConvention3("workflow.events.transport");
+    WorkflowEventType = SemanticConvention3("workflow.event.type");
+    WorkflowClientVersion = SemanticConvention3("workflow.client.version");
+    StepStsoMs2 = SemanticConvention3("step.stso_ms");
+    StepLatencyOptimizations2 = SemanticConvention3("step.latency_optimizations");
+    WorkflowWsUrl = SemanticConvention3("workflow.events.ws.url");
+    WorkflowWsRequestId = SemanticConvention3("workflow.events.ws.req_id");
+    WorkflowWsReconnectAttempt = SemanticConvention3("workflow.events.ws.reconnect_attempt");
   }
 });
 
@@ -55857,8 +55967,14 @@ function errorForResponse(status, message, opts = {}) {
   const { retryAfter, code: code3, url: url3, mitigated, details } = opts;
   if (status === 409)
     return new EntityConflictError2(message);
-  if (status === 410)
+  if (status === 410) {
+    if (code3 === "stream-expired") {
+      const streamDetails = details && typeof details === "object" ? details : void 0;
+      const expiredAt = typeof streamDetails?.expiredAt === "string" ? new Date(streamDetails.expiredAt) : void 0;
+      return new StreamExpiredError2(message, typeof streamDetails?.runId === "string" ? streamDetails.runId : void 0, typeof streamDetails?.streamId === "string" ? streamDetails.streamId : void 0, expiredAt && !Number.isNaN(expiredAt.getTime()) ? expiredAt : void 0);
+    }
     return new RunExpiredError2(message);
+  }
   if (status === 412)
     return new PreconditionFailedError(message, { retryAfter, details });
   if (status === 425)
@@ -55885,9 +56001,10 @@ async function resolveVercelApiToken(opts) {
 function parseServer(url3) {
   try {
     const parsed = new URL(url3);
+    const secure = parsed.protocol === "https:" || parsed.protocol === "wss:";
     return {
       serverAddress: parsed.hostname,
-      serverPort: parsed.port ? parseInt(parsed.port, 10) : parsed.protocol === "https:" ? 443 : 80
+      serverPort: parsed.port ? parseInt(parsed.port, 10) : secure ? 443 : 80
     };
   } catch {
     return {};
@@ -55906,9 +56023,8 @@ function httpClientSpanAttributes(args) {
     ...RpcService3(peerService)
   };
 }
-async function instrumentedFetch(opts) {
-  const { method, url: url3, headers, body, dispatcher, peerService = "workflow-server", timeoutMs = getRequestTimeoutMs(), signal: callerSignal, injectTraceContext: injectTraceContext2 = true, cacheBust = true, logLabel, buildError, spanName, attributes, durationAttribute, onTransportOutcome } = opts;
-  const label = logLabel ?? url3;
+async function withHttpClientSpan(opts, fn) {
+  const { method, url: url3, peerService = "workflow-server", spanName, attributes } = opts;
   return trace4(spanName ?? `http ${method}`, { kind: await getSpanKind3("CLIENT") }, async (span) => {
     if (spanName && HTTP_DEBUG_ENABLED && span) {
       const ctx = span.spanContext();
@@ -55922,6 +56038,19 @@ async function instrumentedFetch(opts) {
     span?.setAttributes(httpClientSpanAttributes({ method, url: url3, peerService }));
     if (attributes)
       span?.setAttributes(attributes);
+    return fn(span);
+  });
+}
+function recordClientSpanStatus(span, status) {
+  span?.setAttributes({ ...HttpResponseStatusCode2(status) });
+  if (status < 200 || status >= 300) {
+    span?.setAttributes({ ...ErrorType2(`HTTP ${status}`) });
+  }
+}
+async function instrumentedFetch(opts) {
+  const { method, url: url3, headers, body, dispatcher, peerService, timeoutMs = getRequestTimeoutMs(), signal: callerSignal, injectTraceContext: injectTraceContext2 = true, cacheBust = true, logLabel, buildError, spanName, attributes, durationAttribute, onTransportOutcome } = opts;
+  const label = logLabel ?? url3;
+  return withHttpClientSpan({ method, url: url3, peerService, spanName, attributes }, async (span) => {
     if (injectTraceContext2)
       await injectTraceContextIntoHeaders(headers);
     if (cacheBust)
@@ -55953,11 +56082,10 @@ async function instrumentedFetch(opts) {
     const ms3 = Date.now() - start3;
     onTransportOutcome?.();
     httpLog(method, label, response, ms3);
-    span?.setAttributes({ ...HttpResponseStatusCode2(response.status) });
+    recordClientSpanStatus(span, response.status);
     if (durationAttribute)
       span?.setAttributes({ [durationAttribute]: ms3 });
     if (!response.ok) {
-      span?.setAttributes({ ...ErrorType2(`HTTP ${response.status}`) });
       logCurlRepro(method, url3, headers);
       if (buildError) {
         const error96 = await buildError(response);
@@ -56005,6 +56133,8 @@ var init_http_core = __esm({
     __name(resolveVercelApiToken, "resolveVercelApiToken");
     __name(parseServer, "parseServer");
     __name(httpClientSpanAttributes, "httpClientSpanAttributes");
+    __name(withHttpClientSpan, "withHttpClientSpan");
+    __name(recordClientSpanStatus, "recordClientSpanStatus");
     __name(instrumentedFetch, "instrumentedFetch");
   }
 });
@@ -56014,7 +56144,7 @@ var version4;
 var init_version3 = __esm({
   "../world-vercel/dist/version.js"() {
     "use strict";
-    version4 = "5.0.0-beta.37";
+    version4 = "5.0.0-beta.38";
   }
 });
 
@@ -56134,7 +56264,8 @@ async function makeRequest({ endpoint, options = {}, config: config4 = {}, schem
           url: url3,
           code: errorCode,
           retryAfter,
-          mitigated: response.headers.get("x-vercel-mitigated")
+          mitigated: response.headers.get("x-vercel-mitigated"),
+          details: errorData.details
         });
         span?.setAttributes({
           ...ErrorType2(errorCode || `HTTP ${response.status}`)
@@ -56315,6 +56446,16 @@ function createQueryString(params) {
   const query = params.toString();
   return query ? `?${query}` : "";
 }
+function normalizeEventIds(eventIds) {
+  const uniqueEventIds = [...new Set(eventIds)];
+  if (uniqueEventIds.length === 0) {
+    throw new RangeError("eventIds must contain at least one event ID");
+  }
+  if (uniqueEventIds.length > ANALYTICS_EVENTS_GET_MANY_LIMIT) {
+    throw new RangeError(`eventIds must contain at most ${ANALYTICS_EVENTS_GET_MANY_LIMIT} unique event IDs`);
+  }
+  return uniqueEventIds;
+}
 function appendAttributeListParams(searchParams, params) {
   if (params.workflowName) {
     searchParams.set("workflowName", params.workflowName);
@@ -56395,6 +56536,15 @@ function createAnalytics(config4) {
           schema: AnalyticsEventSchema2
         });
       },
+      getMany(runId, eventIds) {
+        return makeRequest({
+          endpoint: `/v2/analytics/runs/${encodeURIComponent(runId)}/events/get-many`,
+          options: { method: "POST" },
+          data: { eventIds: normalizeEventIds(eventIds) },
+          config: config4,
+          schema: AnalyticsEventSchema2.array()
+        });
+      },
       list(params) {
         const searchParams = new URLSearchParams();
         if (params.eventType) {
@@ -56474,6 +56624,7 @@ var init_analytics3 = __esm({
     init_utils4();
     __name(appendPagination, "appendPagination");
     __name(createQueryString, "createQueryString");
+    __name(normalizeEventIds, "normalizeEventIds");
     __name(appendAttributeListParams, "appendAttributeListParams");
     __name(createAnalytics, "createAnalytics");
   }
@@ -67265,7 +67416,7 @@ var init_ws_transport = __esm({
         if (conn && conn.ws.readyState === import_websocket2.default.OPEN) {
           return Promise.resolve(conn);
         }
-        this.connecting ??= this.connect().finally(() => {
+        this.connecting ??= this.connectWithSpan().finally(() => {
           this.connecting = null;
         });
         return this.connecting;
@@ -67303,6 +67454,43 @@ var init_ws_transport = __esm({
         if (reason === "auth_expiry")
           this.needsFreshToken = true;
       }
+      /**
+       * The handshake, wrapped in its own CLIENT span.
+       *
+       * The upgrade is the one genuinely-HTTP request this transport makes, and
+       * until it had a span it was the invisible half of every WS write's latency:
+       * a write that waits on a handshake shows the wait inside its own span with
+       * nothing to attribute it to, and an eager reconnect between two writes shows
+       * up nowhere at all. Named for the operation rather than `http GET` so it
+       * doesn't land in the same bucket as the event writes it enables.
+       *
+       * It also puts `resolveUpgradeHeaders`' trace-context injection inside a
+       * client span, matching `makeRequest`'s contract (CLAUDE.md): the server's
+       * per-event spans parent to *this* span rather than directly to whichever
+       * invocation happened to open the socket, so the handshake and everything the
+       * server does over the connection hang together.
+       */
+      connectWithSpan() {
+        return withHttpClientSpan({
+          method: "GET",
+          url: this.wsUrl,
+          spanName: "workflow.events.ws.connect",
+          attributes: {
+            ...WorkflowEventsTransport("ws"),
+            ...NetworkProtocolName("websocket"),
+            ...WorkflowWsReconnectAttempt(this.reconnectAttempts)
+          }
+        }, async (span) => {
+          try {
+            return await this.connect();
+          } catch (err) {
+            span?.setAttributes({ ...ErrorType2("TRANSPORT") });
+            if (err instanceof Error)
+              span?.recordException?.(err);
+            throw err;
+          }
+        });
+      }
       connect() {
         return new Promise((resolve3, reject) => {
           void (async () => {
@@ -67902,36 +68090,61 @@ function errorMarker(err) {
   }
   return collectErrorMarkers(err)[0] ?? (err instanceof Error ? err.name : "unknown");
 }
+function createThrottleWaiter(eventType) {
+  let waitedMs = 0;
+  return async (err) => {
+    const waitMs = Math.max(1, typeof err.retryAfter === "number" ? err.retryAfter : DEFAULT_THROTTLE_RETRY_AFTER_SECONDS) * 1e3;
+    if (waitedMs + waitMs > THROTTLE_RETRY_BUDGET_MS) {
+      logRetry("throttle retry budget exhausted; surfacing to the queue", {
+        eventType,
+        waitedMs,
+        retryAfter: err.retryAfter
+      });
+      throw err;
+    }
+    waitedMs += waitMs;
+    console.warn(`[workflow] Throttled (429) writing ${eventType} event; retrying in-process in ${waitMs / 1e3}s`);
+    await sleep(waitMs);
+  };
+}
+function isEligibleForTransientRetry(eventType, options) {
+  return eventType === "hook_received" && options?.idempotentHookResume === true || (EVENT_RETRY_ELIGIBILITY[eventType]?.retryable ?? false);
+}
 async function withEventPostRetry(fn, eventType, options) {
-  const retryable = eventType === "hook_received" && options?.idempotentHookResume === true || (EVENT_RETRY_ELIGIBILITY[eventType]?.retryable ?? false);
-  for (let attempt = 0; ; attempt++) {
+  const retryable = isEligibleForTransientRetry(eventType, options);
+  const waitOutThrottle = createThrottleWaiter(eventType);
+  for (let attempt = 0; ; ) {
     try {
       return await fn();
     } catch (err) {
-      const transient = retryable && isRetryableEventPostError(err);
-      if (transient && attempt < MAX_EVENT_POST_RETRIES) {
-        const backoff = EVENT_POST_RETRY_BASE_MS * 2 ** attempt + Math.floor(Math.random() * EVENT_POST_RETRY_JITTER_MS);
-        logRetry("retrying event POST after transient failure", {
-          eventType,
-          attempt: attempt + 1,
-          backoffMs: backoff,
-          error: errorMarker(err)
-        });
-        await sleep(backoff);
+      if (ThrottleError2.is(err)) {
+        await waitOutThrottle(err);
         continue;
       }
-      if (transient) {
+      if (!retryable || !isRetryableEventPostError(err)) {
+        throw err;
+      }
+      if (attempt >= MAX_EVENT_POST_RETRIES) {
         logRetry("exhausted in-process retries; surfacing for queue redelivery", {
           eventType,
           attempts: attempt + 1,
           error: errorMarker(err)
         });
+        throw err;
       }
-      throw err;
+      const backoff = EVENT_POST_RETRY_BASE_MS * 2 ** attempt + Math.floor(Math.random() * EVENT_POST_RETRY_JITTER_MS);
+      attempt++;
+      logRetry("retrying event POST after transient failure", {
+        eventType,
+        attempt,
+        backoffMs: backoff,
+        error: errorMarker(err)
+      });
+      await sleep(backoff);
     }
   }
 }
-var EVENT_RETRY_ELIGIBILITY, MAX_EVENT_POST_RETRIES, EVENT_POST_RETRY_BASE_MS, EVENT_POST_RETRY_JITTER_MS, TRANSIENT_CODES, sleep, RETRY_DEBUG_ENABLED;
+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 init_event_retry = __esm({
   "../world-vercel/dist/event-retry.js"() {
     "use strict";
@@ -68014,6 +68227,8 @@ var init_event_retry = __esm({
       }
     };
     MAX_EVENT_POST_RETRIES = 2;
+    THROTTLE_RETRY_BUDGET_MS = 3e4;
+    DEFAULT_THROTTLE_RETRY_AFTER_SECONDS = 1;
     EVENT_POST_RETRY_BASE_MS = 100;
     EVENT_POST_RETRY_JITTER_MS = 50;
     TRANSIENT_CODES = /* @__PURE__ */ new Set([
@@ -68047,6 +68262,8 @@ var init_event_retry = __esm({
     RETRY_DEBUG_ENABLED = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
     __name(logRetry, "logRetry");
     __name(errorMarker, "errorMarker");
+    __name(createThrottleWaiter, "createThrottleWaiter");
+    __name(isEligibleForTransientRetry, "isEligibleForTransientRetry");
     __name(withEventPostRetry, "withEventPostRetry");
   }
 });
@@ -68229,7 +68446,7 @@ var init_steps3 = __esm({
 
 // ../world-vercel/dist/events-v4.js
 import assert4 from "node:assert/strict";
-async function fetchV4(url3, init, config4, opName) {
+async function fetchV4(url3, init, config4, opName, attributes) {
   const dispatcher = getEventsDispatcher(config4);
   return instrumentedFetch({
     method: init.method,
@@ -68237,6 +68454,7 @@ async function fetchV4(url3, init, config4, opName) {
     headers: init.headers,
     body: init.body,
     dispatcher,
+    attributes,
     // Repeated transport failures retire the shared events pool and the next
     // request builds a fresh one. undici keeps a black-holed HTTP/2 session in
     // service indefinitely, so without this every request routed onto it fails
@@ -68249,6 +68467,9 @@ async function fetchV4(url3, init, config4, opName) {
     buildError: /* @__PURE__ */ __name(async (response) => errorFromV4Response(response.status, headersToRecord(response.headers), new Uint8Array(await response.arrayBuffer()), opName, url3), "buildError")
   });
 }
+function eventsV4Url(baseUrl, runId, eventType) {
+  return `${baseUrl}/v4/runs/${encodeURIComponent(runId)}/events/${encodeURIComponent(eventType)}`;
+}
 function decodeLegacyStructuredError(payload) {
   if (hasSerializedDataFormatPrefix(payload))
     return payload;
@@ -68355,14 +68576,6 @@ function buildPostFrameMeta(input) {
     meta5.sinceCursor = input.sinceCursor;
   if (input.skipPreload)
     meta5.skipPreload = true;
-  if (input.stateUpdatedAt !== void 0) {
-    meta5.stateUpdatedAt = input.stateUpdatedAt;
-  }
-  if (input.stateEventCount !== void 0) {
-    meta5.stateEventCount = input.stateEventCount;
-  }
-  if (input.stateCursor !== void 0)
-    meta5.stateCursor = input.stateCursor;
   if (input.maxSlot !== void 0)
     meta5.maxSlot = input.maxSlot;
   if (input.replayDivergenceCount !== void 0) {
@@ -68371,6 +68584,9 @@ function buildPostFrameMeta(input) {
   if (input.resumePayloadDigest !== void 0) {
     meta5.resumePayloadDigest = input.resumePayloadDigest;
   }
+  if (input.viaStepDispatch !== void 0) {
+    meta5.viaStepDispatch = input.viaStepDispatch;
+  }
   return meta5;
 }
 function errorFromV4Response(statusCode, responseHeaders, errorBody, opName, url3) {
@@ -68463,8 +68679,14 @@ async function postWorkflowRunEventV4(input, responseType, config4) {
     headers.set("Accept", V4_FRAME_CONTENT_TYPE);
   }
   const frame3 = encodeFrame(buildPostFrameMeta(input), input.payload ?? new Uint8Array(0));
-  const url3 = `${baseUrl}/v4/runs/${encodeURIComponent(input.runId)}/events/${encodeURIComponent(input.eventType)}`;
-  return fetchV4(url3, { method: "POST", headers, body: frame3 }, config4, "createEvent");
+  const url3 = eventsV4Url(baseUrl, input.runId, input.eventType);
+  return fetchV4(url3, { method: "POST", headers, body: frame3 }, config4, "createEvent", {
+    ...WorkflowEventsTransport("http"),
+    ...WorkflowEventType(input.eventType),
+    ...WorkflowClientVersion(`@workflow/world-vercel/${version4}`),
+    ...input.stso !== void 0 ? StepStsoMs2(input.stso) : {},
+    ...input.optimizations !== void 0 ? StepLatencyOptimizations2(input.optimizations) : {}
+  });
 }
 async function createWorkflowRunEventV4(input, config4) {
   if (isWsEventsTransportEnabled()) {
@@ -68533,21 +68755,51 @@ async function postEventFrameOverWs(input, config4) {
     return void 0;
   const { transport, wsUrl } = resolved;
   const endpoint = `${wsUrl}#runs/${encodeURIComponent(runId)}/events`;
-  let reply;
-  try {
-    reply = await transport.request((reqId) => encodeFrame({ reqId, type: "event", event: buildPostFrameMeta(input) }, input.payload ?? new Uint8Array(0)));
-  } catch (err) {
-    throw new WorkflowWorldError2(`POST ${endpoint} transport failure: ${err instanceof Error ? err.message : String(err)}`, { url: wsUrl, code: "TRANSPORT", cause: err });
-  }
-  const status = wsReplyStatus(reply, endpoint);
-  const headerRecord = replyMetaToHeaderRecord(reply.meta);
-  if (status < 200 || status >= 300) {
-    throw errorFromV4Response(status, headerRecord, new TextDecoder().decode(reply.body), "createEvent", endpoint);
-  }
-  return {
-    headers: { get: /* @__PURE__ */ __name((name) => headerRecord[name.toLowerCase()] ?? null, "get") },
-    arrayBuffer: /* @__PURE__ */ __name(async () => reply.body.slice().buffer, "arrayBuffer")
-  };
+  const restUrl = eventsV4Url(getHttpUrl(config4).baseUrl, runId, input.eventType);
+  return withHttpClientSpan({
+    method: "POST",
+    url: restUrl,
+    attributes: {
+      ...WorkflowEventsTransport("ws"),
+      ...WorkflowEventType(input.eventType),
+      ...WorkflowClientVersion(`@workflow/world-vercel/${version4}`),
+      ...input.stso !== void 0 ? StepStsoMs2(input.stso) : {},
+      ...input.optimizations !== void 0 ? StepLatencyOptimizations2(input.optimizations) : {},
+      ...NetworkProtocolName("websocket"),
+      ...WorkflowWsUrl(wsUrl)
+    }
+  }, async (span) => {
+    const start3 = Date.now();
+    let reply;
+    try {
+      reply = await transport.request((reqId) => {
+        span?.setAttributes({ ...WorkflowWsRequestId(reqId) });
+        return encodeFrame({ reqId, type: "event", event: buildPostFrameMeta(input) }, input.payload ?? new Uint8Array(0));
+      });
+    } catch (err) {
+      const error95 = new WorkflowWorldError2(`POST ${endpoint} transport failure: ${err instanceof Error ? err.message : String(err)}`, { url: wsUrl, code: "TRANSPORT", cause: err });
+      span?.setAttributes({ ...ErrorType2("TRANSPORT") });
+      span?.recordException?.(error95);
+      throw error95;
+    }
+    const ms3 = Date.now() - start3;
+    const status = wsReplyStatus(reply, endpoint);
+    const headerRecord = replyMetaToHeaderRecord(reply.meta);
+    const headers = {
+      get: /* @__PURE__ */ __name((name) => headerRecord[name.toLowerCase()] ?? null, "get")
+    };
+    httpLog("POST", "createEvent", { status, headers }, ms3);
+    recordClientSpanStatus(span, status);
+    if (status < 200 || status >= 300) {
+      const error95 = errorFromV4Response(status, headerRecord, new TextDecoder().decode(reply.body), "createEvent", endpoint);
+      span?.recordException?.(error95);
+      throw error95;
+    }
+    return {
+      headers,
+      arrayBuffer: /* @__PURE__ */ __name(async () => reply.body.slice().buffer, "arrayBuffer")
+    };
+  });
 }
 async function createHookReceivedPreloadEventV4(input, config4) {
   const response = await postWorkflowRunEventV4({ ...input, eventType: "hook_received" }, "event-stream", config4);
@@ -68673,11 +68925,14 @@ var init_events_v4 = __esm({
     init_http_core();
     init_serialized_data();
     init_steps3();
+    init_telemetry3();
     init_utils4();
+    init_version3();
     init_ws_transport_enabled();
     __name(fetchV4, "fetchV4");
     EVENT_ID_HEADER = "x-wf-event-id";
     MAX_EVENTS_HEADER = "x-wf-max-events";
+    __name(eventsV4Url, "eventsV4Url");
     CreateEventV4BodyBaseSchema = external_exports2.object({
       event: EventSchema2,
       run: WorkflowRunSchema2.optional(),
@@ -69152,11 +69407,7 @@ async function createWorkflowRunEventInner(id, data, params, config4) {
     ...data.correlationId ? { correlationId: data.correlationId } : {},
     ...params?.requestId ? { vercelId: params.requestId } : {},
     ...params?.computeInstanceId ? { computeInstanceId: params.computeInstanceId } : {},
-    stateUpdatedAt: params?.stateUpdatedAt,
-    stateEventCount: params?.stateEventCount,
-    ...params?.stateCursor ? { stateCursor: params.stateCursor } : {},
-    // Slot-identity snapshot. The runtime sends `eventCount` instead of the
-    // watermark triple once the run's own ids are slot-shaped; it rides as
+    // Slot-identity snapshot: how much of the log the writer held. Rides as
     // `maxSlot` because the v4 meta already has an unrelated telemetry
     // `eventCount`.
     ...params?.eventCount !== void 0 ? { maxSlot: params.eventCount } : {},
@@ -69172,6 +69423,11 @@ async function createWorkflowRunEventInner(id, data, params, config4) {
     ...params?.sinceCursor ? { sinceCursor: params.sinceCursor } : {},
     ...params?.resumeId ? { resumeId: params.resumeId } : {},
     ...params?.resumePayloadDigest ? { resumePayloadDigest: params.resumePayloadDigest } : {},
+    // Resilient step dispatch re-ensure marker (step_created only). Advisory
+    // — the server MAY refuse it with 410 → RunExpiredError as
+    // defense-in-depth when it recorded a 412 rejection for this correlation
+    // id and no step entity exists.
+    ...params?.viaStepDispatch ? { viaStepDispatch: true } : {},
     remoteRefBehavior,
     payload,
     ...meta5
@@ -69439,6 +69695,17 @@ function streamSpanAttributes(args) {
     ...typeof args.startIndex === "number" ? WorkflowStreamStartIndex(args.startIndex) : {}
   };
 }
+async function createStreamReadError(response) {
+  const fallback = `Failed to fetch stream: ${response.status}`;
+  if (response.status !== 410)
+    return new Error(fallback);
+  try {
+    const body = await response.json();
+    return errorForResponse(response.status, typeof body.message === "string" ? body.message : fallback, { code: body.error, details: body.details });
+  } catch {
+    return new Error(fallback);
+  }
+}
 function createStreamRequestError(operation, url3, response, text) {
   const context2 = [
     `PUT ${url3.origin}${url3.pathname}`,
@@ -69552,6 +69819,7 @@ function createStreamer2(config4) {
       },
       async get(runId, name, startIndex) {
         const httpConfig = await getHttpConfig(config4);
+        httpConfig.headers.set("Accept", "application/json");
         const url3 = getStreamReadUrl(name, runId, httpConfig);
         if (typeof startIndex === "number") {
           url3.searchParams.set("startIndex", String(startIndex));
@@ -69570,7 +69838,7 @@ function createStreamer2(config4) {
             operation: "read",
             startIndex
           }),
-          buildError: /* @__PURE__ */ __name((res) => new Error(`Failed to fetch stream: ${res.status}`), "buildError")
+          buildError: createStreamReadError
         });
         if (!response.body) {
           throw new Error("No response body for stream");
@@ -69636,6 +69904,7 @@ var init_streamer2 = __esm({
     __name(getStreamUrl, "getStreamUrl");
     __name(getStreamReadUrl, "getStreamReadUrl");
     __name(streamSpanAttributes, "streamSpanAttributes");
+    __name(createStreamReadError, "createStreamReadError");
     __name(createStreamRequestError, "createStreamRequestError");
     __name(encodeMultiChunks, "encodeMultiChunks");
     StreamInfoResponseSchema = external_exports2.object({
@@ -69659,31 +69928,25 @@ var init_streamer2 = __esm({
 function createWorld2(config4) {
   const projectId = config4?.projectConfig?.projectId || process.env.VERCEL_PROJECT_ID;
   return {
-    // Spec v6 adds slot-numbered event ids on top of v5's client-side
-    // zstd/gzip payload compression. The version is what tells the backend
-    // which id scheme a run uses: it is stamped on `run_created` and read back
-    // on every later write, so a run created before v6 keeps its ULIDs even
-    // though this adapter now asks for slots.
-    specVersion: SPEC_VERSION_SUPPORTS_SLOT_IDENTITY2,
+    // The version is what tells the backend which id scheme a run uses: it is
+    // stamped on `run_created` and read back on every later write, so a run
+    // created before spec 6 keeps its ULIDs for its whole life even though this
+    // adapter now asks for slot-numbered ids.
+    //
+    // Declared as the runtime's current version rather than as the literal
+    // version that introduced slots: a bump has to move this declaration with
+    // it, or the runtime's compatibility floor rises past the adapter shipped
+    // alongside it and rejects it (see `assertWorldSupportsRuntimeProtocol`).
+    specVersion: SPEC_VERSION_CURRENT2,
     capabilities: {
       hookRetention: { active: true },
-      // workflow-server enforces the `stateUpdatedAt` optimistic-concurrency
-      // guard: creations carrying a stale snapshot are rejected with 412
-      // (PreconditionFailedError) when the run's outside-event marker is
-      // newer. See vercel/workflow-server#484.
-      preconditionGuard: true,
       // Vercel Queues supports maxConcurrency-limited consumers, which
       // WORKFLOW_SEQUENTIAL_REPLAYS=1 uses for per-run `maxConcurrency: 1`
       // flow topics (see queue.ts and @workflow/builders).
       maxConcurrency: true,
       // Vercel deployments are atomic and immutable, so a deployment id names
       // one fixed build for its whole lifetime.
-      deploymentAffinity: true,
-      // New runs get dense per-run slot event ids. Runs created before the
-      // backend adopted them keep their ULIDs; the scheme is pinned by the
-      // spec version stamped on each run, not by this flag, which only says
-      // what new runs get.
-      slotEventIds: true
+      deploymentAffinity: true
       // NOTE: the backend half of resumeHook()'s parallel fast path — that
       // the server enforces the `(runId, resumeId)` dedup constraint — is
       // NO LONGER a static world capability here. It is attested per-lookup by
@@ -70660,7 +70923,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, WorkflowOwnedRecoverySteps2, WorkflowBackstopWakesArmed2, WorkflowRouteType2, WorkflowRouteHandlerCached2, WorkflowRouteInvocationCount2, WorkflowRouteEntrypointAgeMs2, WorkflowRouteModuleBodyInitMs2, FaasInstance2, StepName2, StepId4, StepAttempt2, StepStatus2, StepMaxRetries2, StepTracePropagated2, StepTtfsMs2, StepStsoMs2, StepRsfsMs2, StepFinalSchedulingReplayMs2, StepLatencyOptimizations2, 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, 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, WorkflowParkedEventsCount2, WorkflowParkedEventId2, WorkflowParkedEventType2, WorkflowArgumentsCount2, WorkflowResultType2, WorkflowTracePropagated2, WorkflowVm2, QuickJSOutcome2, QuickJSEventsPreloaded2, QuickJSEventsFetchedCount2, QuickJSEventsFetchedPages2, QuickJSPendingOpsCount2, QuickJSInlineSteps2, WorkflowTraceMode2, WorkflowTurbo2, WorkflowErrorName2, WorkflowErrorMessage2, WorkflowErrorCode2, WorkflowStepsCreated2, WorkflowHooksCreated2, WorkflowWaitsCreated2, 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 init_semantic_conventions2 = __esm({
   "../core/dist/telemetry/semantic-conventions.js"() {
     "use strict";
@@ -70708,10 +70971,10 @@ var init_semantic_conventions2 = __esm({
     StepMaxRetries2 = SemanticConvention4("step.max_retries");
     StepTracePropagated2 = SemanticConvention4("step.trace.propagated");
     StepTtfsMs2 = SemanticConvention4("step.ttfs_ms");
-    StepStsoMs2 = SemanticConvention4("step.stso_ms");
+    StepStsoMs3 = SemanticConvention4("step.stso_ms");
     StepRsfsMs2 = SemanticConvention4("step.rsfs_ms");
     StepFinalSchedulingReplayMs2 = SemanticConvention4("step.final_scheduling_replay_ms");
-    StepLatencyOptimizations2 = SemanticConvention4("step.latency_optimizations");
+    StepLatencyOptimizations3 = SemanticConvention4("step.latency_optimizations");
     StepSkipped2 = SemanticConvention4("step.skipped");
     StepSkipReason2 = SemanticConvention4("step.skip_reason");
     StepArgumentsCount2 = SemanticConvention4("step.arguments.count");
@@ -70737,6 +71000,20 @@ var init_semantic_conventions2 = __esm({
     HookResilientResume2 = SemanticConvention4("workflow.hook.resilient_resume");
     HookResilientResumeMaterialized2 = SemanticConvention4("workflow.hook.resilient_resume_materialized");
     HookResumeSetupSource2 = SemanticConvention4("workflow.resume_setup_source");
+    StepResilientDispatchRecovered2 = SemanticConvention4("workflow.step.resilient_dispatch_recovered");
+    StepResilientDispatchMaterialized2 = SemanticConvention4("workflow.step.resilient_dispatch_materialized");
+    ResumeTotalMs2 = SemanticConvention4("workflow.resume.total_ms");
+    ResumeProducerPrepMs2 = SemanticConvention4("workflow.resume.phase.producer_prep_ms");
+    ResumeQueueDeliveryMs2 = SemanticConvention4("workflow.resume.phase.queue_delivery_ms");
+    ResumeSetupMs2 = SemanticConvention4("workflow.resume.phase.resume_setup_ms");
+    ResumeReplayMs2 = SemanticConvention4("workflow.resume.phase.replay_ms");
+    ResumeStepDispatchMs2 = SemanticConvention4("workflow.resume.phase.step_dispatch_ms");
+    ResumeStepClaimMs2 = SemanticConvention4("workflow.resume.phase.step_claim_ms");
+    ResumeStepPrepareMs2 = SemanticConvention4("workflow.resume.phase.step_prepare_ms");
+    ResumeTrigger2 = SemanticConvention4("workflow.resume.trigger");
+    ResumeStrategy2 = SemanticConvention4("workflow.resume.strategy");
+    ResumeSetupSource2 = SemanticConvention4("workflow.resume.setup_source");
+    ResumeStepExecution2 = SemanticConvention4("workflow.resume.step_execution");
     WebhookHandlersTriggered2 = SemanticConvention4("webhook.handlers.triggered");
     WorkflowSuspensionState2 = SemanticConvention4("workflow.suspension.state");
     WorkflowSuspensionHookCount2 = SemanticConvention4("workflow.suspension.hook_count");
@@ -71246,7 +71523,7 @@ var init_private2 = __esm({
     __name(getBuiltinResponseStepAlias2, "getBuiltinResponseStepAlias");
     __name(getStepFunction2, "getStepFunction");
     DEFER_BEHIND = {
-      hook: ["wait", "step"],
+      hook: ["hook", "wait", "step"],
       wait: ["hook", "step"],
       step: ["wait", "hook", "step"]
     };
@@ -73668,7 +73945,7 @@ function getReviversForMode2(mode, global2 = globalThis, extraRevivers) {
   }
   return base;
 }
-var encoder2, decoder3, devalueCodec2;
+var encoder2, decoder3, MAX_SPARSE_ARRAY_LENGTH2, parseOptions2, devalueCodec2;
 var init_codec_devalue2 = __esm({
   "../core/dist/serialization/codec-devalue.js"() {
     "use strict";
@@ -73680,6 +73957,17 @@ var init_codec_devalue2 = __esm({
     init_types3();
     encoder2 = new TextEncoder();
     decoder3 = new TextDecoder();
+    MAX_SPARSE_ARRAY_LENGTH2 = 1e5;
+    parseOptions2 = {
+      operations: {
+        createSparseArray(length) {
+          if (length > MAX_SPARSE_ARRAY_LENGTH2) {
+            throw new RangeError(`Sparse array length ${length} exceeds the maximum of ${MAX_SPARSE_ARRAY_LENGTH2}`);
+          }
+          return default_parse_operations2.createSparseArray(length);
+        }
+      }
+    };
     __name(getReducersForMode2, "getReducersForMode");
     __name(getReviversForMode2, "getReviversForMode");
     devalueCodec2 = {
@@ -73692,11 +73980,11 @@ var init_codec_devalue2 = __esm({
       deserialize(data, mode, options) {
         const revivers = getReviversForMode2(mode, options?.global, options?.extraRevivers);
         const str = decoder3.decode(data);
-        return parse6(str, revivers);
+        return parse6(str, revivers, parseOptions2);
       },
       deserializeLegacy(data, mode, options) {
         const revivers = getReviversForMode2(mode, options?.global, options?.extraRevivers);
-        return unflatten2(data, revivers);
+        return unflatten2(data, revivers, parseOptions2);
       }
     };
   }
@@ -74295,8 +74583,17 @@ var init_events_consumer2 = __esm({
        * rather than parked for a consumer that cannot exist.
        */
       resolved = /* @__PURE__ */ new Set();
+      /**
+       * `<class>:<correlationId>` for every event class the walk has already
+       * consumed, mapped to the event type that recorded it. The type is kept so a
+       * repeat that decided the same class *differently* (a `step_failed` behind a
+       * `step_completed`) can be reported as more than a re-commit. See
+       * {@link EventsConsumer.firstEventTypeOfClass}.
+       */
+      seenEventClasses = /* @__PURE__ */ new Map();
       onConsumedEvent;
       onUnconsumedEvent;
+      onDuplicateEvent;
       getPromiseQueue;
       isDeliveryIdle;
       pendingUnconsumedCheck = null;
@@ -74307,6 +74604,7 @@ var init_events_consumer2 = __esm({
         this.eventIndex = 0;
         this.onConsumedEvent = options.onConsumedEvent;
         this.onUnconsumedEvent = options.onUnconsumedEvent;
+        this.onDuplicateEvent = options.onDuplicateEvent;
         this.getPromiseQueue = options.getPromiseQueue;
         this.isDeliveryIdle = options.isDeliveryIdle;
       }
@@ -74394,6 +74692,11 @@ var init_events_consumer2 = __esm({
             return;
           }
           if (!consumed) {
+            const firstType = this.firstEventTypeOfClass(currentEvent);
+            if (firstType !== void 0) {
+              this.skipDuplicateEvent(currentEvent, firstType);
+              continue;
+            }
             this.scheduleUnconsumedCheck(currentEvent, true);
             return;
           }
@@ -74420,6 +74723,7 @@ var init_events_consumer2 = __esm({
             if (currentEvent.correlationId && ONE_SHOT_EVENT_TYPES.has(currentEvent.eventType)) {
               this.resolved.add(resolutionKey(currentEvent.eventType, currentEvent.correlationId));
             }
+            this.recordEventClass(currentEvent);
             this.notifyConsumedEvent(currentEvent);
           }
           if (handled === EventConsumerResult2.Finished) {
@@ -74482,6 +74786,93 @@ 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.
+       *
+       * Run events carry no correlation id. They are classes of the run itself, so
+       * they all key off the same bucket.
+       */
+      eventClassKey(event) {
+        const eventClass = entityEventClass(event.eventType);
+        return eventClass === void 0 ? void 0 : `${eventClass}:${event.correlationId}`;
+      }
+      /**
+       * Remembers that `event`'s class is now decided for its entity, if the type
+       * belongs to a class. First writer wins: the recorded type is the one the
+       * workflow observed, and a later repeat is measured against it.
+       */
+      recordEventClass(event) {
+        const key = this.eventClassKey(event);
+        if (key !== void 0 && !this.seenEventClasses.has(key)) {
+          this.seenEventClasses.set(key, event.eventType);
+        }
+      }
+      /**
+       * The type that already decided `event`'s class for the same entity, or
+       * `undefined` when nothing has: a second `step_created` for one step, a
+       * second terminal outcome, a second `step_started` after the step's result is
+       * already in the log.
+       *
+       * Such an event is committed but inert. Concurrent replays write into one
+       * log without a currency guard, so a replay working from a prefix that
+       * predates another replay's write can commit its own copy of work the log
+       * already records. That copy cannot change what the workflow observed: the
+       * outcome was decided by the first event of the class and every later replay
+       * reads that same event at the same log position, so ignoring the straggler
+       * is deterministic across replays.
+       *
+       * Classes are tracked separately, so passing one does not suppress another.
+       * A step whose result is in the log still reaches its `step_created` and
+       * `step_started` consumers if it has yet to see those classes.
+       *
+       * Consulted only after every registered callback has declined the event, so
+       * it can never take an event a consumer wanted. A retry's `step_started` is
+       * claimed by the step's live consumer and counts as an attempt exactly as
+       * before, and a second `step_created` reaching a step that has not finished
+       * is likewise consumed rather than skipped; only the copies nobody claims are
+       * skipped.
+       *
+       * Unlike the divergence report, this does *not* wait out the deferred window
+       * first, and it does not need to. The window buys time for a consumer that
+       * has yet to register, and no such consumer can want this event: the class
+       * was recorded by a consumption in this same replay, which means the entity's
+       * consumer was registered and took an event of this class, and correlation
+       * ids are minted from a monotonic ULID per body position, so nothing later in
+       * the body registers a second consumer under this id. Waiting would cost
+       * `getDeferredCheckDelayMs()` per straggler per replay for information that
+       * cannot arrive — 0.75% of production runs carry at least one straggler, and
+       * the p99 among those carries 155.
+       *
+       * The invariant to preserve if hook identity ever becomes caller-supplied
+       * (an idempotency key rather than a minted id): two `createHook` calls in one
+       * body could then share a correlation id, and the second consumer's
+       * `hook_created` would be a repeat of a class this replay already recorded.
+       * That would make skipping wrong for `hook_created`, and is the reason the
+       * class map lives next to the event types rather than being inferred.
+       */
+      firstEventTypeOfClass(event) {
+        const key = this.eventClassKey(event);
+        return key === void 0 ? void 0 : this.seenEventClasses.get(key);
+      }
+      /** Steps the walk over a repeat of an already-consumed class. */
+      skipDuplicateEvent(event, firstType) {
+        this.eventIndex++;
+        eventsLogger2.debug("Skipping 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
+          });
+        }
+      }
       handleEndOfLog() {
         if (this.parked.length === 0) {
           return;
@@ -74514,20 +74905,39 @@ var init_events_consumer2 = __esm({
                 return;
               }
               this.pendingUnconsumedCheck = null;
-              if (mayPark) {
-                if (this.events[this.eventIndex] !== currentEvent) {
-                  return;
-                }
-                if (this.park(currentEvent)) {
-                  this.consume();
-                  return;
-                }
-              }
-              this.onUnconsumedEvent(currentEvent);
+              this.resolveUnconsumedEvent(currentEvent, mayPark);
             }, getDeferredCheckDelayMs());
           });
         });
       }
+      /**
+       * Decide what a still-unconsumed event is, now that the promise queue has
+       * drained and the delivery gate says the VM is not mid-reaction.
+       *
+       * `mayPark` is false only for the end-of-log recheck of an event {@link park}
+       * already holds. Nothing in the first branch applies to one of those: it is
+       * not the event at the cursor, so the identity guard is not meaningful, and
+       * it is parked already.
+       *
+       * A duplicate class never arrives here. {@link consume} steps over one in the
+       * pass that offered it, before this check is ever scheduled, and a class
+       * 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.
+       */
+      resolveUnconsumedEvent(currentEvent, mayPark) {
+        if (mayPark) {
+          if (this.events[this.eventIndex] !== currentEvent) {
+            return;
+          }
+          if (this.park(currentEvent)) {
+            this.consume();
+            return;
+          }
+        }
+        this.onUnconsumedEvent(currentEvent);
+      }
       /**
        * Run `fn` once no data delivery is in flight, polling the way
        * `scheduleWhenIdle` does: let the promise queue drain, re-check a timer
@@ -74945,7 +75355,7 @@ var require_parse_options2 = __commonJS({
     "use strict";
     var looseOption = Object.freeze({ loose: true });
     var emptyOpts = Object.freeze({});
-    var parseOptions = /* @__PURE__ */ __name((options) => {
+    var parseOptions3 = /* @__PURE__ */ __name((options) => {
       if (!options) {
         return emptyOpts;
       }
@@ -74954,7 +75364,7 @@ var require_parse_options2 = __commonJS({
       }
       return options;
     }, "parseOptions");
-    module.exports = parseOptions;
+    module.exports = parseOptions3;
   }
 });
 
@@ -74990,14 +75400,14 @@ var require_semver4 = __commonJS({
     var debug = require_debug2();
     var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants9();
     var { safeRe: re2, t } = require_re2();
-    var parseOptions = require_parse_options2();
+    var parseOptions3 = require_parse_options2();
     var { compareIdentifiers } = require_identifiers2();
     var SemVer = class _SemVer {
       static {
         __name(this, "SemVer");
       }
       constructor(version6, options) {
-        options = parseOptions(options);
+        options = parseOptions3(options);
         if (version6 instanceof _SemVer) {
           if (version6.loose === !!options.loose && version6.includePrerelease === !!options.includePrerelease) {
             return version6;
@@ -75695,7 +76105,7 @@ var require_range2 = __commonJS({
         __name(this, "Range");
       }
       constructor(range2, options) {
-        options = parseOptions(options);
+        options = parseOptions3(options);
         if (range2 instanceof _Range) {
           if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
             return range2;
@@ -75834,7 +76244,7 @@ var require_range2 = __commonJS({
     module.exports = Range;
     var LRU = require_lrucache2();
     var cache = new LRU();
-    var parseOptions = require_parse_options2();
+    var parseOptions3 = require_parse_options2();
     var Comparator = require_comparator2();
     var debug = require_debug2();
     var SemVer = require_semver4();
@@ -76078,7 +76488,7 @@ var require_comparator2 = __commonJS({
         return ANY;
       }
       constructor(comp, options) {
-        options = parseOptions(options);
+        options = parseOptions3(options);
         if (comp instanceof _Comparator) {
           if (comp.loose === !!options.loose) {
             return comp;
@@ -76146,7 +76556,7 @@ var require_comparator2 = __commonJS({
           }
           return new Range(this.value, options).test(comp.semver);
         }
-        options = parseOptions(options);
+        options = parseOptions3(options);
         if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
           return false;
         }
@@ -76172,7 +76582,7 @@ var require_comparator2 = __commonJS({
       }
     };
     module.exports = Comparator;
-    var parseOptions = require_parse_options2();
+    var parseOptions3 = require_parse_options2();
     var { safeRe: re2, t } = require_re2();
     var cmp = require_cmp2();
     var debug = require_debug2();
@@ -76828,7 +77238,7 @@ var version5;
 var init_version4 = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version5 = "5.0.0-beta.41";
+    version5 = "5.0.0-beta.42";
   }
 });
 
@@ -77008,48 +77418,36 @@ async function loadWorkflowRunEvents(runId, afterCursor) {
     return { events: loadedEvents, cursor };
   });
 }
-function isPreconditionGuardEnabled() {
-  return process.env.WORKFLOW_PRECONDITION_GUARD !== "0";
-}
 function isSlotGapCheckEnabled() {
   return process.env.WORKFLOW_SLOT_GAP_CHECK !== "0";
 }
-function latestEventStateUpdatedAt(events) {
-  let latest;
-  for (const event of events) {
-    if (latest === void 0 || event.eventId > latest) {
-      latest = event.eventId;
-    }
-  }
-  if (latest === void 0) {
-    return void 0;
-  }
-  const eventId = latest;
-  const underscore = eventId.lastIndexOf("_");
-  const rawUlid = underscore === -1 ? eventId : eventId.slice(underscore + 1);
-  const time5 = ulidToDate(rawUlid)?.getTime();
-  if (time5 === void 0) {
-    runtimeLogger2.debug("Precondition guard: latest event id is not a decodable ULID; sending no snapshot", { eventId });
-    return void 0;
-  }
-  return time5;
-}
 function mergeReportedEvents(target2, events) {
   const before = target2.length;
   appendUniqueEvents(target2, events);
   const added = target2.length - before;
-  if (added > 0 && maxEventSlot(target2) !== void 0) {
+  if (added > 0) {
     target2.sort((a, b) => a.eventId < b.eventId ? -1 : a.eventId > b.eventId ? 1 : 0);
   }
   return added;
 }
+function absorbSkippedSlotReport(target2, result2) {
+  const offered = result2.events?.length ?? 0;
+  if (offered === 0) {
+    return { added: 0, offered: 0, truncated: false };
+  }
+  if (result2.hasMore === true) {
+    return { added: 0, offered, truncated: true };
+  }
+  return {
+    added: mergeReportedEvents(target2, result2.events ?? []),
+    offered,
+    truncated: false
+  };
+}
 function maxEventSlot(events) {
   let max;
   for (const event of events) {
-    const slot = eventIdToSlot(event.eventId);
-    if (slot === null) {
-      return void 0;
-    }
+    const slot = requireEventSlot(event.eventId);
     if (max === void 0 || slot > max) {
       max = slot;
     }
@@ -77060,10 +77458,7 @@ function findEventSlotGap(events) {
   const occupied = /* @__PURE__ */ new Set();
   let maxSlot = 0;
   for (const event of events) {
-    const slot = eventIdToSlot(event.eventId);
-    if (slot === null) {
-      return void 0;
-    }
+    const slot = requireEventSlot(event.eventId);
     occupied.add(slot);
     if (slot > maxSlot) {
       maxSlot = slot;
@@ -77099,23 +77494,9 @@ async function settleEventSlotGap(runId, loaded) {
   }
   return { log, gap };
 }
-function preconditionSnapshotParams(events, cursor) {
-  if (!isPreconditionGuardEnabled()) {
-    return {};
-  }
+function slotSnapshotParams(events) {
   const eventCount = maxEventSlot(events);
-  if (eventCount !== void 0) {
-    return { eventCount };
-  }
-  const stateUpdatedAt = latestEventStateUpdatedAt(events);
-  if (stateUpdatedAt === void 0) {
-    return {};
-  }
-  return {
-    stateUpdatedAt,
-    stateEventCount: events.length,
-    ...cursor ? { stateCursor: cursor } : {}
-  };
+  return eventCount === void 0 ? {} : { eventCount };
 }
 function preconditionEventDelta(error95, runId) {
   if (!PreconditionFailedError.is(error95)) {
@@ -77166,6 +77547,17 @@ function withHealthCheck(handler, worldSpecVersion) {
     return await handler(req);
   };
 }
+function fnv1a32Hex(value) {
+  let hash3 = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash3 ^= value.charCodeAt(i);
+    hash3 = Math.imul(hash3, 16777619);
+  }
+  return (hash3 >>> 0).toString(16).padStart(8, "0");
+}
+function stepDispatchIdempotencyKey(correlationId, stepName) {
+  return `${correlationId}:${fnv1a32Hex(stepName)}`;
+}
 async function queueMessage(world, ...args) {
   const queueName = args[0];
   await trace5("queue.publish", {
@@ -77237,16 +77629,15 @@ var init_helpers3 = __esm({
     __name(assertEventPaginationProgress, "assertEventPaginationProgress");
     __name(shouldRetryWithoutEventCursor, "shouldRetryWithoutEventCursor");
     __name(loadWorkflowRunEvents, "loadWorkflowRunEvents");
-    __name(isPreconditionGuardEnabled, "isPreconditionGuardEnabled");
     __name(isSlotGapCheckEnabled, "isSlotGapCheckEnabled");
-    __name(latestEventStateUpdatedAt, "latestEventStateUpdatedAt");
     __name(mergeReportedEvents, "mergeReportedEvents");
+    __name(absorbSkippedSlotReport, "absorbSkippedSlotReport");
     __name(maxEventSlot, "maxEventSlot");
     __name(findEventSlotGap, "findEventSlotGap");
     SLOT_GAP_RECHECK_ATTEMPTS = 3;
     SLOT_GAP_RECHECK_BASE_DELAY_MS = 25;
     __name(settleEventSlotGap, "settleEventSlotGap");
-    __name(preconditionSnapshotParams, "preconditionSnapshotParams");
+    __name(slotSnapshotParams, "slotSnapshotParams");
     __name(preconditionEventDelta, "preconditionEventDelta");
     HEALTH_CHECK_CORS_HEADERS = {
       "Access-Control-Allow-Origin": "*",
@@ -77254,6 +77645,8 @@ var init_helpers3 = __esm({
       "Access-Control-Allow-Headers": "Content-Type"
     };
     __name(withHealthCheck, "withHealthCheck");
+    __name(fnv1a32Hex, "fnv1a32Hex");
+    __name(stepDispatchIdempotencyKey, "stepDispatchIdempotencyKey");
     __name(queueMessage, "queueMessage");
     __name(getQueueOverhead, "getQueueOverhead");
     __name(memoizeEncryptionKey, "memoizeEncryptionKey");
@@ -77359,9 +77752,9 @@ async function getHookByToken3(token) {
   return hook;
 }
 async function resumeHook2(tokenOrHook, payload, encryptionKeyOverride) {
-  return resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, false);
+  return resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, false, Date.now());
 }
-async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp) {
+async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs) {
   return await waitedUntil2(() => {
     return trace5("hook.resume", async (span) => {
       const world = await getWorldLazy2();
@@ -77449,23 +77842,24 @@ async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hook
             }
             throw err;
           }
+          const queuePublishRequestedAtMs = Date.now();
           await world.queue(queueName, {
             runId: hook.runId,
-            traceCarrier: resumeContext.traceCarrier ?? void 0
+            traceCarrier: resumeContext.traceCarrier ?? void 0,
+            hookResumeTiming: {
+              resumeRequestedAtMs,
+              queuePublishRequestedAtMs,
+              strategy: "sequential"
+            }
           }, queueOptions);
           return hook;
         }
         const resumeId = generateResumeId2();
         const payloadDigest = await computeResumePayloadDigest2(dehydratedPayload);
         span?.setAttributes({ "workflow.hook.resume_id": resumeId });
-        const [eventResult, queueResult] = await Promise.allSettled([
-          world.events.create(hook.runId, {
-            eventType: "hook_received",
-            specVersion: SPEC_VERSION_CURRENT2,
-            correlationId: hook.hookId,
-            eventData
-          }, { v1Compat, resumeId, resumePayloadDigest: payloadDigest }),
-          world.queue(queueName, {
+        const publishInvocation = /* @__PURE__ */ __name(() => {
+          const queuePublishRequestedAtMs = Date.now();
+          return world.queue(queueName, {
             runId: hook.runId,
             traceCarrier: resumeContext.traceCarrier ?? void 0,
             hookInput: {
@@ -77478,8 +77872,22 @@ async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hook
               // check: lets a misrouted delivery re-route before its
               // hoisted hook_received write instead of after.
               deploymentId: resumeContext.deploymentId
+            },
+            hookResumeTiming: {
+              resumeRequestedAtMs,
+              queuePublishRequestedAtMs,
+              strategy: "parallel"
             }
-          }, queueOptions)
+          }, queueOptions);
+        }, "publishInvocation");
+        const [eventResult, queueResult] = await Promise.allSettled([
+          world.events.create(hook.runId, {
+            eventType: "hook_received",
+            specVersion: SPEC_VERSION_CURRENT2,
+            correlationId: hook.hookId,
+            eventData
+          }, { v1Compat, resumeId, resumePayloadDigest: payloadDigest }),
+          publishInvocation()
         ]);
         if (queueResult.status === "rejected") {
           throw queueResult.reason;
@@ -77519,6 +77927,7 @@ async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hook
   });
 }
 async function resumeWebhook2(token, request) {
+  const resumeRequestedAtMs = Date.now();
   const { hook, encryptionKey } = await getHookByTokenWithKey2(token);
   if (hook.isWebhook === false) {
     throw new HookNotFoundError2(token);
@@ -77538,7 +77947,7 @@ async function resumeWebhook2(token, request) {
   } else {
     response = new Response(null, { status: 202 });
   }
-  await resumeHookImpl2(hook, request, encryptionKey, true);
+  await resumeHookImpl2(hook, request, encryptionKey, true, resumeRequestedAtMs);
   if (responseReadable) {
     const reader = responseReadable.getReader();
     const chunk = await reader.read();
@@ -77903,7 +78312,9 @@ function createReconnectingFramedStream2(runId, name, startIndex) {
       try {
         await connect2();
         return;
-      } catch {
+      } catch (error95) {
+        if (StreamExpiredError2.is(error95))
+          throw error95;
       }
     }
   }
@@ -79598,6 +80009,9 @@ function getMaxInlineSteps() {
   }
   return parsed;
 }
+function isResilientStepDispatchEnabled() {
+  return process.env.WORKFLOW_RESILIENT_STEP_DISPATCH === "1";
+}
 function getMaxEventsOverride() {
   const raw = process.env.WORKFLOW_MAX_EVENTS_OVERRIDE;
   if (!raw)
@@ -79666,7 +80080,7 @@ function getPreconditionReinvokeDelaySeconds() {
 function getDeploymentMismatchMaxRetries() {
   return envNumber2("WORKFLOW_DEPLOYMENT_MISMATCH_MAX_RETRIES", DEPLOYMENT_MISMATCH_MAX_RETRIES, { integer: true, min: 0 });
 }
-var MAX_QUEUE_DELIVERIES, REPLAY_TIMEOUT_MS, MIN_REPLAY_TIMEOUT_MS, MAX_REPLAY_TIMEOUT_MS, warnedReplayTimeoutValues, REPLAY_TIMEOUT_MAX_RETRIES, MAX_INLINE_STEPS, MIN_MAX_INLINE_STEPS, MAX_MAX_INLINE_STEPS, warnedMaxInlineStepsValues, warnedMaxEventsValues, INLINE_OWNERSHIP_LEASE_SECONDS, MAX_INLINE_OWNERSHIP_LEASE_SECONDS, REPLAY_DIVERGENCE_MAX_RETRIES, PRECONDITION_MAX_INPROCESS_RESTARTS, PRECONDITION_MAX_REINVOCATIONS, PRECONDITION_REINVOKE_DELAY_SECONDS, DEPLOYMENT_MISMATCH_MAX_RETRIES;
+var MAX_QUEUE_DELIVERIES, REPLAY_TIMEOUT_MS, MIN_REPLAY_TIMEOUT_MS, MAX_REPLAY_TIMEOUT_MS, warnedReplayTimeoutValues, REPLAY_TIMEOUT_MAX_RETRIES, MAX_INLINE_STEPS, MIN_MAX_INLINE_STEPS, MAX_MAX_INLINE_STEPS, warnedMaxInlineStepsValues, MAX_RESILIENT_STEP_INPUT_BYTES, warnedMaxEventsValues, INLINE_OWNERSHIP_LEASE_SECONDS, MAX_INLINE_OWNERSHIP_LEASE_SECONDS, REPLAY_DIVERGENCE_MAX_RETRIES, PRECONDITION_MAX_INPROCESS_RESTARTS, PRECONDITION_MAX_REINVOCATIONS, PRECONDITION_REINVOKE_DELAY_SECONDS, DEPLOYMENT_MISMATCH_MAX_RETRIES;
 var init_constants3 = __esm({
   "../core/dist/runtime/constants.js"() {
     "use strict";
@@ -79687,6 +80101,8 @@ var init_constants3 = __esm({
     MAX_MAX_INLINE_STEPS = 16;
     warnedMaxInlineStepsValues = /* @__PURE__ */ new Set();
     __name(getMaxInlineSteps, "getMaxInlineSteps");
+    MAX_RESILIENT_STEP_INPUT_BYTES = 128 * 1024;
+    __name(isResilientStepDispatchEnabled, "isResilientStepDispatchEnabled");
     warnedMaxEventsValues = /* @__PURE__ */ new Set();
     __name(getMaxEventsOverride, "getMaxEventsOverride");
     __name(isOptimisticInlineStartEnabled, "isOptimisticInlineStartEnabled");
@@ -79713,7 +80129,7 @@ var init_constants3 = __esm({
 
 // ../core/dist/runtime/replay-budget.js
 async function handleReplayBudgetExhausted(args) {
-  const { runId, workflowName, requestId, attempt, limitMs } = args;
+  const { runId, workflowName, requestId, attempt, limitMs, slotSnapshot } = args;
   const runLogger = runtimeLogger2.forRun(runId, workflowName);
   const maxRetries = getReplayTimeoutMaxRetries();
   if (attempt <= maxRetries) {
@@ -79742,7 +80158,7 @@ async function handleReplayBudgetExhausted(args) {
       error: await dehydrateRunError(timeoutErr, runId, await getEncryptionKey()),
       errorCode: RUN_ERROR_CODES2.REPLAY_TIMEOUT
     }
-  }, { requestId });
+  }, { requestId, ...slotSnapshot });
 }
 var ReplayBudget, ReplayTimeoutRetryError;
 var init_replay_budget = __esm({
@@ -79886,6 +80302,110 @@ var init_replay_recovery_reporter = __esm({
   }
 });
 
+// ../core/dist/runtime/resume-latency.js
+function resumeTrackingFromMessage(timing, stepExecution) {
+  if (!timing)
+    return void 0;
+  if (!Number.isFinite(timing.resumeRequestedAtMs) || !Number.isFinite(timing.queuePublishRequestedAtMs)) {
+    return void 0;
+  }
+  return {
+    trigger: "hook",
+    ...timing.strategy === "parallel" || timing.strategy === "sequential" ? { strategy: timing.strategy } : {},
+    resumeRequestedAtMs: timing.resumeRequestedAtMs,
+    queuePublishRequestedAtMs: timing.queuePublishRequestedAtMs,
+    // A dispatched step reads the resuming invocation's boundaries off the
+    // message; an inline one has them stamped locally by the caller, which
+    // overwrites this placeholder immediately after construction.
+    consumerStartedAtMs: timing.consumerStartedAtMs ?? Number.NaN,
+    ...timing.replayStartedAtMs !== void 0 ? { replayStartedAtMs: timing.replayStartedAtMs } : {},
+    ...timing.nextStepEncounteredAtMs !== void 0 ? { nextStepEncounteredAtMs: timing.nextStepEncounteredAtMs } : {},
+    ...timing.setupSource === "hook_preload" || timing.setupSource === "run_started" || timing.setupSource === "event_load" ? { setupSource: timing.setupSource } : {},
+    stepExecution
+  };
+}
+function resumeTimingForMessage(tracking) {
+  if (!tracking)
+    return void 0;
+  if (!Number.isFinite(tracking.consumerStartedAtMs))
+    return void 0;
+  return {
+    resumeRequestedAtMs: tracking.resumeRequestedAtMs,
+    queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,
+    ...tracking.strategy !== void 0 ? { strategy: tracking.strategy } : {},
+    consumerStartedAtMs: tracking.consumerStartedAtMs,
+    ...tracking.replayStartedAtMs !== void 0 ? { replayStartedAtMs: tracking.replayStartedAtMs } : {},
+    ...tracking.nextStepEncounteredAtMs !== void 0 ? { nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs } : {},
+    ...tracking.setupSource !== void 0 ? { setupSource: tracking.setupSource } : {}
+  };
+}
+function validateBoundaries(b) {
+  const ordered = [
+    b.resumeRequestedAtMs,
+    b.queuePublishRequestedAtMs,
+    b.consumerStartedAtMs,
+    b.replayStartedAtMs,
+    b.nextStepEncounteredAtMs,
+    b.stepClaimStartedAtMs,
+    ...b.stepClaimCompletedAtMs !== void 0 ? [b.stepClaimCompletedAtMs] : [],
+    b.stepCodeStartedAtMs
+  ];
+  for (const value of ordered) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+      return void 0;
+  }
+  for (let i = 1; i < ordered.length; i++) {
+    if (ordered[i] < ordered[i - 1])
+      return void 0;
+  }
+  return ordered;
+}
+function computeResumeTtrAttributes(params) {
+  const { tracking } = params;
+  if (!tracking || params.attempt !== 1)
+    return void 0;
+  if (tracking.replayStartedAtMs === void 0 || tracking.nextStepEncounteredAtMs === void 0 || params.stepClaimStartedAtMs === void 0) {
+    return void 0;
+  }
+  const boundaries = {
+    resumeRequestedAtMs: tracking.resumeRequestedAtMs,
+    queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,
+    consumerStartedAtMs: tracking.consumerStartedAtMs,
+    replayStartedAtMs: tracking.replayStartedAtMs,
+    nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs,
+    stepClaimStartedAtMs: params.stepClaimStartedAtMs,
+    stepClaimCompletedAtMs: params.stepClaimCompletedAtMs,
+    stepCodeStartedAtMs: params.stepCodeStartedAtMs
+  };
+  if (!validateBoundaries(boundaries))
+    return void 0;
+  const { resumeRequestedAtMs: t0, queuePublishRequestedAtMs: t1, consumerStartedAtMs: t2, replayStartedAtMs: t3, nextStepEncounteredAtMs: t4, stepClaimStartedAtMs: t5, stepClaimCompletedAtMs: t6, stepCodeStartedAtMs: t7 } = boundaries;
+  return {
+    ...ResumeTotalMs2(t7 - t0),
+    ...ResumeProducerPrepMs2(t1 - t0),
+    ...ResumeQueueDeliveryMs2(t2 - t1),
+    ...ResumeSetupMs2(t3 - t2),
+    ...ResumeReplayMs2(t4 - t3),
+    ...ResumeStepDispatchMs2(t5 - t4),
+    ...t6 !== void 0 ? ResumeStepClaimMs2(t6 - t5) : {},
+    ...ResumeStepPrepareMs2(t7 - (t6 ?? t5)),
+    ...ResumeTrigger2(tracking.trigger),
+    ...tracking.strategy !== void 0 ? ResumeStrategy2(tracking.strategy) : {},
+    ...tracking.setupSource !== void 0 ? ResumeSetupSource2(tracking.setupSource) : {},
+    ...ResumeStepExecution2(tracking.stepExecution)
+  };
+}
+var init_resume_latency = __esm({
+  "../core/dist/runtime/resume-latency.js"() {
+    "use strict";
+    init_semantic_conventions2();
+    __name(resumeTrackingFromMessage, "resumeTrackingFromMessage");
+    __name(resumeTimingForMessage, "resumeTimingForMessage");
+    __name(validateBoundaries, "validateBoundaries");
+    __name(computeResumeTtrAttributes, "computeResumeTtrAttributes");
+  }
+});
+
 // ../core/dist/runtime/run-id-time.js
 function runIdCreatedAt(runId) {
   const ulidPart = runId.startsWith(RUN_ID_PREFIX2) ? runId.slice(RUN_ID_PREFIX2.length) : runId;
@@ -80159,7 +80679,30 @@ async function executeStep(params) {
   const isVercel = Boolean(process.env.VERCEL_URL);
   const compression = (params.runSpecVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2;
   const replayRecoveryReporter = params.replayRecoveryReporter ?? ReplayRecoveryReporter.inert();
-  const createEvent = /* @__PURE__ */ __name((data, eventParams) => replayRecoveryReporter.withEventCreate(eventParams, (p) => world.events.create(workflowRunId, data, p)), "createEvent");
+  let knownSlot = params.slotSnapshot?.eventCount;
+  const observeSlot = /* @__PURE__ */ __name((result2) => {
+    if (knownSlot === void 0) {
+      return;
+    }
+    const observed = [];
+    if (result2.event) {
+      observed.push(requireEventSlot(result2.event.eventId));
+    }
+    const reported = maxEventSlot(result2.events ?? []);
+    if (reported !== void 0) {
+      observed.push(reported);
+    }
+    for (const slot of observed) {
+      if (slot > knownSlot) {
+        knownSlot = slot;
+      }
+    }
+  }, "observeSlot");
+  const createEvent = /* @__PURE__ */ __name(async (data, eventParams) => {
+    const result2 = await replayRecoveryReporter.withEventCreate(knownSlot === void 0 ? eventParams : { eventCount: knownSlot, ...eventParams }, (p) => world.events.create(workflowRunId, data, p));
+    observeSlot(result2);
+    return result2;
+  }, "createEvent");
   const spanName = `step.execute ${stepDisplayName(stepName)}`;
   return trace5(spanName, {}, async (span) => {
     span?.setAttributes({
@@ -80316,12 +80859,10 @@ async function executeStep(params) {
     params.suppressOptimisticStart !== true && (isOptimisticInlineStartEnabled() || params.forceOptimisticStart === true && !isOptimisticInlineStartExplicitlyDisabled());
     let step;
     const startEventParams = {
-      computeInstanceId: COMPUTE_INSTANCE_ID,
-      // Spread as a unit: the three snapshot fields describe one snapshot and
-      // must travel together — see StepExecutorParams.preconditionSnapshot.
-      ...params.preconditionSnapshot
+      computeInstanceId: COMPUTE_INSTANCE_ID
     };
     let stepStartPostSentAtMs;
+    let stepClaimCompletedAtMs;
     let optimisticStartSettled;
     const reconcileOptimisticStart = /* @__PURE__ */ __name(async () => {
       if (!optimisticStartSettled)
@@ -80350,7 +80891,7 @@ async function executeStep(params) {
               ...params.ownerMessageId !== void 0 ? { ownerMessageId: params.ownerMessageId } : {}
             }
           },
-          // Guard the claim — see StepExecutorParams.preconditionSnapshot. A
+          // Guard the claim — see StepExecutorParams.slotSnapshot. A
           // stale (412) rejection surfaces via reconcileOptimisticStart as a
           // non-translatable error: the body result is discarded and the
           // rejection propagates to the caller.
@@ -80386,12 +80927,13 @@ async function executeStep(params) {
               ...ownershipStamp
             } : { stepName, ...ownershipStamp }
           },
-          // Guard the claim — see StepExecutorParams.preconditionSnapshot. A
+          // Guard the claim — see StepExecutorParams.slotSnapshot. A
           // stale (412) rejection is intentionally NOT translated by
           // startErrorToResult below, so it propagates to the caller for a
           // fresh replay.
           startEventParams
         );
+        stepClaimCompletedAtMs = Date.now();
         step = startResult.step;
       } catch (err) {
         const mapped = startErrorToResult(err);
@@ -80504,12 +81046,28 @@ async function executeStep(params) {
       if (latencyEventData) {
         span?.setAttributes({
           ...latencyEventData.ttfs !== void 0 ? StepTtfsMs2(latencyEventData.ttfs) : {},
-          ...latencyEventData.stso !== void 0 ? StepStsoMs2(latencyEventData.stso) : {},
+          ...latencyEventData.stso !== void 0 ? StepStsoMs3(latencyEventData.stso) : {},
           ...latencyEventData.rsfs !== void 0 ? StepRsfsMs2(latencyEventData.rsfs) : {},
           ...latencyEventData.finalSchedulingReplay !== void 0 ? StepFinalSchedulingReplayMs2(latencyEventData.finalSchedulingReplay) : {},
-          ...StepLatencyOptimizations2(latencyEventData.optimizations ?? [])
+          ...StepLatencyOptimizations3(latencyEventData.optimizations ?? [])
         });
       }
+      const reportResumeTtr = /* @__PURE__ */ __name(() => {
+        const tracking = params.resumeTracking;
+        if (!tracking || tracking.reported)
+          return;
+        const attributes = computeResumeTtrAttributes({
+          tracking,
+          attempt,
+          stepClaimStartedAtMs: stepStartPostSentAtMs,
+          stepClaimCompletedAtMs,
+          stepCodeStartedAtMs: Date.now()
+        });
+        if (!attributes)
+          return;
+        tracking.reported = true;
+        span?.setAttributes(attributes);
+      }, "reportResumeTtr");
       try {
         result2 = await trace5("step.execute", {}, async () => {
           return await contextStorage2.run({
@@ -80537,7 +81095,10 @@ async function executeStep(params) {
             // (e.g. `setAttributes`) can order itself after the
             // run exists. Undefined on the await path (run already durable).
             runReadyBarrier: optimisticStart ? params.runReadyBarrier : void 0
-          }, () => stepFn.apply(thisVal, args));
+          }, () => {
+            reportResumeTtr();
+            return stepFn.apply(thisVal, args);
+          });
         });
       } catch (err) {
         userCodeError = err;
@@ -80833,6 +81394,7 @@ var init_step_executor = __esm({
     init_get_port_lazy();
     init_helpers3();
     init_replay_recovery_reporter();
+    init_resume_latency();
     init_step_latency();
     init_wait_until2();
     DEFAULT_STEP_MAX_RETRIES = 3;
@@ -88802,29 +89364,39 @@ function isFirstInvocation(preloadedEvents) {
   return preloadedEvents.every((e) => e.eventType === "run_created" || e.eventType === "run_started");
 }
 async function queueStepMessage(params) {
-  const { world, runId, workflowRun, step, delaySeconds, namespace, nextTraceCarrier, purpose, wfdiag } = params;
+  const { world, runId, workflowRun, step, delaySeconds, namespace, nextTraceCarrier, purpose, stepInput, wfdiag } = params;
   const traceCarrier = await nextTraceCarrier();
   await queueMessage(world, getWorkflowQueueName2(workflowRun.workflowName, namespace), {
     runId,
     stepId: step.correlationId,
     stepName: step.stepId,
     traceCarrier,
-    requestedAt: /* @__PURE__ */ new Date()
+    requestedAt: /* @__PURE__ */ new Date(),
+    ...stepInput !== void 0 ? { stepInput: { input: stepInput } } : {}
   }, {
-    idempotencyKey: purpose === "dispatch" ? step.correlationId : `${step.correlationId}:${purpose}`,
+    // The 'dispatch' key is step-identity-scoped (correlationId + hashed
+    // step name) — shared with the node engine's dispatch of the same step
+    // so the two stay mutually exclusive, without a revoked resilient
+    // message absorbing a reassigned correlation id's legitimate dispatch.
+    // See stepDispatchIdempotencyKey.
+    idempotencyKey: purpose === "dispatch" ? stepDispatchIdempotencyKey(step.correlationId, step.stepId) : `${step.correlationId}:${purpose}`,
     ...delaySeconds && delaySeconds > 0 ? { delaySeconds } : {}
   });
   wfdiag("step_queued", {
     stepId: step.stepId,
     correlationId: step.correlationId,
     purpose,
-    delaySeconds: delaySeconds ?? 0
+    delaySeconds: delaySeconds ?? 0,
+    ...stepInput !== void 0 ? { resilient: true } : {}
   });
 }
 async function dispatchPendingOps(params) {
   const { world, runId, workflowRun, encryptionKey, pendingOperations, namespace, nextTraceCarrier } = params;
   const skipStepCreation = params.skipStepCreation;
+  const queueStepCids = params.queueStepCids;
   const wfdiag = params.wfdiag;
+  const queuedStepCids = /* @__PURE__ */ new Set();
+  const resilientDispatchEligible = queueStepCids !== void 0 && queueStepCids.size > 0 && isResilientStepDispatchEnabled() && (workflowRun.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT2;
   let createdGetConflictHook = false;
   let createdAttributeEvent = false;
   const opsPromises = [];
@@ -88955,6 +89527,56 @@ async function dispatchPendingOps(params) {
     if (op.type === "step" && !op.hasCreatedEvent && !skipStepCreation?.has(op.correlationId)) {
       const step = op;
       opsPromises.push((async () => {
+        const encryptedInput = await encrypt4(step.input, encryptionKey);
+        if (resilientDispatchEligible && queueStepCids?.has(step.correlationId) && encryptedInput instanceof Uint8Array && encryptedInput.byteLength <= MAX_RESILIENT_STEP_INPUT_BYTES) {
+          const [createResult, queueResult] = await Promise.allSettled([
+            world.events.create(runId, {
+              eventType: "step_created",
+              specVersion: SPEC_VERSION_CURRENT2,
+              correlationId: step.correlationId,
+              eventData: {
+                stepName: step.stepId,
+                input: encryptedInput
+              }
+            }),
+            queueStepMessage({
+              world,
+              runId,
+              workflowRun,
+              step,
+              namespace,
+              nextTraceCarrier,
+              purpose: "dispatch",
+              stepInput: encryptedInput,
+              wfdiag
+            })
+          ]);
+          if (queueResult.status === "rejected") {
+            throw queueResult.reason;
+          }
+          queuedStepCids.add(step.correlationId);
+          if (createResult.status === "rejected") {
+            const err = createResult.reason;
+            if (EntityConflictError2.is(err)) {
+              return;
+            }
+            if (isRetryableWorldError2(err)) {
+              runtimeLogger2.warn("Step creation event write failed, but the step was dispatched via the queue. The step_created event will be ensured by the queue consumer.", {
+                workflowRunId: runId,
+                correlationId: step.correlationId,
+                stepName: step.stepId,
+                error: err instanceof Error ? err.message : String(err)
+              });
+              wfdiag("step_resilient_dispatch_recovered", {
+                stepId: step.stepId,
+                correlationId: step.correlationId
+              });
+              return;
+            }
+            throw err;
+          }
+          return;
+        }
         try {
           await world.events.create(runId, {
             eventType: "step_created",
@@ -88962,7 +89584,7 @@ async function dispatchPendingOps(params) {
             correlationId: step.correlationId,
             eventData: {
               stepName: step.stepId,
-              input: await encrypt4(step.input, encryptionKey)
+              input: encryptedInput
             }
           });
         } catch (err) {
@@ -89015,7 +89637,7 @@ async function dispatchPendingOps(params) {
     }
   }
   await Promise.all(opsPromises);
-  return { createdAttributeEvent, createdGetConflictHook };
+  return { createdAttributeEvent, createdGetConflictHook, queuedStepCids };
 }
 async function runWorkflowWithQuickJS(params) {
   const { workflowCode: workflowCode2, workflowName, workflowRun, preloadedEvents, preloadedEventsComplete, runInput, parentSpan, maxEventsLimit, deliveryAttempt, ownerMessageId, namespace } = params;
@@ -89239,6 +89861,7 @@ async function runWorkflowWithQuickJS(params) {
           recordedAbortIds.add(op.correlationId);
         }
       }
+      const overflowSteps = freshSteps.slice(inlineCandidates.length);
       const dispatched = await dispatchPendingOps({
         world,
         runId,
@@ -89248,15 +89871,18 @@ async function runWorkflowWithQuickJS(params) {
         nextTraceCarrier,
         pendingOperations: opsToDispatch,
         skipStepCreation: inlineClaimCids,
+        queueStepCids: new Set(overflowSteps.map((s) => s.correlationId)),
         wfdiag
       });
       if (dispatched.createdAttributeEvent || dispatched.createdGetConflictHook) {
         pendingRequeueSignal = true;
       }
-      const overflowSteps = freshSteps.slice(inlineCandidates.length);
-      for (const step of overflowSteps) {
+      for (const cid of dispatched.queuedStepCids) {
+        queuedStepIds.add(cid);
+      }
+      await Promise.all(overflowSteps.filter((step) => !dispatched.queuedStepCids.has(step.correlationId)).map((step) => {
         queuedStepIds.add(step.correlationId);
-        await queueStepMessage({
+        return queueStepMessage({
           world,
           runId,
           workflowRun,
@@ -89266,7 +89892,7 @@ async function runWorkflowWithQuickJS(params) {
           purpose: "dispatch",
           wfdiag
         });
-      }
+      }));
       const waitCompletePromises = [];
       for (const op of pendingOperations) {
         if (op.type !== "wait")
@@ -89429,7 +90055,7 @@ async function runWorkflowWithQuickJS(params) {
             namespace,
             nextTraceCarrier,
             // Suffixed key: this step was inline-claimed, so no dispatch
-            // publish exists under the bare correlationId — but suffixing
+            // publish exists under the dispatch key — but suffixing
             // keeps the retry enqueueable even if a world retired a
             // historical key for this step (see the purpose docs above).
             purpose: "retry:1",
@@ -90161,6 +90787,7 @@ var HookConflictError;
 var HookNotFoundError;
 var EntityConflictError;
 var RunExpiredError;
+var StreamExpiredError;
 var ThrottleError;
 var WorkflowRunCancelledError;
 var FatalError;
@@ -90486,6 +91113,30 @@ Caused by: ${options.cause.stack}`;
         return isError(value) && value.name === "RunExpiredError";
       }
     };
+    StreamExpiredError = class extends WorkflowWorldError {
+      static {
+        __name(this, "StreamExpiredError");
+      }
+      static {
+        __name2(this, "StreamExpiredError");
+      }
+      runId;
+      streamId;
+      expiredAt;
+      constructor(message, runId, streamId, expiredAt) {
+        super(message, {
+          status: 410,
+          code: "stream-expired"
+        });
+        this.runId = runId;
+        this.streamId = streamId;
+        this.expiredAt = expiredAt;
+        this.name = "StreamExpiredError";
+      }
+      static is(value) {
+        return isError(value) && value.name === "StreamExpiredError";
+      }
+    };
     ThrottleError = class extends WorkflowWorldError {
       static {
         __name(this, "ThrottleError");
@@ -107894,7 +108545,9 @@ var QueueNamespace;
 var MessageId;
 var TraceCarrierSchema;
 var RunInputSchema;
+var StepDispatchInputSchema;
 var HookResumeInputSchema;
+var HookResumeTimingSchema;
 var WorkflowInvokePayloadSchema;
 var HealthCheckPayloadSchema;
 var QueuePayloadSchema;
@@ -107944,6 +108597,19 @@ var init_queue = __esm2({
        */
       environment: external_exports.string().optional()
     });
+    StepDispatchInputSchema = external_exports.object({
+      /**
+       * The serialized step input, reused verbatim from the direct write. Always
+       * binary: producers only attach `stepInput` when the dehydrated input is a
+       * `Uint8Array` and the run's queue transport preserves bytes (CBOR).
+       * Validated here so a malformed or transport-mangled payload fails the
+       * message parse instead of being silently written into a `step_created` as
+       * non-binary data. `Buffer` is a `Uint8Array` subclass and passes.
+       */
+      input: external_exports.custom((value) => value instanceof Uint8Array, {
+        message: "stepInput.input must be a Uint8Array"
+      })
+    });
     HookResumeInputSchema = external_exports.object({
       /** Stable idempotency key minted once per `resumeHook()` call. */
       resumeId: external_exports.string(),
@@ -107977,6 +108643,22 @@ var init_queue = __esm2({
        */
       deploymentId: external_exports.string().optional()
     });
+    HookResumeTimingSchema = external_exports.object({
+      /** Epoch ms at entry into `resumeHook()` — the start of the TTR window. */
+      resumeRequestedAtMs: external_exports.number(),
+      /** Epoch ms immediately before the queue publish was requested. */
+      queuePublishRequestedAtMs: external_exports.number(),
+      /** Which `resumeHook()` dispatch path ran: `parallel` or `sequential`. */
+      strategy: external_exports.string().optional(),
+      /** Epoch ms the final consumer's queue handler was entered. */
+      consumerStartedAtMs: external_exports.number().optional(),
+      /** Epoch ms this invocation's first replay pass began. */
+      replayStartedAtMs: external_exports.number().optional(),
+      /** Epoch ms replay first encountered a durable step after the resume. */
+      nextStepEncounteredAtMs: external_exports.number().optional(),
+      /** How the consumer initialized replay state: see `ResumeSetupSource`. */
+      setupSource: external_exports.string().optional()
+    });
     WorkflowInvokePayloadSchema = external_exports.object({
       runId: external_exports.string(),
       traceCarrier: TraceCarrierSchema.optional(),
@@ -108010,7 +108692,28 @@ var init_queue = __esm2({
        * fast path. A consumer that understands this field idempotently ensures the
        * `hook_received` event exists (keyed by `resumeId`) before replaying.
        */
-      hookInput: HookResumeInputSchema.optional()
+      hookInput: HookResumeInputSchema.optional(),
+      /**
+       * Resilient step dispatch data, only present alongside `stepId` when the
+       * producer parallelized the `step_created` write with this queue publish. A
+       * consumer that understands this field idempotently ensures the
+       * `step_created` event exists (keyed by `stepId`) before executing the step.
+       */
+      stepInput: StepDispatchInputSchema.optional(),
+      /**
+       * Hook-resume TTR timing. Present on both `resumeHook()` dispatch paths
+       * (unlike `hookInput`, which only rides the parallel fast path), and
+       * forwarded onto a dispatched step message when the resuming invocation
+       * hands the next durable step to another invocation. Purely observational —
+       * see {@link HookResumeTimingSchema}.
+       *
+       * `.catch(undefined)` because this field must never be able to fail the
+       * parse of the invocation payload: a malformed value (a NaN boundary, a
+       * shape change from a future producer) would otherwise throw on every
+       * delivery of that message and burn the run's delivery budget over a
+       * telemetry field. Anything unparseable degrades to "no measurement".
+       */
+      hookResumeTiming: HookResumeTimingSchema.optional().catch(void 0)
     });
     HealthCheckPayloadSchema = external_exports.object({
       __healthCheck: external_exports.literal(true),
@@ -108170,7 +108873,7 @@ var init_spec_version = __esm2({
     SPEC_VERSION_SUPPORTS_ATTRIBUTES = 4;
     SPEC_VERSION_SUPPORTS_COMPRESSION = 5;
     SPEC_VERSION_SUPPORTS_SLOT_IDENTITY = 6;
-    SPEC_VERSION_CURRENT = SPEC_VERSION_SUPPORTS_COMPRESSION;
+    SPEC_VERSION_CURRENT = SPEC_VERSION_SUPPORTS_SLOT_IDENTITY;
     SPEC_VERSION_MAX_SUPPORTED = SPEC_VERSION_SUPPORTS_SLOT_IDENTITY;
     __name2(isLegacySpecVersion, "isLegacySpecVersion");
   }
@@ -111181,6 +111884,8 @@ function getReviversForMode(mode, global2 = globalThis, extraRevivers) {
 __name(getReviversForMode, "getReviversForMode");
 var encoder;
 var decoder;
+var MAX_SPARSE_ARRAY_LENGTH;
+var parseOptions;
 var devalueCodec;
 var init_codec_devalue = __esm2({
   "../core/dist/serialization/codec-devalue.js"() {
@@ -111193,6 +111898,17 @@ var init_codec_devalue = __esm2({
     init_types();
     encoder = new TextEncoder();
     decoder = new TextDecoder();
+    MAX_SPARSE_ARRAY_LENGTH = 1e5;
+    parseOptions = {
+      operations: {
+        createSparseArray(length) {
+          if (length > MAX_SPARSE_ARRAY_LENGTH) {
+            throw new RangeError(`Sparse array length ${length} exceeds the maximum of ${MAX_SPARSE_ARRAY_LENGTH}`);
+          }
+          return default_parse_operations.createSparseArray(length);
+        }
+      }
+    };
     __name2(getReducersForMode, "getReducersForMode");
     __name2(getReviversForMode, "getReviversForMode");
     devalueCodec = {
@@ -111207,11 +111923,11 @@ var init_codec_devalue = __esm2({
       deserialize(data, mode, options) {
         const revivers = getReviversForMode(mode, options?.global, options?.extraRevivers);
         const str = decoder.decode(data);
-        return parse3(str, revivers);
+        return parse3(str, revivers, parseOptions);
       },
       deserializeLegacy(data, mode, options) {
         const revivers = getReviversForMode(mode, options?.global, options?.extraRevivers);
-        return unflatten(data, revivers);
+        return unflatten(data, revivers, parseOptions);
       }
     };
   }
@@ -111831,6 +112547,20 @@ var HookFound;
 var HookResilientResume;
 var HookResilientResumeMaterialized;
 var HookResumeSetupSource;
+var StepResilientDispatchRecovered;
+var StepResilientDispatchMaterialized;
+var ResumeTotalMs;
+var ResumeProducerPrepMs;
+var ResumeQueueDeliveryMs;
+var ResumeSetupMs;
+var ResumeReplayMs;
+var ResumeStepDispatchMs;
+var ResumeStepClaimMs;
+var ResumeStepPrepareMs;
+var ResumeTrigger;
+var ResumeStrategy;
+var ResumeSetupSource;
+var ResumeStepExecution;
 var WebhookHandlersTriggered;
 var WorkflowSuspensionState;
 var WorkflowSuspensionHookCount;
@@ -111938,6 +112668,20 @@ var init_semantic_conventions = __esm2({
     HookResilientResume = SemanticConvention("workflow.hook.resilient_resume");
     HookResilientResumeMaterialized = SemanticConvention("workflow.hook.resilient_resume_materialized");
     HookResumeSetupSource = SemanticConvention("workflow.resume_setup_source");
+    StepResilientDispatchRecovered = SemanticConvention("workflow.step.resilient_dispatch_recovered");
+    StepResilientDispatchMaterialized = SemanticConvention("workflow.step.resilient_dispatch_materialized");
+    ResumeTotalMs = SemanticConvention("workflow.resume.total_ms");
+    ResumeProducerPrepMs = SemanticConvention("workflow.resume.phase.producer_prep_ms");
+    ResumeQueueDeliveryMs = SemanticConvention("workflow.resume.phase.queue_delivery_ms");
+    ResumeSetupMs = SemanticConvention("workflow.resume.phase.resume_setup_ms");
+    ResumeReplayMs = SemanticConvention("workflow.resume.phase.replay_ms");
+    ResumeStepDispatchMs = SemanticConvention("workflow.resume.phase.step_dispatch_ms");
+    ResumeStepClaimMs = SemanticConvention("workflow.resume.phase.step_claim_ms");
+    ResumeStepPrepareMs = SemanticConvention("workflow.resume.phase.step_prepare_ms");
+    ResumeTrigger = SemanticConvention("workflow.resume.trigger");
+    ResumeStrategy = SemanticConvention("workflow.resume.strategy");
+    ResumeSetupSource = SemanticConvention("workflow.resume.setup_source");
+    ResumeStepExecution = SemanticConvention("workflow.resume.step_execution");
     WebhookHandlersTriggered = SemanticConvention("webhook.handlers.triggered");
     WorkflowSuspensionState = SemanticConvention("workflow.suspension.state");
     WorkflowSuspensionHookCount = SemanticConvention("workflow.suspension.hook_count");
@@ -114697,7 +115441,7 @@ var require_parse_options = __commonJS2({
       loose: true
     });
     var emptyOpts = Object.freeze({});
-    var parseOptions = /* @__PURE__ */ __name2((options) => {
+    var parseOptions22 = /* @__PURE__ */ __name2((options) => {
       if (!options) {
         return emptyOpts;
       }
@@ -114706,7 +115450,7 @@ var require_parse_options = __commonJS2({
       }
       return options;
     }, "parseOptions");
-    module.exports = parseOptions;
+    module.exports = parseOptions22;
   }
 });
 var require_identifiers = __commonJS2({
@@ -114738,7 +115482,7 @@ var require_semver2 = __commonJS2({
     var debug = require_debug();
     var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
     var { safeRe: re2, t } = require_re();
-    var parseOptions = require_parse_options();
+    var parseOptions22 = require_parse_options();
     var { compareIdentifiers } = require_identifiers();
     var SemVer = class _SemVer {
       static {
@@ -114748,7 +115492,7 @@ var require_semver2 = __commonJS2({
         __name2(this, "SemVer");
       }
       constructor(version32, options) {
-        options = parseOptions(options);
+        options = parseOptions22(options);
         if (version32 instanceof _SemVer) {
           if (version32.loose === !!options.loose && version32.includePrerelease === !!options.includePrerelease) {
             return version32;
@@ -115404,7 +116148,7 @@ var require_range = __commonJS2({
         __name2(this, "Range");
       }
       constructor(range2, options) {
-        options = parseOptions(options);
+        options = parseOptions22(options);
         if (range2 instanceof _Range) {
           if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
             return range2;
@@ -115555,7 +116299,7 @@ var require_range = __commonJS2({
     module.exports = Range;
     var LRU = require_lrucache();
     var cache = new LRU();
-    var parseOptions = require_parse_options();
+    var parseOptions22 = require_parse_options();
     var Comparator = require_comparator();
     var debug = require_debug();
     var SemVer = require_semver2();
@@ -115794,7 +116538,7 @@ var require_comparator = __commonJS2({
         return ANY;
       }
       constructor(comp, options) {
-        options = parseOptions(options);
+        options = parseOptions22(options);
         if (comp instanceof _Comparator) {
           if (comp.loose === !!options.loose) {
             return comp;
@@ -115862,7 +116606,7 @@ var require_comparator = __commonJS2({
           }
           return new Range(this.value, options).test(comp.semver);
         }
-        options = parseOptions(options);
+        options = parseOptions22(options);
         if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
           return false;
         }
@@ -115888,7 +116632,7 @@ var require_comparator = __commonJS2({
       }
     };
     module.exports = Comparator;
-    var parseOptions = require_parse_options();
+    var parseOptions22 = require_parse_options();
     var { safeRe: re2, t } = require_re();
     var cmp = require_cmp();
     var debug = require_debug();
@@ -116576,7 +117320,7 @@ var version2;
 var init_version = __esm2({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.41";
+    version2 = "5.0.0-beta.42";
   }
 });
 function getWorkflowQueueName(workflowName, namespace) {
@@ -121843,10 +122587,10 @@ async function getHookByToken(token) {
 }
 __name(getHookByToken, "getHookByToken");
 async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
-  return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false);
+  return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false, Date.now());
 }
 __name(resumeHook, "resumeHook");
-async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp) {
+async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs) {
   return await waitedUntil(() => {
     return trace("hook.resume", async (span) => {
       const world = await getWorldLazy();
@@ -121938,9 +122682,15 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
             }
             throw err;
           }
+          const queuePublishRequestedAtMs = Date.now();
           await world.queue(queueName, {
             runId: hook.runId,
-            traceCarrier: resumeContext.traceCarrier ?? void 0
+            traceCarrier: resumeContext.traceCarrier ?? void 0,
+            hookResumeTiming: {
+              resumeRequestedAtMs,
+              queuePublishRequestedAtMs,
+              strategy: "sequential"
+            }
           }, queueOptions);
           return hook;
         }
@@ -121949,18 +122699,9 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
         span?.setAttributes({
           "workflow.hook.resume_id": resumeId
         });
-        const [eventResult, queueResult] = await Promise.allSettled([
-          world.events.create(hook.runId, {
-            eventType: "hook_received",
-            specVersion: SPEC_VERSION_CURRENT,
-            correlationId: hook.hookId,
-            eventData
-          }, {
-            v1Compat,
-            resumeId,
-            resumePayloadDigest: payloadDigest
-          }),
-          world.queue(queueName, {
+        const publishInvocation = /* @__PURE__ */ __name2(() => {
+          const queuePublishRequestedAtMs = Date.now();
+          return world.queue(queueName, {
             runId: hook.runId,
             traceCarrier: resumeContext.traceCarrier ?? void 0,
             hookInput: {
@@ -121973,8 +122714,26 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
               // check: lets a misrouted delivery re-route before its
               // hoisted hook_received write instead of after.
               deploymentId: resumeContext.deploymentId
+            },
+            hookResumeTiming: {
+              resumeRequestedAtMs,
+              queuePublishRequestedAtMs,
+              strategy: "parallel"
             }
-          }, queueOptions)
+          }, queueOptions);
+        }, "publishInvocation");
+        const [eventResult, queueResult] = await Promise.allSettled([
+          world.events.create(hook.runId, {
+            eventType: "hook_received",
+            specVersion: SPEC_VERSION_CURRENT,
+            correlationId: hook.hookId,
+            eventData
+          }, {
+            v1Compat,
+            resumeId,
+            resumePayloadDigest: payloadDigest
+          }),
+          publishInvocation()
         ]);
         if (queueResult.status === "rejected") {
           throw queueResult.reason;
@@ -122018,6 +122777,7 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
 }
 __name(resumeHookImpl, "resumeHookImpl");
 async function resumeWebhook(token, request) {
+  const resumeRequestedAtMs = Date.now();
   const { hook, encryptionKey } = await getHookByTokenWithKey(token);
   if (hook.isWebhook === false) {
     throw new HookNotFoundError(token);
@@ -122041,7 +122801,7 @@ async function resumeWebhook(token, request) {
       status: 202
     });
   }
-  await resumeHookImpl(hook, request, encryptionKey, true);
+  await resumeHookImpl(hook, request, encryptionKey, true, resumeRequestedAtMs);
   if (responseReadable) {
     const reader = responseReadable.getReader();
     const chunk = await reader.read();
@@ -122429,7 +123189,8 @@ function createReconnectingFramedStream(runId, name, startIndex) {
       try {
         await connect2();
         return;
-      } catch {
+      } catch (error482) {
+        if (StreamExpiredError.is(error482)) throw error482;
       }
     }
   }
@@ -124268,7 +125029,7 @@ __name2(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.41//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.42//start");
 async function wakeUpRun(world, runId, options) {
   try {
     const run22 = await world.runs.get(runId, {
@@ -124613,7 +125374,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.41//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.42//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);
@@ -124622,7 +125383,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.41//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.42//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);
@@ -124631,7 +125392,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.41//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.42//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);
@@ -124640,7 +125401,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.41//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.42//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);
@@ -124649,7 +125410,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.41//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.42//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);
@@ -124658,7 +125419,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.41//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.42//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);
@@ -124667,7 +125428,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.41//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.42//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);
@@ -124676,7 +125437,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.41//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.42//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);
@@ -124685,7 +125446,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.41//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.42//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);
@@ -124694,7 +125455,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.41//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.42//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);
@@ -124704,7 +125465,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.41//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.42//Run");
 async function fetch2(...args) {
   return globalThis.fetch(...args);
 }
@@ -125535,6 +126296,7 @@ __name(guardDeploymentAffinity, "guardDeploymentAffinity");
 init_helpers3();
 init_replay_budget();
 init_replay_recovery_reporter();
+init_resume_latency();
 init_run_id_time();
 init_step_executor();
 init_step_latency();
@@ -125585,6 +126347,7 @@ init_step_single_flight();
 // ../core/dist/runtime/suspension-handler.js
 init_dist7();
 init_dist6();
+init_classify_error2();
 init_encryption4();
 init_logger2();
 init_serialization4();
@@ -125638,7 +126401,7 @@ async function createHookEvent({ runId, hookEvent, queueItem, requestId, createE
   }
 }
 __name(createHookEvent, "createHookEvent");
-async function handleSuspension({ suspension, world, run: run3, span, requestId, eventLog, runReadyBarrier, replayRecoveryReporter }) {
+async function handleSuspension({ suspension, world, run: run3, span, requestId, eventLog, runReadyBarrier, replayRecoveryReporter, stepDispatch }) {
   const runId = run3.runId;
   const ensureRunReady = /* @__PURE__ */ __name(async () => {
     if (runReadyBarrier) {
@@ -125664,25 +126427,23 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
     const log = eventLog;
     const result2 = await createEvent(data, {
       ...params,
-      ...preconditionSnapshotParams(log.events, log.cursor)
+      ...slotSnapshotParams(log.events)
     });
-    if (result2.events?.length && result2.hasMore !== true) {
-      const added = mergeReportedEvents(log.events, result2.events);
-      reportedEvents += added;
-      if (added > 0) {
-        runtimeLogger2.debug("Suspension write skipped occupied slots", {
-          workflowRunId: runId,
-          eventType: data.eventType,
-          eventId: result2.event?.eventId,
-          reported: added
-        });
-      }
-    } else if (result2.events?.length) {
+    const report = absorbSkippedSlotReport(log.events, result2);
+    reportedEvents += report.added;
+    if (report.truncated) {
       runtimeLogger2.debug("Dropped a truncated skipped-slot report", {
         workflowRunId: runId,
         eventType: data.eventType,
         eventId: result2.event?.eventId,
-        offered: result2.events.length
+        offered: report.offered
+      });
+    } else if (report.added > 0) {
+      runtimeLogger2.debug("Suspension write skipped occupied slots", {
+        workflowRunId: runId,
+        eventType: data.eventType,
+        eventId: result2.event?.eventId,
+        reported: report.added
       });
     }
     return result2;
@@ -125828,6 +126589,14 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
   const lazyInlineCorrelationIds = new Set(hasAwaitedHookCreation === false ? stepItems.filter((item) => stepsNeedingCreation.has(item.correlationId)).slice(0, getMaxInlineSteps()).map((item) => item.correlationId) : []);
   const lazyInlineByCorrelationId = /* @__PURE__ */ new Map();
   const ops = [];
+  const queuedStepCorrelationIds = /* @__PURE__ */ new Set();
+  const resilientDispatchEligible = stepDispatch !== void 0 && isResilientStepDispatchEnabled() && (run3.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT2;
+  let stepDispatchTraceCarrier;
+  const getStepDispatchTraceCarrier = /* @__PURE__ */ __name(() => {
+    stepDispatchTraceCarrier ??= stepDispatch?.getTraceCarrier() ?? Promise.resolve({});
+    return stepDispatchTraceCarrier;
+  }, "getStepDispatchTraceCarrier");
+  let resilientDispatchRecovered = 0;
   for (const queueItem of stepItems) {
     if (stepsNeedingCreation.has(queueItem.correlationId)) {
       ops.push((async () => {
@@ -125856,6 +126625,61 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
             input: dehydratedInput
           }
         };
+        if (resilientDispatchEligible && dehydratedInput instanceof Uint8Array && dehydratedInput.byteLength <= MAX_RESILIENT_STEP_INPUT_BYTES) {
+          await ensureRunReady();
+          const traceCarrier = await getStepDispatchTraceCarrier();
+          const [createResult, queueResult] = await Promise.allSettled([
+            createGuarded(stepEvent, { requestId }),
+            queueMessage(
+              world,
+              // biome-ignore lint/style/noNonNullAssertion: implied by resilientDispatchEligible
+              stepDispatch.queueName,
+              {
+                runId,
+                stepId: queueItem.correlationId,
+                stepName: queueItem.stepName,
+                traceCarrier,
+                requestedAt: /* @__PURE__ */ new Date(),
+                stepInput: { input: dehydratedInput }
+              },
+              // Same key as the caller's dispatch pass and any concurrent
+              // handler's — redundant publishes for this step dedupe. The
+              // key is step-identity-scoped so a revoked message for a
+              // reassigned correlation id cannot absorb the corrected
+              // schedule's dispatch — see stepDispatchIdempotencyKey.
+              {
+                idempotencyKey: stepDispatchIdempotencyKey(queueItem.correlationId, queueItem.stepName)
+              }
+            )
+          ]);
+          if (queueResult.status === "rejected") {
+            throw queueResult.reason;
+          }
+          queuedStepCorrelationIds.add(queueItem.correlationId);
+          if (createResult.status === "rejected") {
+            const err = createResult.reason;
+            if (EntityConflictError2.is(err)) {
+              runtimeLogger2.info("Step already exists, continuing", {
+                workflowRunId: runId,
+                correlationId: queueItem.correlationId,
+                message: err.message
+              });
+            } else if (isRetryableWorldError2(err)) {
+              resilientDispatchRecovered++;
+              runtimeLogger2.warn("Step creation event write failed, but the step was dispatched via the queue. The step_created event will be ensured by the queue consumer.", {
+                workflowRunId: runId,
+                correlationId: queueItem.correlationId,
+                stepName: queueItem.stepName,
+                error: err instanceof Error ? err.message : String(err)
+              });
+            } else {
+              throw err;
+            }
+          } else {
+            createdStepCorrelationIds.add(queueItem.correlationId);
+          }
+          return;
+        }
         try {
           await ensureRunReady();
           await createGuarded(stepEvent, { requestId });
@@ -125964,11 +126788,13 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
     ...WorkflowRunStatus2("workflow_suspended"),
     ...WorkflowStepsCreated2(stepItems.length),
     ...WorkflowHooksCreated2(hooksNeedingCreation.length),
-    ...WorkflowWaitsCreated2(waitItems.length)
+    ...WorkflowWaitsCreated2(waitItems.length),
+    ...resilientDispatchRecovered > 0 ? StepResilientDispatchRecovered2(resilientDispatchRecovered) : {}
   });
   return {
     pendingSteps: stepItems,
     createdStepCorrelationIds,
+    queuedStepCorrelationIds,
     lazyInlineSteps,
     // On hook conflict the caller re-invokes immediately and never reads
     // the wait timeout, so don't report one.
@@ -127373,6 +128199,20 @@ async function createWorkflowSession({ workflowCode: workflowCode2, workflowRun,
     onUnconsumedEvent: /* @__PURE__ */ __name((event) => {
       onWorkflowError(new ReplayDivergenceError(`Replay could not consume event: eventType=${event.eventType}, correlationId=${event.correlationId}, eventId=${event.eventId}.`, { eventId: event.eventId }));
     }, "onUnconsumedEvent"),
+    onDuplicateEvent: /* @__PURE__ */ __name((event, firstEventType) => {
+      const details = {
+        workflowRunId: workflowRun.runId,
+        eventId: event.eventId,
+        eventType: event.eventType,
+        firstEventType,
+        correlationId: event.correlationId
+      };
+      if (firstEventType !== event.eventType) {
+        runtimeLogger2.error("Ignoring event that decides an already-decided outcome differently", details);
+        return;
+      }
+      runtimeLogger2.info("Ignoring event that repeats a class already in the event log", details);
+    }, "onDuplicateEvent"),
     getPromiseQueue: /* @__PURE__ */ __name(() => promiseQueueHolder.current, "getPromiseQueue"),
     isDeliveryIdle: /* @__PURE__ */ __name(() => deliveryIdleHolder.current(), "isDeliveryIdle")
   });
@@ -127400,6 +128240,7 @@ async function createWorkflowSession({ workflowCode: workflowCode2, workflowRun,
     replayPayloadCache
   };
   deliveryIdleHolder.current = () => isDeliveryIdle(workflowContext);
+  let consumedRunStarted = false;
   workflowContext.eventsConsumer.subscribe((event) => {
     if (!event) {
       return EventConsumerResult2.NotConsumed;
@@ -127408,6 +128249,10 @@ async function createWorkflowSession({ workflowCode: workflowCode2, workflowRun,
       return EventConsumerResult2.Consumed;
     }
     if (event.eventType === "run_started") {
+      if (consumedRunStarted) {
+        return EventConsumerResult2.NotConsumed;
+      }
+      consumedRunStarted = true;
       return EventConsumerResult2.Consumed;
     }
     if (event.eventType === "attr_set" && event.eventData.writer.type === "step") {
@@ -128335,6 +129180,14 @@ function getWorkflowSetupErrorCode(err) {
   return null;
 }
 __name(getWorkflowSetupErrorCode, "getWorkflowSetupErrorCode");
+function isStepMissingError(err) {
+  if (!WorkflowWorldError2.is(err))
+    return false;
+  if (err.status !== void 0 && err.status !== 404)
+    return false;
+  return /step/i.test(err.message) && /not found/i.test(err.message);
+}
+__name(isStepMissingError, "isStepMissingError");
 async function recordFatalRunError({ world, workflowRun, runId, requestId, err, errorCode, logMessage }) {
   runtimeLogger2.error(logMessage, {
     workflowRunId: runId,
@@ -128468,12 +129321,20 @@ function workflowEntrypoint(workflowCode2, options) {
   const namespace = resolveQueueNamespace2(options?.namespace);
   const workflowPrefix = getQueueTopicPrefix2("workflow", namespace);
   const handler = /* @__PURE__ */ __name((worldHandlers) => worldHandlers.createQueueHandler(workflowPrefix, async (message_, metadata) => {
+    const handlerEnteredAtMs = Date.now();
     const healthCheck3 = parseHealthCheckPayload(message_);
     if (healthCheck3) {
       await handleHealthCheckMessage(healthCheck3, worldHandlers.specVersion);
       return;
     }
-    const { runId, traceCarrier: incomingTraceCarrier, requestedAt, stepId: incomingStepId, stepName: incomingStepName, replayDivergence, preconditionReinvocations, deploymentMismatchRetryCount, runInput, hookInput } = WorkflowInvokePayloadSchema2.parse(message_);
+    const { runId, traceCarrier: incomingTraceCarrier, requestedAt, stepId: incomingStepId, stepName: incomingStepName, replayDivergence, preconditionReinvocations, deploymentMismatchRetryCount, runInput, hookInput, stepInput, hookResumeTiming } = WorkflowInvokePayloadSchema2.parse(message_);
+    let resumeTracking = resumeTrackingFromMessage(hookResumeTiming, incomingStepId !== void 0 ? "dispatched" : "inline");
+    if (resumeTracking && incomingStepId === void 0) {
+      resumeTracking.consumerStartedAtMs = handlerEnteredAtMs;
+    }
+    if (resumeTracking && !Number.isFinite(resumeTracking.consumerStartedAtMs)) {
+      resumeTracking = void 0;
+    }
     const traceContext = isUsableTraceCarrier(incomingTraceCarrier) ? incomingTraceCarrier : void 0;
     const { requestId } = metadata;
     const workflowName = metadata.queueName.slice(workflowPrefix.length);
@@ -128553,12 +129414,14 @@ function workflowEntrypoint(workflowCode2, options) {
           const replayRecoveryReporter = replayDivergence ? new ReplayRecoveryReporter(replayDivergence.count) : ReplayRecoveryReporter.inert();
           const createEvent = /* @__PURE__ */ __name(async (data, params) => {
             const sinceCursor = deltaRequestCursor(data, params);
-            const result2 = await replayRecoveryReporter.withEventCreate(sinceCursor === void 0 ? params : { ...params, sinceCursor }, (p) => world.events.create(runId, data, p));
+            const withSnapshot = { ...slotSnapshot(), ...params };
+            const result2 = await replayRecoveryReporter.withEventCreate(sinceCursor === void 0 ? withSnapshot : { ...withSnapshot, sinceCursor }, (p) => world.events.create(runId, data, p));
             if (sinceCursor !== void 0) {
               absorbCreateDelta(sinceCursor, result2);
             }
             return result2;
           }, "createEvent");
+          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)) {
               return void 0;
@@ -128717,9 +129580,58 @@ function workflowEntrypoint(workflowCode2, options) {
           }, "guardDeployment");
           if (incomingStepId && incomingStepName) {
             try {
-              const bgRun = await world.runs.get(runId, {
-                resolveData: "none"
-              });
+              const ensureStepFromMessage = /* @__PURE__ */ __name(async () => {
+                if (!stepInput)
+                  return "ok";
+                try {
+                  await world.events.create(runId, {
+                    eventType: "step_created",
+                    specVersion: SPEC_VERSION_CURRENT2,
+                    correlationId: incomingStepId,
+                    eventData: {
+                      stepName: incomingStepName,
+                      workflowName,
+                      // Typed Uint8Array by StepDispatchInputSchema:
+                      // a non-binary (mangled) payload fails the
+                      // message parse above and never reaches this
+                      // write.
+                      input: stepInput.input
+                    }
+                  }, {
+                    requestId,
+                    // Marks this create as a dispatch re-ensure so
+                    // a guard-enforcing backend can refuse it when
+                    // the producer's write was 412-rejected (the
+                    // dispatch was revoked). Surfaces as
+                    // RunExpiredError → 'gone' below, acking the
+                    // message. Worlds without the guard ignore it.
+                    viaStepDispatch: true
+                  });
+                  span?.setAttributes(StepResilientDispatchMaterialized2(true));
+                  runtimeLogger2.warn("Materialized step_created from the queue message \u2014 the producer\u2019s direct write did not land", {
+                    workflowRunId: runId,
+                    stepId: incomingStepId,
+                    stepName: incomingStepName
+                  });
+                } catch (err) {
+                  if (EntityConflictError2.is(err))
+                    return "ok";
+                  if (RunExpiredError2.is(err))
+                    return "gone";
+                  throw err;
+                }
+                return "ok";
+              }, "ensureStepFromMessage");
+              const [bgRun, ensureOutcome] = await Promise.all([
+                world.runs.get(runId, {
+                  resolveData: "none"
+                }),
+                stepInput && metadata.attempt > 1 ? ensureStepFromMessage() : "ok"
+              ]);
+              if (ensureOutcome === "gone") {
+                runtimeLogger2.debug("Run already finished, skipping background step", { workflowRunId: runId });
+                return;
+              }
               if (bgRun.status !== "running") {
                 runtimeLogger2.debug("Run already finished, skipping background step", { workflowRunId: runId, status: bgRun.status });
                 return;
@@ -128727,7 +129639,11 @@ function workflowEntrypoint(workflowCode2, options) {
               if (await guardDeployment(bgRun, async () => ({
                 ...await replayMessage(),
                 stepId: incomingStepId,
-                stepName: incomingStepName
+                stepName: incomingStepName,
+                // Carry the resume timing verbatim so the re-routed
+                // hop stays inside `step_dispatch` rather than
+                // vanishing from the TTR decomposition.
+                ...hookResumeTiming ? { hookResumeTiming } : {}
               })) !== "continue") {
                 return;
               }
@@ -128738,10 +129654,12 @@ function workflowEntrypoint(workflowCode2, options) {
                 const loaded = await loadWorkflowRunEvents(runId);
                 bgAuthoritativeAttempt = countStepStartedEvents(loaded.events, incomingStepId, { type: "totalAttempts" }) + 1;
               }
+              const bgResumeTracking = resumeTracking;
+              resumeTracking = void 0;
               replayBudget.pause();
               let stepResult;
               try {
-                stepResult = await runStepSingleFlight(runId, incomingStepId, () => executeStep({
+                const executeQueuedStep = /* @__PURE__ */ __name(() => executeStep({
                   world,
                   workflowRunId: runId,
                   workflowDeploymentId: bgRun.deploymentId,
@@ -128754,8 +129672,22 @@ function workflowEntrypoint(workflowCode2, options) {
                   // Retry ceiling: the queue delivery count as a fast
                   // gate, verified against the recorded step_started
                   // count once it crosses the ceiling (see above).
-                  authoritativeAttempt: bgAuthoritativeAttempt
-                }));
+                  authoritativeAttempt: bgAuthoritativeAttempt,
+                  ...bgResumeTracking ? { resumeTracking: bgResumeTracking } : {}
+                }), "executeQueuedStep");
+                stepResult = await runStepSingleFlight(runId, incomingStepId, async () => {
+                  try {
+                    return await executeQueuedStep();
+                  } catch (err) {
+                    if (!stepInput || !isStepMissingError(err)) {
+                      throw err;
+                    }
+                    if (await ensureStepFromMessage() === "gone") {
+                      return { type: "gone" };
+                    }
+                    return await executeQueuedStep();
+                  }
+                });
               } finally {
                 replayBudget.resume();
               }
@@ -128863,7 +129795,12 @@ function workflowEntrypoint(workflowCode2, options) {
               });
               if (await guardDeployment(run3, async () => ({
                 ...await replayMessage(),
-                hookInput
+                hookInput,
+                // Forwarded UNMODIFIED — in particular without
+                // this delivery's entry time — so the misrouted
+                // hop is attributed to `queue_delivery` and T2
+                // ends up being the final consumer's entry.
+                ...hookResumeTiming ? { hookResumeTiming } : {}
               }), awaitRunReady) !== "continue") {
                 return;
               }
@@ -128915,6 +129852,9 @@ function workflowEntrypoint(workflowCode2, options) {
                 workflowRun = result2.run;
                 maxEventsLimit = clampMaxEvents(result2.maxEvents);
                 runStartedReceivedAtMs = Date.now();
+                if (resumeTracking) {
+                  resumeTracking.setupSource = "hook_preload";
+                }
                 eventLog = {
                   type: "ready",
                   events: result2.events,
@@ -129028,6 +129968,9 @@ function workflowEntrypoint(workflowCode2, options) {
                 workflowRun = result2.run;
                 maxEventsLimit = clampMaxEvents(result2.maxEvents);
                 runStartedReceivedAtMs = Date.now();
+                if (resumeTracking) {
+                  resumeTracking.setupSource = "run_started";
+                }
                 if (result2.events?.length) {
                   const loaded = {
                     events: [...result2.events],
@@ -129071,9 +130014,15 @@ function workflowEntrypoint(workflowCode2, options) {
             }
           }
           assert5(workflowRun, "Workflow run must be loaded before replay");
+          if (resumeTracking && resumeTracking.setupSource === void 0) {
+            resumeTracking.setupSource = "event_load";
+          }
           if (await guardDeployment(workflowRun, async () => ({
             ...await replayMessage(),
-            ...hookInput ? { hookInput } : {}
+            ...hookInput ? { hookInput } : {},
+            // See the pre-check re-route above: forwarded as
+            // received, so the extra hop is queue delivery.
+            ...hookResumeTiming ? { hookResumeTiming } : {}
           }), awaitRunReady) !== "continue") {
             return;
           }
@@ -129137,7 +130086,8 @@ function workflowEntrypoint(workflowCode2, options) {
                 workflowName,
                 requestId,
                 attempt: metadata.attempt,
-                limitMs: replayBudget.configuredLimitMs
+                limitMs: replayBudget.configuredLimitMs,
+                slotSnapshot: slotSnapshot()
               });
               return;
             }
@@ -129221,12 +130171,9 @@ function workflowEntrypoint(workflowCode2, options) {
               for (const waitEvent of waitsToComplete) {
                 try {
                   const created = await createEvent(waitEvent, {
-                    requestId,
-                    ...preconditionSnapshotParams(eventLog.events, eventLog.cursor)
+                    requestId
                   });
-                  if (created.events?.length && created.hasMore !== true) {
-                    mergeReportedEvents(eventLog.events, created.events);
-                  }
+                  absorbSkippedSlotReport(eventLog.events, created);
                 } catch (err) {
                   if (EntityConflictError2.is(err)) {
                     runtimeLogger2.info("Wait already completed, skipping", {
@@ -129285,6 +130232,9 @@ function workflowEntrypoint(workflowCode2, options) {
                 executionMode: retainedSession ? "retained" : "replay"
               });
               replayStart = Date.now();
+              if (resumeTracking) {
+                resumeTracking.replayStartedAtMs ??= replayStart;
+              }
               const payloadPrewarm = replayPayloadCache.prewarm(workflowRun, eventLog.events);
               let workflowResult = retainedSession ? await resumeWorkflow(retainedSession, eventLog.events) : { type: "replay" };
               if (workflowResult.type === "replay") {
@@ -129321,10 +130271,7 @@ function workflowEntrypoint(workflowCode2, options) {
                   eventType: "run_completed",
                   specVersion: SPEC_VERSION_CURRENT2,
                   eventData: { output: result2 }
-                }, {
-                  requestId,
-                  ...preconditionSnapshotParams(eventLog.events, eventLog.cursor)
-                });
+                }, { requestId });
               } catch (err) {
                 if (EntityConflictError2.is(err) || RunExpiredError2.is(err)) {
                   runtimeLogger2.info("Tried completing workflow run, but run has already finished.", { workflowRunId: runId, message: err.message });
@@ -129339,7 +130286,11 @@ function workflowEntrypoint(workflowCode2, options) {
             } catch (err) {
               if (WorkflowSuspension2.is(err)) {
                 replayRecoveryReporter.activate();
-                const replayDurationMs = Date.now() - replayStart;
+                const suspendedAtMs = Date.now();
+                const replayDurationMs = suspendedAtMs - replayStart;
+                if (resumeTracking && err.stepCount > 0) {
+                  resumeTracking.nextStepEncounteredAtMs ??= suspendedAtMs;
+                }
                 runtimeLogger2.debug("Workflow suspended", {
                   workflowRunId: runId,
                   loopIteration,
@@ -129364,7 +130315,17 @@ function workflowEntrypoint(workflowCode2, options) {
                     requestId,
                     eventLog,
                     runReadyBarrier,
-                    replayRecoveryReporter
+                    replayRecoveryReporter,
+                    // Resilient step dispatch: lets eligible newly
+                    // created steps publish their step-execution
+                    // message (carrying `stepInput`) in parallel with
+                    // the step_created write. Steps queued there are
+                    // reported back in `queuedStepCorrelationIds` and
+                    // skipped by the dispatch pass below.
+                    stepDispatch: {
+                      queueName: getWorkflowQueueName2(workflowName, namespace),
+                      getTraceCarrier: nextTraceCarrier
+                    }
                   });
                 } catch (suspensionError) {
                   if (PreconditionFailedError.is(suspensionError)) {
@@ -129454,10 +130415,14 @@ function workflowEntrypoint(workflowCode2, options) {
                 const dispatchNowMs = Date.now();
                 const ownedRecoverySteps = [];
                 let backstopWakesArmed = 0;
+                let handOffResumeTiming = resumeTracking !== void 0 && lazyInlineSteps.length === 0 && !pendingSteps.some((step) => !inlineCorrelationIds.has(step.correlationId) && inlineOwnership && isStepOwnershipActive(step) && step.ownerMessageId === metadata.messageId);
                 for (const step of pendingSteps) {
                   if (inlineCorrelationIds.has(step.correlationId)) {
                     continue;
                   }
+                  if (suspensionResult.queuedStepCorrelationIds.has(step.correlationId)) {
+                    continue;
+                  }
                   const ownershipActive = inlineOwnership && isStepOwnershipActive(step);
                   if (ownershipActive && step.ownerMessageId === metadata.messageId) {
                     ownedRecoverySteps.push(step);
@@ -129482,14 +130447,27 @@ function workflowEntrypoint(workflowCode2, options) {
                     }));
                     continue;
                   }
+                  const stepResumeTiming = handOffResumeTiming ? resumeTimingForMessage(resumeTracking) : void 0;
+                  if (stepResumeTiming) {
+                    handOffResumeTiming = false;
+                    resumeTracking = void 0;
+                  }
                   dispatches.push(queueMessage(world, getWorkflowQueueName2(workflowName, namespace), {
                     runId,
                     stepId: step.correlationId,
                     stepName: step.stepName,
                     traceCarrier,
-                    requestedAt: /* @__PURE__ */ new Date()
+                    requestedAt: /* @__PURE__ */ new Date(),
+                    ...stepResumeTiming ? { hookResumeTiming: stepResumeTiming } : {}
                   }, {
-                    idempotencyKey: step.correlationId
+                    // Step-identity-scoped: dedupes against every
+                    // other dispatch of THIS step (concurrent
+                    // handlers, crash-recovery re-dispatch, the
+                    // suspension handler's resilient publish)
+                    // without absorbing a dispatch of a different
+                    // step under a reassigned correlation id —
+                    // see stepDispatchIdempotencyKey.
+                    idempotencyKey: stepDispatchIdempotencyKey(step.correlationId, step.stepName)
                   }));
                 }
                 if (suspensionResult.waitTimeout) {
@@ -129530,9 +130508,8 @@ function workflowEntrypoint(workflowCode2, options) {
                   return;
                 }
                 const openHookWaitState = openHookWait.value;
-                const guardEnforced = isPreconditionGuardEnabled() && world.capabilities?.preconditionGuard === true;
-                const requestInlineDelta = typeof eventLog.cursor === "string" && err.stepCount === 1 && err.waitCount === 0 && pendingSteps.length === 1 && lazyInlineSteps.length === 1 && ownedRecoverySteps.length === 0 && !suspensionResult.waitTimeout && !openHookWaitState.openWait && (guardEnforced || err.hookCount === 0 && !openHookWaitState.openHook);
-                const suppressOptimisticStart = guardEnforced && (openHookWaitState.openHook || err.hookCount > 0 || suspensionResult.hasHookEvents);
+                const requestInlineDelta = typeof eventLog.cursor === "string" && err.stepCount === 1 && err.waitCount === 0 && pendingSteps.length === 1 && lazyInlineSteps.length === 1 && ownedRecoverySteps.length === 0 && !suspensionResult.waitTimeout && !openHookWaitState.openWait;
+                const suppressOptimisticStart = openHookWaitState.openHook || err.hookCount > 0 || suspensionResult.hasHookEvents;
                 const forceOptimisticStart = turbo && !suspensionResult.hasAttributeEvents && !suspensionResult.waitTimeout && !suspensionResult.hasHookEvents && !suspensionResult.hasAwaitedHookCreation && !openHookWaitState.openHook && !openHookWaitState.openWait;
                 const latencyTracking = computeStepLatencyTracking({
                   events: eventLog.events,
@@ -129548,7 +130525,9 @@ function workflowEntrypoint(workflowCode2, options) {
                   suspensionCreatedHooks: err.hookCount > 0 || suspensionResult.hasHookEvents,
                   turbo
                 });
-                const inlineClaimSnapshot = preconditionSnapshotParams(eventLog.events, eventLog.cursor);
+                const inlineClaimSnapshot = slotSnapshotParams(eventLog.events);
+                const batchResumeTracking = resumeTracking;
+                resumeTracking = void 0;
                 replayBudget.pause();
                 let stepResults;
                 const stepExecutionPromises = inlineExecutions.map((s, stepIndex) => {
@@ -129614,8 +130593,9 @@ function workflowEntrypoint(workflowCode2, options) {
                       // see suppressOptimisticStart above.
                       suppressOptimisticStart,
                       runReadyBarrier,
-                      preconditionSnapshot: inlineClaimSnapshot,
+                      slotSnapshot: inlineClaimSnapshot,
                       ...stepIndex === 0 && s.lazyStepInput !== void 0 && latencyTracking ? { latencyTracking } : {},
+                      ...batchResumeTracking ? { resumeTracking: batchResumeTracking } : {},
                       ...requestInlineDelta && eventLog.cursor ? {
                         inlineDeltaSinceCursor: eventLog.cursor
                       } : {},
@@ -129677,10 +130657,10 @@ function workflowEntrypoint(workflowCode2, options) {
                   }, {
                     delaySeconds,
                     // Key the delayed retry on the step's
-                    // correlationId so it dedupes against the
+                    // dispatch key so it dedupes against the
                     // keyed re-dispatch the suspension handler
-                    // performs on replay (it also uses
-                    // `idempotencyKey: step.correlationId`).
+                    // performs on replay (it uses the same
+                    // stepDispatchIdempotencyKey).
                     //
                     // Without this, a mixed batch where one step
                     // `completed` with unflushed background ops
@@ -129699,7 +130679,7 @@ function workflowEntrypoint(workflowCode2, options) {
                     // retry body could run early/concurrently.
                     // Sharing the key lets the earlier delayed
                     // message win, honoring the backoff.
-                    idempotencyKey: step.correlationId
+                    idempotencyKey: stepDispatchIdempotencyKey(step.correlationId, step.stepName)
                   })));
                 }
                 if (anyPendingOps) {
@@ -146406,6 +147386,19 @@ var RunInputSchema = external_exports.object({
    */
   environment: external_exports.string().optional()
 });
+var StepDispatchInputSchema = external_exports.object({
+  /**
+   * The serialized step input, reused verbatim from the direct write. Always
+   * binary: producers only attach \`stepInput\` when the dehydrated input is a
+   * \`Uint8Array\` and the run's queue transport preserves bytes (CBOR).
+   * Validated here so a malformed or transport-mangled payload fails the
+   * message parse instead of being silently written into a \`step_created\` as
+   * non-binary data. \`Buffer\` is a \`Uint8Array\` subclass and passes.
+   */
+  input: external_exports.custom((value) => value instanceof Uint8Array, {
+    message: "stepInput.input must be a Uint8Array"
+  })
+});
 var HookResumeInputSchema = external_exports.object({
   /** Stable idempotency key minted once per \`resumeHook()\` call. */
   resumeId: external_exports.string(),
@@ -146439,6 +147432,22 @@ var HookResumeInputSchema = external_exports.object({
    */
   deploymentId: external_exports.string().optional()
 });
+var HookResumeTimingSchema = external_exports.object({
+  /** Epoch ms at entry into \`resumeHook()\` \u2014 the start of the TTR window. */
+  resumeRequestedAtMs: external_exports.number(),
+  /** Epoch ms immediately before the queue publish was requested. */
+  queuePublishRequestedAtMs: external_exports.number(),
+  /** Which \`resumeHook()\` dispatch path ran: \`parallel\` or \`sequential\`. */
+  strategy: external_exports.string().optional(),
+  /** Epoch ms the final consumer's queue handler was entered. */
+  consumerStartedAtMs: external_exports.number().optional(),
+  /** Epoch ms this invocation's first replay pass began. */
+  replayStartedAtMs: external_exports.number().optional(),
+  /** Epoch ms replay first encountered a durable step after the resume. */
+  nextStepEncounteredAtMs: external_exports.number().optional(),
+  /** How the consumer initialized replay state: see \`ResumeSetupSource\`. */
+  setupSource: external_exports.string().optional()
+});
 var WorkflowInvokePayloadSchema = external_exports.object({
   runId: external_exports.string(),
   traceCarrier: TraceCarrierSchema.optional(),
@@ -146472,7 +147481,28 @@ var WorkflowInvokePayloadSchema = external_exports.object({
    * fast path. A consumer that understands this field idempotently ensures the
    * \`hook_received\` event exists (keyed by \`resumeId\`) before replaying.
    */
-  hookInput: HookResumeInputSchema.optional()
+  hookInput: HookResumeInputSchema.optional(),
+  /**
+   * Resilient step dispatch data, only present alongside \`stepId\` when the
+   * producer parallelized the \`step_created\` write with this queue publish. A
+   * consumer that understands this field idempotently ensures the
+   * \`step_created\` event exists (keyed by \`stepId\`) before executing the step.
+   */
+  stepInput: StepDispatchInputSchema.optional(),
+  /**
+   * Hook-resume TTR timing. Present on both \`resumeHook()\` dispatch paths
+   * (unlike \`hookInput\`, which only rides the parallel fast path), and
+   * forwarded onto a dispatched step message when the resuming invocation
+   * hands the next durable step to another invocation. Purely observational \u2014
+   * see {@link HookResumeTimingSchema}.
+   *
+   * \`.catch(undefined)\` because this field must never be able to fail the
+   * parse of the invocation payload: a malformed value (a NaN boundary, a
+   * shape change from a future producer) would otherwise throw on every
+   * delivery of that message and burn the run's delivery budget over a
+   * telemetry field. Anything unparseable degrades to "no measurement".
+   */
+  hookResumeTiming: HookResumeTimingSchema.optional().catch(void 0)
 });
 var HealthCheckPayloadSchema = external_exports.object({
   __healthCheck: external_exports.literal(true),
@@ -146630,10 +147660,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.41//Run#wakeUp");
-Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.41//Run#cancel");
-Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.41//Run#getReadable");
-var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.41//Run#exists");
+Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.42//Run#wakeUp");
+Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.42//Run#cancel");
+Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.42//Run#getReadable");
+var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.42//Run#exists");
 Object.defineProperty(Run.prototype, "exists", {
   get() {
     return __step_Run$exists.call(this);
@@ -146641,7 +147671,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.41//Run#status");
+var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.42//Run#status");
 Object.defineProperty(Run.prototype, "status", {
   get() {
     return __step_Run$status.call(this);
@@ -146649,7 +147679,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.41//Run#returnValue");
+var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.42//Run#returnValue");
 Object.defineProperty(Run.prototype, "returnValue", {
   get() {
     return __step_Run$returnValue.call(this);
@@ -146657,7 +147687,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.41//Run#workflowName");
+var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.42//Run#workflowName");
 Object.defineProperty(Run.prototype, "workflowName", {
   get() {
     return __step_Run$workflowName.call(this);
@@ -146665,7 +147695,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.41//Run#createdAt");
+var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.42//Run#createdAt");
 Object.defineProperty(Run.prototype, "createdAt", {
   get() {
     return __step_Run$createdAt.call(this);
@@ -146673,7 +147703,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.41//Run#startedAt");
+var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.42//Run#startedAt");
 Object.defineProperty(Run.prototype, "startedAt", {
   get() {
     return __step_Run$startedAt.call(this);
@@ -146681,7 +147711,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.41//Run#completedAt");
+var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.42//Run#completedAt");
 Object.defineProperty(Run.prototype, "completedAt", {
   get() {
     return __step_Run$completedAt.call(this);
@@ -146698,7 +147728,7 @@ Object.defineProperty(Run.prototype, "completedAt", {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.41//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.42//Run");
 
 // ../core/dist/workflow/create-hook.js
 aliasSerializationClass(RUN_CLASS_ID, Run);
@@ -146861,7 +147891,7 @@ hookWorkflow.workflowId = "workflow//./workflows/inline-execution//hookWorkflow"
 globalThis.__private_workflows.set("workflow//./workflows/inline-execution//hookWorkflow", hookWorkflow);
 
 // ../core/dist/runtime/start.js
-var start = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/start@5.0.0-beta.41//start");
+var start = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/start@5.0.0-beta.42//start");
 
 // workflows/lineage.ts
 var noop = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//./workflows/lineage//noop");