@workflow/world-testing 5.0.0-beta.34 → 5.0.0-beta.36

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

@@ -14879,12 +14879,14 @@ function applyAttributeChanges(existing, changes) {
   }
   return next2;
 }
-var RESERVED_ATTRIBUTE_KEY_PREFIX2, ATTRIBUTE_KEY_MAX_LENGTH2, ATTRIBUTE_VALUE_MAX_BYTES2, ATTRIBUTE_MAX_PER_RUN2, AttributeChangeSchema2, AttributeChangesSchema2, AttributeValidationError2, valueByteLength2;
+var RESERVED_ATTRIBUTE_KEY_PREFIX2, ROOT_RUN_ID_ATTRIBUTE2, PARENT_RUN_ID_ATTRIBUTE2, ATTRIBUTE_KEY_MAX_LENGTH2, ATTRIBUTE_VALUE_MAX_BYTES2, ATTRIBUTE_MAX_PER_RUN2, AttributeChangeSchema2, AttributeChangesSchema2, AttributeValidationError2, valueByteLength2;
 var init_attributes2 = __esm({
   "../world/dist/attributes.js"() {
     "use strict";
     init_zod2();
     RESERVED_ATTRIBUTE_KEY_PREFIX2 = "$";
+    ROOT_RUN_ID_ATTRIBUTE2 = `${RESERVED_ATTRIBUTE_KEY_PREFIX2}rootRunId`;
+    PARENT_RUN_ID_ATTRIBUTE2 = `${RESERVED_ATTRIBUTE_KEY_PREFIX2}parentRunId`;
     ATTRIBUTE_KEY_MAX_LENGTH2 = 256;
     ATTRIBUTE_VALUE_MAX_BYTES2 = 256;
     ATTRIBUTE_MAX_PER_RUN2 = 64;
@@ -15110,6 +15112,17 @@ var init_events2 = __esm({
       // stso.
       stepCount: external_exports2.number().int().positive().optional(),
       eventCount: external_exports2.number().int().positive().optional(),
+      // Run-started-to-first-step: milliseconds from the `run_started` response
+      // landing (or, under turbo, the local run synthesis instant) until this
+      // step's start POST was issued. A sub-window of ttfs. Only reported
+      // alongside the same eligibility as ttfs.
+      rsfs: external_exports2.number().optional(),
+      // Synchronous workflow-function replay duration of only the FINAL replay
+      // pass within the rsfs window (the pass that scheduled the first step),
+      // excluding awaited network I/O — not accumulated across earlier
+      // pre-first-step passes, so it is not "the replay portion of rsfs". Only
+      // present alongside rsfs, and only for the run's first step.
+      finalSchedulingReplay: external_exports2.number().optional(),
       // Names of the runtime's optional startup-latency optimizations that were
       // active for this measurement (e.g. 'turbo', 'lazyStepStart',
       // 'optimisticStart'), so latency metrics can be segmented by them.
@@ -15191,6 +15204,7 @@ var init_events2 = __esm({
       correlationId: external_exports2.string(),
       eventData: external_exports2.object({
         token: external_exports2.string(),
+        tokenRetentionUntil: external_exports2.coerce.date().optional(),
         metadata: SerializedDataSchema2.optional(),
         isWebhook: external_exports2.boolean().optional(),
         isSystem: external_exports2.boolean().optional()
@@ -15362,7 +15376,7 @@ var init_events2 = __esm({
 });
 
 // ../world/dist/runs.js
-function isTerminalWorkflowRunStatus(status) {
+function isTerminalWorkflowRunStatus2(status) {
   return TERMINAL_WORKFLOW_RUN_STATUSES2.includes(status);
 }
 var WorkflowRunStatusSchema2, TerminalWorkflowRunStatusSchema2, TERMINAL_WORKFLOW_RUN_STATUSES2, WorkflowRunBaseSchema2, WorkflowRunSchema2;
@@ -15384,7 +15398,7 @@ var init_runs2 = __esm({
       "cancelled"
     ]);
     TERMINAL_WORKFLOW_RUN_STATUSES2 = TerminalWorkflowRunStatusSchema2.options;
-    __name(isTerminalWorkflowRunStatus, "isTerminalWorkflowRunStatus");
+    __name(isTerminalWorkflowRunStatus2, "isTerminalWorkflowRunStatus");
     WorkflowRunBaseSchema2 = external_exports2.object({
       runId: external_exports2.string(),
       status: WorkflowRunStatusSchema2,
@@ -16208,10 +16222,12 @@ __export(dist_exports, {
   HookSchema: () => HookSchema2,
   LegacySerializedDataSchemaV1: () => LegacySerializedDataSchemaV12,
   MessageId: () => MessageId2,
+  PARENT_RUN_ID_ATTRIBUTE: () => PARENT_RUN_ID_ATTRIBUTE2,
   PaginatedResponseSchema: () => PaginatedResponseSchema,
   QueuePayloadSchema: () => QueuePayloadSchema2,
   QueuePrefix: () => QueuePrefix2,
   RESERVED_ATTRIBUTE_KEY_PREFIX: () => RESERVED_ATTRIBUTE_KEY_PREFIX2,
+  ROOT_RUN_ID_ATTRIBUTE: () => ROOT_RUN_ID_ATTRIBUTE2,
   RUN_EVENT_TYPES: () => RUN_EVENT_TYPES2,
   RunInputSchema: () => RunInputSchema2,
   SPEC_VERSION_CURRENT: () => SPEC_VERSION_CURRENT2,
@@ -16258,7 +16274,7 @@ __export(dist_exports, {
   isTerminalRunEventType: () => isTerminalRunEventType,
   isTerminalStepEventType: () => isTerminalStepEventType,
   isTerminalStepStatus: () => isTerminalStepStatus,
-  isTerminalWorkflowRunStatus: () => isTerminalWorkflowRunStatus,
+  isTerminalWorkflowRunStatus: () => isTerminalWorkflowRunStatus2,
   isWaitEventType: () => isWaitEventType,
   parseQueueName: () => parseQueueName,
   reenqueueActiveRuns: () => reenqueueActiveRuns,
@@ -16646,6 +16662,8 @@ var init_error_codes2 = __esm({
       REPLAY_DIVERGENCE: "REPLAY_DIVERGENCE",
       /** Run exceeded the maximum number of queue deliveries */
       MAX_DELIVERIES_EXCEEDED: "MAX_DELIVERIES_EXCEEDED",
+      /** Run exceeded the maximum number of events per run */
+      MAX_EVENTS_EXCEEDED: "MAX_EVENTS_EXCEEDED",
       /** Workflow replay exceeded the maximum allowed duration */
       REPLAY_TIMEOUT: "REPLAY_TIMEOUT",
       /** World response violated the SDK contract and cannot be retried safely */
@@ -16679,7 +16697,7 @@ function buildFramedDetails2(hint3, slug) {
     out.push({ label: "docs", value: `${BASE_URL2}/${slug}` });
   return out;
 }
-var BASE_URL2, ERROR_SLUGS2, WorkflowError2, WorkflowWorldError2, WorkflowRunFailedError2, WorkflowRunNotCompletedError2, WorkflowRuntimeError2, CorruptedEventLogError, ReplayDivergenceError, RuntimeDecryptionError2, SerializationError2, StepNotRegisteredError2, WorkflowNotRegisteredError2, WorkflowRunNotFoundError2, HookConflictError2, HookNotFoundError2, EntityConflictError2, RunExpiredError, TooEarlyError, ThrottleError2, WorkflowRunCancelledError2, RunNotSupportedError, FatalError2, RetryableError2, FATAL_ERROR_KEY2, RETRYABLE_ERROR_KEY2, HOOK_CONFLICT_ERROR_KEY2, RUNTIME_DECRYPTION_ERROR_KEY2;
+var BASE_URL2, ERROR_SLUGS2, WorkflowError2, WorkflowWorldError2, WorkflowRunFailedError2, WorkflowRunNotCompletedError2, WorkflowRuntimeError2, CorruptedEventLogError, ReplayDivergenceError, MaxEventsExceededError, RuntimeDecryptionError2, SerializationError2, StepNotRegisteredError2, WorkflowNotRegisteredError2, WorkflowRunNotFoundError2, HookConflictError2, HookNotFoundError2, EntityConflictError2, RunExpiredError, 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";
@@ -16834,6 +16852,22 @@ Caused by: ${options.cause.stack}`;
         return isError2(value) && value.name === "ReplayDivergenceError" && typeof value.eventId === "string";
       }
     };
+    MaxEventsExceededError = class extends WorkflowError2 {
+      static {
+        __name(this, "MaxEventsExceededError");
+      }
+      eventCount;
+      limit;
+      constructor(eventCount, limit, options) {
+        super(`Workflow exceeded the maximum of ${limit} events per run`, options);
+        this.name = "MaxEventsExceededError";
+        this.eventCount = eventCount;
+        this.limit = limit;
+      }
+      static is(value) {
+        return isError2(value) && value.name === "MaxEventsExceededError";
+      }
+    };
     RuntimeDecryptionError2 = class extends WorkflowRuntimeError2 {
       static {
         __name(this, "RuntimeDecryptionError");
@@ -17004,6 +17038,18 @@ Caused by: ${options.cause.stack}`;
         return isError2(value) && value.name === "ThrottleError";
       }
     };
+    PreconditionFailedError = class extends WorkflowWorldError2 {
+      static {
+        __name(this, "PreconditionFailedError");
+      }
+      constructor(message, options) {
+        super(message, { status: 412, retryAfter: options?.retryAfter });
+        this.name = "PreconditionFailedError";
+      }
+      static is(value) {
+        return isError2(value) && value.name === "PreconditionFailedError";
+      }
+    };
     WorkflowRunCancelledError2 = class extends WorkflowError2 {
       static {
         __name(this, "WorkflowRunCancelledError");
@@ -20055,9 +20101,9 @@ var require_util = __commonJS({
         yield* this[kBody];
       }
     };
-    function noop2() {
+    function noop3() {
     }
-    __name(noop2, "noop");
+    __name(noop3, "noop");
     function wrapRequestBody(body) {
       if (isStream(body)) {
         if (bodyLength(body) === 0) {
@@ -20760,7 +20806,7 @@ var require_util = __commonJS({
     __name(errorRequest, "errorRequest");
     var setupConnectTimeout = process.platform === "win32" ? (socketWeakRef, opts) => {
       if (!opts.timeout) {
-        return noop2;
+        return noop3;
       }
       let s1 = null;
       let s2 = null;
@@ -20776,7 +20822,7 @@ var require_util = __commonJS({
       };
     } : (socketWeakRef, opts) => {
       if (!opts.timeout) {
-        return noop2;
+        return noop3;
       }
       let s1 = null;
       const fastTimer = timers.setFastTimeout(() => {
@@ -25496,13 +25542,13 @@ var require_body = __commonJS({
     var { runtimeFeatures } = require_runtime_features();
     var random = runtimeFeatures.has("crypto") ? __require("node:crypto").randomInt : (max) => Math.floor(Math.random() * max);
     var textEncoder = new TextEncoder();
-    function noop2() {
+    function noop3() {
     }
-    __name(noop2, "noop");
+    __name(noop3, "noop");
     var streamRegistry = new FinalizationRegistry((weakRef) => {
       const stream = weakRef.deref();
       if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) {
-        stream.cancel("Response object has been garbage collected").catch(noop2);
+        stream.cancel("Response object has been garbage collected").catch(noop3);
       }
     });
     function extractBody(object3, keepalive = false) {
@@ -27867,7 +27913,7 @@ var require_client = __commonJS({
     var getDefaultNodeMaxHeaderSize = http && http.maxHeaderSize && Number.isInteger(http.maxHeaderSize) && http.maxHeaderSize > 0 ? () => http.maxHeaderSize : () => {
       throw new InvalidArgumentError("http module not available or http.maxHeaderSize invalid");
     };
-    var noop2 = /* @__PURE__ */ __name(() => {
+    var noop3 = /* @__PURE__ */ __name(() => {
     }, "noop");
     function getPipelining(client) {
       return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1;
@@ -28174,7 +28220,7 @@ var require_client = __commonJS({
             return;
           }
           if (client.destroyed) {
-            util.destroy(socket.on("error", noop2), new ClientDestroyedError());
+            util.destroy(socket.on("error", noop3), new ClientDestroyedError());
             client[kResume]();
             return;
           }
@@ -28182,7 +28228,7 @@ var require_client = __commonJS({
           try {
             client[kHTTPContext] = socket.alpnProtocol === "h2" ? connectH2(client, socket) : connectH1(client, socket);
           } catch (err2) {
-            socket.destroy().on("error", noop2);
+            socket.destroy().on("error", noop3);
             handleConnectError(client, err2, { host, hostname: hostname5, protocol, port });
             client[kResume]();
             return;
@@ -29846,7 +29892,7 @@ var require_proxy_agent = __commonJS({
       return new Pool(origin, opts);
     }
     __name(defaultFactory, "defaultFactory");
-    var noop2 = /* @__PURE__ */ __name(() => {
+    var noop3 = /* @__PURE__ */ __name(() => {
     }, "noop");
     function defaultAgentFactory(origin, opts) {
       if (opts.connections === 1) {
@@ -29990,7 +30036,7 @@ var require_proxy_agent = __commonJS({
               };
               const { socket, statusCode } = await this[kClient].connect(connectParams);
               if (statusCode !== 200) {
-                socket.on("error", noop2).destroy();
+                socket.on("error", noop3).destroy();
                 callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`));
                 return;
               }
@@ -30628,7 +30674,7 @@ var require_readable = __commonJS({
     var kContentLength = /* @__PURE__ */ Symbol("kContentLength");
     var kUsed = /* @__PURE__ */ Symbol("kUsed");
     var kBytesRead = /* @__PURE__ */ Symbol("kBytesRead");
-    var noop2 = /* @__PURE__ */ __name(() => {
+    var noop3 = /* @__PURE__ */ __name(() => {
     }, "noop");
     var BodyReadable = class extends Readable {
       static {
@@ -30856,7 +30902,7 @@ var require_readable = __commonJS({
           } else {
             this.on("close", resolve2);
           }
-          this.on("error", noop2).on("data", () => {
+          this.on("error", noop3).on("data", () => {
             if (this[kBytesRead] > limit) {
               this.destroy();
             }
@@ -31034,9 +31080,9 @@ var require_api_request = __commonJS({
     var { Readable } = require_readable();
     var { InvalidArgumentError, RequestAbortedError } = require_errors();
     var util = require_util();
-    function noop2() {
+    function noop3() {
     }
-    __name(noop2, "noop");
+    __name(noop3, "noop");
     var RequestHandler = class extends AsyncResource {
       static {
         __name(this, "RequestHandler");
@@ -31065,7 +31111,7 @@ var require_api_request = __commonJS({
           super("UNDICI_REQUEST");
         } catch (err) {
           if (util.isStream(body)) {
-            util.destroy(body.on("error", noop2), err);
+            util.destroy(body.on("error", noop3), err);
           }
           throw err;
         }
@@ -31088,7 +31134,7 @@ var require_api_request = __commonJS({
           this.removeAbortListener = util.addAbortListener(signal, () => {
             this.reason = signal.reason ?? new RequestAbortedError();
             if (this.res) {
-              util.destroy(this.res.on("error", noop2), this.reason);
+              util.destroy(this.res.on("error", noop3), this.reason);
             } else if (this.abort) {
               this.abort(this.reason);
             }
@@ -31142,7 +31188,7 @@ var require_api_request = __commonJS({
             });
           } catch (err) {
             this.res = null;
-            util.destroy(res.on("error", noop2), err);
+            util.destroy(res.on("error", noop3), err);
             queueMicrotask(() => {
               throw err;
             });
@@ -31167,13 +31213,13 @@ var require_api_request = __commonJS({
         if (res) {
           this.res = null;
           queueMicrotask(() => {
-            util.destroy(res.on("error", noop2), err);
+            util.destroy(res.on("error", noop3), err);
           });
         }
         if (body) {
           this.body = null;
           if (util.isStream(body)) {
-            body.on("error", noop2);
+            body.on("error", noop3);
             util.destroy(body, err);
           }
         }
@@ -31273,9 +31319,9 @@ var require_api_stream = __commonJS({
     var { InvalidArgumentError, InvalidReturnValueError } = require_errors();
     var util = require_util();
     var { addSignal, removeSignal } = require_abort_signal();
-    function noop2() {
+    function noop3() {
     }
-    __name(noop2, "noop");
+    __name(noop3, "noop");
     var StreamHandler = class extends AsyncResource {
       static {
         __name(this, "StreamHandler");
@@ -31304,7 +31350,7 @@ var require_api_stream = __commonJS({
           super("UNDICI_STREAM");
         } catch (err) {
           if (util.isStream(body)) {
-            util.destroy(body.on("error", noop2), err);
+            util.destroy(body.on("error", noop3), err);
           }
           throw err;
         }
@@ -31447,9 +31493,9 @@ var require_api_pipeline = __commonJS({
     } = require_errors();
     var util = require_util();
     var { addSignal, removeSignal } = require_abort_signal();
-    function noop2() {
+    function noop3() {
     }
-    __name(noop2, "noop");
+    __name(noop3, "noop");
     var kResume = /* @__PURE__ */ Symbol("resume");
     var PipelineRequest = class extends Readable {
       static {
@@ -31517,7 +31563,7 @@ var require_api_pipeline = __commonJS({
         this.abort = null;
         this.context = null;
         this.onInfo = onInfo || null;
-        this.req = new PipelineRequest().on("error", noop2);
+        this.req = new PipelineRequest().on("error", noop3);
         this.ret = new Duplex({
           readableObjectMode: opts.objectMode,
           autoDestroy: true,
@@ -31588,7 +31634,7 @@ var require_api_pipeline = __commonJS({
             context: context2
           });
         } catch (err) {
-          this.res.on("error", noop2);
+          this.res.on("error", noop3);
           throw err;
         }
         if (!body || typeof body.on !== "function") {
@@ -33943,7 +33989,7 @@ var require_redirect_handler = __commonJS({
     var EE = __require("node:events");
     var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
     var kBody = /* @__PURE__ */ Symbol("body");
-    var noop2 = /* @__PURE__ */ __name(() => {
+    var noop3 = /* @__PURE__ */ __name(() => {
     }, "noop");
     var BodyAsyncIterable = class {
       static {
@@ -34012,14 +34058,14 @@ var require_redirect_handler = __commonJS({
         if ((statusCode === 301 || statusCode === 302) && this.opts.method === "POST") {
           this.opts.method = "GET";
           if (util.isStream(this.opts.body)) {
-            util.destroy(this.opts.body.on("error", noop2));
+            util.destroy(this.opts.body.on("error", noop3));
           }
           this.opts.body = null;
         }
         if (statusCode === 303 && this.opts.method !== "HEAD") {
           this.opts.method = "GET";
           if (util.isStream(this.opts.body)) {
-            util.destroy(this.opts.body.on("error", noop2));
+            util.destroy(this.opts.body.on("error", noop3));
           }
           this.opts.body = null;
         }
@@ -35569,9 +35615,9 @@ var require_cache_handler = __commonJS({
       isEtagUsable
     } = require_cache2();
     var { parseHttpDate } = require_date();
-    function noop2() {
+    function noop3() {
     }
-    __name(noop2, "noop");
+    __name(noop3, "noop");
     var HEURISTICALLY_CACHEABLE_STATUS_CODES = [
       200,
       203,
@@ -35654,7 +35700,7 @@ var require_cache_handler = __commonJS({
         const handler = this;
         if (!util.safeHTTPMethods.includes(this.#cacheKey.method) && statusCode >= 200 && statusCode <= 399) {
           try {
-            this.#store.delete(this.#cacheKey)?.catch?.(noop2);
+            this.#store.delete(this.#cacheKey)?.catch?.(noop3);
           } catch {
           }
           return downstreamOnHeaders();
@@ -45121,7 +45167,7 @@ var init_log_format2 = __esm({
 function SemanticConvention3(...names) {
   return (value) => Object.fromEntries(names.map((name) => [name, value]));
 }
-var WorkflowName2, WorkflowOperation2, WorkflowRunId3, WorkflowRunStatus2, WorkflowStartedAt2, WorkflowEventsCount2, WorkflowArgumentsCount2, WorkflowResultType2, WorkflowTracePropagated2, WorkflowTraceMode2, WorkflowTurbo2, WorkflowErrorName2, WorkflowErrorMessage2, WorkflowErrorCode2, WorkflowStepsCreated2, WorkflowHooksCreated2, WorkflowWaitsCreated2, WorkflowOwnedRecoverySteps2, WorkflowBackstopWakesArmed2, WorkflowRouteType2, WorkflowRouteHandlerCached2, WorkflowRouteInvocationCount2, WorkflowRouteEntrypointAgeMs2, WorkflowRouteModuleBodyInitMs2, StepName2, StepId3, StepAttempt2, StepStatus2, StepMaxRetries2, StepTracePropagated2, StepTtfsMs2, StepStsoMs2, StepLatencyOptimizations2, StepSkipped2, StepSkipReason2, StepArgumentsCount2, StepResultType2, StepErrorName2, StepErrorMessage2, StepFatalError2, StepRetryExhausted2, StepRetryTimeoutSeconds2, StepRetryWillRetry2, MessagingSystem2, MessagingDestinationName2, MessagingMessageId2, MessagingOperationType2, QueueOverheadMs2, DeploymentId2, HookToken2, HookId2, HookFound2, WebhookHandlersTriggered2, WorkflowSuspensionState2, WorkflowSuspensionHookCount2, WorkflowSuspensionStepCount2, WorkflowSuspensionWaitCount2, HttpRequestMethod2, HttpRoute2, UrlFull2, ServerAddress2, ServerPort2, HttpResponseStatusCode2, ErrorType2, WorldParseFormat2, WorkflowEventsPagesLoaded2, QueueDeserializeTimeMs2, QueueExecutionTimeMs2, QueueSerializeTimeMs2, SerializationOperation2, SerializationCompressed2, SerializationCodec2, SerializationUncompressedBytes2, SerializationStoredBytes2, SerializationCompressionRatio2, PeerService3, RpcSystem3, RpcService3, RpcMethod3, ErrorRetryable2, ErrorCategory2;
+var WorkflowName2, WorkflowOperation2, WorkflowRunId3, WorkflowRunStatus2, WorkflowStartedAt2, WorkflowEventsCount2, WorkflowArgumentsCount2, WorkflowResultType2, WorkflowTracePropagated2, WorkflowTraceMode2, WorkflowTurbo2, WorkflowErrorName2, WorkflowErrorMessage2, WorkflowErrorCode2, WorkflowStepsCreated2, WorkflowHooksCreated2, WorkflowWaitsCreated2, WorkflowOwnedRecoverySteps2, WorkflowBackstopWakesArmed2, WorkflowRouteType2, WorkflowRouteHandlerCached2, WorkflowRouteInvocationCount2, WorkflowRouteEntrypointAgeMs2, WorkflowRouteModuleBodyInitMs2, StepName2, StepId3, 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, HookToken2, HookId2, HookFound2, WebhookHandlersTriggered2, WorkflowSuspensionState2, WorkflowSuspensionHookCount2, WorkflowSuspensionStepCount2, WorkflowSuspensionWaitCount2, HttpRequestMethod2, HttpRoute2, UrlFull2, ServerAddress2, ServerPort2, HttpResponseStatusCode2, ErrorType2, WorldParseFormat2, WorkflowEventsPagesLoaded2, QueueDeserializeTimeMs2, QueueExecutionTimeMs2, QueueSerializeTimeMs2, SerializationOperation2, SerializationCompressed2, SerializationCodec2, SerializationUncompressedBytes2, SerializationStoredBytes2, SerializationCompressionRatio2, PeerService3, RpcSystem3, RpcService3, RpcMethod3, ErrorRetryable2, ErrorCategory2;
 var init_semantic_conventions2 = __esm({
   "../core/dist/telemetry/semantic-conventions.js"() {
     "use strict";
@@ -45158,6 +45204,8 @@ var init_semantic_conventions2 = __esm({
     StepTracePropagated2 = SemanticConvention3("step.trace.propagated");
     StepTtfsMs2 = SemanticConvention3("step.ttfs_ms");
     StepStsoMs2 = SemanticConvention3("step.stso_ms");
+    StepRsfsMs2 = SemanticConvention3("step.rsfs_ms");
+    StepFinalSchedulingReplayMs2 = SemanticConvention3("step.final_scheduling_replay_ms");
     StepLatencyOptimizations2 = SemanticConvention3("step.latency_optimizations");
     StepSkipped2 = SemanticConvention3("step.skipped");
     StepSkipReason2 = SemanticConvention3("step.skip_reason");
@@ -45504,370 +45552,6 @@ var init_logger2 = __esm({
   }
 });
 
-// ../core/dist/encryption.js
-async function importKey2(raw, usages = ["encrypt", "decrypt"]) {
-  if (raw.byteLength !== KEY_LENGTH2) {
-    throw new WorkflowRuntimeError2(`Encryption key must be exactly ${KEY_LENGTH2} bytes, got ${raw.byteLength}`);
-  }
-  return globalThis.crypto.subtle.importKey(
-    "raw",
-    raw,
-    "AES-GCM",
-    false,
-    // `KeyUsage` is a DOM-lib type that's not in scope under `es2022`.
-    // The `ReadonlyArray<'encrypt' | 'decrypt'>` parameter type matches
-    // a strict subset of `KeyUsage[]`, so this cast is sound.
-    usages
-  );
-}
-async function encrypt3(key, data) {
-  const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH2));
-  let ciphertext;
-  try {
-    ciphertext = await globalThis.crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce, tagLength: TAG_LENGTH2 }, key, data);
-  } catch (cause) {
-    throw new RuntimeDecryptionError2(`AES-256-GCM encryption failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
-      cause,
-      context: {
-        operation: "encrypt",
-        byteLength: data.byteLength
-      }
-    });
-  }
-  const result = new Uint8Array(NONCE_LENGTH2 + ciphertext.byteLength);
-  result.set(nonce, 0);
-  result.set(new Uint8Array(ciphertext), NONCE_LENGTH2);
-  return result;
-}
-async function decrypt3(key, data) {
-  const minLength = NONCE_LENGTH2 + TAG_LENGTH2 / 8;
-  if (data.byteLength < minLength) {
-    throw new RuntimeDecryptionError2(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`, {
-      context: {
-        operation: "decrypt",
-        byteLength: data.byteLength
-      }
-    });
-  }
-  const nonce = data.subarray(0, NONCE_LENGTH2);
-  const ciphertext = data.subarray(NONCE_LENGTH2);
-  let plaintext;
-  try {
-    plaintext = await globalThis.crypto.subtle.decrypt({ name: "AES-GCM", iv: nonce, tagLength: TAG_LENGTH2 }, key, ciphertext);
-  } catch (cause) {
-    const causeMsg = cause instanceof Error ? cause.message : String(cause);
-    throw new RuntimeDecryptionError2(`AES-256-GCM decryption failed: ${causeMsg}`, {
-      cause,
-      context: {
-        operation: "decrypt",
-        byteLength: data.byteLength
-      }
-    });
-  }
-  return new Uint8Array(plaintext);
-}
-var NONCE_LENGTH2, TAG_LENGTH2, KEY_LENGTH2;
-var init_encryption3 = __esm({
-  "../core/dist/encryption.js"() {
-    "use strict";
-    init_dist7();
-    NONCE_LENGTH2 = 12;
-    TAG_LENGTH2 = 128;
-    KEY_LENGTH2 = 32;
-    __name(importKey2, "importKey");
-    __name(encrypt3, "encrypt");
-    __name(decrypt3, "decrypt");
-  }
-});
-
-// ../core/dist/version.js
-var version4;
-var init_version3 = __esm({
-  "../core/dist/version.js"() {
-    "use strict";
-    version4 = "5.0.0-beta.34";
-  }
-});
-
-// ../core/dist/runtime/get-world-lazy.js
-async function getWorldLazy2() {
-  const g = globalThis;
-  if (g[WorldCacheKey2]) {
-    assertWorldSupportsRuntimeProtocol2(g[WorldCacheKey2]);
-    return g[WorldCacheKey2];
-  }
-  if (g[WorldCachePromiseKey2]) {
-    g[WorldCacheKey2] = await g[WorldCachePromiseKey2];
-    assertWorldSupportsRuntimeProtocol2(g[WorldCacheKey2]);
-    return g[WorldCacheKey2];
-  }
-  const getWorldFn = g[GetWorldFnKey3];
-  if (getWorldFn) {
-    const world = await getWorldFn();
-    assertWorldSupportsRuntimeProtocol2(world);
-    return world;
-  }
-  throw new Error("Workflow world runtime was not initialized. Import from the host workflow entrypoints (`workflow`, `workflow/api`, or `workflow/runtime`) so @workflow/core/runtime/world-init can register getWorld before getWorldLazy() is used.");
-}
-var WorldCacheKey2, WorldCachePromiseKey2, GetWorldFnKey3;
-var init_get_world_lazy2 = __esm({
-  "../core/dist/runtime/get-world-lazy.js"() {
-    "use strict";
-    init_world_compatibility2();
-    WorldCacheKey2 = /* @__PURE__ */ Symbol.for("@workflow/world//cache");
-    WorldCachePromiseKey2 = /* @__PURE__ */ Symbol.for("@workflow/world//cachePromise");
-    GetWorldFnKey3 = /* @__PURE__ */ Symbol.for("@workflow/world//getWorldFn");
-    __name(getWorldLazy2, "getWorldLazy");
-  }
-});
-
-// ../core/dist/runtime/helpers.js
-function getWorkflowQueueName2(workflowName, namespace) {
-  if (!SAFE_WORKFLOW_NAME_PATTERN2.test(workflowName)) {
-    throw new Error(`Invalid workflow name "${workflowName}": must only contain alphanumeric characters, underscores, hyphens, dots, forward slashes, or at signs`);
-  }
-  const prefix = getQueueTopicPrefix2("workflow", resolveQueueNamespace2(namespace));
-  return `${prefix}${workflowName}`;
-}
-function getHealthCheckStreamName2(correlationId) {
-  return `__health_check__${correlationId}`;
-}
-function parseHealthCheckPayload(message) {
-  const result = HealthCheckPayloadSchema2.safeParse(message);
-  if (result.success) {
-    return result.data;
-  }
-  return void 0;
-}
-function generateHealthCheckRunId2(correlationId) {
-  return `wrun_hc_${correlationId}`;
-}
-async function handleHealthCheckMessage(healthCheck3, endpoint, worldSpecVersion) {
-  const world = await getWorldLazy2();
-  const streamName = getHealthCheckStreamName2(healthCheck3.correlationId);
-  const response = JSON.stringify({
-    healthy: true,
-    endpoint,
-    correlationId: healthCheck3.correlationId,
-    specVersion: worldSpecVersion ?? SPEC_VERSION_CURRENT2,
-    workflowCoreVersion: version4,
-    timestamp: Date.now()
-  });
-  const fakeRunId = generateHealthCheckRunId2(healthCheck3.correlationId);
-  await world.streams.write(fakeRunId, streamName, response);
-  await world.streams.close(fakeRunId, streamName);
-}
-function eventPaginationContractError(runId, message) {
-  return new WorkflowWorldError2(`Event pagination ${message} for workflow run "${runId}".`, { code: RUN_ERROR_CODES2.WORLD_CONTRACT_ERROR });
-}
-function recordRequestedEventCursor(runId, cursor, requestedCursors) {
-  if (!cursor) {
-    return;
-  }
-  if (requestedCursors.has(cursor)) {
-    throw eventPaginationContractError(runId, "did not advance");
-  }
-  requestedCursors.add(cursor);
-}
-function appendUniqueEvents(target, targetIds, events) {
-  for (const event of events) {
-    if (!targetIds.has(event.eventId)) {
-      targetIds.add(event.eventId);
-      target.push(event);
-    }
-  }
-}
-function assertEventPaginationProgress(runId, hasMore, cursor, requestedCursors) {
-  if (!hasMore) {
-    return;
-  }
-  if (cursor === null) {
-    throw eventPaginationContractError(runId, "returned more pages without a cursor");
-  }
-  if (requestedCursors.has(cursor)) {
-    throw eventPaginationContractError(runId, "repeated a cursor");
-  }
-}
-function shouldRetryWithoutEventCursor(error95, cursor, alreadyRetried) {
-  return cursor !== null && !alreadyRetried && WorkflowWorldError2.is(error95) && error95.status === 400;
-}
-async function loadWorkflowRunEvents(runId, afterCursor) {
-  const incremental = afterCursor !== void 0;
-  return trace4(incremental ? "workflow.loadNewEvents" : "workflow.loadEvents", async (span) => {
-    span?.setAttributes({
-      ...WorkflowRunId3(runId)
-    });
-    const loadedEvents = [];
-    const loadedEventIds = /* @__PURE__ */ new Set();
-    const requestedCursors = /* @__PURE__ */ new Set();
-    let cursor = afterCursor ?? null;
-    let hasMore = true;
-    let pagesLoaded = 0;
-    let retriedWithoutCursor = false;
-    const world = await getWorldLazy2();
-    const loadStart = Date.now();
-    while (hasMore) {
-      const pageStart = Date.now();
-      const requestedCursor = cursor;
-      recordRequestedEventCursor(runId, requestedCursor, requestedCursors);
-      let response;
-      try {
-        response = await world.events.list({
-          runId,
-          pagination: {
-            sortOrder: "asc",
-            cursor: requestedCursor ?? void 0
-          }
-        });
-      } catch (error95) {
-        if (shouldRetryWithoutEventCursor(error95, requestedCursor, retriedWithoutCursor)) {
-          runtimeLogger2.warn("Event cursor was rejected; retrying with a full event reload.", { workflowRunId: runId });
-          loadedEvents.length = 0;
-          loadedEventIds.clear();
-          requestedCursors.clear();
-          cursor = null;
-          retriedWithoutCursor = true;
-          continue;
-        }
-        throw error95;
-      }
-      appendUniqueEvents(loadedEvents, loadedEventIds, response.data);
-      hasMore = response.hasMore;
-      assertEventPaginationProgress(runId, hasMore, response.cursor, requestedCursors);
-      cursor = response.cursor ?? cursor;
-      pagesLoaded++;
-      runtimeLogger2.debug("Loaded event page", {
-        workflowRunId: runId,
-        incremental,
-        page: pagesLoaded,
-        pageEvents: response.data.length,
-        totalEvents: loadedEvents.length,
-        hasMore,
-        pageMs: Date.now() - pageStart
-      });
-    }
-    runtimeLogger2.debug("Event load complete", {
-      workflowRunId: runId,
-      incremental,
-      totalEvents: loadedEvents.length,
-      pagesLoaded,
-      totalMs: Date.now() - loadStart
-    });
-    span?.setAttributes({
-      ...WorkflowEventsCount2(loadedEvents.length),
-      ...WorkflowEventsPagesLoaded2(pagesLoaded)
-    });
-    return { events: loadedEvents, cursor };
-  });
-}
-function withHealthCheck(handler, worldSpecVersion) {
-  return async (req) => {
-    const url3 = new URL(req.url);
-    const isHealthCheck = url3.searchParams.has("__health");
-    if (isHealthCheck) {
-      if (req.method === "OPTIONS") {
-        return new Response(null, {
-          status: 204,
-          headers: HEALTH_CHECK_CORS_HEADERS
-        });
-      }
-      return new Response(JSON.stringify({
-        healthy: true,
-        endpoint: url3.pathname,
-        specVersion: worldSpecVersion ?? SPEC_VERSION_CURRENT2,
-        workflowCoreVersion: version4
-      }), {
-        status: 200,
-        headers: {
-          "Content-Type": "application/json",
-          ...HEALTH_CHECK_CORS_HEADERS
-        }
-      });
-    }
-    return await handler(req);
-  };
-}
-async function queueMessage(world, ...args) {
-  const queueName = args[0];
-  await trace4("queue.publish", {
-    // Standard OTEL messaging conventions
-    attributes: {
-      ...MessagingSystem2("vercel-queue"),
-      ...MessagingDestinationName2(queueName),
-      ...MessagingOperationType2("publish"),
-      // Peer service for Datadog service maps
-      ...PeerService3("vercel-queue"),
-      ...RpcSystem3("vercel-queue"),
-      ...RpcService3("vqs"),
-      ...RpcMethod3("publish")
-    },
-    kind: await getSpanKind3("PRODUCER")
-  }, async (span) => {
-    const { messageId } = await world.queue(...args);
-    if (messageId) {
-      span?.setAttributes(MessagingMessageId2(messageId));
-    }
-  });
-}
-function getQueueOverhead(message) {
-  if (!message.requestedAt)
-    return;
-  try {
-    return QueueOverheadMs2(Date.now() - message.requestedAt.getTime());
-  } catch {
-    return;
-  }
-}
-function memoizeEncryptionKey(world, runOrId) {
-  let cached3;
-  return () => {
-    if (!cached3) {
-      cached3 = (async () => {
-        const rawKey = typeof runOrId === "string" ? await world.getEncryptionKeyForRun?.(runOrId) : await world.getEncryptionKeyForRun?.(runOrId);
-        return rawKey ? await importKey2(rawKey) : void 0;
-      })();
-    }
-    return cached3;
-  };
-}
-var SAFE_WORKFLOW_NAME_PATTERN2, generateId2, HEALTH_CHECK_CORS_HEADERS;
-var init_helpers2 = __esm({
-  "../core/dist/runtime/helpers.js"() {
-    "use strict";
-    init_dist7();
-    init_dist5();
-    init_node2();
-    init_encryption3();
-    init_logger2();
-    init_semantic_conventions2();
-    init_telemetry2();
-    init_version3();
-    init_get_world_lazy2();
-    SAFE_WORKFLOW_NAME_PATTERN2 = /^[a-zA-Z0-9_\-./@]+$/;
-    __name(getWorkflowQueueName2, "getWorkflowQueueName");
-    generateId2 = monotonicFactory2();
-    __name(getHealthCheckStreamName2, "getHealthCheckStreamName");
-    __name(parseHealthCheckPayload, "parseHealthCheckPayload");
-    __name(generateHealthCheckRunId2, "generateHealthCheckRunId");
-    __name(handleHealthCheckMessage, "handleHealthCheckMessage");
-    __name(eventPaginationContractError, "eventPaginationContractError");
-    __name(recordRequestedEventCursor, "recordRequestedEventCursor");
-    __name(appendUniqueEvents, "appendUniqueEvents");
-    __name(assertEventPaginationProgress, "assertEventPaginationProgress");
-    __name(shouldRetryWithoutEventCursor, "shouldRetryWithoutEventCursor");
-    __name(loadWorkflowRunEvents, "loadWorkflowRunEvents");
-    HEALTH_CHECK_CORS_HEADERS = {
-      "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "POST, OPTIONS, GET, HEAD",
-      "Access-Control-Allow-Headers": "Content-Type"
-    };
-    __name(withHealthCheck, "withHealthCheck");
-    __name(queueMessage, "queueMessage");
-    __name(getQueueOverhead, "getQueueOverhead");
-    __name(memoizeEncryptionKey, "memoizeEncryptionKey");
-  }
-});
-
 // ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/constants.js
 var UNDEFINED2, HOLE2, NAN2, POSITIVE_INFINITY2, NEGATIVE_INFINITY2, NEGATIVE_ZERO2, SPARSE2, MAX_ARRAY_LEN2, MAX_ARRAY_INDEX2;
 var init_constants2 = __esm({
@@ -46506,6 +46190,109 @@ var init_devalue2 = __esm({
   }
 });
 
+// ../core/dist/encryption.js
+async function importKey2(raw, usages = ["encrypt", "decrypt"]) {
+  if (raw.byteLength !== KEY_LENGTH2) {
+    throw new WorkflowRuntimeError2(`Encryption key must be exactly ${KEY_LENGTH2} bytes, got ${raw.byteLength}`);
+  }
+  return globalThis.crypto.subtle.importKey(
+    "raw",
+    raw,
+    "AES-GCM",
+    false,
+    // `KeyUsage` is a DOM-lib type that's not in scope under `es2022`.
+    // The `ReadonlyArray<'encrypt' | 'decrypt'>` parameter type matches
+    // a strict subset of `KeyUsage[]`, so this cast is sound.
+    usages
+  );
+}
+async function encrypt3(key, data) {
+  const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH2));
+  let ciphertext;
+  try {
+    ciphertext = await globalThis.crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce, tagLength: TAG_LENGTH2 }, key, data);
+  } catch (cause) {
+    throw new RuntimeDecryptionError2(`AES-256-GCM encryption failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
+      cause,
+      context: {
+        operation: "encrypt",
+        byteLength: data.byteLength
+      }
+    });
+  }
+  const result = new Uint8Array(NONCE_LENGTH2 + ciphertext.byteLength);
+  result.set(nonce, 0);
+  result.set(new Uint8Array(ciphertext), NONCE_LENGTH2);
+  return result;
+}
+async function decrypt3(key, data) {
+  const minLength = NONCE_LENGTH2 + TAG_LENGTH2 / 8;
+  if (data.byteLength < minLength) {
+    throw new RuntimeDecryptionError2(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`, {
+      context: {
+        operation: "decrypt",
+        byteLength: data.byteLength
+      }
+    });
+  }
+  const nonce = data.subarray(0, NONCE_LENGTH2);
+  const ciphertext = data.subarray(NONCE_LENGTH2);
+  let plaintext;
+  try {
+    plaintext = await globalThis.crypto.subtle.decrypt({ name: "AES-GCM", iv: nonce, tagLength: TAG_LENGTH2 }, key, ciphertext);
+  } catch (cause) {
+    const causeMsg = cause instanceof Error ? cause.message : String(cause);
+    throw new RuntimeDecryptionError2(`AES-256-GCM decryption failed: ${causeMsg}`, {
+      cause,
+      context: {
+        operation: "decrypt",
+        byteLength: data.byteLength
+      }
+    });
+  }
+  return new Uint8Array(plaintext);
+}
+var NONCE_LENGTH2, TAG_LENGTH2, KEY_LENGTH2;
+var init_encryption3 = __esm({
+  "../core/dist/encryption.js"() {
+    "use strict";
+    init_dist7();
+    NONCE_LENGTH2 = 12;
+    TAG_LENGTH2 = 128;
+    KEY_LENGTH2 = 32;
+    __name(importKey2, "importKey");
+    __name(encrypt3, "encrypt");
+    __name(decrypt3, "decrypt");
+  }
+});
+
+// ../core/dist/symbols.js
+var WORKFLOW_USE_STEP, WORKFLOW_SET_ATTRIBUTES, WORKFLOW_CREATE_HOOK, WORKFLOW_SLEEP, WORKFLOW_GET_STREAM_ID, STABLE_ULID2, STREAM_NAME_SYMBOL2, STREAM_TYPE_SYMBOL2, STREAM_FRAMING_SYMBOL2, STREAM_SERVER_RUN_ID_SYMBOL2, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL2, STREAM_WRITE_BATCH_SYMBOL2, BODY_INIT_SYMBOL2, WEBHOOK_RESPONSE_WRITABLE2, WORKFLOW_CLASS_REGISTRY2, ABORT_STREAM_NAME2, ABORT_HOOK_TOKEN2, ABORT_LISTENER_ATTACHED2, ABORT_READER_CANCEL2;
+var init_symbols2 = __esm({
+  "../core/dist/symbols.js"() {
+    "use strict";
+    WORKFLOW_USE_STEP = /* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP");
+    WORKFLOW_SET_ATTRIBUTES = /* @__PURE__ */ Symbol.for("WORKFLOW_SET_ATTRIBUTES");
+    WORKFLOW_CREATE_HOOK = /* @__PURE__ */ Symbol.for("WORKFLOW_CREATE_HOOK");
+    WORKFLOW_SLEEP = /* @__PURE__ */ Symbol.for("WORKFLOW_SLEEP");
+    WORKFLOW_GET_STREAM_ID = /* @__PURE__ */ Symbol.for("WORKFLOW_GET_STREAM_ID");
+    STABLE_ULID2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STABLE_ULID");
+    STREAM_NAME_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_NAME");
+    STREAM_TYPE_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_TYPE");
+    STREAM_FRAMING_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_FRAMING");
+    STREAM_SERVER_RUN_ID_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_RUN_ID");
+    STREAM_SERVER_DEPLOYMENT_ID_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID");
+    STREAM_WRITE_BATCH_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_WRITE_BATCH");
+    BODY_INIT_SYMBOL2 = /* @__PURE__ */ Symbol.for("BODY_INIT");
+    WEBHOOK_RESPONSE_WRITABLE2 = /* @__PURE__ */ Symbol.for("WEBHOOK_RESPONSE_WRITABLE");
+    WORKFLOW_CLASS_REGISTRY2 = /* @__PURE__ */ Symbol.for("workflow-class-registry");
+    ABORT_STREAM_NAME2 = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_STREAM_NAME");
+    ABORT_HOOK_TOKEN2 = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_HOOK_TOKEN");
+    ABORT_LISTENER_ATTACHED2 = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_LISTENER_ATTACHED");
+    ABORT_READER_CANCEL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_READER_CANCEL");
+  }
+});
+
 // ../core/dist/flushable-stream.js
 function createFlushableState2() {
   const state = {
@@ -46588,7 +46375,11 @@ function pollReadableLock2(readable, state) {
   }, getLockPollIntervalMs2());
   state.readablePollingInterval = intervalId;
 }
-async function flushablePipe2(source, sink, state) {
+function flushablePipe2(source, sink, state) {
+  const batchWrite = sink[STREAM_WRITE_BATCH_SYMBOL2];
+  return typeof batchWrite === "function" ? flushablePipeCoalescing2(source, sink, state, batchWrite) : flushablePipePerChunk2(source, sink, state);
+}
+async function flushablePipePerChunk2(source, sink, state) {
   const reader = source.getReader();
   const writer = sink.getWriter();
   let cancelReason;
@@ -46637,13 +46428,147 @@ async function flushablePipe2(source, sink, state) {
     writer.releaseLock();
   }
 }
-var LOCK_POLL_INTERVAL_MS2, getLockPollIntervalMs2;
+function wake2(ctx, which) {
+  const resolve2 = ctx[which];
+  if (resolve2) {
+    ctx[which] = null;
+    resolve2();
+  }
+}
+function nextBatchSize2(ctx) {
+  let count2 = 0;
+  let bytes = 0;
+  for (const chunk of ctx.queue) {
+    if (count2 >= ctx.maxChunksPerBatch)
+      break;
+    if (count2 > 0 && bytes + chunk.byteLength > ctx.maxBytesPerBatch)
+      break;
+    count2++;
+    bytes += chunk.byteLength;
+  }
+  return count2;
+}
+async function drainBatches2(ctx) {
+  while (true) {
+    if (ctx.queue.length === 0) {
+      if (ctx.sourceDone)
+        return;
+      await new Promise((resolve2) => {
+        ctx.wakeConsumer = resolve2;
+      });
+      continue;
+    }
+    const count2 = nextBatchSize2(ctx);
+    const batch = ctx.queue.slice(0, count2);
+    ctx.queue = ctx.queue.slice(count2);
+    await ctx.batchWrite(batch);
+    ctx.state.pendingOps -= batch.length;
+    wake2(ctx, "wakeProducer");
+  }
+}
+function readNextChunk2(reader, writer, consumer) {
+  return Promise.race([
+    reader.read(),
+    writer.closed.then(() => {
+      throw new WorkflowRuntimeError2("Writable stream closed prematurely");
+    }),
+    consumer.then(() => {
+      throw new WorkflowRuntimeError2("Stream consumer ended prematurely");
+    }, (err) => {
+      throw err;
+    })
+  ]);
+}
+async function awaitBackpressureRelief2(ctx, consumer, maxInflight) {
+  if (ctx.state.pendingOps < maxInflight)
+    return;
+  await Promise.race([
+    new Promise((resolve2) => {
+      ctx.wakeProducer = resolve2;
+    }),
+    consumer.then(() => void 0, () => void 0)
+  ]);
+}
+async function flushablePipeCoalescing2(source, sink, state, batchWrite) {
+  const reader = source.getReader();
+  const writer = sink.getWriter();
+  const maxInflight = getMaxInflightChunks2();
+  let cancelReason;
+  const ctx = {
+    state,
+    batchWrite,
+    queue: [],
+    sourceDone: false,
+    wakeConsumer: null,
+    wakeProducer: null,
+    maxChunksPerBatch: getMaxChunksPerBatch2(),
+    maxBytesPerBatch: getMaxBytesPerBatch2()
+  };
+  const consumer = drainBatches2(ctx);
+  try {
+    while (!state.streamEnded) {
+      const readResult = await readNextChunk2(reader, writer, consumer);
+      if (state.streamEnded)
+        return;
+      if (readResult.done) {
+        ctx.sourceDone = true;
+        wake2(ctx, "wakeConsumer");
+        await consumer;
+        state.streamEnded = true;
+        await writer.close();
+        if (!state.doneResolved) {
+          state.doneResolved = true;
+          state.resolve();
+        }
+        return;
+      }
+      ctx.queue.push(readResult.value);
+      state.pendingOps++;
+      wake2(ctx, "wakeConsumer");
+      await awaitBackpressureRelief2(ctx, consumer, maxInflight);
+    }
+  } catch (err) {
+    state.streamEnded = true;
+    cancelReason = err;
+    ctx.sourceDone = true;
+    wake2(ctx, "wakeConsumer");
+    await consumer.catch(() => {
+    });
+    if (!state.doneResolved) {
+      state.doneResolved = true;
+      state.reject(err);
+    }
+    throw err;
+  } finally {
+    reader.cancel(cancelReason).catch(() => {
+    });
+    reader.releaseLock();
+    writer.releaseLock();
+  }
+}
+var MAX_INFLIGHT_CHUNKS2, getMaxInflightChunks2, MAX_CHUNKS_PER_BATCH2, getMaxChunksPerBatch2, MAX_BYTES_PER_BATCH2, getMaxBytesPerBatch2, LOCK_POLL_INTERVAL_MS2, getLockPollIntervalMs2;
 var init_flushable_stream2 = __esm({
   "../core/dist/flushable-stream.js"() {
     "use strict";
     init_dist7();
     init_dist6();
     init_dist5();
+    init_symbols2();
+    MAX_INFLIGHT_CHUNKS2 = 1e3;
+    getMaxInflightChunks2 = /* @__PURE__ */ __name(() => envNumber2("WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS", MAX_INFLIGHT_CHUNKS2, {
+      integer: true,
+      min: 1
+    }), "getMaxInflightChunks");
+    MAX_CHUNKS_PER_BATCH2 = 1e3;
+    getMaxChunksPerBatch2 = /* @__PURE__ */ __name(() => envNumber2("WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH", MAX_CHUNKS_PER_BATCH2, {
+      integer: true,
+      min: 1
+    }), "getMaxChunksPerBatch");
+    MAX_BYTES_PER_BATCH2 = 1024 * 1024;
+    getMaxBytesPerBatch2 = /* @__PURE__ */ __name(() => envNumber2("WORKFLOW_STREAM_MAX_BYTES_PER_BATCH", MAX_BYTES_PER_BATCH2, {
+      integer: true,
+      min: 1
+    }), "getMaxBytesPerBatch");
     LOCK_POLL_INTERVAL_MS2 = 10;
     getLockPollIntervalMs2 = /* @__PURE__ */ __name(() => envNumber2("WORKFLOW_LOCK_POLL_INTERVAL_MS", LOCK_POLL_INTERVAL_MS2, {
       integer: true,
@@ -46655,6 +46580,13 @@ var init_flushable_stream2 = __esm({
     __name(pollWritableLock2, "pollWritableLock");
     __name(pollReadableLock2, "pollReadableLock");
     __name(flushablePipe2, "flushablePipe");
+    __name(flushablePipePerChunk2, "flushablePipePerChunk");
+    __name(wake2, "wake");
+    __name(nextBatchSize2, "nextBatchSize");
+    __name(drainBatches2, "drainBatches");
+    __name(readNextChunk2, "readNextChunk");
+    __name(awaitBackpressureRelief2, "awaitBackpressureRelief");
+    __name(flushablePipeCoalescing2, "flushablePipeCoalescing");
   }
 });
 
@@ -46786,6 +46718,38 @@ var init_private2 = __esm({
   }
 });
 
+// ../core/dist/runtime/get-world-lazy.js
+async function getWorldLazy2() {
+  const g = globalThis;
+  if (g[WorldCacheKey2]) {
+    assertWorldSupportsRuntimeProtocol2(g[WorldCacheKey2]);
+    return g[WorldCacheKey2];
+  }
+  if (g[WorldCachePromiseKey2]) {
+    g[WorldCacheKey2] = await g[WorldCachePromiseKey2];
+    assertWorldSupportsRuntimeProtocol2(g[WorldCacheKey2]);
+    return g[WorldCacheKey2];
+  }
+  const getWorldFn = g[GetWorldFnKey3];
+  if (getWorldFn) {
+    const world = await getWorldFn();
+    assertWorldSupportsRuntimeProtocol2(world);
+    return world;
+  }
+  throw new Error("Workflow world runtime was not initialized. Import from the host workflow entrypoints (`workflow`, `workflow/api`, or `workflow/runtime`) so @workflow/core/runtime/world-init can register getWorld before getWorldLazy() is used.");
+}
+var WorldCacheKey2, WorldCachePromiseKey2, GetWorldFnKey3;
+var init_get_world_lazy2 = __esm({
+  "../core/dist/runtime/get-world-lazy.js"() {
+    "use strict";
+    init_world_compatibility2();
+    WorldCacheKey2 = /* @__PURE__ */ Symbol.for("@workflow/world//cache");
+    WorldCachePromiseKey2 = /* @__PURE__ */ Symbol.for("@workflow/world//cachePromise");
+    GetWorldFnKey3 = /* @__PURE__ */ Symbol.for("@workflow/world//getWorldFn");
+    __name(getWorldLazy2, "getWorldLazy");
+  }
+});
+
 // ../serde/dist/index.js
 var WORKFLOW_SERIALIZE2, WORKFLOW_DESERIALIZE2;
 var init_dist8 = __esm({
@@ -46796,32 +46760,6 @@ var init_dist8 = __esm({
   }
 });
 
-// ../core/dist/symbols.js
-var WORKFLOW_USE_STEP, WORKFLOW_SET_ATTRIBUTES, WORKFLOW_CREATE_HOOK, WORKFLOW_SLEEP, WORKFLOW_GET_STREAM_ID, STABLE_ULID2, STREAM_NAME_SYMBOL2, STREAM_TYPE_SYMBOL2, STREAM_FRAMING_SYMBOL2, STREAM_SERVER_RUN_ID_SYMBOL2, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL2, BODY_INIT_SYMBOL2, WEBHOOK_RESPONSE_WRITABLE2, WORKFLOW_CLASS_REGISTRY2, ABORT_STREAM_NAME2, ABORT_HOOK_TOKEN2, ABORT_LISTENER_ATTACHED2, ABORT_READER_CANCEL2;
-var init_symbols2 = __esm({
-  "../core/dist/symbols.js"() {
-    "use strict";
-    WORKFLOW_USE_STEP = /* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP");
-    WORKFLOW_SET_ATTRIBUTES = /* @__PURE__ */ Symbol.for("WORKFLOW_SET_ATTRIBUTES");
-    WORKFLOW_CREATE_HOOK = /* @__PURE__ */ Symbol.for("WORKFLOW_CREATE_HOOK");
-    WORKFLOW_SLEEP = /* @__PURE__ */ Symbol.for("WORKFLOW_SLEEP");
-    WORKFLOW_GET_STREAM_ID = /* @__PURE__ */ Symbol.for("WORKFLOW_GET_STREAM_ID");
-    STABLE_ULID2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STABLE_ULID");
-    STREAM_NAME_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_NAME");
-    STREAM_TYPE_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_TYPE");
-    STREAM_FRAMING_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_FRAMING");
-    STREAM_SERVER_RUN_ID_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_RUN_ID");
-    STREAM_SERVER_DEPLOYMENT_ID_SYMBOL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID");
-    BODY_INIT_SYMBOL2 = /* @__PURE__ */ Symbol.for("BODY_INIT");
-    WEBHOOK_RESPONSE_WRITABLE2 = /* @__PURE__ */ Symbol.for("WEBHOOK_RESPONSE_WRITABLE");
-    WORKFLOW_CLASS_REGISTRY2 = /* @__PURE__ */ Symbol.for("workflow-class-registry");
-    ABORT_STREAM_NAME2 = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_STREAM_NAME");
-    ABORT_HOOK_TOKEN2 = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_HOOK_TOKEN");
-    ABORT_LISTENER_ATTACHED2 = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_LISTENER_ATTACHED");
-    ABORT_READER_CANCEL2 = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_READER_CANCEL");
-  }
-});
-
 // ../core/dist/class-serialization.js
 function getRegistry2(global2 = globalThis) {
   const g = global2;
@@ -48077,7 +48015,8 @@ function createCreateAbortController(ctx) {
             try {
               if (rawPayload !== void 0) {
                 try {
-                  const hydrated = await hydrateStepReturnValue(rawPayload, ctx.runId, ctx.encryptionKey, ctx.globalThis);
+                  const prepared = await ctx.replayPayloadCache.prepareEventPayload(event.eventId, "payload", rawPayload);
+                  const hydrated = await hydrateStepReturnValue(rawPayload, ctx.runId, ctx.encryptionKey, ctx.globalThis, {}, prepared);
                   if (hydrated && typeof hydrated === "object" && "reason" in hydrated) {
                     reason = hydrated.reason;
                   }
@@ -50227,6 +50166,307 @@ var init_capabilities2 = __esm({
   }
 });
 
+// ../core/dist/version.js
+var version4;
+var init_version3 = __esm({
+  "../core/dist/version.js"() {
+    "use strict";
+    version4 = "5.0.0-beta.36";
+  }
+});
+
+// ../core/dist/runtime/helpers.js
+function getWorkflowQueueName2(workflowName, namespace) {
+  if (!SAFE_WORKFLOW_NAME_PATTERN2.test(workflowName)) {
+    throw new Error(`Invalid workflow name "${workflowName}": must only contain alphanumeric characters, underscores, hyphens, dots, forward slashes, or at signs`);
+  }
+  const prefix = getQueueTopicPrefix2("workflow", resolveQueueNamespace2(namespace));
+  return `${prefix}${workflowName}`;
+}
+function getHealthCheckStreamName2(correlationId) {
+  return `__health_check__${correlationId}`;
+}
+function parseHealthCheckPayload(message) {
+  const result = HealthCheckPayloadSchema2.safeParse(message);
+  if (result.success) {
+    return result.data;
+  }
+  return void 0;
+}
+function generateHealthCheckRunId2(correlationId) {
+  return `wrun_hc_${correlationId}`;
+}
+async function handleHealthCheckMessage(healthCheck3, endpoint, worldSpecVersion) {
+  const world = await getWorldLazy2();
+  const streamName = getHealthCheckStreamName2(healthCheck3.correlationId);
+  const response = JSON.stringify({
+    healthy: true,
+    endpoint,
+    correlationId: healthCheck3.correlationId,
+    specVersion: worldSpecVersion ?? SPEC_VERSION_CURRENT2,
+    workflowCoreVersion: version4,
+    timestamp: Date.now()
+  });
+  const fakeRunId = generateHealthCheckRunId2(healthCheck3.correlationId);
+  await world.streams.write(fakeRunId, streamName, response);
+  await world.streams.close(fakeRunId, streamName);
+}
+function eventPaginationContractError(runId, message) {
+  return new WorkflowWorldError2(`Event pagination ${message} for workflow run "${runId}".`, { code: RUN_ERROR_CODES2.WORLD_CONTRACT_ERROR });
+}
+function recordRequestedEventCursor(runId, cursor, requestedCursors) {
+  if (!cursor) {
+    return;
+  }
+  if (requestedCursors.has(cursor)) {
+    throw eventPaginationContractError(runId, "did not advance");
+  }
+  requestedCursors.add(cursor);
+}
+function appendUniqueEvents(target, targetIds, events) {
+  for (const event of events) {
+    if (!targetIds.has(event.eventId)) {
+      targetIds.add(event.eventId);
+      target.push(event);
+    }
+  }
+}
+function assertEventPaginationProgress(runId, hasMore, cursor, requestedCursors) {
+  if (!hasMore) {
+    return;
+  }
+  if (cursor === null) {
+    throw eventPaginationContractError(runId, "returned more pages without a cursor");
+  }
+  if (requestedCursors.has(cursor)) {
+    throw eventPaginationContractError(runId, "repeated a cursor");
+  }
+}
+function shouldRetryWithoutEventCursor(error95, cursor, alreadyRetried) {
+  return cursor !== null && !alreadyRetried && WorkflowWorldError2.is(error95) && error95.status === 400;
+}
+async function loadWorkflowRunEvents(runId, afterCursor) {
+  const incremental = afterCursor !== void 0;
+  return trace4(incremental ? "workflow.loadNewEvents" : "workflow.loadEvents", async (span) => {
+    span?.setAttributes({
+      ...WorkflowRunId3(runId)
+    });
+    const loadedEvents = [];
+    const loadedEventIds = /* @__PURE__ */ new Set();
+    const requestedCursors = /* @__PURE__ */ new Set();
+    let cursor = afterCursor ?? null;
+    let hasMore = true;
+    let pagesLoaded = 0;
+    let retriedWithoutCursor = false;
+    const world = await getWorldLazy2();
+    const loadStart = Date.now();
+    while (hasMore) {
+      const pageStart = Date.now();
+      const requestedCursor = cursor;
+      recordRequestedEventCursor(runId, requestedCursor, requestedCursors);
+      let response;
+      try {
+        response = await world.events.list({
+          runId,
+          pagination: {
+            sortOrder: "asc",
+            cursor: requestedCursor ?? void 0
+          }
+        });
+      } catch (error95) {
+        if (shouldRetryWithoutEventCursor(error95, requestedCursor, retriedWithoutCursor)) {
+          runtimeLogger2.warn("Event cursor was rejected; retrying with a full event reload.", { workflowRunId: runId });
+          loadedEvents.length = 0;
+          loadedEventIds.clear();
+          requestedCursors.clear();
+          cursor = null;
+          retriedWithoutCursor = true;
+          continue;
+        }
+        throw error95;
+      }
+      appendUniqueEvents(loadedEvents, loadedEventIds, response.data);
+      hasMore = response.hasMore;
+      assertEventPaginationProgress(runId, hasMore, response.cursor, requestedCursors);
+      cursor = response.cursor ?? cursor;
+      pagesLoaded++;
+      runtimeLogger2.debug("Loaded event page", {
+        workflowRunId: runId,
+        incremental,
+        page: pagesLoaded,
+        pageEvents: response.data.length,
+        totalEvents: loadedEvents.length,
+        hasMore,
+        pageMs: Date.now() - pageStart
+      });
+    }
+    runtimeLogger2.debug("Event load complete", {
+      workflowRunId: runId,
+      incremental,
+      totalEvents: loadedEvents.length,
+      pagesLoaded,
+      totalMs: Date.now() - loadStart
+    });
+    span?.setAttributes({
+      ...WorkflowEventsCount2(loadedEvents.length),
+      ...WorkflowEventsPagesLoaded2(pagesLoaded)
+    });
+    return { events: loadedEvents, cursor };
+  });
+}
+function isPreconditionGuardEnabled() {
+  return process.env.WORKFLOW_PRECONDITION_GUARD !== "0";
+}
+function latestEventStateUpdatedAt(events) {
+  const last = events[events.length - 1];
+  if (!last) {
+    return void 0;
+  }
+  const eventId = last.eventId;
+  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 stateUpdatedAtForCreate(events) {
+  return isPreconditionGuardEnabled() ? latestEventStateUpdatedAt(events) : void 0;
+}
+async function withPreconditionRetry(runId, log, op) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await op(stateUpdatedAtForCreate(log.events));
+    } catch (error95) {
+      if (!PreconditionFailedError.is(error95) || attempt >= PRECONDITION_MAX_RELOAD_RETRIES) {
+        throw error95;
+      }
+      runtimeLogger2.info("Event creation rejected as stale; reloading event log and retrying", {
+        workflowRunId: runId,
+        attempt: attempt + 1,
+        maxRetries: PRECONDITION_MAX_RELOAD_RETRIES
+      });
+      const loaded = await loadWorkflowRunEvents(runId, log.cursor ?? void 0);
+      appendUniqueEvents(log.events, new Set(log.events.map((e) => e.eventId)), loaded.events);
+      log.cursor = loaded.cursor ?? log.cursor;
+    }
+  }
+}
+function withHealthCheck(handler, worldSpecVersion) {
+  return async (req) => {
+    const url3 = new URL(req.url);
+    const isHealthCheck = url3.searchParams.has("__health");
+    if (isHealthCheck) {
+      if (req.method === "OPTIONS") {
+        return new Response(null, {
+          status: 204,
+          headers: HEALTH_CHECK_CORS_HEADERS
+        });
+      }
+      return new Response(JSON.stringify({
+        healthy: true,
+        endpoint: url3.pathname,
+        specVersion: worldSpecVersion ?? SPEC_VERSION_CURRENT2,
+        workflowCoreVersion: version4
+      }), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          ...HEALTH_CHECK_CORS_HEADERS
+        }
+      });
+    }
+    return await handler(req);
+  };
+}
+async function queueMessage(world, ...args) {
+  const queueName = args[0];
+  await trace4("queue.publish", {
+    // Standard OTEL messaging conventions
+    attributes: {
+      ...MessagingSystem2("vercel-queue"),
+      ...MessagingDestinationName2(queueName),
+      ...MessagingOperationType2("publish"),
+      // Peer service for Datadog service maps
+      ...PeerService3("vercel-queue"),
+      ...RpcSystem3("vercel-queue"),
+      ...RpcService3("vqs"),
+      ...RpcMethod3("publish")
+    },
+    kind: await getSpanKind3("PRODUCER")
+  }, async (span) => {
+    const { messageId } = await world.queue(...args);
+    if (messageId) {
+      span?.setAttributes(MessagingMessageId2(messageId));
+    }
+  });
+}
+function getQueueOverhead(message) {
+  if (!message.requestedAt)
+    return;
+  try {
+    return QueueOverheadMs2(Date.now() - message.requestedAt.getTime());
+  } catch {
+    return;
+  }
+}
+function memoizeEncryptionKey(world, runOrId) {
+  let cached3;
+  return () => {
+    if (!cached3) {
+      cached3 = (async () => {
+        const rawKey = typeof runOrId === "string" ? await world.getEncryptionKeyForRun?.(runOrId) : await world.getEncryptionKeyForRun?.(runOrId);
+        return rawKey ? await importKey2(rawKey) : void 0;
+      })();
+    }
+    return cached3;
+  };
+}
+var SAFE_WORKFLOW_NAME_PATTERN2, generateId2, PRECONDITION_MAX_RELOAD_RETRIES, HEALTH_CHECK_CORS_HEADERS;
+var init_helpers2 = __esm({
+  "../core/dist/runtime/helpers.js"() {
+    "use strict";
+    init_dist7();
+    init_dist5();
+    init_node2();
+    init_encryption3();
+    init_logger2();
+    init_semantic_conventions2();
+    init_telemetry2();
+    init_version3();
+    init_get_world_lazy2();
+    SAFE_WORKFLOW_NAME_PATTERN2 = /^[a-zA-Z0-9_\-./@]+$/;
+    __name(getWorkflowQueueName2, "getWorkflowQueueName");
+    generateId2 = monotonicFactory2();
+    __name(getHealthCheckStreamName2, "getHealthCheckStreamName");
+    __name(parseHealthCheckPayload, "parseHealthCheckPayload");
+    __name(generateHealthCheckRunId2, "generateHealthCheckRunId");
+    __name(handleHealthCheckMessage, "handleHealthCheckMessage");
+    __name(eventPaginationContractError, "eventPaginationContractError");
+    __name(recordRequestedEventCursor, "recordRequestedEventCursor");
+    __name(appendUniqueEvents, "appendUniqueEvents");
+    __name(assertEventPaginationProgress, "assertEventPaginationProgress");
+    __name(shouldRetryWithoutEventCursor, "shouldRetryWithoutEventCursor");
+    __name(loadWorkflowRunEvents, "loadWorkflowRunEvents");
+    PRECONDITION_MAX_RELOAD_RETRIES = 2;
+    __name(isPreconditionGuardEnabled, "isPreconditionGuardEnabled");
+    __name(latestEventStateUpdatedAt, "latestEventStateUpdatedAt");
+    __name(stateUpdatedAtForCreate, "stateUpdatedAtForCreate");
+    __name(withPreconditionRetry, "withPreconditionRetry");
+    HEALTH_CHECK_CORS_HEADERS = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "POST, OPTIONS, GET, HEAD",
+      "Access-Control-Allow-Headers": "Content-Type"
+    };
+    __name(withHealthCheck, "withHealthCheck");
+    __name(queueMessage, "queueMessage");
+    __name(getQueueOverhead, "getQueueOverhead");
+    __name(memoizeEncryptionKey, "memoizeEncryptionKey");
+  }
+});
+
 // ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.49/node_modules/@vercel/functions/headers.js
 var require_headers3 = __commonJS({
   "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.49/node_modules/@vercel/functions/headers.js"(exports, module) {
@@ -51372,16 +51612,20 @@ __export(resume_hook_exports2, {
   resumeHook: () => resumeHook2,
   resumeWebhook: () => resumeWebhook2
 });
-async function getHookByTokenWithKey2(token) {
+async function getHookAndRun2(token) {
   const world = await getWorldLazy2();
   const hook = await world.hooks.getByToken(token);
   const run3 = await world.runs.get(hook.runId);
-  const rawKey = await world.getEncryptionKeyForRun?.(run3);
+  return { hook, run: run3 };
+}
+async function getHookByTokenWithKey2(token) {
+  const { hook, run: run3 } = await getHookAndRun2(token);
+  const rawKey = await (await getWorldLazy2()).getEncryptionKeyForRun?.(run3);
   const encryptionKey = rawKey ? await importKey2(rawKey) : void 0;
   if (typeof hook.metadata !== "undefined") {
     hook.metadata = await hydrateStepArguments2(hook.metadata, hook.runId, encryptionKey);
   }
-  return { hook, run: run3, encryptionKey };
+  return { hook, encryptionKey };
 }
 async function getHookByToken2(token) {
   const { hook } = await getHookByTokenWithKey2(token);
@@ -51394,27 +51638,27 @@ async function resumeHook2(tokenOrHook, payload, encryptionKeyOverride) {
       try {
         let hook;
         let workflowRun;
-        let encryptionKey;
         if (typeof tokenOrHook === "string") {
-          const result = await getHookByTokenWithKey2(tokenOrHook);
+          const result = await getHookAndRun2(tokenOrHook);
           hook = result.hook;
           workflowRun = result.run;
-          encryptionKey = encryptionKeyOverride ?? result.encryptionKey;
         } else {
           hook = tokenOrHook;
           workflowRun = await world.runs.get(hook.runId);
-          if (encryptionKeyOverride) {
-            encryptionKey = encryptionKeyOverride;
-          } else {
-            const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);
-            encryptionKey = rawKey ? await importKey2(rawKey) : void 0;
-          }
         }
         span?.setAttributes({
           ...HookToken2(hook.token),
           ...HookId2(hook.hookId),
           ...WorkflowRunId3(hook.runId)
         });
+        if (isTerminalWorkflowRunStatus2(workflowRun.status)) {
+          throw new HookNotFoundError2(hook.token);
+        }
+        let encryptionKey = encryptionKeyOverride;
+        if (!encryptionKey) {
+          const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);
+          encryptionKey = rawKey ? await importKey2(rawKey) : void 0;
+        }
         const rawVersion = workflowRun.executionContext?.workflowCoreVersion;
         const capabilities = getRunCapabilities2(typeof rawVersion === "string" ? rawVersion : void 0);
         if (!capabilities.supportedFormats.has(SerializationFormat2.ENCRYPTED)) {
@@ -51519,6 +51763,7 @@ var init_resume_hook2 = __esm({
     init_get_world_lazy2();
     init_helpers2();
     init_wait_until2();
+    __name(getHookAndRun2, "getHookAndRun");
     __name(getHookByTokenWithKey2, "getHookByTokenWithKey");
     __name(getHookByToken2, "getHookByToken");
     __name(resumeHook2, "resumeHook");
@@ -52757,14 +53002,8 @@ function getStepRevivers2(global2 = globalThis, ops, runId, cryptoKey, deploymen
 async function maybeEncrypt(data, key) {
   return await encrypt4(data, key);
 }
-async function maybeDecrypt2(data, key) {
-  return decrypt4(data, key);
-}
-async function hydrateWorkflowArguments(value, _runId, key, global2 = globalThis, extraRevivers = {}) {
-  const compressionStats = {};
-  const inflated = await decompress2(await maybeDecrypt2(value, key), compressionStats);
-  await recordCompression2(compressionStats, "deserialize");
-  return deserialize5(inflated, {
+function deserializePreparedReplayPayload(prepared, global2 = globalThis, extraRevivers = {}) {
+  return deserialize5(prepared.data, {
     global: global2,
     extraRevivers: {
       ...getStreamAndRequestRevivers2(getWorkflowRevivers(global2)),
@@ -52772,6 +53011,27 @@ async function hydrateWorkflowArguments(value, _runId, key, global2 = globalThis
     }
   });
 }
+function deserializePreparedStepError(prepared, global2 = globalThis, extraRevivers = {}) {
+  const { data } = prepared;
+  if (!(data instanceof Uint8Array)) {
+    return unflatten2(data, {
+      ...getWorkflowRevivers(global2),
+      ...extraRevivers
+    });
+  }
+  const { format, payload } = decodeFormatPrefix2(data);
+  if (format === SerializationFormat2.DEVALUE_V1) {
+    const str = new TextDecoder().decode(payload);
+    return parse6(str, {
+      ...getWorkflowRevivers(global2),
+      ...extraRevivers
+    });
+  }
+  throw new Error(`Unsupported serialization format: ${format}`);
+}
+async function hydrateWorkflowArguments(value, _runId, key, global2 = globalThis, extraRevivers = {}, prepared) {
+  return deserializePreparedReplayPayload(prepared ?? await prepareReplayPayload(value, key), global2, extraRevivers);
+}
 async function dehydrateWorkflowReturnValue(value, _runId, key, global2 = globalThis, v1Compat = false, compression = false) {
   if (v1Compat) {
     const str = stringify2(value, getWorkflowReducers2(global2));
@@ -52877,25 +53137,8 @@ async function dehydrateStepError(value, runId, key, ops = [], global2 = globalT
     throw new SerializationError2(message, { hint: hint3, cause });
   }
 }
-async function hydrateStepError(value, _runId, key, global2 = globalThis, extraRevivers = {}) {
-  const compressionStats = {};
-  const decrypted = await decompress2(await maybeDecrypt2(value, key), compressionStats);
-  await recordCompression2(compressionStats, "deserialize");
-  if (!(decrypted instanceof Uint8Array)) {
-    return unflatten2(decrypted, {
-      ...getWorkflowRevivers(global2),
-      ...extraRevivers
-    });
-  }
-  const { format, payload } = decodeFormatPrefix2(decrypted);
-  if (format === SerializationFormat2.DEVALUE_V1) {
-    const str = new TextDecoder().decode(payload);
-    return parse6(str, {
-      ...getWorkflowRevivers(global2),
-      ...extraRevivers
-    });
-  }
-  throw new Error(`Unsupported serialization format: ${format}`);
+async function hydrateStepError(value, _runId, key, global2 = globalThis, extraRevivers = {}, prepared) {
+  return deserializePreparedStepError(prepared ?? await prepareReplayPayload(value, key), global2, extraRevivers);
 }
 async function dehydrateRunError(value, _runId, key, global2 = globalThis, compression = false) {
   try {
@@ -52915,7 +53158,7 @@ async function dehydrateRunError(value, _runId, key, global2 = globalThis, compr
 }
 async function hydrateRunError2(value, runId, key, ops = [], global2 = globalThis, extraRevivers = {}) {
   const compressionStats = {};
-  const decrypted = await decompress2(await maybeDecrypt2(value, key), compressionStats);
+  const decrypted = await decompress2(await decrypt4(value, key), compressionStats);
   await recordCompression2(compressionStats, "deserialize");
   if (!(decrypted instanceof Uint8Array)) {
     return unflatten2(decrypted, {
@@ -52933,17 +53176,8 @@ async function hydrateRunError2(value, runId, key, ops = [], global2 = globalThi
   }
   throw new Error(`Unsupported serialization format: ${format}`);
 }
-async function hydrateStepReturnValue(value, _runId, key, global2 = globalThis, extraRevivers = {}) {
-  const compressionStats = {};
-  const inflated = await decompress2(await maybeDecrypt2(value, key), compressionStats);
-  await recordCompression2(compressionStats, "deserialize");
-  return deserialize5(inflated, {
-    global: global2,
-    extraRevivers: {
-      ...getStreamAndRequestRevivers2(getWorkflowRevivers(global2)),
-      ...extraRevivers
-    }
-  });
+async function hydrateStepReturnValue(value, _runId, key, global2 = globalThis, extraRevivers = {}, prepared) {
+  return deserializePreparedReplayPayload(prepared ?? await prepareReplayPayload(value, key), global2, extraRevivers);
 }
 function getStreamAndRequestReducers2(allReducers) {
   const extra = {};
@@ -52963,7 +53197,7 @@ function getStreamAndRequestRevivers2(allRevivers) {
   }
   return extra;
 }
-var defaultUlid2, FRAME_HEADER_SIZE2, MAX_FRAME_SIZE2, WorkflowServerReadableStream2, FRAMED_STREAM_MAX_RECONNECTS2, getFramedStreamMaxReconnects2, FRAMED_STREAM_MAX_TOTAL_RECONNECTS2, getFramedStreamMaxTotalReconnects2, STREAM_FLUSH_INTERVAL_MS2, getStreamFlushIntervalMs2, WorkflowServerWritableStream2, STREAM_AND_REQUEST_KEYS2;
+var defaultUlid2, FRAME_HEADER_SIZE2, MAX_FRAME_SIZE2, WorkflowServerReadableStream2, FRAMED_STREAM_MAX_RECONNECTS2, getFramedStreamMaxReconnects2, FRAMED_STREAM_MAX_TOTAL_RECONNECTS2, getFramedStreamMaxTotalReconnects2, STREAM_FLUSH_INTERVAL_MS2, getStreamFlushIntervalMs2, WorkflowServerWritableStream2, prepareReplayPayload, STREAM_AND_REQUEST_KEYS2;
 var init_serialization4 = __esm({
   "../core/dist/serialization.js"() {
     "use strict";
@@ -53205,6 +53439,19 @@ var init_serialization4 = __esm({
               w.reject(abortError);
           }
         });
+        Object.defineProperty(this, STREAM_WRITE_BATCH_SYMBOL2, {
+          value: /* @__PURE__ */ __name(async (chunks) => {
+            if (chunks.length === 0)
+              return;
+            if (batchStartAt === void 0)
+              batchStartAt = Date.now();
+            for (const chunk of chunks)
+              buffer3.push(chunk);
+            await flush();
+          }, "value"),
+          enumerable: false,
+          writable: false
+        });
       }
     };
     __name(getAllBaseReducers2, "getAllBaseReducers");
@@ -53226,7 +53473,14 @@ var init_serialization4 = __esm({
     __name(getWorkflowRevivers, "getWorkflowRevivers");
     __name(getStepRevivers2, "getStepRevivers");
     __name(maybeEncrypt, "maybeEncrypt");
-    __name(maybeDecrypt2, "maybeDecrypt");
+    prepareReplayPayload = /* @__PURE__ */ __name(async (value, key) => {
+      const compressionStats = {};
+      const prepared = await decompress2(await decrypt4(value, key), compressionStats);
+      await recordCompression2(compressionStats, "deserialize");
+      return { data: prepared };
+    }, "prepareReplayPayload");
+    __name(deserializePreparedReplayPayload, "deserializePreparedReplayPayload");
+    __name(deserializePreparedStepError, "deserializePreparedStepError");
     __name(hydrateWorkflowArguments, "hydrateWorkflowArguments");
     __name(dehydrateWorkflowReturnValue, "dehydrateWorkflowReturnValue");
     __name(hydrateWorkflowReturnValue2, "hydrateWorkflowReturnValue");
@@ -54332,6 +54586,8 @@ var init_error_codes = __esm2({
       REPLAY_DIVERGENCE: "REPLAY_DIVERGENCE",
       /** Run exceeded the maximum number of queue deliveries */
       MAX_DELIVERIES_EXCEEDED: "MAX_DELIVERIES_EXCEEDED",
+      /** Run exceeded the maximum number of events per run */
+      MAX_EVENTS_EXCEEDED: "MAX_EVENTS_EXCEEDED",
       /** Workflow replay exceeded the maximum allowed duration */
       REPLAY_TIMEOUT: "REPLAY_TIMEOUT",
       /** World response violated the SDK contract and cannot be retried safely */
@@ -71113,6 +71369,8 @@ function validateAttributeChanges(changes, context2 = {}) {
 }
 __name(validateAttributeChanges, "validateAttributeChanges");
 var RESERVED_ATTRIBUTE_KEY_PREFIX;
+var ROOT_RUN_ID_ATTRIBUTE;
+var PARENT_RUN_ID_ATTRIBUTE;
 var ATTRIBUTE_KEY_MAX_LENGTH;
 var ATTRIBUTE_VALUE_MAX_BYTES;
 var ATTRIBUTE_MAX_PER_RUN;
@@ -71125,6 +71383,8 @@ var init_attributes = __esm2({
     "use strict";
     init_zod();
     RESERVED_ATTRIBUTE_KEY_PREFIX = "$";
+    ROOT_RUN_ID_ATTRIBUTE = `${RESERVED_ATTRIBUTE_KEY_PREFIX}rootRunId`;
+    PARENT_RUN_ID_ATTRIBUTE = `${RESERVED_ATTRIBUTE_KEY_PREFIX}parentRunId`;
     ATTRIBUTE_KEY_MAX_LENGTH = 256;
     ATTRIBUTE_VALUE_MAX_BYTES = 256;
     ATTRIBUTE_MAX_PER_RUN = 64;
@@ -71329,6 +71589,17 @@ var init_events = __esm2({
       // stso.
       stepCount: external_exports.number().int().positive().optional(),
       eventCount: external_exports.number().int().positive().optional(),
+      // Run-started-to-first-step: milliseconds from the `run_started` response
+      // landing (or, under turbo, the local run synthesis instant) until this
+      // step's start POST was issued. A sub-window of ttfs. Only reported
+      // alongside the same eligibility as ttfs.
+      rsfs: external_exports.number().optional(),
+      // Synchronous workflow-function replay duration of only the FINAL replay
+      // pass within the rsfs window (the pass that scheduled the first step),
+      // excluding awaited network I/O — not accumulated across earlier
+      // pre-first-step passes, so it is not "the replay portion of rsfs". Only
+      // present alongside rsfs, and only for the run's first step.
+      finalSchedulingReplay: external_exports.number().optional(),
       // Names of the runtime's optional startup-latency optimizations that were
       // active for this measurement (e.g. 'turbo', 'lazyStepStart',
       // 'optimisticStart'), so latency metrics can be segmented by them.
@@ -71410,6 +71681,7 @@ var init_events = __esm2({
       correlationId: external_exports.string(),
       eventData: external_exports.object({
         token: external_exports.string(),
+        tokenRetentionUntil: external_exports.coerce.date().optional(),
         metadata: SerializedDataSchema.optional(),
         isWebhook: external_exports.boolean().optional(),
         isSystem: external_exports.boolean().optional()
@@ -71577,6 +71849,10 @@ var init_events = __esm2({
     }));
   }
 });
+function isTerminalWorkflowRunStatus(status) {
+  return TERMINAL_WORKFLOW_RUN_STATUSES.includes(status);
+}
+__name(isTerminalWorkflowRunStatus, "isTerminalWorkflowRunStatus");
 var WorkflowRunStatusSchema;
 var TerminalWorkflowRunStatusSchema;
 var TERMINAL_WORKFLOW_RUN_STATUSES;
@@ -71600,6 +71876,7 @@ var init_runs = __esm2({
       "cancelled"
     ]);
     TERMINAL_WORKFLOW_RUN_STATUSES = TerminalWorkflowRunStatusSchema.options;
+    __name2(isTerminalWorkflowRunStatus, "isTerminalWorkflowRunStatus");
     WorkflowRunBaseSchema = external_exports.object({
       runId: external_exports.string(),
       status: WorkflowRunStatusSchema,
@@ -73078,6 +73355,39 @@ var init_devalue = __esm2({
     init_utils();
   }
 });
+var STABLE_ULID;
+var STREAM_NAME_SYMBOL;
+var STREAM_TYPE_SYMBOL;
+var STREAM_FRAMING_SYMBOL;
+var STREAM_SERVER_RUN_ID_SYMBOL;
+var STREAM_SERVER_DEPLOYMENT_ID_SYMBOL;
+var STREAM_WRITE_BATCH_SYMBOL;
+var BODY_INIT_SYMBOL;
+var WEBHOOK_RESPONSE_WRITABLE;
+var WORKFLOW_CLASS_REGISTRY;
+var ABORT_STREAM_NAME;
+var ABORT_HOOK_TOKEN;
+var ABORT_LISTENER_ATTACHED;
+var ABORT_READER_CANCEL;
+var init_symbols = __esm2({
+  "../core/dist/symbols.js"() {
+    "use strict";
+    STABLE_ULID = /* @__PURE__ */ Symbol.for("WORKFLOW_STABLE_ULID");
+    STREAM_NAME_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_NAME");
+    STREAM_TYPE_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_TYPE");
+    STREAM_FRAMING_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_FRAMING");
+    STREAM_SERVER_RUN_ID_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_RUN_ID");
+    STREAM_SERVER_DEPLOYMENT_ID_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID");
+    STREAM_WRITE_BATCH_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_WRITE_BATCH");
+    BODY_INIT_SYMBOL = /* @__PURE__ */ Symbol.for("BODY_INIT");
+    WEBHOOK_RESPONSE_WRITABLE = /* @__PURE__ */ Symbol.for("WEBHOOK_RESPONSE_WRITABLE");
+    WORKFLOW_CLASS_REGISTRY = /* @__PURE__ */ Symbol.for("workflow-class-registry");
+    ABORT_STREAM_NAME = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_STREAM_NAME");
+    ABORT_HOOK_TOKEN = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_HOOK_TOKEN");
+    ABORT_LISTENER_ATTACHED = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_LISTENER_ATTACHED");
+    ABORT_READER_CANCEL = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_READER_CANCEL");
+  }
+});
 function createFlushableState() {
   const state = {
     ...withResolvers(),
@@ -73162,7 +73472,12 @@ function pollReadableLock(readable, state) {
   state.readablePollingInterval = intervalId;
 }
 __name(pollReadableLock, "pollReadableLock");
-async function flushablePipe(source, sink, state) {
+function flushablePipe(source, sink, state) {
+  const batchWrite = sink[STREAM_WRITE_BATCH_SYMBOL];
+  return typeof batchWrite === "function" ? flushablePipeCoalescing(source, sink, state, batchWrite) : flushablePipePerChunk(source, sink, state);
+}
+__name(flushablePipe, "flushablePipe");
+async function flushablePipePerChunk(source, sink, state) {
   const reader = source.getReader();
   const writer = sink.getWriter();
   let cancelReason;
@@ -73211,7 +73526,132 @@ async function flushablePipe(source, sink, state) {
     writer.releaseLock();
   }
 }
-__name(flushablePipe, "flushablePipe");
+__name(flushablePipePerChunk, "flushablePipePerChunk");
+function wake(ctx, which) {
+  const resolve2 = ctx[which];
+  if (resolve2) {
+    ctx[which] = null;
+    resolve2();
+  }
+}
+__name(wake, "wake");
+function nextBatchSize(ctx) {
+  let count2 = 0;
+  let bytes = 0;
+  for (const chunk of ctx.queue) {
+    if (count2 >= ctx.maxChunksPerBatch) break;
+    if (count2 > 0 && bytes + chunk.byteLength > ctx.maxBytesPerBatch) break;
+    count2++;
+    bytes += chunk.byteLength;
+  }
+  return count2;
+}
+__name(nextBatchSize, "nextBatchSize");
+async function drainBatches(ctx) {
+  while (true) {
+    if (ctx.queue.length === 0) {
+      if (ctx.sourceDone) return;
+      await new Promise((resolve2) => {
+        ctx.wakeConsumer = resolve2;
+      });
+      continue;
+    }
+    const count2 = nextBatchSize(ctx);
+    const batch = ctx.queue.slice(0, count2);
+    ctx.queue = ctx.queue.slice(count2);
+    await ctx.batchWrite(batch);
+    ctx.state.pendingOps -= batch.length;
+    wake(ctx, "wakeProducer");
+  }
+}
+__name(drainBatches, "drainBatches");
+function readNextChunk(reader, writer, consumer) {
+  return Promise.race([
+    reader.read(),
+    writer.closed.then(() => {
+      throw new WorkflowRuntimeError("Writable stream closed prematurely");
+    }),
+    consumer.then(() => {
+      throw new WorkflowRuntimeError("Stream consumer ended prematurely");
+    }, (err) => {
+      throw err;
+    })
+  ]);
+}
+__name(readNextChunk, "readNextChunk");
+async function awaitBackpressureRelief(ctx, consumer, maxInflight) {
+  if (ctx.state.pendingOps < maxInflight) return;
+  await Promise.race([
+    new Promise((resolve2) => {
+      ctx.wakeProducer = resolve2;
+    }),
+    consumer.then(() => void 0, () => void 0)
+  ]);
+}
+__name(awaitBackpressureRelief, "awaitBackpressureRelief");
+async function flushablePipeCoalescing(source, sink, state, batchWrite) {
+  const reader = source.getReader();
+  const writer = sink.getWriter();
+  const maxInflight = getMaxInflightChunks();
+  let cancelReason;
+  const ctx = {
+    state,
+    batchWrite,
+    queue: [],
+    sourceDone: false,
+    wakeConsumer: null,
+    wakeProducer: null,
+    maxChunksPerBatch: getMaxChunksPerBatch(),
+    maxBytesPerBatch: getMaxBytesPerBatch()
+  };
+  const consumer = drainBatches(ctx);
+  try {
+    while (!state.streamEnded) {
+      const readResult = await readNextChunk(reader, writer, consumer);
+      if (state.streamEnded) return;
+      if (readResult.done) {
+        ctx.sourceDone = true;
+        wake(ctx, "wakeConsumer");
+        await consumer;
+        state.streamEnded = true;
+        await writer.close();
+        if (!state.doneResolved) {
+          state.doneResolved = true;
+          state.resolve();
+        }
+        return;
+      }
+      ctx.queue.push(readResult.value);
+      state.pendingOps++;
+      wake(ctx, "wakeConsumer");
+      await awaitBackpressureRelief(ctx, consumer, maxInflight);
+    }
+  } catch (err) {
+    state.streamEnded = true;
+    cancelReason = err;
+    ctx.sourceDone = true;
+    wake(ctx, "wakeConsumer");
+    await consumer.catch(() => {
+    });
+    if (!state.doneResolved) {
+      state.doneResolved = true;
+      state.reject(err);
+    }
+    throw err;
+  } finally {
+    reader.cancel(cancelReason).catch(() => {
+    });
+    reader.releaseLock();
+    writer.releaseLock();
+  }
+}
+__name(flushablePipeCoalescing, "flushablePipeCoalescing");
+var MAX_INFLIGHT_CHUNKS;
+var getMaxInflightChunks;
+var MAX_CHUNKS_PER_BATCH;
+var getMaxChunksPerBatch;
+var MAX_BYTES_PER_BATCH;
+var getMaxBytesPerBatch;
 var LOCK_POLL_INTERVAL_MS;
 var getLockPollIntervalMs;
 var init_flushable_stream = __esm2({
@@ -73220,6 +73660,22 @@ var init_flushable_stream = __esm2({
     init_dist2();
     init_dist();
     init_dist4();
+    init_symbols();
+    MAX_INFLIGHT_CHUNKS = 1e3;
+    getMaxInflightChunks = /* @__PURE__ */ __name2(() => envNumber("WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS", MAX_INFLIGHT_CHUNKS, {
+      integer: true,
+      min: 1
+    }), "getMaxInflightChunks");
+    MAX_CHUNKS_PER_BATCH = 1e3;
+    getMaxChunksPerBatch = /* @__PURE__ */ __name2(() => envNumber("WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH", MAX_CHUNKS_PER_BATCH, {
+      integer: true,
+      min: 1
+    }), "getMaxChunksPerBatch");
+    MAX_BYTES_PER_BATCH = 1024 * 1024;
+    getMaxBytesPerBatch = /* @__PURE__ */ __name2(() => envNumber("WORKFLOW_STREAM_MAX_BYTES_PER_BATCH", MAX_BYTES_PER_BATCH, {
+      integer: true,
+      min: 1
+    }), "getMaxBytesPerBatch");
     LOCK_POLL_INTERVAL_MS = 10;
     getLockPollIntervalMs = /* @__PURE__ */ __name2(() => envNumber("WORKFLOW_LOCK_POLL_INTERVAL_MS", LOCK_POLL_INTERVAL_MS, {
       integer: true,
@@ -73231,6 +73687,13 @@ var init_flushable_stream = __esm2({
     __name2(pollWritableLock, "pollWritableLock");
     __name2(pollReadableLock, "pollReadableLock");
     __name2(flushablePipe, "flushablePipe");
+    __name2(flushablePipePerChunk, "flushablePipePerChunk");
+    __name2(wake, "wake");
+    __name2(nextBatchSize, "nextBatchSize");
+    __name2(drainBatches, "drainBatches");
+    __name2(readNextChunk, "readNextChunk");
+    __name2(awaitBackpressureRelief, "awaitBackpressureRelief");
+    __name2(flushablePipeCoalescing, "flushablePipeCoalescing");
   }
 });
 function getStepIdAliasCandidates(stepId) {
@@ -73362,37 +73825,6 @@ var init_get_world_lazy = __esm2({
     __name2(getWorldLazy, "getWorldLazy");
   }
 });
-var STABLE_ULID;
-var STREAM_NAME_SYMBOL;
-var STREAM_TYPE_SYMBOL;
-var STREAM_FRAMING_SYMBOL;
-var STREAM_SERVER_RUN_ID_SYMBOL;
-var STREAM_SERVER_DEPLOYMENT_ID_SYMBOL;
-var BODY_INIT_SYMBOL;
-var WEBHOOK_RESPONSE_WRITABLE;
-var WORKFLOW_CLASS_REGISTRY;
-var ABORT_STREAM_NAME;
-var ABORT_HOOK_TOKEN;
-var ABORT_LISTENER_ATTACHED;
-var ABORT_READER_CANCEL;
-var init_symbols = __esm2({
-  "../core/dist/symbols.js"() {
-    "use strict";
-    STABLE_ULID = /* @__PURE__ */ Symbol.for("WORKFLOW_STABLE_ULID");
-    STREAM_NAME_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_NAME");
-    STREAM_TYPE_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_TYPE");
-    STREAM_FRAMING_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_FRAMING");
-    STREAM_SERVER_RUN_ID_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_RUN_ID");
-    STREAM_SERVER_DEPLOYMENT_ID_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID");
-    BODY_INIT_SYMBOL = /* @__PURE__ */ Symbol.for("BODY_INIT");
-    WEBHOOK_RESPONSE_WRITABLE = /* @__PURE__ */ Symbol.for("WEBHOOK_RESPONSE_WRITABLE");
-    WORKFLOW_CLASS_REGISTRY = /* @__PURE__ */ Symbol.for("workflow-class-registry");
-    ABORT_STREAM_NAME = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_STREAM_NAME");
-    ABORT_HOOK_TOKEN = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_HOOK_TOKEN");
-    ABORT_LISTENER_ATTACHED = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_LISTENER_ATTACHED");
-    ABORT_READER_CANCEL = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_READER_CANCEL");
-  }
-});
 function getRegistry(global2 = globalThis) {
   const g = global2;
   let registry22 = g[WORKFLOW_CLASS_REGISTRY];
@@ -74667,6 +75099,8 @@ var StepMaxRetries;
 var StepTracePropagated;
 var StepTtfsMs;
 var StepStsoMs;
+var StepRsfsMs;
+var StepFinalSchedulingReplayMs;
 var StepLatencyOptimizations;
 var StepSkipped;
 var StepSkipReason;
@@ -74752,6 +75186,8 @@ var init_semantic_conventions = __esm2({
     StepTracePropagated = SemanticConvention("step.trace.propagated");
     StepTtfsMs = SemanticConvention("step.ttfs_ms");
     StepStsoMs = SemanticConvention("step.stso_ms");
+    StepRsfsMs = SemanticConvention("step.rsfs_ms");
+    StepFinalSchedulingReplayMs = SemanticConvention("step.final_scheduling_replay_ms");
     StepLatencyOptimizations = SemanticConvention("step.latency_optimizations");
     StepSkipped = SemanticConvention("step.skipped");
     StepSkipReason = SemanticConvention("step.skip_reason");
@@ -79347,7 +79783,7 @@ var version2;
 var init_version = __esm2({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.34";
+    version2 = "5.0.0-beta.36";
   }
 });
 function getWorkflowQueueName(workflowName, namespace) {
@@ -80694,18 +81130,25 @@ __export2(resume_hook_exports, {
   resumeHook: /* @__PURE__ */ __name(() => resumeHook, "resumeHook"),
   resumeWebhook: /* @__PURE__ */ __name(() => resumeWebhook, "resumeWebhook")
 });
-async function getHookByTokenWithKey(token) {
+async function getHookAndRun(token) {
   const world = await getWorldLazy();
   const hook = await world.hooks.getByToken(token);
   const run22 = await world.runs.get(hook.runId);
-  const rawKey = await world.getEncryptionKeyForRun?.(run22);
+  return {
+    hook,
+    run: run22
+  };
+}
+__name(getHookAndRun, "getHookAndRun");
+async function getHookByTokenWithKey(token) {
+  const { hook, run: run22 } = await getHookAndRun(token);
+  const rawKey = await (await getWorldLazy()).getEncryptionKeyForRun?.(run22);
   const encryptionKey = rawKey ? await importKey(rawKey) : void 0;
   if (typeof hook.metadata !== "undefined") {
     hook.metadata = await hydrateStepArguments(hook.metadata, hook.runId, encryptionKey);
   }
   return {
     hook,
-    run: run22,
     encryptionKey
   };
 }
@@ -80722,27 +81165,27 @@ async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
       try {
         let hook;
         let workflowRun;
-        let encryptionKey;
         if (typeof tokenOrHook === "string") {
-          const result = await getHookByTokenWithKey(tokenOrHook);
+          const result = await getHookAndRun(tokenOrHook);
           hook = result.hook;
           workflowRun = result.run;
-          encryptionKey = encryptionKeyOverride ?? result.encryptionKey;
         } else {
           hook = tokenOrHook;
           workflowRun = await world.runs.get(hook.runId);
-          if (encryptionKeyOverride) {
-            encryptionKey = encryptionKeyOverride;
-          } else {
-            const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);
-            encryptionKey = rawKey ? await importKey(rawKey) : void 0;
-          }
         }
         span?.setAttributes({
           ...HookToken(hook.token),
           ...HookId(hook.hookId),
           ...WorkflowRunId(hook.runId)
         });
+        if (isTerminalWorkflowRunStatus(workflowRun.status)) {
+          throw new HookNotFoundError(hook.token);
+        }
+        let encryptionKey = encryptionKeyOverride;
+        if (!encryptionKey) {
+          const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);
+          encryptionKey = rawKey ? await importKey(rawKey) : void 0;
+        }
         const rawVersion = workflowRun.executionContext?.workflowCoreVersion;
         const capabilities = getRunCapabilities(typeof rawVersion === "string" ? rawVersion : void 0);
         if (!capabilities.supportedFormats.has(SerializationFormat.ENCRYPTED)) {
@@ -80856,6 +81299,7 @@ var init_resume_hook = __esm2({
     init_get_world_lazy();
     init_helpers();
     init_wait_until();
+    __name2(getHookAndRun, "getHookAndRun");
     __name2(getHookByTokenWithKey, "getHookByTokenWithKey");
     __name2(getHookByToken, "getHookByToken");
     __name2(resumeHook, "resumeHook");
@@ -81989,10 +82433,6 @@ function getStepRevivers(global2 = globalThis, ops, runId, cryptoKey, deployment
   };
 }
 __name(getStepRevivers, "getStepRevivers");
-async function maybeDecrypt(data, key) {
-  return decrypt2(data, key);
-}
-__name(maybeDecrypt, "maybeDecrypt");
 async function dehydrateWorkflowArguments(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false) {
   if (v1Compat) {
     const str = stringify(value, getExternalReducers(global2, ops, runId, key, framedByteStreams));
@@ -82098,7 +82538,7 @@ async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = g
 __name(dehydrateStepReturnValue, "dehydrateStepReturnValue");
 async function hydrateRunError(value, runId, key, ops = [], global2 = globalThis, extraRevivers = {}) {
   const compressionStats = {};
-  const decrypted = await decompress(await maybeDecrypt(value, key), compressionStats);
+  const decrypted = await decompress(await decrypt2(value, key), compressionStats);
   await recordCompression(compressionStats, "deserialize");
   if (!(decrypted instanceof Uint8Array)) {
     return unflatten(decrypted, {
@@ -82395,6 +82835,16 @@ var init_serialization2 = __esm2({
             for (const w of waiters) w.reject(abortError);
           }
         });
+        Object.defineProperty(this, STREAM_WRITE_BATCH_SYMBOL, {
+          value: /* @__PURE__ */ __name2(async (chunks) => {
+            if (chunks.length === 0) return;
+            if (batchStartAt === void 0) batchStartAt = Date.now();
+            for (const chunk of chunks) buffer22.push(chunk);
+            await flush();
+          }, "value"),
+          enumerable: false,
+          writable: false
+        });
       }
     };
     __name2(getAllBaseReducers, "getAllBaseReducers");
@@ -82413,7 +82863,6 @@ var init_serialization2 = __esm2({
     __name2(getForwardedWritableEncryptionKey, "getForwardedWritableEncryptionKey");
     __name2(getExternalRevivers, "getExternalRevivers");
     __name2(getStepRevivers, "getStepRevivers");
-    __name2(maybeDecrypt, "maybeDecrypt");
     __name2(dehydrateWorkflowArguments, "dehydrateWorkflowArguments");
     __name2(hydrateWorkflowReturnValue, "hydrateWorkflowReturnValue");
     __name2(dehydrateStepArguments, "dehydrateStepArguments");
@@ -82609,6 +83058,7 @@ __name2(isRetryableWorldError, "isRetryableWorldError");
 init_encryption();
 init_logger();
 init_serialization2();
+init_context_storage();
 init_semantic_conventions();
 init_telemetry();
 init_version();
@@ -82618,6 +83068,17 @@ init_wait_until();
 init_world_compatibility();
 var CROSS_DEPLOYMENT_CAPABILITY_PROBE_TIMEOUT_MS = 2e3;
 var ulid3 = monotonicFactory();
+function resolveLineageAttributes() {
+  const store = contextStorage.getStore();
+  const parentRunId = store?.workflowMetadata?.workflowRunId;
+  if (!parentRunId) return void 0;
+  return {
+    [ROOT_RUN_ID_ATTRIBUTE]: store.rootRunId ?? parentRunId,
+    [PARENT_RUN_ID_ATTRIBUTE]: parentRunId
+  };
+}
+__name(resolveLineageAttributes, "resolveLineageAttributes");
+__name2(resolveLineageAttributes, "resolveLineageAttributes");
 var hasWarnedLatestNoOp = false;
 async function start(workflow, argsOrOptions, options) {
   return await waitedUntil(() => {
@@ -82702,9 +83163,14 @@ async function start(workflow, argsOrOptions, options) {
           value
         ]));
       }
-      const attributeSeed = attributes ? {
-        attributes,
-        ...allowReservedAttributes ? {
+      const lineage = specVersion >= SPEC_VERSION_SUPPORTS_ATTRIBUTES ? resolveLineageAttributes() : void 0;
+      const runAttributes = lineage ? {
+        ...lineage,
+        ...attributes
+      } : attributes;
+      const attributeSeed = runAttributes ? {
+        attributes: runAttributes,
+        ...allowReservedAttributes || lineage != null ? {
           allowReservedAttributes: true
         } : {}
       } : {};
@@ -82819,7 +83285,7 @@ __name2(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.34//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.36//start");
 async function wakeUpRun(world, runId, options) {
   try {
     const run22 = await world.runs.get(runId, {
@@ -83155,7 +83621,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.34//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.36//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);
@@ -83164,7 +83630,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.34//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.36//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);
@@ -83173,7 +83639,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.34//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.36//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);
@@ -83182,7 +83648,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.34//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//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);
@@ -83191,7 +83657,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.34//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//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);
@@ -83200,7 +83666,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.34//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//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);
@@ -83209,7 +83675,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.34//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//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);
@@ -83218,7 +83684,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.34//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//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);
@@ -83227,7 +83693,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.34//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//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);
@@ -83236,7 +83702,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.34//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//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);
@@ -83246,7 +83712,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.34//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.36//Run");
 async function fetch2(...args) {
   return globalThis.fetch(...args);
 }
@@ -83287,6 +83753,26 @@ async function addTenWorkflow(input) {
 __name(addTenWorkflow, "addTenWorkflow");
 __name2(addTenWorkflow, "addTenWorkflow");
 addTenWorkflow.workflowId = "workflow//./workflows/addition//addTenWorkflow";
+async function tick(i) {
+  return i;
+}
+__name(tick, "tick");
+__name2(tick, "tick");
+(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);
+  __wf_fn.stepId = __wf_id;
+  Object.defineProperty(__wf_fn, "name", {
+    value: "tick",
+    configurable: true
+  });
+})(tick, "step//./workflows/event-limit//tick");
+async function runawayWorkflow() {
+  throw new Error("You attempted to execute workflow runawayWorkflow function directly. To start a workflow, use start(runawayWorkflow) from workflow/api");
+}
+__name(runawayWorkflow, "runawayWorkflow");
+__name2(runawayWorkflow, "runawayWorkflow");
+runawayWorkflow.workflowId = "workflow//./workflows/event-limit//runawayWorkflow";
 init_dist2();
 function redirectStackToCaller(err, stackStartFn) {
   const capture = Error.captureStackTrace;
@@ -83612,13 +84098,56 @@ async function hookWorkflow(token) {
 __name(hookWorkflow, "hookWorkflow");
 __name2(hookWorkflow, "hookWorkflow");
 hookWorkflow.workflowId = "workflow//./workflows/inline-execution//hookWorkflow";
+async function noop() {
+}
+__name(noop, "noop");
+__name2(noop, "noop");
+(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);
+  __wf_fn.stepId = __wf_id;
+  Object.defineProperty(__wf_fn, "name", {
+    value: "noop",
+    configurable: true
+  });
+})(noop, "step//./workflows/lineage//noop");
+async function bodyStartsChild() {
+  throw new Error("You attempted to execute workflow bodyStartsChild function directly. To start a workflow, use start(bodyStartsChild) from workflow/api");
+}
+__name(bodyStartsChild, "bodyStartsChild");
+__name2(bodyStartsChild, "bodyStartsChild");
+bodyStartsChild.workflowId = "workflow//./workflows/lineage//bodyStartsChild";
+async function spawnedChild() {
+  throw new Error("You attempted to execute workflow spawnedChild function directly. To start a workflow, use start(spawnedChild) from workflow/api");
+}
+__name(spawnedChild, "spawnedChild");
+__name2(spawnedChild, "spawnedChild");
+spawnedChild.workflowId = "workflow//./workflows/lineage//spawnedChild";
+async function chainRoot() {
+  throw new Error("You attempted to execute workflow chainRoot function directly. To start a workflow, use start(chainRoot) from workflow/api");
+}
+__name(chainRoot, "chainRoot");
+__name2(chainRoot, "chainRoot");
+chainRoot.workflowId = "workflow//./workflows/lineage//chainRoot";
+async function chainMiddle() {
+  throw new Error("You attempted to execute workflow chainMiddle function directly. To start a workflow, use start(chainMiddle) from workflow/api");
+}
+__name(chainMiddle, "chainMiddle");
+__name2(chainMiddle, "chainMiddle");
+chainMiddle.workflowId = "workflow//./workflows/lineage//chainMiddle";
+async function chainLeaf() {
+  throw new Error("You attempted to execute workflow chainLeaf function directly. To start a workflow, use start(chainLeaf) from workflow/api");
+}
+__name(chainLeaf, "chainLeaf");
+__name2(chainLeaf, "chainLeaf");
+chainLeaf.workflowId = "workflow//./workflows/lineage//chainLeaf";
 var count = 0;
-async function noop(_i) {
+async function noop2(_i) {
   count++;
   return count;
 }
-__name(noop, "noop");
-__name2(noop, "noop");
+__name(noop2, "noop2");
+__name2(noop2, "noop");
 (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);
@@ -83627,7 +84156,7 @@ __name2(noop, "noop");
     value: "noop",
     configurable: true
   });
-})(noop, "step//./workflows/noop//noop");
+})(noop2, "step//./workflows/noop//noop");
 async function brokenWf() {
   throw new Error("You attempted to execute workflow brokenWf function directly. To start a workflow, use start(brokenWf) from workflow/api");
 }
@@ -83732,7 +84261,7 @@ __export(dist_exports2, {
   parseVersion: () => parseVersion
 });
 init_dist5();
-import { promises as fs6 } from "node:fs";
+import { promises as fs7 } from "node:fs";
 import { rm } from "node:fs/promises";
 import path10 from "node:path";
 
@@ -83997,6 +84526,18 @@ var config3 = once3(() => {
   const baseUrl = getBaseUrlFromEnv();
   return { dataDir, baseUrl };
 });
+function resolveRecoverActiveRuns(config4) {
+  if (config4.recoverActiveRuns !== void 0) {
+    return config4.recoverActiveRuns;
+  }
+  const raw = process.env.WORKFLOW_LOCAL_RECOVER_ACTIVE_RUNS?.toLowerCase();
+  if (raw === "0" || raw === "false")
+    return false;
+  if (raw === "1" || raw === "true")
+    return true;
+  return true;
+}
+__name(resolveRecoverActiveRuns, "resolveRecoverActiveRuns");
 function resolveDirectBaseUrl(config4) {
   return config4.baseUrl ?? process.env.WORKFLOW_LOCAL_BASE_URL ?? createWorkflowBaseUrl("http://localhost");
 }
@@ -84290,6 +84831,21 @@ async function writeExclusive(filePath, data) {
   }
 }
 __name(writeExclusive, "writeExclusive");
+async function promoteExclusive(stagedPath, filePath) {
+  try {
+    await withEnsuredDirectory(path.dirname(filePath), () => withWindowsRetry(() => fs.link(stagedPath, filePath)));
+    return "linked";
+  } catch (error95) {
+    if (error95.code === "EEXIST") {
+      return "exists";
+    }
+    if (error95.code === "ENOENT") {
+      return "missing";
+    }
+    throw error95;
+  }
+}
+__name(promoteExclusive, "promoteExclusive");
 async function listJSONFiles(dirPath) {
   return listFilesByExtension(dirPath, ".json");
 }
@@ -85063,6 +85619,104 @@ async function isHookDisposalCommitted(basedir, hookId, tag) {
   return false;
 }
 __name(isHookDisposalCommitted, "isHookDisposalCommitted");
+function runTerminalMarkerPath(basedir, runId, tag) {
+  const name = tag ? `${runId}.terminal.${tag}` : `${runId}.terminal`;
+  return resolveWithinBase(basedir, ".locks", "runs", name);
+}
+__name(runTerminalMarkerPath, "runTerminalMarkerPath");
+async function isRunTerminalCommitted(basedir, runId, tag) {
+  const candidates = [runTerminalMarkerPath(basedir, runId)];
+  if (tag) {
+    candidates.push(runTerminalMarkerPath(basedir, runId, tag));
+  }
+  for (const markerPath of candidates) {
+    try {
+      await fs2.access(markerPath);
+      return true;
+    } catch (error95) {
+      if (error95.code !== "ENOENT") {
+        throw error95;
+      }
+    }
+  }
+  return false;
+}
+__name(isRunTerminalCommitted, "isRunTerminalCommitted");
+function pendingHookEventDir(basedir, runId, tag) {
+  const name = tag ? `${runId}.pending.${tag}` : `${runId}.pending`;
+  return resolveWithinBase(basedir, ".locks", "runs", name);
+}
+__name(pendingHookEventDir, "pendingHookEventDir");
+function pendingHookEventPath(basedir, runId, eventId, tag) {
+  return path3.join(pendingHookEventDir(basedir, runId, tag), `${eventId}.json`);
+}
+__name(pendingHookEventPath, "pendingHookEventPath");
+async function reapPendingHookEvents(basedir, runId, tag) {
+  const dirs = [pendingHookEventDir(basedir, runId)];
+  if (tag) {
+    dirs.push(pendingHookEventDir(basedir, runId, tag));
+  }
+  for (const dir of dirs) {
+    let entries;
+    try {
+      entries = await fs2.readdir(dir);
+    } catch (error95) {
+      if (error95.code === "ENOENT") {
+        continue;
+      }
+      throw error95;
+    }
+    for (const entry of entries) {
+      try {
+        await withWindowsRetry(() => fs2.unlink(path3.join(dir, entry)));
+      } catch (error95) {
+        if (error95.code !== "ENOENT") {
+          throw error95;
+        }
+      }
+    }
+    await fs2.rmdir(dir).catch(() => {
+    });
+  }
+}
+__name(reapPendingHookEvents, "reapPendingHookEvents");
+async function mintRunDominantEventKey(basedir, runId, tag) {
+  let files = [];
+  try {
+    files = await fs2.readdir(path3.join(basedir, "events"));
+  } catch (error95) {
+    if (error95.code !== "ENOENT") {
+      throw error95;
+    }
+  }
+  const prefix = `${runId}-`;
+  let maxUlid = null;
+  for (const file3 of files) {
+    if (!file3.startsWith(prefix) || !file3.endsWith(".json")) {
+      continue;
+    }
+    const fileId = file3.slice(0, -".json".length);
+    if (!isUntagged(fileId) && !(tag && hasTag(fileId, tag))) {
+      continue;
+    }
+    const candidate = stripTag(fileId).slice(prefix.length);
+    if (!maxUlid || candidate > maxUlid) {
+      maxUlid = candidate;
+    }
+  }
+  let ts = Date.now();
+  if (maxUlid) {
+    try {
+      const maxTs = decodeTime(maxUlid.replace(/^evnt_/, ""));
+      if (ts <= maxTs) {
+        ts = maxTs + 1;
+      }
+    } catch {
+    }
+  }
+  return { eventId: `evnt_${monotonicUlid(ts)}`, createdAt: new Date(ts) };
+}
+__name(mintRunDominantEventKey, "mintRunDominantEventKey");
 function hookTokenClaimPath(basedir, token) {
   return path3.join(basedir, "hooks", "tokens", `${hashToken(token)}.json`);
 }
@@ -85321,7 +85975,7 @@ __name(findNewestIndexedHookCreatedEvent, "findNewestIndexedHookCreatedEvent");
 init_dist7();
 init_dist5();
 init_zod2();
-import fs4 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import path7 from "node:path";
 
 // ../world-local/dist/storage/filters.js
@@ -85392,7 +86046,7 @@ function isMatchingHookCreatedEvent(event, matches) {
 __name(isMatchingHookCreatedEvent, "isMatchingHookCreatedEvent");
 async function isTerminalRunCache(basedir, runId, tag) {
   const run3 = await readJSONWithFallback(basedir, "runs", runId, WorkflowRunSchema2, tag);
-  return run3 ? isTerminalWorkflowRunStatus(run3.status) : false;
+  return run3 ? isTerminalWorkflowRunStatus2(run3.status) : false;
 }
 __name(isTerminalRunCache, "isTerminalRunCache");
 async function findLiveHookCreatedEvent(basedir, index, matches, tag) {
@@ -85550,12 +86204,36 @@ async function deleteAllHooksForRun(basedir, runId) {
 __name(deleteAllHooksForRun, "deleteAllHooksForRun");
 
 // ../world-local/dist/storage/legacy.js
+init_dist7();
 init_dist5();
+import fs4 from "node:fs/promises";
+async function publishLegacyHookReceived(basedir, runId, eventId, serializedEvent, eventPath, currentRun) {
+  if (isTerminalWorkflowRunStatus2(currentRun.status) || await isRunTerminalCommitted(basedir, runId)) {
+    throw new RunExpiredError(`Workflow run "${runId}" is already in a terminal state`);
+  }
+  const stagedPath = pendingHookEventPath(basedir, runId, eventId);
+  await writeExclusive(stagedPath, serializedEvent);
+  try {
+    if (await isRunTerminalCommitted(basedir, runId)) {
+      throw new RunExpiredError(`Workflow run "${runId}" is already in a terminal state`);
+    }
+    const promoted = await promoteExclusive(stagedPath, eventPath);
+    if (promoted !== "linked") {
+      throw new RunExpiredError(`Workflow run "${runId}" is already in a terminal state`);
+    }
+  } finally {
+    await fs4.unlink(stagedPath).catch(() => {
+    });
+  }
+}
+__name(publishLegacyHookReceived, "publishLegacyHookReceived");
 async function handleLegacyEvent(basedir, runId, data, currentRun, params) {
   assertSafeEntityId("runId", runId);
   const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
   switch (data.eventType) {
     case "run_cancelled": {
+      await writeExclusive(runTerminalMarkerPath(basedir, runId), "");
+      await reapPendingHookEvents(basedir, runId);
       const now = /* @__PURE__ */ new Date();
       const run3 = {
         runId: currentRun.runId,
@@ -85595,7 +86273,11 @@ async function handleLegacyEvent(basedir, runId, data, currentRun, params) {
       };
       const compositeKey = `${runId}-${eventId}`;
       const eventPath = resolveWithinBase(basedir, "events", `${compositeKey}.json`);
-      await writeJSON(eventPath, event);
+      if (data.eventType === "hook_received") {
+        await publishLegacyHookReceived(basedir, runId, eventId, JSON.stringify(event, jsonReplacer, 2), eventPath, currentRun);
+      } else {
+        await writeJSON(eventPath, event);
+      }
       return { event: stripEventDataRefs(event, resolveData) };
     }
     default:
@@ -85629,16 +86311,32 @@ function withRunFileLock(key, fn) {
 }
 __name(withRunFileLock, "withRunFileLock");
 function createRunsStorage(basedir, tag) {
+  const get = /* @__PURE__ */ __name((async (id, params) => {
+    assertSafeEntityId("runId", id);
+    const run3 = await readJSONWithFallback(basedir, "runs", id, WorkflowRunSchema2, tag);
+    if (!run3) {
+      throw new WorkflowRunNotFoundError2(id);
+    }
+    const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+    return filterRunData(run3, resolveData);
+  }), "get");
   return {
-    get: /* @__PURE__ */ __name((async (id, params) => {
-      assertSafeEntityId("runId", id);
-      const run3 = await readJSONWithFallback(basedir, "runs", id, WorkflowRunSchema2, tag);
-      if (!run3) {
-        throw new WorkflowRunNotFoundError2(id);
-      }
-      const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-      return filterRunData(run3, resolveData);
-    }), "get"),
+    get,
+    getMany: /* @__PURE__ */ __name((async (ids, params) => {
+      const uniqueIds = [...new Set(ids)];
+      const runs = await Promise.all(uniqueIds.map(async (id) => {
+        try {
+          return await get(id, params);
+        } catch (error95) {
+          if (error95 instanceof WorkflowRunNotFoundError2) {
+            return null;
+          }
+          throw error95;
+        }
+      }));
+      const runById = new Map(uniqueIds.map((id, i) => [id, runs[i]]));
+      return ids.map((id) => runById.get(id) ?? null);
+    }), "getMany"),
     list: /* @__PURE__ */ __name((async (params) => {
       const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
       const result = await paginatedFileSystemQuery({
@@ -85710,6 +86408,13 @@ function createRunsStorage(basedir, tag) {
 __name(createRunsStorage, "createRunsStorage");
 
 // ../world-local/dist/storage/events-storage.js
+var DEFAULT_MAX_EVENTS_PER_RUN = 25e3;
+function getMaxEventsPerRun() {
+  const raw = process.env.WORKFLOW_MAX_EVENTS;
+  const parsed = raw !== void 0 ? Number(raw) : Number.NaN;
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_EVENTS_PER_RUN;
+}
+__name(getMaxEventsPerRun, "getMaxEventsPerRun");
 var HookTokenClaimSchema = external_exports2.object({
   // The token-claim writer below has always persisted `hookId`, but
   // this read schema previously omitted it, which is the bug fixed
@@ -85751,7 +86456,7 @@ async function isHookTokenClaimReleasable(basedir, claim, tag) {
   if (!owningRun) {
     return true;
   }
-  return isTerminalWorkflowRunStatus(owningRun.status);
+  return isTerminalWorkflowRunStatus2(owningRun.status);
 }
 __name(isHookTokenClaimReleasable, "isHookTokenClaimReleasable");
 async function readHookRecoveryMarker(markerPath) {
@@ -86046,7 +86751,7 @@ function createEventsStorage(basedir, tag) {
         }
         const createsChildEntity = isChildEntityCreationEvent(data);
         const lazyStepStart = createsChildEntity && data.eventType === "step_started";
-        if (currentRun && isTerminalWorkflowRunStatus(currentRun.status)) {
+        if (currentRun && isTerminalWorkflowRunStatus2(currentRun.status)) {
           if (data.eventType === "run_cancelled" && currentRun.status === "cancelled") {
             const event2 = {
               ...data,
@@ -86059,7 +86764,8 @@ function createEventsStorage(basedir, tag) {
             const resolveData2 = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
             return {
               event: stripEventDataRefs(event2, resolveData2),
-              run: currentRun
+              run: currentRun,
+              ...currentRun ? { maxEvents: getMaxEventsPerRun() } : {}
             };
           }
           if (data.eventType === "run_started") {
@@ -86090,7 +86796,7 @@ function createEventsStorage(basedir, tag) {
             if (isTerminalStepStatus(validatedStep.status)) {
               throw new EntityConflictError2(`Cannot modify step in terminal state "${validatedStep.status}"`);
             }
-            if (currentRun && isTerminalWorkflowRunStatus(currentRun.status)) {
+            if (currentRun && isTerminalWorkflowRunStatus2(currentRun.status)) {
               if (validatedStep.status !== "running") {
                 throw new RunExpiredError(`Cannot modify non-running step on run in terminal state "${currentRun.status}"`);
               }
@@ -86126,6 +86832,13 @@ function createEventsStorage(basedir, tag) {
         let wait;
         let stepCreatedLazily = false;
         let hookEntityWriteOptions;
+        if (isTerminalRunEventType(data.eventType) && currentRun) {
+          await writeExclusive(runTerminalMarkerPath(basedir, effectiveRunId, tag), "");
+          await reapPendingHookEvents(basedir, effectiveRunId, tag);
+          const dominantKey = await mintRunDominantEventKey(basedir, effectiveRunId, tag);
+          eventId = dominantKey.eventId;
+          event = { ...event, eventId, createdAt: dominantKey.createdAt };
+        }
         if (data.eventType === "run_created" && "eventData" in data) {
           const runData = data.eventData;
           validateAttributeChanges2(Object.entries(runData.attributes ?? {}).map(([key, value]) => ({
@@ -86159,7 +86872,7 @@ function createEventsStorage(basedir, tag) {
         } else if (data.eventType === "run_started") {
           if (currentRun) {
             if (currentRun.status === "running") {
-              return { run: currentRun };
+              return { run: currentRun, maxEvents: getMaxEventsPerRun() };
             }
             run3 = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
               runId: currentRun.runId,
@@ -86591,7 +87304,7 @@ function createEventsStorage(basedir, tag) {
           }
           const existingWait = await readJSONWithFallback(basedir, "waits", waitCompositeKey, WaitSchema2, tag);
           if (!existingWait) {
-            await fs4.unlink(lockPath).catch(() => {
+            await fs5.unlink(lockPath).catch(() => {
             });
             throw new WorkflowWorldError2(`Wait "${data.correlationId}" not found`);
           }
@@ -86609,7 +87322,34 @@ function createEventsStorage(basedir, tag) {
         const compositeKey = `${effectiveRunId}-${eventId}`;
         const eventPath = taggedPath(basedir, "events", compositeKey, tag);
         const serializedEvent = JSON.stringify(event, jsonReplacer, 2);
-        const eventPublished = await writeExclusive(eventPath, serializedEvent);
+        let eventPublished;
+        if (data.eventType === "hook_received") {
+          const terminalByMarker = await isRunTerminalCommitted(basedir, effectiveRunId, tag);
+          const runNow = terminalByMarker ? null : await readJSONWithFallback(basedir, "runs", effectiveRunId, WorkflowRunSchema2, tag);
+          if (terminalByMarker || runNow && isTerminalWorkflowRunStatus2(runNow.status)) {
+            throw new RunExpiredError(`Workflow run "${effectiveRunId}" is already in a terminal state`);
+          }
+          const stagedPath = pendingHookEventPath(basedir, effectiveRunId, eventId, tag);
+          const staged = await writeExclusive(stagedPath, serializedEvent);
+          if (!staged) {
+            throw new EntityConflictError2(`Event "${eventId}" already exists for run "${effectiveRunId}"`);
+          }
+          try {
+            if (await isRunTerminalCommitted(basedir, effectiveRunId, tag)) {
+              throw new RunExpiredError(`Workflow run "${effectiveRunId}" is already in a terminal state`);
+            }
+            const promoted = await promoteExclusive(stagedPath, eventPath);
+            if (promoted === "missing") {
+              throw new RunExpiredError(`Workflow run "${effectiveRunId}" is already in a terminal state`);
+            }
+            eventPublished = promoted === "linked";
+          } finally {
+            await deleteJSON(stagedPath).catch(() => {
+            });
+          }
+        } else {
+          eventPublished = await writeExclusive(eventPath, serializedEvent);
+        }
         if (!eventPublished) {
           if (data.eventType === "hook_created" && data.correlationId) {
             await repairHookEntityFromPersistedEvent(basedir, effectiveRunId, data.correlationId, eventId, tag);
@@ -86664,7 +87404,9 @@ function createEventsStorage(basedir, tag) {
           events,
           cursor,
           hasMore,
-          ...stepCreatedLazily ? { stepCreated: true } : {}
+          ...stepCreatedLazily ? { stepCreated: true } : {},
+          // Per-run event ceiling (mirrors the Vercel World).
+          ...run3 ? { maxEvents: getMaxEventsPerRun() } : {}
         };
       }
       __name(createImpl, "createImpl");
@@ -86800,7 +87542,7 @@ __name(createStorage, "createStorage");
 init_node2();
 init_zod2();
 import { EventEmitter } from "node:events";
-import fs5 from "node:fs/promises";
+import fs6 from "node:fs/promises";
 import path9 from "node:path";
 var monotonicUlid2 = monotonicFactory2(() => Math.random());
 var RunStreamsSchema = external_exports2.object({
@@ -86828,7 +87570,7 @@ function deserializeChunk(serialized) {
 __name(deserializeChunk, "deserializeChunk");
 async function listChunkEntries(chunksDir) {
   try {
-    return await fs5.readdir(chunksDir);
+    return await fs6.readdir(chunksDir);
   } catch (error95) {
     if (error95.code === "ENOENT")
       return [];
@@ -87193,7 +87935,7 @@ function createWorld(args) {
   const tag = mergedConfig.tag;
   const queue = createQueue(mergedConfig);
   const { clearCache: clearStorageCache, ...storage } = createStorage(mergedConfig.dataDir, tag);
-  const recoverActiveRuns = mergedConfig.recoverActiveRuns ?? true;
+  const recoverActiveRuns = resolveRecoverActiveRuns(mergedConfig);
   return {
     specVersion: SPEC_VERSION_CURRENT2,
     ...queue,
@@ -87255,7 +87997,7 @@ function createWorld(args) {
           const fullIndexDir = path10.join(basedir, "hooks", indexDir);
           let keyDirEntries;
           try {
-            keyDirEntries = await fs6.readdir(fullIndexDir, {
+            keyDirEntries = await fs7.readdir(fullIndexDir, {
               withFileTypes: true
             });
           } catch {
@@ -87267,12 +88009,12 @@ function createWorld(args) {
             await Promise.all(taggedEntryFiles.map((f) => deleteJSON(path10.join(keyDir, f))));
           }));
         }
-        await fs6.rm(path10.join(basedir, ".locks"), { recursive: true, force: true }).catch(() => {
+        await fs7.rm(path10.join(basedir, ".locks"), { recursive: true, force: true }).catch(() => {
         });
         const chunksDir = path10.join(basedir, "streams", "chunks");
         let streamDirEntries;
         try {
-          streamDirEntries = await fs6.readdir(chunksDir, {
+          streamDirEntries = await fs7.readdir(chunksDir, {
             withFileTypes: true
           });
         } catch {
@@ -87281,7 +88023,7 @@ function createWorld(args) {
         await Promise.all(streamDirEntries.filter((entry) => entry.isDirectory()).map(async (entry) => {
           const streamChunkDir = path10.join(chunksDir, entry.name);
           const taggedBinFiles = await listTaggedFilesByExtension(streamChunkDir, tag, ".bin");
-          await Promise.all(taggedBinFiles.map((f) => fs6.unlink(path10.join(streamChunkDir, f)).catch(() => {
+          await Promise.all(taggedBinFiles.map((f) => fs7.unlink(path10.join(streamChunkDir, f)).catch(() => {
           })));
         }));
         clearCreatedFilesCache();
@@ -87429,6 +88171,9 @@ function classifyRunError(err) {
   if (CorruptedEventLogError.is(err)) {
     return RUN_ERROR_CODES2.CORRUPTED_EVENT_LOG;
   }
+  if (MaxEventsExceededError.is(err)) {
+    return RUN_ERROR_CODES2.MAX_EVENTS_EXCEEDED;
+  }
   if (isWorldContractError(err) || isRetryableWorldError2(err)) {
     return RUN_ERROR_CODES2.WORLD_CONTRACT_ERROR;
   }
@@ -87630,6 +88375,7 @@ var RUNTIME_ERROR_HINT = "This is an internal workflow SDK error, not a bug in y
 var CORRUPTED_EVENT_LOG_HINT = "The workflow event log contains orphaned or mismatched events and cannot be replayed. This is an internal workflow SDK error; please report it with the runId.";
 var REPLAY_TIMEOUT_HINT = 'The workflow replay between step boundaries took too long. This bounds workflow-VM and event-log replay time only \u2014 step bodies (`"use step"` functions) are excluded. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work in workflow code outside of step bodies. Override the default budget via the WORKFLOW_REPLAY_TIMEOUT_MS env var if needed.';
 var MAX_DELIVERIES_HINT = "The workflow queue exceeded its max-delivery budget. This usually indicates a persistent runtime failure \u2014 check the most recent stack traces for the underlying cause.";
+var MAX_EVENTS_HINT = "The workflow exceeded the maximum number of events per run. This usually means unbounded work in the workflow function \u2014 e.g. a loop that keeps creating steps without terminating. Break long-running workflows into child workflows to stay under the limit.";
 var WORLD_CONTRACT_HINT = "The workflow backend returned data that violated the SDK contract. This is not retryable; please report it with the stack trace and runId.";
 function describeError(err, errorCode) {
   const effectiveCode = errorCode ?? classifyRunError(err);
@@ -87675,6 +88421,13 @@ function describeError(err, errorCode) {
       hint: MAX_DELIVERIES_HINT
     };
   }
+  if (effectiveCode === RUN_ERROR_CODES2.MAX_EVENTS_EXCEEDED) {
+    return {
+      attribution: "user",
+      errorCode: effectiveCode,
+      hint: MAX_EVENTS_HINT
+    };
+  }
   if (effectiveCode === RUN_ERROR_CODES2.CORRUPTED_EVENT_LOG) {
     return {
       attribution: "sdk",
@@ -87697,6 +88450,129 @@ __name(describeError, "describeError");
 init_global2();
 init_logger2();
 
+// ../core/dist/replay-payload-cache.js
+init_serialization4();
+var MAX_MEMOIZED_PRIMITIVE_LENGTH = 4096;
+function isMemoizablePrimitive(value) {
+  if (value === null)
+    return true;
+  const type = typeof value;
+  if (type === "object" || type === "function")
+    return false;
+  if (type === "string") {
+    return value.length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;
+  }
+  if (type === "bigint") {
+    return value.toString().length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;
+  }
+  return true;
+}
+__name(isMemoizablePrimitive, "isMemoizablePrimitive");
+var ReplayPayloadCache = class {
+  static {
+    __name(this, "ReplayPayloadCache");
+  }
+  encryptionKey;
+  preparer;
+  preparedPayloads = /* @__PURE__ */ new Map();
+  primitiveStepResults = /* @__PURE__ */ new Map();
+  constructor(encryptionKey, preparer = prepareReplayPayload) {
+    this.encryptionKey = encryptionKey;
+    this.preparer = preparer;
+  }
+  /**
+   * Start every missing binary preparation before workflow execution. Failures
+   * are intentionally retained: the ordered event consumer must observe the
+   * original rejection before that entry becomes retryable.
+   */
+  async prewarm(workflowRun, events) {
+    const preparations = [];
+    const start3 = /* @__PURE__ */ __name((cacheKey, value) => {
+      if (!(value instanceof Uint8Array))
+        return;
+      if (this.preparedPayloads.has(cacheKey))
+        return;
+      preparations.push(this.ensurePreparation(cacheKey, value));
+    }, "start");
+    start3(this.workflowInputKey(workflowRun.runId), workflowRun.input);
+    for (const event of events) {
+      switch (event.eventType) {
+        case "step_completed":
+          start3(this.eventPayloadKey(event.eventId, "result"), event.eventData?.result);
+          break;
+        case "step_failed":
+          start3(this.eventPayloadKey(event.eventId, "error"), event.eventData?.error);
+          break;
+        case "hook_received":
+          start3(this.eventPayloadKey(event.eventId, "payload"), event.eventData?.payload);
+          break;
+      }
+    }
+    await Promise.allSettled(preparations);
+  }
+  /** Return the workflow input after shared host-side preparation. */
+  prepareWorkflowInput(workflowRun) {
+    return this.consumePreparation(this.workflowInputKey(workflowRun.runId), workflowRun.input);
+  }
+  /**
+   * Return an event payload after shared host-side preparation. A rejected
+   * preparation is evicted only after this ordered consumer requests it, so a
+   * later replay can retry without hiding the original failure.
+   */
+  prepareEventPayload(eventId, field, value) {
+    return this.consumePreparation(this.eventPayloadKey(eventId, field), value);
+  }
+  /**
+   * Reuse final step values only when sharing them across VMs is unobservable.
+   * Objects and large strings/bigints always run `hydrate` again, producing a
+   * fresh VM-specific value from the separately cached prepared payload.
+   */
+  async getStepResult(eventId, hydrate) {
+    if (this.primitiveStepResults.has(eventId)) {
+      return this.primitiveStepResults.get(eventId);
+    }
+    const value = await hydrate();
+    if (isMemoizablePrimitive(value)) {
+      this.primitiveStepResults.set(eventId, value);
+    }
+    return value;
+  }
+  /**
+   * Consumer-facing lookup. Binary payloads share preparation; legacy values
+   * bypass the cache because their flattened representation may be mutated.
+   */
+  consumePreparation(cacheKey, value) {
+    if (!(value instanceof Uint8Array))
+      return this.runPreparation(value);
+    const preparation = this.ensurePreparation(cacheKey, value);
+    void preparation.catch(() => {
+      if (this.preparedPayloads.get(cacheKey) === preparation) {
+        this.preparedPayloads.delete(cacheKey);
+      }
+    });
+    return preparation;
+  }
+  /** Start preparation once and share the exact in-flight promise. */
+  ensurePreparation(cacheKey, value) {
+    const cached3 = this.preparedPayloads.get(cacheKey);
+    if (cached3)
+      return cached3;
+    const preparation = this.runPreparation(value);
+    this.preparedPayloads.set(cacheKey, preparation);
+    return preparation;
+  }
+  /** Normalize synchronous and asynchronous preparers to one promise contract. */
+  async runPreparation(value) {
+    return this.preparer(value, this.encryptionKey);
+  }
+  workflowInputKey(runId) {
+    return `run:${runId}:input`;
+  }
+  eventPayloadKey(eventId, field) {
+    return `event:${eventId}:${field}`;
+  }
+};
+
 // ../core/dist/runtime/constants.js
 init_dist5();
 init_logger2();
@@ -87785,6 +88661,22 @@ function getMaxInlineSteps() {
   return parsed;
 }
 __name(getMaxInlineSteps, "getMaxInlineSteps");
+var warnedMaxEventsValues = /* @__PURE__ */ new Set();
+function getMaxEventsOverride() {
+  const raw = process.env.WORKFLOW_MAX_EVENTS_OVERRIDE;
+  if (!raw)
+    return void 0;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    if (!warnedMaxEventsValues.has(raw)) {
+      warnedMaxEventsValues.add(raw);
+      runtimeLogger2.warn("Ignoring WORKFLOW_MAX_EVENTS_OVERRIDE: not a positive integer; using server limit", { raw });
+    }
+    return void 0;
+  }
+  return parsed;
+}
+__name(getMaxEventsOverride, "getMaxEventsOverride");
 function isOptimisticInlineStartEnabled() {
   const raw = process.env.WORKFLOW_OPTIMISTIC_INLINE_START;
   if (raw === void 0 || raw === "")
@@ -87955,13 +88847,155 @@ async function handleReplayBudgetExhausted(args) {
 }
 __name(handleReplayBudgetExhausted, "handleReplayBudgetExhausted");
 
+// ../world-vercel/dist/run-id/codec.js
+var ENCODING3 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var DECODE_TABLE = (() => {
+  const table = new Int8Array(128).fill(-1);
+  for (let i = 0; i < ENCODING3.length; i++) {
+    table[ENCODING3.charCodeAt(i)] = i;
+  }
+  for (let i = 0; i < ENCODING3.length; i++) {
+    const lower = ENCODING3[i].toLowerCase();
+    if (lower !== ENCODING3[i]) {
+      table[lower.charCodeAt(0)] = i;
+    }
+  }
+  return table;
+})();
+var ULID_LENGTH = 26;
+var ULID_BYTE_LENGTH = 16;
+var TAG_BIT_MASK = 128;
+var REGION_MASK = 252;
+var VERSION_HIGH_MASK = 3;
+var VERSION_LOW_MASK = 224;
+var REGION_BYTE_INDEX = 6;
+var VERSION_LOW_BYTE_INDEX = 7;
+var VERSION_BIT_WIDTH = 5;
+var REGION_BIT_WIDTH = 6;
+var MAX_VERSION = (1 << VERSION_BIT_WIDTH) - 1;
+var MAX_REGION = (1 << REGION_BIT_WIDTH) - 1;
+function ulidToBytes(ulid8) {
+  if (typeof ulid8 !== "string") {
+    throw new TypeError(`Expected ULID string, got ${typeof ulid8}`);
+  }
+  if (ulid8.length !== ULID_LENGTH) {
+    throw new Error(`Invalid ULID length: expected ${ULID_LENGTH}, got ${ulid8.length}`);
+  }
+  const values = new Uint8Array(ULID_LENGTH);
+  for (let i = 0; i < ULID_LENGTH; i++) {
+    const code3 = ulid8.charCodeAt(i);
+    const v = code3 < 128 ? DECODE_TABLE[code3] : -1;
+    if (v < 0) {
+      throw new Error(`Invalid Crockford-Base32 character at index ${i}: ${JSON.stringify(ulid8[i])}`);
+    }
+    values[i] = v;
+  }
+  if ((values[0] & 24) !== 0) {
+    throw new Error(`Invalid ULID: top 2 bits must be zero (first char > '7'): ${JSON.stringify(ulid8[0])}`);
+  }
+  const out = new Uint8Array(ULID_BYTE_LENGTH);
+  let bitBuf = values[0] & 7;
+  let bitCount = 3;
+  let outIdx = 0;
+  for (let i = 1; i < ULID_LENGTH; i++) {
+    bitBuf = bitBuf << 5 | values[i];
+    bitCount += 5;
+    while (bitCount >= 8) {
+      bitCount -= 8;
+      out[outIdx++] = bitBuf >> bitCount & 255;
+    }
+  }
+  if (outIdx !== ULID_BYTE_LENGTH || bitCount !== 0) {
+    throw new Error("Internal error: ULID bit packing did not consume cleanly");
+  }
+  return out;
+}
+__name(ulidToBytes, "ulidToBytes");
+function bytesToUlid(bytes) {
+  if (bytes.length !== ULID_BYTE_LENGTH) {
+    throw new Error(`Invalid byte length: expected ${ULID_BYTE_LENGTH}, got ${bytes.length}`);
+  }
+  let bitBuf = 0;
+  let bitCount = 0;
+  bitBuf = 0;
+  bitCount = 2;
+  let out = "";
+  for (let i = 0; i < ULID_BYTE_LENGTH; i++) {
+    bitBuf = bitBuf << 8 | bytes[i];
+    bitCount += 8;
+    while (bitCount >= 5) {
+      bitCount -= 5;
+      out += ENCODING3[bitBuf >> bitCount & 31];
+    }
+  }
+  if (out.length !== ULID_LENGTH || bitCount !== 0) {
+    throw new Error("Internal error: ULID bit packing did not flush cleanly");
+  }
+  return out;
+}
+__name(bytesToUlid, "bytesToUlid");
+
+// ../world-vercel/dist/run-id/regions.js
+var REGION_IDS = {
+  unknown: 0,
+  iad1: 1,
+  sfo1: 2,
+  pdx1: 3,
+  cle1: 4,
+  yul1: 5,
+  gru1: 6,
+  dub1: 7,
+  lhr1: 8,
+  cdg1: 9,
+  fra1: 10,
+  bru1: 11,
+  arn1: 12,
+  hel1: 13,
+  zrh1: 14,
+  cpt1: 15,
+  dxb1: 16,
+  bom1: 17,
+  sin1: 18,
+  hkg1: 19,
+  hnd1: 20,
+  icn1: 21,
+  kix1: 22,
+  syd1: 23
+};
+var REGION_CODES_BY_ID = new Map(Object.entries(REGION_IDS).filter((entry) => entry[0] !== "unknown").map(([code3, id]) => [id, code3]));
+function lookupRegion(regionId) {
+  return REGION_CODES_BY_ID.get(regionId) ?? null;
+}
+__name(lookupRegion, "lookupRegion");
+
+// ../world-vercel/dist/run-id/index.js
+function decode5(taggedUlid) {
+  const bytes = ulidToBytes(taggedUlid);
+  const tagged = (bytes[0] & TAG_BIT_MASK) !== 0;
+  bytes[0] = bytes[0] & ~TAG_BIT_MASK;
+  const ulid8 = bytesToUlid(bytes);
+  if (!tagged) {
+    return { tagged: false, ulid: ulid8, version: null, regionId: null, region: null };
+  }
+  const regionId = (bytes[REGION_BYTE_INDEX] & REGION_MASK) >> 2;
+  const version5 = (bytes[REGION_BYTE_INDEX] & VERSION_HIGH_MASK) << 3 | (bytes[VERSION_LOW_BYTE_INDEX] & VERSION_LOW_MASK) >> 5;
+  return {
+    tagged: true,
+    ulid: ulid8,
+    version: version5,
+    regionId,
+    region: lookupRegion(regionId)
+  };
+}
+__name(decode5, "decode");
+
 // ../core/dist/runtime/run-id-time.js
 init_node2();
 var RUN_ID_PREFIX = "wrun_";
 function runIdCreatedAt(runId) {
   const ulidPart = runId.startsWith(RUN_ID_PREFIX) ? runId.slice(RUN_ID_PREFIX.length) : runId;
   try {
-    return decodeTime(ulidPart);
+    return decodeTime(decode5(ulidPart).ulid);
   } catch {
     return void 0;
   }
@@ -88107,6 +89141,7 @@ __name(getPortLazy, "getPortLazy");
 init_helpers2();
 
 // ../core/dist/runtime/step-latency.js
+var MAX_CLOCK_SKEW_MS = 6e4;
 var TTFS_DISQUALIFYING_EVENT_TYPES = /* @__PURE__ */ new Set([
   "step_created",
   "step_started",
@@ -88148,6 +89183,7 @@ function computeStepLatencyTracking(params) {
     stepCount = terminalStepIds.size;
     eventCount = events.length;
   }
+  const rsfsEligible = ttfsEligible && params.runStartedReceivedAtMs !== void 0;
   if (!ttfsEligible && prevStepEndMs === void 0) {
     return void 0;
   }
@@ -88159,6 +89195,10 @@ function computeStepLatencyTracking(params) {
       preStepBlockingMs: preStepAttrStartMs !== void 0 ? params.preStepBlockingBeforeAttrMs ?? 0 : params.preStepBlockingMs,
       ...preStepAttrStartMs !== void 0 ? { preStepAttrStartMs } : {}
     } : {},
+    ...rsfsEligible ? {
+      rsfsAnchorMs: params.runStartedReceivedAtMs,
+      replayMs: params.replayMs
+    } : {},
     ...prevStepEndMs !== void 0 ? { prevStepEndMs, stepCount, eventCount } : {},
     turbo: params.turbo
   };
@@ -88170,8 +89210,12 @@ function computeStepLatencyEventData(params) {
     return void 0;
   }
   const ttfsEndMs = tracking.preStepAttrStartMs ?? params.stepCodeStartedAtMs;
-  const ttfs = tracking.ttfsAnchorMs !== void 0 ? Math.max(0, ttfsEndMs - tracking.ttfsAnchorMs - (tracking.preStepBlockingMs ?? 0)) : void 0;
-  const stso = tracking.prevStepEndMs !== void 0 ? Math.max(0, params.stepCodeStartedAtMs - tracking.prevStepEndMs) : void 0;
+  const rawTtfs = tracking.ttfsAnchorMs !== void 0 ? ttfsEndMs - tracking.ttfsAnchorMs - (tracking.preStepBlockingMs ?? 0) : void 0;
+  const ttfs = rawTtfs !== void 0 && rawTtfs >= -MAX_CLOCK_SKEW_MS ? Math.max(0, rawTtfs) : void 0;
+  const rawStso = tracking.prevStepEndMs !== void 0 ? params.stepCodeStartedAtMs - tracking.prevStepEndMs : void 0;
+  const stso = rawStso !== void 0 && rawStso >= -MAX_CLOCK_SKEW_MS ? Math.max(0, rawStso) : void 0;
+  const rsfs = tracking.rsfsAnchorMs !== void 0 && params.stepStartPostSentAtMs !== void 0 ? Math.max(0, params.stepStartPostSentAtMs - tracking.rsfsAnchorMs) : void 0;
+  const finalSchedulingReplay = tracking.replayMs !== void 0 ? Math.max(0, tracking.replayMs) : void 0;
   if (ttfs === void 0 && stso === void 0) {
     return void 0;
   }
@@ -88187,6 +89231,8 @@ function computeStepLatencyEventData(params) {
     ...stso !== void 0 ? { stso } : {},
     ...stso !== void 0 && tracking.stepCount !== void 0 ? { stepCount: tracking.stepCount } : {},
     ...stso !== void 0 && tracking.eventCount !== void 0 ? { eventCount: tracking.eventCount } : {},
+    ...rsfs !== void 0 ? { rsfs } : {},
+    ...finalSchedulingReplay !== void 0 ? { finalSchedulingReplay } : {},
     optimizations
   };
 }
@@ -88284,6 +89330,47 @@ async function executeStep(params) {
     span?.setAttributes({
       ...StepMaxRetries2(maxRetries)
     });
+    if (params.authoritativeAttempt !== void 0 && params.authoritativeAttempt > maxRetries + 1) {
+      const retryCount = maxRetries;
+      const errorMessage = `Step "${stepName}" exceeded max retries (${retryCount} ${pluralize2("retry", "retries", retryCount)})`;
+      stepLogger2.error("Step exceeded max retries", {
+        workflowRunId,
+        stepName,
+        stepId,
+        attempt: params.authoritativeAttempt,
+        maxRetries
+      });
+      try {
+        await world.events.create(workflowRunId, {
+          eventType: "step_failed",
+          specVersion: SPEC_VERSION_CURRENT2,
+          correlationId: stepId,
+          eventData: {
+            stepName,
+            error: await dehydrateStepError(new FatalError2(errorMessage), workflowRunId, await getEncryptionKey(), [], globalThis, compression)
+          }
+        });
+      } catch (err) {
+        if (EntityConflictError2.is(err)) {
+          runtimeLogger2.info("Tried failing step for exceeded retries, but step has already finished.", {
+            workflowRunId,
+            stepId,
+            stepName,
+            message: err instanceof Error ? err.message : String(err)
+          });
+          return { type: "skipped" };
+        }
+        if (RunExpiredError.is(err)) {
+          return { type: "gone" };
+        }
+        throw err;
+      }
+      span?.setAttributes({
+        ...StepStatus2("failed"),
+        ...StepRetryExhausted2(true)
+      });
+      return { type: "failed" };
+    }
     const startErrorToResult = /* @__PURE__ */ __name((err) => {
       if (ThrottleError2.is(err)) {
         const retryAfter = Math.max(1, typeof err.retryAfter === "number" ? err.retryAfter : 1);
@@ -88320,8 +89407,12 @@ async function executeStep(params) {
       }
       return void 0;
     }, "startErrorToResult");
-    const optimisticStart = params.lazyStepInput !== void 0 && (isOptimisticInlineStartEnabled() || params.forceOptimisticStart === true && !isOptimisticInlineStartExplicitlyDisabled());
+    const optimisticStart = params.lazyStepInput !== void 0 && // Stale-sensitive guarded batches await the claim so the 412 fence
+    // covers the body, not just durable writes — see
+    // StepExecutorParams.suppressOptimisticStart.
+    params.suppressOptimisticStart !== true && (isOptimisticInlineStartEnabled() || params.forceOptimisticStart === true && !isOptimisticInlineStartExplicitlyDisabled());
     let step;
+    let stepStartPostSentAtMs;
     let optimisticStartSettled;
     const reconcileOptimisticStart = /* @__PURE__ */ __name(async () => {
       if (!optimisticStartSettled)
@@ -88335,18 +89426,29 @@ async function executeStep(params) {
       return mapped;
     }, "reconcileOptimisticStart");
     if (optimisticStart) {
-      const startedPromise = (params.runReadyBarrier ?? Promise.resolve()).then(() => world.events.create(workflowRunId, {
-        eventType: "step_started",
-        specVersion: SPEC_VERSION_CURRENT2,
-        correlationId: stepId,
-        eventData: {
-          stepName,
-          workflowName,
-          input: params.lazyStepInput,
-          // Inline-ownership stamp — see StepExecutorParams.ownerMessageId.
-          ...params.ownerMessageId !== void 0 ? { ownerMessageId: params.ownerMessageId } : {}
-        }
-      }));
+      const startedPromise = (params.runReadyBarrier ?? Promise.resolve()).then(() => {
+        stepStartPostSentAtMs = Date.now();
+        return world.events.create(
+          workflowRunId,
+          {
+            eventType: "step_started",
+            specVersion: SPEC_VERSION_CURRENT2,
+            correlationId: stepId,
+            eventData: {
+              stepName,
+              workflowName,
+              input: params.lazyStepInput,
+              // Inline-ownership stamp — see StepExecutorParams.ownerMessageId.
+              ...params.ownerMessageId !== void 0 ? { ownerMessageId: params.ownerMessageId } : {}
+            }
+          },
+          // Guard the claim — see StepExecutorParams.stateUpdatedAt. A stale
+          // (412) rejection surfaces via reconcileOptimisticStart as a
+          // non-translatable error: the body result is discarded and the
+          // rejection propagates to the caller.
+          params.stateUpdatedAt !== void 0 ? { stateUpdatedAt: params.stateUpdatedAt } : void 0
+        );
+      });
       optimisticStartSettled = startedPromise.then(() => ({ ok: true }), (err) => ({ ok: false, err }));
       const now = /* @__PURE__ */ new Date();
       step = {
@@ -88363,17 +89465,26 @@ async function executeStep(params) {
     } else {
       try {
         const ownershipStamp = params.ownerMessageId !== void 0 ? { ownerMessageId: params.ownerMessageId } : {};
-        const startResult = await world.events.create(workflowRunId, {
-          eventType: "step_started",
-          specVersion: SPEC_VERSION_CURRENT2,
-          correlationId: stepId,
-          eventData: params.lazyStepInput !== void 0 ? {
-            stepName,
-            workflowName,
-            input: params.lazyStepInput,
-            ...ownershipStamp
-          } : { stepName, ...ownershipStamp }
-        });
+        stepStartPostSentAtMs = Date.now();
+        const startResult = await world.events.create(
+          workflowRunId,
+          {
+            eventType: "step_started",
+            specVersion: SPEC_VERSION_CURRENT2,
+            correlationId: stepId,
+            eventData: params.lazyStepInput !== void 0 ? {
+              stepName,
+              workflowName,
+              input: params.lazyStepInput,
+              ...ownershipStamp
+            } : { stepName, ...ownershipStamp }
+          },
+          // Guard the claim — see StepExecutorParams.stateUpdatedAt. A stale
+          // (412) rejection is intentionally NOT translated by
+          // startErrorToResult below, so it propagates to the caller for a
+          // fresh replay.
+          params.stateUpdatedAt !== void 0 ? { stateUpdatedAt: params.stateUpdatedAt } : void 0
+        );
         if (!startResult.step) {
           throw new WorkflowRuntimeError2(`step_started event for "${stepId}" did not return step entity`);
         }
@@ -88442,6 +89553,19 @@ async function executeStep(params) {
     const ops = [];
     let opsSettled = true;
     let latencyEventData;
+    const backfillOptimisticRsfs = /* @__PURE__ */ __name(() => {
+      if (!latencyEventData || latencyEventData.rsfs !== void 0)
+        return;
+      const anchorMs = params.latencyTracking?.rsfsAnchorMs;
+      if (anchorMs === void 0 || stepStartPostSentAtMs === void 0)
+        return;
+      latencyEventData.rsfs = Math.max(0, stepStartPostSentAtMs - anchorMs);
+      if (span) {
+        span.setAttributes({
+          ...StepRsfsMs2(latencyEventData.rsfs)
+        });
+      }
+    }, "backfillOptimisticRsfs");
     try {
       const attempt = step.attempt;
       if (!step.startedAt) {
@@ -88470,12 +89594,15 @@ async function executeStep(params) {
         stepCodeStartedAtMs: executionStartTime,
         attempt,
         lazyStepStart: params.lazyStepInput !== void 0,
-        optimisticStart
+        optimisticStart,
+        stepStartPostSentAtMs
       });
       if (latencyEventData) {
         span?.setAttributes({
           ...latencyEventData.ttfs !== void 0 ? StepTtfsMs2(latencyEventData.ttfs) : {},
           ...latencyEventData.stso !== void 0 ? StepStsoMs2(latencyEventData.stso) : {},
+          ...latencyEventData.rsfs !== void 0 ? StepRsfsMs2(latencyEventData.rsfs) : {},
+          ...latencyEventData.finalSchedulingReplay !== void 0 ? StepFinalSchedulingReplayMs2(latencyEventData.finalSchedulingReplay) : {},
           ...StepLatencyOptimizations2(latencyEventData.optimizations ?? [])
         });
       }
@@ -88496,6 +89623,7 @@ async function executeStep(params) {
               features: { encryption: !!encryptionKey }
             },
             workflowDeploymentId: params.workflowDeploymentId,
+            rootRunId: params.rootRunId,
             ops,
             preCompletionOps,
             closureVars: hydratedInput.closureVars,
@@ -88565,6 +89693,7 @@ async function executeStep(params) {
         const reconcile = await reconcileOptimisticStart();
         if (reconcile)
           return reconcile;
+        backfillOptimisticRsfs();
       }
       if (preCompletionOps.length > 0) {
         await Promise.all(preCompletionOps).catch(() => {
@@ -88575,6 +89704,7 @@ async function executeStep(params) {
         const reconcile = await reconcileOptimisticStart();
         if (reconcile)
           return reconcile;
+        backfillOptimisticRsfs();
       }
       if (preCompletionOps.length > 0) {
         await Promise.all(preCompletionOps).catch(() => {
@@ -88782,6 +89912,9 @@ async function executeStep(params) {
 }
 __name(executeStep, "executeStep");
 
+// ../core/dist/runtime.js
+init_private2();
+
 // ../core/dist/runtime/step-ownership.js
 function isStepOwnershipActive(step) {
   return step.hasCreatedEvent === true && step.ownerMessageId !== void 0 && step.sawRetrying !== true;
@@ -88853,9 +89986,10 @@ init_logger2();
 init_serialization4();
 init_semantic_conventions2();
 init_util4();
-async function createHookEvent({ world, runId, hookEvent, queueItem, requestId }) {
+init_helpers2();
+async function createHookEvent({ runId, hookEvent, queueItem, requestId, createEvent }) {
   try {
-    const result = await world.events.create(runId, hookEvent, {
+    const result = await createEvent(hookEvent, {
       requestId
     });
     if (result.event?.eventType === "hook_conflict") {
@@ -88893,7 +90027,7 @@ async function createHookEvent({ world, runId, hookEvent, queueItem, requestId }
   }
 }
 __name(createHookEvent, "createHookEvent");
-async function handleSuspension({ suspension, world, run: run3, span, requestId, runReadyBarrier }) {
+async function handleSuspension({ suspension, world, run: run3, span, requestId, eventLog, runReadyBarrier }) {
   const runId = run3.runId;
   const ensureRunReady = /* @__PURE__ */ __name(async () => {
     if (runReadyBarrier) {
@@ -88903,6 +90037,12 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
       }
     }
   }, "ensureRunReady");
+  const createGuarded = /* @__PURE__ */ __name((data, params) => {
+    if (!eventLog) {
+      return world.events.create(runId, data, params);
+    }
+    return withPreconditionRetry(runId, eventLog, (stateUpdatedAt) => world.events.create(runId, data, { ...params, stateUpdatedAt }));
+  }, "createGuarded");
   const stepItems = suspension.steps.filter((item) => item.type === "step");
   const allHookItems = suspension.steps.filter((item) => item.type === "hook");
   const waitItems = suspension.steps.filter((item) => item.type === "wait");
@@ -88933,7 +90073,7 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
       }
     };
     try {
-      await world.events.create(runId, hookDisposedEvent, { requestId });
+      await createGuarded(hookDisposedEvent, { requestId });
     } catch (err) {
       if (EntityConflictError2.is(err)) {
         runtimeLogger2.info("Hook already disposed, skipping duplicate disposal", {
@@ -88976,17 +90116,18 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
             correlationId: queueItem.correlationId,
             eventData: {
               token: queueItem.token,
+              tokenRetentionUntil: queueItem.tokenRetentionUntil,
               metadata: hookMetadata,
               isWebhook: queueItem.isWebhook ?? false,
               ...queueItem.isSystem && { isSystem: true }
             }
           };
           const result = await createHookEvent({
-            world,
             runId,
             hookEvent,
             queueItem,
-            requestId
+            requestId,
+            createEvent: createGuarded
           });
           hasHookConflict ||= result.hasHookConflict;
           hasAwaitedHookCreation ||= result.hasAwaitedHookCreation;
@@ -89005,7 +90146,7 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
     await Promise.all(hooksNeedingAbort.map(async (queueItem) => {
       try {
         const abortPayload = await dehydrateStepArguments2({ aborted: true, reason: queueItem.abortReason }, runId, encryptionKey, suspension.globalThis, false, compression);
-        await world.events.create(runId, {
+        await createGuarded({
           eventType: "hook_received",
           specVersion: SPEC_VERSION_CURRENT2,
           correlationId: queueItem.correlationId,
@@ -89070,7 +90211,7 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
         };
         try {
           await ensureRunReady();
-          await world.events.create(runId, stepEvent, { requestId });
+          await createGuarded(stepEvent, { requestId });
           createdStepCorrelationIds.add(queueItem.correlationId);
         } catch (err) {
           if (EntityConflictError2.is(err)) {
@@ -89099,7 +90240,7 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
         };
         try {
           await ensureRunReady();
-          await world.events.create(runId, waitEvent, { requestId });
+          await createGuarded(waitEvent, { requestId });
         } catch (err) {
           if (EntityConflictError2.is(err)) {
             runtimeLogger2.info("Wait already exists, continuing", {
@@ -89277,7 +90418,7 @@ var StringReader = class {
     return idx === -1 ? buffer3.length : idx;
   }
 };
-function decode5(mappings) {
+function decode6(mappings) {
   const { length } = mappings;
   const reader = new StringReader(mappings);
   const decoded = [];
@@ -89319,7 +90460,7 @@ function decode5(mappings) {
   } while (reader.pos <= length);
   return decoded;
 }
-__name(decode5, "decode");
+__name(decode6, "decode");
 function sort(line) {
   line.sort(sortComparator);
 }
@@ -89674,7 +90815,7 @@ function cast(map3) {
 __name(cast, "cast");
 function decodedMappings(map3) {
   var _a3;
-  return (_a3 = cast(map3))._decoded || (_a3._decoded = decode5(cast(map3)._encoded));
+  return (_a3 = cast(map3))._decoded || (_a3._decoded = decode6(cast(map3)._encoded));
 }
 __name(decodedMappings, "decodedMappings");
 function originalPositionFor(map3, needle) {
@@ -89825,42 +90966,6 @@ function remapErrorStack(stack, filename, workflowCode2) {
 }
 __name(remapErrorStack, "remapErrorStack");
 
-// ../core/dist/step-hydration-cache.js
-var MAX_MEMOIZED_PRIMITIVE_LENGTH = 4096;
-function isMemoizablePrimitive(value) {
-  if (value === null)
-    return true;
-  const t = typeof value;
-  if (t === "object" || t === "function")
-    return false;
-  if (t === "string") {
-    return value.length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;
-  }
-  if (t === "bigint") {
-    return value.toString().length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;
-  }
-  return true;
-}
-__name(isMemoizablePrimitive, "isMemoizablePrimitive");
-function createStepHydrationCache() {
-  return /* @__PURE__ */ new Map();
-}
-__name(createStepHydrationCache, "createStepHydrationCache");
-async function getOrHydrateStepReturnValue(cache, eventId, hydrate) {
-  if (!cache || eventId === void 0) {
-    return hydrate();
-  }
-  if (cache.has(eventId)) {
-    return cache.get(eventId);
-  }
-  const value = await hydrate();
-  if (isMemoizablePrimitive(value)) {
-    cache.set(eventId, value);
-  }
-  return value;
-}
-__name(getOrHydrateStepReturnValue, "getOrHydrateStepReturnValue");
-
 // ../core/dist/runtime.js
 init_semantic_conventions2();
 init_telemetry2();
@@ -89990,7 +91095,8 @@ function createUseStep(ctx) {
           ctx.invocationsQueue.delete(event.correlationId);
           ctx.promiseQueue = ctx.promiseQueue.then(async () => {
             try {
-              const hydrated = await hydrateStepError(event.eventData.error, ctx.runId, ctx.encryptionKey, ctx.globalThis);
+              const prepared = await ctx.replayPayloadCache.prepareEventPayload(event.eventId, "error", event.eventData.error);
+              const hydrated = await hydrateStepError(event.eventData.error, ctx.runId, ctx.encryptionKey, ctx.globalThis, {}, prepared);
               reject(hydrated);
             } catch (hydrateErr) {
               stepLogger2.error("Failed to hydrate step_failed error", {
@@ -90009,7 +91115,10 @@ function createUseStep(ctx) {
           ctx.pendingDeliveries++;
           ctx.promiseQueue = ctx.promiseQueue.then(async () => {
             try {
-              const hydratedResult = await getOrHydrateStepReturnValue(ctx.stepHydrationCache, completedEventId, () => hydrateStepReturnValue(serializedResult, ctx.runId, ctx.encryptionKey, ctx.globalThis));
+              const hydratedResult = await ctx.replayPayloadCache.getStepResult(completedEventId, async () => {
+                const prepared = await ctx.replayPayloadCache.prepareEventPayload(completedEventId, "result", serializedResult);
+                return await hydrateStepReturnValue(serializedResult, ctx.runId, ctx.encryptionKey, ctx.globalThis, {}, prepared);
+              });
               resolve2(hydratedResult);
             } catch (error95) {
               reject(error95);
@@ -90657,13 +91766,13 @@ __name(createSetAttributes, "createSetAttributes");
 
 // ../core/dist/workflow/hook.js
 init_dist7();
+init_dist8();
 init_dist6();
+init_class_serialization2();
 init_events_consumer2();
 init_global2();
 init_logger2();
 init_private2();
-init_dist8();
-init_class_serialization2();
 init_serialization4();
 function createConflictingRun(ctx, conflictingRunId) {
   if (typeof conflictingRunId !== "string") {
@@ -90682,13 +91791,21 @@ function createCreateHook(ctx) {
     if (options.token === "") {
       throw new Error("`createHook()` was called with an empty string token. Pass a non-empty token, or omit the `token` option to use a randomly generated one.");
     }
+    if (options.isWebhook === true && options.experimental_minRetention !== void 0) {
+      throw new Error("Webhook hooks do not support `experimental_minRetention`. Use a non-webhook `createHook()` with `resumeHook()`.");
+    }
+    if (options.experimental_minRetention !== void 0 && ctx.worldCapabilities?.hookRetention?.active !== true) {
+      throw new FatalError2("The configured World does not support `experimental_minRetention` for Hooks.");
+    }
     const correlationId = `hook_${ctx.generateUlid()}`;
     const token = options.token ?? ctx.generateNanoid();
+    const tokenRetentionUntil = options.experimental_minRetention === void 0 ? void 0 : parseDurationToDate2(options.experimental_minRetention);
     const isWebhook = options.isWebhook ?? false;
     ctx.invocationsQueue.set(correlationId, {
       type: "hook",
       correlationId,
       token,
+      tokenRetentionUntil,
       metadata: options.metadata,
       isWebhook
     });
@@ -90726,6 +91843,7 @@ function createCreateHook(ctx) {
         const queueItem = ctx.invocationsQueue.get(correlationId);
         if (queueItem && queueItem.type === "hook") {
           queueItem.hasCreatedEvent = true;
+          queueItem.tokenRetentionUntil = event.eventData.tokenRetentionUntil;
         }
         hasCreated = true;
         const pendingGetConflictPromises = getConflictPromises.slice();
@@ -90772,7 +91890,8 @@ function createCreateHook(ctx) {
             let hydrateOutcome;
             ctx.promiseQueue = ctx.promiseQueue.then(async () => {
               try {
-                const payload = await hydrateStepReturnValue(event.eventData.payload, ctx.runId, ctx.encryptionKey, ctx.globalThis);
+                const prepared = await ctx.replayPayloadCache.prepareEventPayload(event.eventId, "payload", event.eventData.payload);
+                const payload = await hydrateStepReturnValue(event.eventData.payload, ctx.runId, ctx.encryptionKey, ctx.globalThis, {}, prepared);
                 hydrateOutcome = { ok: true, value: payload };
               } catch (error95) {
                 hydrateOutcome = { ok: false, error: error95 };
@@ -90802,7 +91921,8 @@ function createCreateHook(ctx) {
           ctx.pendingDeliveries++;
           ctx.promiseQueue = ctx.promiseQueue.then(async () => {
             try {
-              const payload = await hydrateStepReturnValue(event.eventData.payload, ctx.runId, ctx.encryptionKey, ctx.globalThis);
+              const prepared = await ctx.replayPayloadCache.prepareEventPayload(event.eventId, "payload", event.eventData.payload);
+              const payload = await hydrateStepReturnValue(event.eventData.payload, ctx.runId, ctx.encryptionKey, ctx.globalThis, {}, prepared);
               outcome = { ok: true, value: payload };
             } catch (error95) {
               outcome = { ok: false, error: error95 };
@@ -91025,7 +92145,7 @@ async function drainPendingQueueItems(runId, pendingQueue, vmGlobalThis, workflo
   }
 }
 __name(drainPendingQueueItems, "drainPendingQueueItems");
-async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, stepHydrationCache, runReadyBarrier) {
+async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, replayPayloadCache = new ReplayPayloadCache(encryptionKey), runReadyBarrier, worldCapabilities) {
   return trace4(`workflow.run ${workflowRun.workflowName}`, async (span) => {
     span?.setAttributes({
       ...WorkflowName2(workflowRun.workflowName),
@@ -91060,6 +92180,7 @@ async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, st
     const workflowContext = {
       runId: workflowRun.runId,
       encryptionKey,
+      worldCapabilities,
       globalThis: vmGlobalThis,
       onWorkflowError: workflowDiscontinuation.reject,
       eventsConsumer,
@@ -91085,7 +92206,7 @@ async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, st
       },
       pendingDeliveries: 0,
       pendingDeliveryBarriers: /* @__PURE__ */ new Map(),
-      stepHydrationCache
+      replayPayloadCache
     };
     workflowContext.eventsConsumer.subscribe((event) => {
       if (!event) {
@@ -91511,7 +92632,8 @@ Learn more: https://workflow-sdk.dev/err/${ERROR_SLUGS2.FETCH_IN_WORKFLOW_FUNCTI
     }
     let args = [];
     workflowContext.promiseQueue = workflowContext.promiseQueue.then(async () => {
-      args = await hydrateWorkflowArguments(workflowRun.input, workflowRun.runId, encryptionKey, vmGlobalThis);
+      const prepared = await replayPayloadCache.prepareWorkflowInput(workflowRun);
+      args = await hydrateWorkflowArguments(workflowRun.input, workflowRun.runId, encryptionKey, vmGlobalThis, {}, prepared);
     });
     await workflowContext.promiseQueue;
     span?.setAttributes({
@@ -91585,6 +92707,7 @@ init_capabilities2();
 init_encryption3();
 init_logger2();
 init_serialization4();
+init_context_storage2();
 init_semantic_conventions2();
 init_telemetry2();
 init_version3();
@@ -91906,6 +93029,13 @@ var Run2 = class _Run2 {
 };
 
 // ../core/dist/runtime.js
+function clampMaxEvents(serverValue) {
+  const override = getMaxEventsOverride();
+  if (override === void 0)
+    return serverValue;
+  return serverValue === void 0 ? override : Math.min(serverValue, override);
+}
+__name(clampMaxEvents, "clampMaxEvents");
 function getWorkflowSetupErrorCode(err) {
   if (WorkflowRuntimeError2.is(err)) {
     return RUN_ERROR_CODES2.RUNTIME_ERROR;
@@ -91961,7 +93091,24 @@ function hasRecordedTerminalRunEvent(events, runId) {
   return true;
 }
 __name(hasRecordedTerminalRunEvent, "hasRecordedTerminalRunEvent");
-function hasOpenHookOrWait(events) {
+function countStepStartedEvents(events, stepId) {
+  if (!events) {
+    return 0;
+  }
+  let count2 = 0;
+  for (const e of events) {
+    if (e.eventType === "step_started" && e.correlationId === stepId) {
+      count2++;
+    }
+  }
+  return count2;
+}
+__name(countStepStartedEvents, "countStepStartedEvents");
+function rootRunIdFrom(attributes, runId) {
+  return attributes?.[ROOT_RUN_ID_ATTRIBUTE2] ?? runId;
+}
+__name(rootRunIdFrom, "rootRunIdFrom");
+function openHookAndWaitState(events) {
   const disposedHookIds = /* @__PURE__ */ new Set();
   const completedWaitIds = /* @__PURE__ */ new Set();
   for (const e of events) {
@@ -91971,17 +93118,20 @@ function hasOpenHookOrWait(events) {
       completedWaitIds.add(e.correlationId);
     }
   }
+  let openHook = false;
+  let openWait = false;
   for (const e of events) {
     if (e.eventType === "hook_created" && !disposedHookIds.has(e.correlationId)) {
-      return true;
-    }
-    if (e.eventType === "wait_created" && !completedWaitIds.has(e.correlationId)) {
-      return true;
+      openHook = true;
+    } else if (e.eventType === "wait_created" && !completedWaitIds.has(e.correlationId)) {
+      openWait = true;
     }
+    if (openHook && openWait)
+      break;
   }
-  return false;
+  return { openHook, openWait };
 }
-__name(hasOpenHookOrWait, "hasOpenHookOrWait");
+__name(openHookAndWaitState, "openHookAndWaitState");
 function workflowEntrypoint(workflowCode2, options) {
   setWorkflowBasePath(options?.basePath);
   const NO_INLINE_REPLAY_AFTER_MS = Number(process.env.WORKFLOW_V2_TIMEOUT_MS) || 12e4;
@@ -92057,13 +93207,14 @@ function workflowEntrypoint(workflowCode2, options) {
           let loopIteration = 0;
           let cachedEvents = null;
           let eventsCursor = null;
-          const stepHydrationCache = createStepHydrationCache();
           let pendingInlineDelta = null;
           let workflowRun;
+          let maxEventsLimit;
           let workflowStartedAt = -1;
           let preloadedEvents;
           let preloadedEventsCursor;
           let invocationStartedClean;
+          let runStartedReceivedAtMs;
           let preStepBlockingMs = 0;
           let preStepBlockingBeforeAttrMs;
           const turbo = isTurboEnabled() && runInput !== void 0 && metadata.attempt === 1 && incomingStepId === void 0 && !replayDivergence;
@@ -92100,12 +93251,22 @@ function workflowEntrypoint(workflowCode2, options) {
           }, "reinvoke");
           if (incomingStepId && incomingStepName) {
             try {
-              const bgRun = await world.runs.get(runId);
+              const bgRun = await world.runs.get(runId, {
+                resolveData: "none"
+              });
               if (bgRun.status !== "running") {
                 runtimeLogger2.debug("Run already finished, skipping background step", { workflowRunId: runId, status: bgRun.status });
                 return;
               }
               const bgStartedAt = bgRun.startedAt ? +bgRun.startedAt : Date.now();
+              let bgAuthoritativeAttempt = metadata.attempt;
+              const bgMaxRetries = getStepFunction2(incomingStepName)?.maxRetries ?? DEFAULT_STEP_MAX_RETRIES;
+              if (metadata.attempt > bgMaxRetries + 1) {
+                const loaded = await loadWorkflowRunEvents(runId);
+                cachedEvents = loaded.events;
+                eventsCursor = loaded.cursor;
+                bgAuthoritativeAttempt = countStepStartedEvents(cachedEvents, incomingStepId) + 1;
+              }
               replayBudget.pause();
               let stepResult;
               try {
@@ -92115,9 +93276,14 @@ function workflowEntrypoint(workflowCode2, options) {
                   workflowDeploymentId: bgRun.deploymentId,
                   workflowName,
                   workflowStartedAt: bgStartedAt,
+                  rootRunId: rootRunIdFrom(bgRun.attributes, runId),
                   stepId: incomingStepId,
                   stepName: incomingStepName,
-                  runSpecVersion: bgRun.specVersion
+                  runSpecVersion: bgRun.specVersion,
+                  // 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
                 }));
               } finally {
                 replayBudget.resume();
@@ -92164,7 +93330,30 @@ function workflowEntrypoint(workflowCode2, options) {
                   }
                 }
                 runtimeLogger2.debug("All parallel steps done, replaying inline after background step", { workflowRunId: runId });
-                workflowRun = bgRun;
+                const runCreatedEvent = cachedEvents.find((event) => event.eventType === "run_created");
+                let replayInput;
+                if (runCreatedEvent) {
+                  replayInput = runCreatedEvent.eventData.input;
+                } else {
+                  if (!isLegacySpecVersion2(bgRun.specVersion)) {
+                    throw new WorkflowRuntimeError2(`Workflow run "${runId}" has no "run_created" event`);
+                  }
+                  const legacyRun = await world.runs.get(runId, {
+                    resolveData: "all"
+                  });
+                  if (legacyRun.status !== "running") {
+                    return;
+                  }
+                  replayInput = legacyRun.input;
+                }
+                workflowRun = {
+                  ...bgRun,
+                  input: replayInput,
+                  status: "running",
+                  output: void 0,
+                  error: void 0,
+                  completedAt: void 0
+                };
                 workflowStartedAt = bgStartedAt;
               } else {
                 return;
@@ -92228,6 +93417,12 @@ function workflowEntrypoint(workflowCode2, options) {
                 { requestId, skipPreload: true }
               );
               runReadyBarrier = startedPromise;
+              startedPromise.then((r) => {
+                const limit = clampMaxEvents(r?.maxEvents);
+                if (limit !== void 0)
+                  maxEventsLimit = limit;
+              }, () => {
+              });
               startedPromise.catch(() => {
               });
               preloadedEvents = [];
@@ -92258,6 +93453,7 @@ function workflowEntrypoint(workflowCode2, options) {
                 updatedAt: now
               };
               workflowStartedAt = +now;
+              runStartedReceivedAtMs = +now;
               span?.setAttributes({
                 ...WorkflowRunStatus2("running"),
                 ...WorkflowStartedAt2(workflowStartedAt)
@@ -92270,6 +93466,8 @@ function workflowEntrypoint(workflowCode2, options) {
                   throw new WorkflowRuntimeError2(`Event creation for 'run_started' did not return the run entity for run "${runId}"`);
                 }
                 workflowRun = result.run;
+                maxEventsLimit = clampMaxEvents(result.maxEvents);
+                runStartedReceivedAtMs = Date.now();
                 if (result.events && result.events.length > 0 && result.hasMore !== true) {
                   preloadedEvents = result.events;
                   preloadedEventsCursor = result.cursor;
@@ -92314,6 +93512,7 @@ function workflowEntrypoint(workflowCode2, options) {
           }
           const getEncryptionKey = memoizeEncryptionKey(world, workflowRun);
           const encryptionKey = await getEncryptionKey();
+          const replayPayloadCache = new ReplayPayloadCache(encryptionKey);
           while (true) {
             loopIteration++;
             if (replayBudget.isExhausted()) {
@@ -92406,10 +93605,15 @@ function workflowEntrypoint(workflowCode2, options) {
                 }
               }));
               for (const waitEvent of waitsToComplete) {
+                const waitLog = {
+                  events,
+                  cursor: eventsCursor
+                };
                 try {
-                  await world.events.create(runId, waitEvent, {
-                    requestId
-                  });
+                  await withPreconditionRetry(runId, waitLog, (stateUpdatedAt) => world.events.create(runId, waitEvent, {
+                    requestId,
+                    stateUpdatedAt
+                  }));
                 } catch (err) {
                   if (EntityConflictError2.is(err)) {
                     runtimeLogger2.info("Wait already completed, skipping", {
@@ -92419,6 +93623,8 @@ function workflowEntrypoint(workflowCode2, options) {
                     continue;
                   }
                   throw err;
+                } finally {
+                  eventsCursor = waitLog.cursor;
                 }
               }
               if (waitsToComplete.length > 0) {
@@ -92449,6 +93655,9 @@ function workflowEntrypoint(workflowCode2, options) {
               if (hasRecordedTerminalRunEvent(events, runId)) {
                 return;
               }
+              if (maxEventsLimit !== void 0 && events.length >= maxEventsLimit) {
+                throw new MaxEventsExceededError(events.length, maxEventsLimit);
+              }
               cachedEvents = events;
               invocationStartedClean ??= events.every((e) => e.eventType === "run_created" || e.eventType === "run_started" || e.eventType === "attr_set");
               preInlineWriteCursor = eventsCursor;
@@ -92458,18 +93667,21 @@ function workflowEntrypoint(workflowCode2, options) {
                 eventCount: events.length
               });
               replayStart = Date.now();
+              const payloadPrewarm = replayPayloadCache.prewarm(workflowRun, events);
               const result = await runWorkflow(
                 workflowCode2,
                 workflowRun,
                 events,
                 encryptionKey,
-                stepHydrationCache,
+                replayPayloadCache,
                 // Turbo: the end-of-run drain inside runWorkflow commits
                 // fire-and-forget `*_created` events before the terminal
                 // `awaitRunReady()` below, so gate those writes on the
                 // backgrounded run_started too. Undefined outside turbo.
-                runReadyBarrier
+                runReadyBarrier,
+                world.capabilities
               );
+              await payloadPrewarm;
               runtimeLogger2.debug("Workflow replay completed", {
                 workflowRunId: runId,
                 loopIteration,
@@ -92481,7 +93693,10 @@ function workflowEntrypoint(workflowCode2, options) {
                   eventType: "run_completed",
                   specVersion: SPEC_VERSION_CURRENT2,
                   eventData: { output: result }
-                }, { requestId });
+                }, {
+                  requestId,
+                  stateUpdatedAt: stateUpdatedAtForCreate(events)
+                });
               } catch (err) {
                 if (EntityConflictError2.is(err) || RunExpiredError.is(err)) {
                   runtimeLogger2.info("Tried completing workflow run, but run has already finished.", { workflowRunId: runId, message: err.message });
@@ -92495,10 +93710,11 @@ function workflowEntrypoint(workflowCode2, options) {
               return;
             } catch (err) {
               if (WorkflowSuspension2.is(err)) {
+                const replayDurationMs = Date.now() - replayStart;
                 runtimeLogger2.debug("Workflow suspended", {
                   workflowRunId: runId,
                   loopIteration,
-                  replayMs: Date.now() - replayStart,
+                  replayMs: replayDurationMs,
                   steps: err.stepCount,
                   hooks: err.hookCount,
                   waits: err.waitCount
@@ -92508,6 +93724,13 @@ function workflowEntrypoint(workflowCode2, options) {
                   runtimeLogger2.debug(suspensionMessage);
                 }
                 const suspensionStart = Date.now();
+                if (!cachedEvents) {
+                  throw new Error("Invariant violation: workflow suspended before its event log was loaded");
+                }
+                const suspensionLog = {
+                  events: cachedEvents,
+                  cursor: eventsCursor
+                };
                 let suspensionResult;
                 try {
                   suspensionResult = await handleSuspension({
@@ -92516,9 +93739,14 @@ function workflowEntrypoint(workflowCode2, options) {
                     run: workflowRun,
                     span,
                     requestId,
+                    eventLog: suspensionLog,
                     runReadyBarrier
                   });
                 } catch (suspensionError) {
+                  if (PreconditionFailedError.is(suspensionError)) {
+                    runtimeLogger2.warn("Suspension event creation rejected as stale after reload retries; re-invoking run for a fresh replay", { workflowRunId: runId, loopIteration });
+                    return await reinvoke(0);
+                  }
                   if (!FatalError2.is(suspensionError)) {
                     throw suspensionError;
                   }
@@ -92558,6 +93786,7 @@ function workflowEntrypoint(workflowCode2, options) {
                   });
                   return;
                 }
+                eventsCursor = suspensionLog.cursor;
                 preStepBlockingMs += suspensionResult.hookCreationMs;
                 if (suspensionResult.hasAttributeEvents && preStepBlockingBeforeAttrMs === void 0) {
                   preStepBlockingBeforeAttrMs = preStepBlockingMs;
@@ -92661,12 +93890,17 @@ function workflowEntrypoint(workflowCode2, options) {
                   }
                   return;
                 }
-                const requestInlineDelta = typeof preInlineWriteCursor === "string" && err.stepCount === 1 && err.hookCount === 0 && err.waitCount === 0 && pendingSteps.length === 1 && lazyInlineSteps.length === 1 && ownedRecoverySteps.length === 0 && !suspensionResult.waitTimeout && !hasOpenHookOrWait(cachedEvents ?? []);
-                const forceOptimisticStart = turbo && !suspensionResult.waitTimeout && !suspensionResult.hasHookEvents && !suspensionResult.hasAttributeEvents && !suspensionResult.hasAwaitedHookCreation && !hasOpenHookOrWait(cachedEvents ?? []);
+                const openHookWaitState = openHookAndWaitState(cachedEvents ?? []);
+                const guardEnforced = isPreconditionGuardEnabled() && world.capabilities?.preconditionGuard === true;
+                const requestInlineDelta = typeof preInlineWriteCursor === "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 forceOptimisticStart = turbo && !suspensionResult.hasAttributeEvents && !suspensionResult.waitTimeout && !suspensionResult.hasHookEvents && !suspensionResult.hasAwaitedHookCreation && !openHookWaitState.openHook && !openHookWaitState.openWait;
                 const latencyTracking = computeStepLatencyTracking({
                   events: cachedEvents ?? [],
                   invocationStartedClean: invocationStartedClean === true,
                   runCreatedAtMs: runIdCreatedAt(runId) ?? (turbo ? void 0 : +workflowRun.createdAt),
+                  runStartedReceivedAtMs,
+                  replayMs: replayDurationMs,
                   preStepBlockingMs,
                   preStepBlockingBeforeAttrMs,
                   // This suspension's own hook/wait writes are not in
@@ -92675,47 +93909,76 @@ function workflowEntrypoint(workflowCode2, options) {
                   suspensionCreatedHooks: err.hookCount > 0 || suspensionResult.hasHookEvents,
                   turbo
                 });
+                const inlineClaimStateUpdatedAt = stateUpdatedAtForCreate(cachedEvents ?? []);
                 replayBudget.pause();
                 let stepResults;
+                const stepExecutionPromises = inlineExecutions.map((s, stepIndex) => {
+                  const run3 = /* @__PURE__ */ __name(() => executeStep({
+                    world,
+                    workflowRunId: runId,
+                    workflowDeploymentId: workflowRun.deploymentId,
+                    workflowName,
+                    workflowStartedAt,
+                    rootRunId: rootRunIdFrom(workflowRun.attributes, runId),
+                    stepId: s.correlationId,
+                    stepName: s.stepName,
+                    runSpecVersion: workflowRun.specVersion,
+                    // Attempt number = prior step_started count + 1
+                    // (this execution's start). A lazy step is
+                    // brand-new by construction (it enters the batch
+                    // only when it has no step_created yet), so it
+                    // has zero prior starts and is always attempt 1 —
+                    // skip the log scan entirely. Only an
+                    // owned-recovery re-run (this message re-executing
+                    // a step it crashed/timed out on) can have prior
+                    // starts, and that path is uncommon, so reserve
+                    // the O(n) scan for it rather than walking the
+                    // growing log for every inline step (which would
+                    // be O(n²) across a long sequential workflow).
+                    authoritativeAttempt: s.lazyStepInput !== void 0 ? 1 : countStepStartedEvents(cachedEvents, s.correlationId) + 1,
+                    // Lazy inline start: send the deferred step's
+                    // input on step_started so the world creates
+                    // the step on the fly. Absent for
+                    // owned-recovery steps, whose input hydrates
+                    // from the existing step entity.
+                    lazyStepInput: s.lazyStepInput,
+                    // Inline ownership: stamp (or re-stamp) this
+                    // invocation's queue message ID on the
+                    // step_started, so wake replays see the body
+                    // as in flight here and suppress the
+                    // immediate requeue (workflow#2780).
+                    ownerMessageId: metadata.messageId,
+                    // Turbo: force optimistic start and hold the
+                    // lazy step_started until the backgrounded
+                    // run_started lands (the body still runs
+                    // immediately). Both are undefined/false
+                    // outside turbo.
+                    forceOptimisticStart,
+                    // Guard-enforced batches with an open hook
+                    // await the claim before running the body, so
+                    // a 412-fenced step never executes user code —
+                    // see suppressOptimisticStart above.
+                    suppressOptimisticStart,
+                    runReadyBarrier,
+                    stateUpdatedAt: inlineClaimStateUpdatedAt,
+                    ...stepIndex === 0 && s.lazyStepInput !== void 0 && latencyTracking ? { latencyTracking } : {},
+                    ...requestInlineDelta && preInlineWriteCursor ? {
+                      inlineDeltaSinceCursor: preInlineWriteCursor
+                    } : {}
+                  }), "run");
+                  inFlightOwnedSteps.add(s.correlationId);
+                  const executed = s.lazyStepInput === void 0 ? runStepSingleFlight(runId, s.correlationId, run3) : run3();
+                  return executed.finally(() => inFlightOwnedSteps.delete(s.correlationId));
+                });
                 try {
-                  stepResults = await Promise.all(inlineExecutions.map((s, stepIndex) => {
-                    const run3 = /* @__PURE__ */ __name(() => executeStep({
-                      world,
-                      workflowRunId: runId,
-                      workflowDeploymentId: workflowRun.deploymentId,
-                      workflowName,
-                      workflowStartedAt,
-                      stepId: s.correlationId,
-                      stepName: s.stepName,
-                      runSpecVersion: workflowRun.specVersion,
-                      // Lazy inline start: send the deferred step's
-                      // input on step_started so the world creates
-                      // the step on the fly. Absent for
-                      // owned-recovery steps, whose input hydrates
-                      // from the existing step entity.
-                      lazyStepInput: s.lazyStepInput,
-                      // Inline ownership: stamp (or re-stamp) this
-                      // invocation's queue message ID on the
-                      // step_started, so wake replays see the body
-                      // as in flight here and suppress the
-                      // immediate requeue (workflow#2780).
-                      ownerMessageId: metadata.messageId,
-                      // Turbo: force optimistic start and hold the
-                      // lazy step_started until the backgrounded
-                      // run_started lands (the body still runs
-                      // immediately). Both are undefined/false
-                      // outside turbo.
-                      forceOptimisticStart,
-                      runReadyBarrier,
-                      ...stepIndex === 0 && s.lazyStepInput !== void 0 && latencyTracking ? { latencyTracking } : {},
-                      ...requestInlineDelta && preInlineWriteCursor ? {
-                        inlineDeltaSinceCursor: preInlineWriteCursor
-                      } : {}
-                    }), "run");
-                    inFlightOwnedSteps.add(s.correlationId);
-                    const executed = s.lazyStepInput === void 0 ? runStepSingleFlight(runId, s.correlationId, run3) : run3();
-                    return executed.finally(() => inFlightOwnedSteps.delete(s.correlationId));
-                  }));
+                  stepResults = await Promise.all(stepExecutionPromises);
+                } catch (stepErr) {
+                  if (PreconditionFailedError.is(stepErr)) {
+                    await Promise.allSettled(stepExecutionPromises);
+                    runtimeLogger2.warn("Inline step claim rejected as stale; re-invoking run for a fresh replay", { workflowRunId: runId, loopIteration });
+                    return await reinvoke(0);
+                  }
+                  throw stepErr;
                 } finally {
                   replayBudget.resume();
                 }
@@ -92797,6 +94060,10 @@ function workflowEntrypoint(workflowCode2, options) {
                   }
                 }
               } else {
+                if (PreconditionFailedError.is(err)) {
+                  runtimeLogger2.warn("Event creation rejected as stale; re-invoking run for a fresh replay", { workflowRunId: runId, loopIteration });
+                  return await reinvoke(0);
+                }
                 if (isRetryableWorldError2(err)) {
                   runLogger.warn("Transient world error during replay; redelivering via queue instead of failing the run", {
                     errorName: err instanceof Error ? err.name : "UnknownError",
@@ -93111,6 +94378,19 @@ __name(addTenWorkflow, "addTenWorkflow");
 addTenWorkflow.workflowId = "workflow//./workflows/addition//addTenWorkflow";
 globalThis.__private_workflows.set("workflow//./workflows/addition//addTenWorkflow", addTenWorkflow);
 
+// workflows/event-limit.ts
+var tick = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//./workflows/event-limit//tick");
+async function runawayWorkflow() {
+  let total = 0;
+  for (let i = 0; i < 15; i++) {
+    total += await tick(i);
+  }
+  return total;
+}
+__name(runawayWorkflow, "runawayWorkflow");
+runawayWorkflow.workflowId = "workflow//./workflows/event-limit//runawayWorkflow";
+globalThis.__private_workflows.set("workflow//./workflows/event-limit//runawayWorkflow", runawayWorkflow);
+
 // ../core/dist/capture-stack.js
 function redirectStackToCaller(err, stackStartFn) {
   const capture = Error.captureStackTrace;
@@ -93661,10 +94941,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.34//Run#wakeUp");
-Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.34//Run#cancel");
-Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.34//Run#getReadable");
-var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.34//Run#exists");
+Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.36//Run#wakeUp");
+Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.36//Run#cancel");
+Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.36//Run#getReadable");
+var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.36//Run#exists");
 Object.defineProperty(Run.prototype, "exists", {
   get() {
     return __step_Run$exists.call(this);
@@ -93672,7 +94952,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.34//Run#status");
+var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.36//Run#status");
 Object.defineProperty(Run.prototype, "status", {
   get() {
     return __step_Run$status.call(this);
@@ -93680,7 +94960,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.34//Run#returnValue");
+var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.36//Run#returnValue");
 Object.defineProperty(Run.prototype, "returnValue", {
   get() {
     return __step_Run$returnValue.call(this);
@@ -93688,7 +94968,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.34//Run#workflowName");
+var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.36//Run#workflowName");
 Object.defineProperty(Run.prototype, "workflowName", {
   get() {
     return __step_Run$workflowName.call(this);
@@ -93696,7 +94976,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.34//Run#createdAt");
+var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.36//Run#createdAt");
 Object.defineProperty(Run.prototype, "createdAt", {
   get() {
     return __step_Run$createdAt.call(this);
@@ -93704,7 +94984,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.34//Run#startedAt");
+var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.36//Run#startedAt");
 Object.defineProperty(Run.prototype, "startedAt", {
   get() {
     return __step_Run$startedAt.call(this);
@@ -93712,7 +94992,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.34//Run#completedAt");
+var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.36//Run#completedAt");
 Object.defineProperty(Run.prototype, "completedAt", {
   get() {
     return __step_Run$completedAt.call(this);
@@ -93729,7 +95009,7 @@ Object.defineProperty(Run.prototype, "completedAt", {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.34//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.36//Run");
 
 // ../core/dist/workflow/create-hook.js
 aliasSerializationClass(RUN_CLASS_ID, Run);
@@ -94488,9 +95768,9 @@ function nullish(input) {
 }
 __name(nullish, "nullish");
 function cleanRegex(source) {
-  const start = source.startsWith("^") ? 1 : 0;
+  const start2 = source.startsWith("^") ? 1 : 0;
   const end = source.endsWith("$") ? source.length - 1 : source.length;
-  return source.slice(start, end);
+  return source.slice(start2, end);
 }
 __name(cleanRegex, "cleanRegex");
 function floatSafeRemainder(val, step) {
@@ -98105,9 +99385,9 @@ var $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (i
       }
       const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
       if (!source) throw new Error(\`Invalid template literal part: \${part._zod.traits}\`);
-      const start = source.startsWith("^") ? 1 : 0;
+      const start2 = source.startsWith("^") ? 1 : 0;
       const end = source.endsWith("$") ? source.length - 1 : source.length;
-      regexParts.push(source.slice(start, end));
+      regexParts.push(source.slice(start2, end));
     } else if (part === null || primitiveTypes.has(typeof part)) {
       regexParts.push(escapeRegex(\`\${part}\`));
     } else {
@@ -108757,6 +110037,9 @@ __name(date4, "date");
 config(en_default());
 
 // ../world/dist/attributes.js
+var RESERVED_ATTRIBUTE_KEY_PREFIX = "$";
+var ROOT_RUN_ID_ATTRIBUTE = \`\${RESERVED_ATTRIBUTE_KEY_PREFIX}rootRunId\`;
+var PARENT_RUN_ID_ATTRIBUTE = \`\${RESERVED_ATTRIBUTE_KEY_PREFIX}parentRunId\`;
 var AttributeChangeSchema = external_exports.object({
   key: external_exports.string(),
   value: external_exports.union([
@@ -108887,6 +110170,17 @@ var stepLatencyTelemetryFields = {
   // stso.
   stepCount: external_exports.number().int().positive().optional(),
   eventCount: external_exports.number().int().positive().optional(),
+  // Run-started-to-first-step: milliseconds from the \`run_started\` response
+  // landing (or, under turbo, the local run synthesis instant) until this
+  // step's start POST was issued. A sub-window of ttfs. Only reported
+  // alongside the same eligibility as ttfs.
+  rsfs: external_exports.number().optional(),
+  // Synchronous workflow-function replay duration of only the FINAL replay
+  // pass within the rsfs window (the pass that scheduled the first step),
+  // excluding awaited network I/O \u2014 not accumulated across earlier
+  // pre-first-step passes, so it is not "the replay portion of rsfs". Only
+  // present alongside rsfs, and only for the run's first step.
+  finalSchedulingReplay: external_exports.number().optional(),
   // Names of the runtime's optional startup-latency optimizations that were
   // active for this measurement (e.g. 'turbo', 'lazyStepStart',
   // 'optimisticStart'), so latency metrics can be segmented by them.
@@ -108968,6 +110262,7 @@ var HookCreatedEventSchema = BaseEventSchema.extend({
   correlationId: external_exports.string(),
   eventData: external_exports.object({
     token: external_exports.string(),
+    tokenRetentionUntil: external_exports.coerce.date().optional(),
     metadata: SerializedDataSchema.optional(),
     isWebhook: external_exports.boolean().optional(),
     isSystem: external_exports.boolean().optional()
@@ -109673,14 +110968,58 @@ __name(hookWorkflow, "hookWorkflow");
 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.36//start");
+
+// workflows/lineage.ts
+var noop = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//./workflows/lineage//noop");
+async function bodyStartsChild() {
+  await noop();
+  const child = await start(spawnedChild, []);
+  return child.runId;
+}
+__name(bodyStartsChild, "bodyStartsChild");
+bodyStartsChild.workflowId = "workflow//./workflows/lineage//bodyStartsChild";
+globalThis.__private_workflows.set("workflow//./workflows/lineage//bodyStartsChild", bodyStartsChild);
+async function spawnedChild() {
+  await noop();
+  return "done";
+}
+__name(spawnedChild, "spawnedChild");
+spawnedChild.workflowId = "workflow//./workflows/lineage//spawnedChild";
+globalThis.__private_workflows.set("workflow//./workflows/lineage//spawnedChild", spawnedChild);
+async function chainRoot() {
+  await noop();
+  const middle = await start(chainMiddle, []);
+  return middle.runId;
+}
+__name(chainRoot, "chainRoot");
+chainRoot.workflowId = "workflow//./workflows/lineage//chainRoot";
+globalThis.__private_workflows.set("workflow//./workflows/lineage//chainRoot", chainRoot);
+async function chainMiddle() {
+  await noop();
+  const leaf = await start(chainLeaf, []);
+  return leaf.runId;
+}
+__name(chainMiddle, "chainMiddle");
+chainMiddle.workflowId = "workflow//./workflows/lineage//chainMiddle";
+globalThis.__private_workflows.set("workflow//./workflows/lineage//chainMiddle", chainMiddle);
+async function chainLeaf() {
+  await noop();
+  return "done";
+}
+__name(chainLeaf, "chainLeaf");
+chainLeaf.workflowId = "workflow//./workflows/lineage//chainLeaf";
+globalThis.__private_workflows.set("workflow//./workflows/lineage//chainLeaf", chainLeaf);
+
 // workflows/noop.ts
-var noop = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//./workflows/noop//noop");
+var noop2 = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//./workflows/noop//noop");
 async function brokenWf() {
   const numbers = [];
   {
     const promises = [];
     for (let i = 0; i < 5; i++) {
-      promises.push(noop(i));
+      promises.push(noop2(i));
     }
     console.log("await 5");
     numbers.push(...await Promise.all(promises));
@@ -109688,7 +111027,7 @@ async function brokenWf() {
   {
     const promises = [];
     for (let i = 0; i < 15; i++) {
-      promises.push(noop(100 + i));
+      promises.push(noop2(100 + i));
     }
     console.log("await 15");
     numbers.push(...await Promise.all(promises));