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

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

@@ -15204,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()
@@ -15375,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;
@@ -15397,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,
@@ -16273,7 +16274,7 @@ __export(dist_exports, {
   isTerminalRunEventType: () => isTerminalRunEventType,
   isTerminalStepEventType: () => isTerminalStepEventType,
   isTerminalStepStatus: () => isTerminalStepStatus,
-  isTerminalWorkflowRunStatus: () => isTerminalWorkflowRunStatus,
+  isTerminalWorkflowRunStatus: () => isTerminalWorkflowRunStatus2,
   isWaitEventType: () => isWaitEventType,
   parseQueueName: () => parseQueueName,
   reenqueueActiveRuns: () => reenqueueActiveRuns,
@@ -16661,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 */
@@ -16694,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, PreconditionFailedError, WorkflowRunCancelledError2, RunNotSupportedError, FatalError2, RetryableError2, FATAL_ERROR_KEY2, RETRYABLE_ERROR_KEY2, HOOK_CONFLICT_ERROR_KEY2, RUNTIME_DECRYPTION_ERROR_KEY2;
+var BASE_URL2, ERROR_SLUGS2, WorkflowError2, WorkflowWorldError2, WorkflowRunFailedError2, WorkflowRunNotCompletedError2, WorkflowRuntimeError2, CorruptedEventLogError, ReplayDivergenceError, MaxEventsExceededError, RuntimeDecryptionError2, SerializationError2, StepNotRegisteredError2, WorkflowNotRegisteredError2, 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";
@@ -16849,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");
@@ -45533,410 +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.35";
-  }
-});
-
-// ../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 isPreconditionGuardEnabled() {
-  return process.env.WORKFLOW_PRECONDITION_GUARD === "1";
-}
-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);
-  return ulidToDate(rawUlid)?.getTime() ?? void 0;
-}
-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/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({
@@ -46575,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 = {
@@ -46657,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;
@@ -46706,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,
@@ -46724,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");
   }
 });
 
@@ -46855,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({
@@ -46865,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;
@@ -48146,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;
                   }
@@ -50296,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) {
@@ -51441,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);
@@ -51463,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)) {
@@ -51588,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");
@@ -52826,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)),
@@ -52841,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));
@@ -52946,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 {
@@ -52984,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, {
@@ -53002,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 = {};
@@ -53032,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";
@@ -53274,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");
@@ -53295,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");
@@ -54401,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 */
@@ -71494,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()
@@ -71661,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;
@@ -71684,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,
@@ -73162,296 +73355,13 @@ var init_devalue = __esm2({
     init_utils();
   }
 });
-function createFlushableState() {
-  const state = {
-    ...withResolvers(),
-    pendingOps: 0,
-    doneResolved: false,
-    streamEnded: false
-  };
-  state.promise.catch(() => {
-  });
-  return state;
-}
-__name(createFlushableState, "createFlushableState");
-function isWritableUnlockedNotClosed(writable) {
-  if (writable.locked) return false;
-  let writer;
-  try {
-    writer = writable.getWriter();
-  } catch {
-    return false;
-  }
-  try {
-    writer.releaseLock();
-  } catch {
-    return false;
-  }
-  return true;
-}
-__name(isWritableUnlockedNotClosed, "isWritableUnlockedNotClosed");
-function isReadableUnlockedNotClosed(readable) {
-  if (readable.locked) return false;
-  let reader;
-  try {
-    reader = readable.getReader();
-  } catch {
-    return false;
-  }
-  try {
-    reader.releaseLock();
-  } catch {
-    return false;
-  }
-  return true;
-}
-__name(isReadableUnlockedNotClosed, "isReadableUnlockedNotClosed");
-function pollWritableLock(writable, state) {
-  if (state.writablePollingInterval !== void 0) {
-    return;
-  }
-  const intervalId = setInterval(() => {
-    if (state.doneResolved || state.streamEnded) {
-      clearInterval(intervalId);
-      state.writablePollingInterval = void 0;
-      return;
-    }
-    if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {
-      state.doneResolved = true;
-      state.resolve();
-      clearInterval(intervalId);
-      state.writablePollingInterval = void 0;
-    }
-  }, getLockPollIntervalMs());
-  state.writablePollingInterval = intervalId;
-}
-__name(pollWritableLock, "pollWritableLock");
-function pollReadableLock(readable, state) {
-  if (state.readablePollingInterval !== void 0) {
-    return;
-  }
-  const intervalId = setInterval(() => {
-    if (state.doneResolved || state.streamEnded) {
-      clearInterval(intervalId);
-      state.readablePollingInterval = void 0;
-      return;
-    }
-    if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {
-      state.doneResolved = true;
-      state.resolve();
-      clearInterval(intervalId);
-      state.readablePollingInterval = void 0;
-    }
-  }, getLockPollIntervalMs());
-  state.readablePollingInterval = intervalId;
-}
-__name(pollReadableLock, "pollReadableLock");
-async function flushablePipe(source, sink, state) {
-  const reader = source.getReader();
-  const writer = sink.getWriter();
-  let cancelReason;
-  try {
-    while (true) {
-      if (state.streamEnded) {
-        return;
-      }
-      const readResult = await Promise.race([
-        reader.read(),
-        writer.closed.then(() => {
-          throw new WorkflowRuntimeError("Writable stream closed prematurely");
-        })
-      ]);
-      if (state.streamEnded) {
-        return;
-      }
-      if (readResult.done) {
-        state.streamEnded = true;
-        await writer.close();
-        if (!state.doneResolved) {
-          state.doneResolved = true;
-          state.resolve();
-        }
-        return;
-      }
-      state.pendingOps++;
-      try {
-        await writer.write(readResult.value);
-      } finally {
-        state.pendingOps--;
-      }
-    }
-  } catch (err) {
-    state.streamEnded = true;
-    cancelReason = err;
-    if (!state.doneResolved) {
-      state.doneResolved = true;
-      state.reject(err);
-    }
-    throw err;
-  } finally {
-    reader.cancel(cancelReason).catch(() => {
-    });
-    reader.releaseLock();
-    writer.releaseLock();
-  }
-}
-__name(flushablePipe, "flushablePipe");
-var LOCK_POLL_INTERVAL_MS;
-var getLockPollIntervalMs;
-var init_flushable_stream = __esm2({
-  "../core/dist/flushable-stream.js"() {
-    "use strict";
-    init_dist2();
-    init_dist();
-    init_dist4();
-    LOCK_POLL_INTERVAL_MS = 10;
-    getLockPollIntervalMs = /* @__PURE__ */ __name2(() => envNumber("WORKFLOW_LOCK_POLL_INTERVAL_MS", LOCK_POLL_INTERVAL_MS, {
-      integer: true,
-      min: 1
-    }), "getLockPollIntervalMs");
-    __name2(createFlushableState, "createFlushableState");
-    __name2(isWritableUnlockedNotClosed, "isWritableUnlockedNotClosed");
-    __name2(isReadableUnlockedNotClosed, "isReadableUnlockedNotClosed");
-    __name2(pollWritableLock, "pollWritableLock");
-    __name2(pollReadableLock, "pollReadableLock");
-    __name2(flushablePipe, "flushablePipe");
-  }
-});
-function getStepIdAliasCandidates(stepId) {
-  const parts = stepId.split("//");
-  if (parts.length !== 3 || parts[0] !== "step") {
-    return [];
-  }
-  const modulePath = parts[1];
-  const fnName = parts[2];
-  const modulePathAliases = /* @__PURE__ */ new Set();
-  const addAlias = /* @__PURE__ */ __name2((aliasModulePath) => {
-    if (aliasModulePath !== modulePath) {
-      modulePathAliases.add(aliasModulePath);
-    }
-  }, "addAlias");
-  if (modulePath.startsWith("./workflows/")) {
-    const workflowRelativePath = modulePath.slice("./".length);
-    addAlias(`./example/${workflowRelativePath}`);
-    addAlias(`./src/${workflowRelativePath}`);
-  } else if (modulePath.startsWith("./example/workflows/")) {
-    const workflowRelativePath = modulePath.slice("./example/".length);
-    addAlias(`./${workflowRelativePath}`);
-    addAlias(`./src/${workflowRelativePath}`);
-  } else if (modulePath.startsWith("./src/workflows/")) {
-    const workflowRelativePath = modulePath.slice("./src/".length);
-    addAlias(`./${workflowRelativePath}`);
-    addAlias(`./example/${workflowRelativePath}`);
-  }
-  return Array.from(modulePathAliases, (aliasModulePath) => `step//${aliasModulePath}//${fnName}`);
-}
-__name(getStepIdAliasCandidates, "getStepIdAliasCandidates");
-function getBuiltinResponseStepAlias(stepId) {
-  if (!BUILTIN_RESPONSE_STEP_NAMES.has(stepId)) {
-    return void 0;
-  }
-  for (const [registeredStepId, stepFn] of registeredSteps.entries()) {
-    if (registeredStepId.endsWith(`//${stepId}`)) {
-      return stepFn;
-    }
-  }
-  return void 0;
-}
-__name(getBuiltinResponseStepAlias, "getBuiltinResponseStepAlias");
-function getStepFunction(stepId) {
-  const directMatch = registeredSteps.get(stepId);
-  if (directMatch) {
-    return directMatch;
-  }
-  for (const aliasStepId of getStepIdAliasCandidates(stepId)) {
-    const aliasMatch = registeredSteps.get(aliasStepId);
-    if (aliasMatch) {
-      return aliasMatch;
-    }
-  }
-  const builtinAliasMatch = getBuiltinResponseStepAlias(stepId);
-  if (builtinAliasMatch) {
-    return builtinAliasMatch;
-  }
-  return void 0;
-}
-__name(getStepFunction, "getStepFunction");
-var RegisteredStepsKey;
-var globalSymbols;
-var registeredSteps;
-var BUILTIN_RESPONSE_STEP_NAMES;
-var init_private = __esm2({
-  "../core/dist/private.js"() {
-    "use strict";
-    init_dist();
-    RegisteredStepsKey = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps");
-    globalSymbols = globalThis;
-    registeredSteps = globalSymbols[RegisteredStepsKey] ??= /* @__PURE__ */ new Map();
-    BUILTIN_RESPONSE_STEP_NAMES = /* @__PURE__ */ new Set([
-      "__builtin_response_array_buffer",
-      "__builtin_response_json",
-      "__builtin_response_text"
-    ]);
-    __name2(getStepIdAliasCandidates, "getStepIdAliasCandidates");
-    __name2(getBuiltinResponseStepAlias, "getBuiltinResponseStepAlias");
-    __name2(getStepFunction, "getStepFunction");
-  }
-});
-function assertWorldSupportsRuntimeProtocol(world) {
-  if (world.specVersion === SPEC_VERSION_CURRENT) {
-    return;
-  }
-  const supportedVersion = world.specVersion ?? "none";
-  throw new WorkflowRuntimeError(`This Workflow runtime requires a World with matching spec version ${SPEC_VERSION_CURRENT}, but the configured World declares spec version ${supportedVersion}. Install a World package version compatible with the current Workflow runtime.`);
-}
-__name(assertWorldSupportsRuntimeProtocol, "assertWorldSupportsRuntimeProtocol");
-var init_world_compatibility = __esm2({
-  "../core/dist/runtime/world-compatibility.js"() {
-    "use strict";
-    init_dist2();
-    init_dist4();
-    __name2(assertWorldSupportsRuntimeProtocol, "assertWorldSupportsRuntimeProtocol");
-  }
-});
-async function getWorldLazy() {
-  const g = globalThis;
-  if (g[WorldCacheKey]) {
-    assertWorldSupportsRuntimeProtocol(g[WorldCacheKey]);
-    return g[WorldCacheKey];
-  }
-  if (g[WorldCachePromiseKey]) {
-    g[WorldCacheKey] = await g[WorldCachePromiseKey];
-    assertWorldSupportsRuntimeProtocol(g[WorldCacheKey]);
-    return g[WorldCacheKey];
-  }
-  const getWorldFn = g[GetWorldFnKey];
-  if (getWorldFn) {
-    const world = await getWorldFn();
-    assertWorldSupportsRuntimeProtocol(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.");
-}
-__name(getWorldLazy, "getWorldLazy");
-var WorldCacheKey;
-var WorldCachePromiseKey;
-var GetWorldFnKey;
-var init_get_world_lazy = __esm2({
-  "../core/dist/runtime/get-world-lazy.js"() {
-    "use strict";
-    init_world_compatibility();
-    WorldCacheKey = /* @__PURE__ */ Symbol.for("@workflow/world//cache");
-    WorldCachePromiseKey = /* @__PURE__ */ Symbol.for("@workflow/world//cachePromise");
-    GetWorldFnKey = /* @__PURE__ */ Symbol.for("@workflow/world//getWorldFn");
-    __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 STREAM_WRITE_BATCH_SYMBOL;
 var BODY_INIT_SYMBOL;
 var WEBHOOK_RESPONSE_WRITABLE;
 var WORKFLOW_CLASS_REGISTRY;
@@ -73468,6 +73378,7 @@ var init_symbols = __esm2({
     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");
@@ -73477,6 +73388,443 @@ var init_symbols = __esm2({
     ABORT_READER_CANCEL = /* @__PURE__ */ Symbol.for("WORKFLOW_ABORT_READER_CANCEL");
   }
 });
+function createFlushableState() {
+  const state = {
+    ...withResolvers(),
+    pendingOps: 0,
+    doneResolved: false,
+    streamEnded: false
+  };
+  state.promise.catch(() => {
+  });
+  return state;
+}
+__name(createFlushableState, "createFlushableState");
+function isWritableUnlockedNotClosed(writable) {
+  if (writable.locked) return false;
+  let writer;
+  try {
+    writer = writable.getWriter();
+  } catch {
+    return false;
+  }
+  try {
+    writer.releaseLock();
+  } catch {
+    return false;
+  }
+  return true;
+}
+__name(isWritableUnlockedNotClosed, "isWritableUnlockedNotClosed");
+function isReadableUnlockedNotClosed(readable) {
+  if (readable.locked) return false;
+  let reader;
+  try {
+    reader = readable.getReader();
+  } catch {
+    return false;
+  }
+  try {
+    reader.releaseLock();
+  } catch {
+    return false;
+  }
+  return true;
+}
+__name(isReadableUnlockedNotClosed, "isReadableUnlockedNotClosed");
+function pollWritableLock(writable, state) {
+  if (state.writablePollingInterval !== void 0) {
+    return;
+  }
+  const intervalId = setInterval(() => {
+    if (state.doneResolved || state.streamEnded) {
+      clearInterval(intervalId);
+      state.writablePollingInterval = void 0;
+      return;
+    }
+    if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {
+      state.doneResolved = true;
+      state.resolve();
+      clearInterval(intervalId);
+      state.writablePollingInterval = void 0;
+    }
+  }, getLockPollIntervalMs());
+  state.writablePollingInterval = intervalId;
+}
+__name(pollWritableLock, "pollWritableLock");
+function pollReadableLock(readable, state) {
+  if (state.readablePollingInterval !== void 0) {
+    return;
+  }
+  const intervalId = setInterval(() => {
+    if (state.doneResolved || state.streamEnded) {
+      clearInterval(intervalId);
+      state.readablePollingInterval = void 0;
+      return;
+    }
+    if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {
+      state.doneResolved = true;
+      state.resolve();
+      clearInterval(intervalId);
+      state.readablePollingInterval = void 0;
+    }
+  }, getLockPollIntervalMs());
+  state.readablePollingInterval = intervalId;
+}
+__name(pollReadableLock, "pollReadableLock");
+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;
+  try {
+    while (true) {
+      if (state.streamEnded) {
+        return;
+      }
+      const readResult = await Promise.race([
+        reader.read(),
+        writer.closed.then(() => {
+          throw new WorkflowRuntimeError("Writable stream closed prematurely");
+        })
+      ]);
+      if (state.streamEnded) {
+        return;
+      }
+      if (readResult.done) {
+        state.streamEnded = true;
+        await writer.close();
+        if (!state.doneResolved) {
+          state.doneResolved = true;
+          state.resolve();
+        }
+        return;
+      }
+      state.pendingOps++;
+      try {
+        await writer.write(readResult.value);
+      } finally {
+        state.pendingOps--;
+      }
+    }
+  } catch (err) {
+    state.streamEnded = true;
+    cancelReason = err;
+    if (!state.doneResolved) {
+      state.doneResolved = true;
+      state.reject(err);
+    }
+    throw err;
+  } finally {
+    reader.cancel(cancelReason).catch(() => {
+    });
+    reader.releaseLock();
+    writer.releaseLock();
+  }
+}
+__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({
+  "../core/dist/flushable-stream.js"() {
+    "use strict";
+    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,
+      min: 1
+    }), "getLockPollIntervalMs");
+    __name2(createFlushableState, "createFlushableState");
+    __name2(isWritableUnlockedNotClosed, "isWritableUnlockedNotClosed");
+    __name2(isReadableUnlockedNotClosed, "isReadableUnlockedNotClosed");
+    __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) {
+  const parts = stepId.split("//");
+  if (parts.length !== 3 || parts[0] !== "step") {
+    return [];
+  }
+  const modulePath = parts[1];
+  const fnName = parts[2];
+  const modulePathAliases = /* @__PURE__ */ new Set();
+  const addAlias = /* @__PURE__ */ __name2((aliasModulePath) => {
+    if (aliasModulePath !== modulePath) {
+      modulePathAliases.add(aliasModulePath);
+    }
+  }, "addAlias");
+  if (modulePath.startsWith("./workflows/")) {
+    const workflowRelativePath = modulePath.slice("./".length);
+    addAlias(`./example/${workflowRelativePath}`);
+    addAlias(`./src/${workflowRelativePath}`);
+  } else if (modulePath.startsWith("./example/workflows/")) {
+    const workflowRelativePath = modulePath.slice("./example/".length);
+    addAlias(`./${workflowRelativePath}`);
+    addAlias(`./src/${workflowRelativePath}`);
+  } else if (modulePath.startsWith("./src/workflows/")) {
+    const workflowRelativePath = modulePath.slice("./src/".length);
+    addAlias(`./${workflowRelativePath}`);
+    addAlias(`./example/${workflowRelativePath}`);
+  }
+  return Array.from(modulePathAliases, (aliasModulePath) => `step//${aliasModulePath}//${fnName}`);
+}
+__name(getStepIdAliasCandidates, "getStepIdAliasCandidates");
+function getBuiltinResponseStepAlias(stepId) {
+  if (!BUILTIN_RESPONSE_STEP_NAMES.has(stepId)) {
+    return void 0;
+  }
+  for (const [registeredStepId, stepFn] of registeredSteps.entries()) {
+    if (registeredStepId.endsWith(`//${stepId}`)) {
+      return stepFn;
+    }
+  }
+  return void 0;
+}
+__name(getBuiltinResponseStepAlias, "getBuiltinResponseStepAlias");
+function getStepFunction(stepId) {
+  const directMatch = registeredSteps.get(stepId);
+  if (directMatch) {
+    return directMatch;
+  }
+  for (const aliasStepId of getStepIdAliasCandidates(stepId)) {
+    const aliasMatch = registeredSteps.get(aliasStepId);
+    if (aliasMatch) {
+      return aliasMatch;
+    }
+  }
+  const builtinAliasMatch = getBuiltinResponseStepAlias(stepId);
+  if (builtinAliasMatch) {
+    return builtinAliasMatch;
+  }
+  return void 0;
+}
+__name(getStepFunction, "getStepFunction");
+var RegisteredStepsKey;
+var globalSymbols;
+var registeredSteps;
+var BUILTIN_RESPONSE_STEP_NAMES;
+var init_private = __esm2({
+  "../core/dist/private.js"() {
+    "use strict";
+    init_dist();
+    RegisteredStepsKey = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps");
+    globalSymbols = globalThis;
+    registeredSteps = globalSymbols[RegisteredStepsKey] ??= /* @__PURE__ */ new Map();
+    BUILTIN_RESPONSE_STEP_NAMES = /* @__PURE__ */ new Set([
+      "__builtin_response_array_buffer",
+      "__builtin_response_json",
+      "__builtin_response_text"
+    ]);
+    __name2(getStepIdAliasCandidates, "getStepIdAliasCandidates");
+    __name2(getBuiltinResponseStepAlias, "getBuiltinResponseStepAlias");
+    __name2(getStepFunction, "getStepFunction");
+  }
+});
+function assertWorldSupportsRuntimeProtocol(world) {
+  if (world.specVersion === SPEC_VERSION_CURRENT) {
+    return;
+  }
+  const supportedVersion = world.specVersion ?? "none";
+  throw new WorkflowRuntimeError(`This Workflow runtime requires a World with matching spec version ${SPEC_VERSION_CURRENT}, but the configured World declares spec version ${supportedVersion}. Install a World package version compatible with the current Workflow runtime.`);
+}
+__name(assertWorldSupportsRuntimeProtocol, "assertWorldSupportsRuntimeProtocol");
+var init_world_compatibility = __esm2({
+  "../core/dist/runtime/world-compatibility.js"() {
+    "use strict";
+    init_dist2();
+    init_dist4();
+    __name2(assertWorldSupportsRuntimeProtocol, "assertWorldSupportsRuntimeProtocol");
+  }
+});
+async function getWorldLazy() {
+  const g = globalThis;
+  if (g[WorldCacheKey]) {
+    assertWorldSupportsRuntimeProtocol(g[WorldCacheKey]);
+    return g[WorldCacheKey];
+  }
+  if (g[WorldCachePromiseKey]) {
+    g[WorldCacheKey] = await g[WorldCachePromiseKey];
+    assertWorldSupportsRuntimeProtocol(g[WorldCacheKey]);
+    return g[WorldCacheKey];
+  }
+  const getWorldFn = g[GetWorldFnKey];
+  if (getWorldFn) {
+    const world = await getWorldFn();
+    assertWorldSupportsRuntimeProtocol(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.");
+}
+__name(getWorldLazy, "getWorldLazy");
+var WorldCacheKey;
+var WorldCachePromiseKey;
+var GetWorldFnKey;
+var init_get_world_lazy = __esm2({
+  "../core/dist/runtime/get-world-lazy.js"() {
+    "use strict";
+    init_world_compatibility();
+    WorldCacheKey = /* @__PURE__ */ Symbol.for("@workflow/world//cache");
+    WorldCachePromiseKey = /* @__PURE__ */ Symbol.for("@workflow/world//cachePromise");
+    GetWorldFnKey = /* @__PURE__ */ Symbol.for("@workflow/world//getWorldFn");
+    __name2(getWorldLazy, "getWorldLazy");
+  }
+});
 function getRegistry(global2 = globalThis) {
   const g = global2;
   let registry22 = g[WORKFLOW_CLASS_REGISTRY];
@@ -79435,7 +79783,7 @@ var version2;
 var init_version = __esm2({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.35";
+    version2 = "5.0.0-beta.36";
   }
 });
 function getWorkflowQueueName(workflowName, namespace) {
@@ -80782,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
   };
 }
@@ -80810,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)) {
@@ -80944,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");
@@ -82077,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));
@@ -82186,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, {
@@ -82483,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");
@@ -82501,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");
@@ -82924,7 +83285,7 @@ __name2(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.35//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, {
@@ -83260,7 +83621,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.35//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);
@@ -83269,7 +83630,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.35//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);
@@ -83278,7 +83639,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.35//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);
@@ -83287,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.35//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);
@@ -83296,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.35//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);
@@ -83305,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.35//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);
@@ -83314,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.35//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);
@@ -83323,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.35//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);
@@ -83332,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.35//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);
@@ -83341,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.35//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);
@@ -83351,7 +83712,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.35//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.36//Run");
 async function fetch2(...args) {
   return globalThis.fetch(...args);
 }
@@ -83392,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;
@@ -83880,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";
 
@@ -84450,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");
 }
@@ -85223,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`);
 }
@@ -85481,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
@@ -85552,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) {
@@ -85710,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,
@@ -85755,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:
@@ -85789,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({
@@ -85870,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
@@ -85911,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) {
@@ -86206,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,
@@ -86219,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") {
@@ -86250,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}"`);
               }
@@ -86286,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]) => ({
@@ -86319,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,
@@ -86751,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`);
           }
@@ -86769,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);
@@ -86824,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");
@@ -86960,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({
@@ -86988,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 [];
@@ -87415,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 {
@@ -87427,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 {
@@ -87441,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();
@@ -87589,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;
   }
@@ -87790,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);
@@ -87835,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",
@@ -87857,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();
@@ -87945,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 === "")
@@ -88598,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);
@@ -88634,7 +89407,10 @@ 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;
@@ -88652,18 +89428,26 @@ async function executeStep(params) {
     if (optimisticStart) {
       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 } : {}
-          }
-        });
+        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();
@@ -88682,17 +89466,25 @@ async function executeStep(params) {
       try {
         const ownershipStamp = params.ownerMessageId !== void 0 ? { ownerMessageId: params.ownerMessageId } : {};
         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 }
-        });
+        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`);
         }
@@ -89120,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;
@@ -89321,6 +90116,7 @@ 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 }
@@ -90170,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();
@@ -90335,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", {
@@ -90354,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);
@@ -91002,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") {
@@ -91027,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
     });
@@ -91071,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();
@@ -91117,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 };
@@ -91147,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 };
@@ -91370,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),
@@ -91405,6 +92180,7 @@ async function runWorkflow(workflowCode2, workflowRun, events, encryptionKey, st
     const workflowContext = {
       runId: workflowRun.runId,
       encryptionKey,
+      worldCapabilities,
       globalThis: vmGlobalThis,
       onWorkflowError: workflowDiscontinuation.reject,
       eventsConsumer,
@@ -91430,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) {
@@ -91856,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({
@@ -92252,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;
@@ -92307,11 +93091,24 @@ function hasRecordedTerminalRunEvent(events, runId) {
   return true;
 }
 __name(hasRecordedTerminalRunEvent, "hasRecordedTerminalRunEvent");
+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 hasOpenHookOrWait(events) {
+function openHookAndWaitState(events) {
   const disposedHookIds = /* @__PURE__ */ new Set();
   const completedWaitIds = /* @__PURE__ */ new Set();
   for (const e of events) {
@@ -92321,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;
@@ -92407,9 +93207,9 @@ 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;
@@ -92451,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 {
@@ -92469,7 +93279,11 @@ function workflowEntrypoint(workflowCode2, options) {
                   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();
@@ -92516,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;
@@ -92580,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 = [];
@@ -92623,6 +93466,7 @@ 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;
@@ -92668,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()) {
@@ -92810,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;
@@ -92819,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,
@@ -93039,8 +93890,11 @@ 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,
@@ -93055,48 +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,
-                      rootRunId: rootRunIdFrom(workflowRun.attributes, runId),
-                      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();
                 }
@@ -93496,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;
@@ -94046,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.35//Run#wakeUp");
-Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.35//Run#cancel");
-Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.35//Run#getReadable");
-var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.35//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);
@@ -94057,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.35//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);
@@ -94065,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.35//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);
@@ -94073,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.35//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);
@@ -94081,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.35//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);
@@ -94089,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.35//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);
@@ -94097,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.35//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);
@@ -94114,7 +95009,7 @@ Object.defineProperty(Run.prototype, "completedAt", {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.35//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.36//Run");
 
 // ../core/dist/workflow/create-hook.js
 aliasSerializationClass(RUN_CLASS_ID, Run);
@@ -109367,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()
@@ -110073,7 +110969,7 @@ hookWorkflow.workflowId = "workflow//./workflows/inline-execution//hookWorkflow"
 globalThis.__private_workflows.set("workflow//./workflows/inline-execution//hookWorkflow", hookWorkflow);
 
 // ../core/dist/runtime/start.js
-var start = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/start@5.0.0-beta.35//start");
+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");