@workflow/world-testing 5.0.0-beta.53 → 5.0.0-beta.54

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

@@ -20629,6 +20629,12 @@ function readRunRetention(attributes) {
 function purgesUserDataOnFinish(attributes) {
   return readRunRetention(attributes).mode === "none";
 }
+function validateAttributeEventDataSize2(eventData) {
+  const bytes = textEncoder3.encode(JSON.stringify(eventData)).length;
+  if (bytes > ATTRIBUTE_EVENT_DATA_MAX_BYTES2) {
+    throw new AttributeValidationError2(`Attribute eventData exceeds limit ${ATTRIBUTE_EVENT_DATA_MAX_BYTES2} UTF-8 JSON bytes (received ${bytes} bytes). Split the changes into smaller setAttributes() calls.`);
+  }
+}
 function assertValidAttributeKey2(key, allowReservedAttributes) {
   if (typeof key !== "string") {
     throw new AttributeValidationError2(`Attribute key must be a string, got ${typeof key}`);
@@ -20692,7 +20698,7 @@ function applyAttributeChanges(existing, changes) {
   }
   return next2;
 }
-var RESERVED_ATTRIBUTE_KEY_PREFIX2, ROOT_RUN_ID_ATTRIBUTE2, PARENT_RUN_ID_ATTRIBUTE2, RETENTION_ATTRIBUTE2, RETENTION_ZERO, RETENTION_DEFAULT, RETENTION_INTEGER_PATTERN, ATTRIBUTE_KEY_MAX_LENGTH2, ATTRIBUTE_VALUE_MAX_BYTES2, ATTRIBUTE_MAX_PER_RUN2, textEncoder3, AttributeValidationError2;
+var RESERVED_ATTRIBUTE_KEY_PREFIX2, ROOT_RUN_ID_ATTRIBUTE2, PARENT_RUN_ID_ATTRIBUTE2, RETENTION_ATTRIBUTE2, RETENTION_ZERO, RETENTION_DEFAULT, RETENTION_INTEGER_PATTERN, ATTRIBUTE_KEY_MAX_LENGTH2, ATTRIBUTE_VALUE_MAX_BYTES2, ATTRIBUTE_MAX_PER_RUN2, ATTRIBUTE_EVENT_DATA_MAX_BYTES2, textEncoder3, AttributeValidationError2;
 var init_attributes_validation2 = __esm({
   "../world/dist/attributes-validation.js"() {
     "use strict";
@@ -20708,6 +20714,7 @@ var init_attributes_validation2 = __esm({
     ATTRIBUTE_KEY_MAX_LENGTH2 = 256;
     ATTRIBUTE_VALUE_MAX_BYTES2 = 256;
     ATTRIBUTE_MAX_PER_RUN2 = 64;
+    ATTRIBUTE_EVENT_DATA_MAX_BYTES2 = 8192;
     textEncoder3 = new TextEncoder();
     AttributeValidationError2 = class extends Error {
       static {
@@ -20718,6 +20725,7 @@ var init_attributes_validation2 = __esm({
         this.name = "AttributeValidationError";
       }
     };
+    __name(validateAttributeEventDataSize2, "validateAttributeEventDataSize");
     __name(assertValidAttributeKey2, "assertValidAttributeKey");
     __name(assertValidAttributeValue2, "assertValidAttributeValue");
     __name(attributeCountDelta2, "attributeCountDelta");
@@ -21899,6 +21907,11 @@ var init_queue2 = __esm({
     }));
     WorkflowInvokePayloadSchema2 = external_exports2.compile(external_exports2.object({
       runId: external_exports2.string(),
+      /** Process this input and return the handler's result as response data. */
+      invoke: external_exports2.literal(true).optional(),
+      /** Identifies one input across retries, separately from the queue delivery ID. */
+      requestId: external_exports2.string().optional(),
+      input: external_exports2.unknown().optional(),
       traceCarrier: TraceCarrierSchema2.optional(),
       requestedAt: external_exports2.coerce.date().optional(),
       /**
@@ -22509,6 +22522,7 @@ __export(dist_exports, {
   ANALYTICS_MAX_ATTRIBUTE_FILTERS: () => ANALYTICS_MAX_ATTRIBUTE_FILTERS,
   ANALYTICS_PAGE_LIMIT: () => ANALYTICS_PAGE_LIMIT,
   ANALYTICS_RUN_SCOPED_PAGE_LIMIT: () => ANALYTICS_RUN_SCOPED_PAGE_LIMIT,
+  ATTRIBUTE_EVENT_DATA_MAX_BYTES: () => ATTRIBUTE_EVENT_DATA_MAX_BYTES2,
   ATTRIBUTE_KEY_MAX_LENGTH: () => ATTRIBUTE_KEY_MAX_LENGTH2,
   ATTRIBUTE_MAX_PER_RUN: () => ATTRIBUTE_MAX_PER_RUN2,
   ATTRIBUTE_VALUE_MAX_BYTES: () => ATTRIBUTE_VALUE_MAX_BYTES2,
@@ -22633,6 +22647,7 @@ __export(dist_exports, {
   stripEventDataRefs: () => stripEventDataRefs,
   ulidToDate: () => ulidToDate,
   validateAttributeChanges: () => validateAttributeChanges2,
+  validateAttributeEventDataSize: () => validateAttributeEventDataSize2,
   validateUlidTimestamp: () => validateUlidTimestamp,
   workflowRunIdSchema: () => workflowRunIdSchema2
 });
@@ -29272,7 +29287,7 @@ var require_dispatcher = __commonJS({
     "use strict";
     var EventEmitter3 = __require("node:events");
     var WrapHandler = require_wrap_handler();
-    var wrapInterceptor = /* @__PURE__ */ __name((dispatch) => (opts, handler) => dispatch(opts, WrapHandler.wrap(handler)), "wrapInterceptor");
+    var wrapInterceptor = /* @__PURE__ */ __name((dispatch2) => (opts, handler) => dispatch2(opts, WrapHandler.wrap(handler)), "wrapInterceptor");
     var Dispatcher = class extends EventEmitter3 {
       static {
         __name(this, "Dispatcher");
@@ -29288,7 +29303,7 @@ var require_dispatcher = __commonJS({
       }
       compose(...args) {
         const interceptors = Array.isArray(args[0]) ? args[0] : args;
-        let dispatch = this.dispatch.bind(this);
+        let dispatch2 = this.dispatch.bind(this);
         for (const interceptor of interceptors) {
           if (interceptor == null) {
             continue;
@@ -29296,14 +29311,14 @@ var require_dispatcher = __commonJS({
           if (typeof interceptor !== "function") {
             throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`);
           }
-          dispatch = interceptor(dispatch);
-          dispatch = wrapInterceptor(dispatch);
-          if (dispatch == null || typeof dispatch !== "function" || dispatch.length !== 2) {
+          dispatch2 = interceptor(dispatch2);
+          dispatch2 = wrapInterceptor(dispatch2);
+          if (dispatch2 == null || typeof dispatch2 !== "function" || dispatch2.length !== 2) {
             throw new TypeError("invalid interceptor");
           }
         }
         return new Proxy(this, {
-          get: /* @__PURE__ */ __name((target2, key) => key === "dispatch" ? dispatch : target2[key], "get")
+          get: /* @__PURE__ */ __name((target2, key) => key === "dispatch" ? dispatch2 : target2[key], "get")
         });
       }
     };
@@ -37913,7 +37928,7 @@ var require_retry_handler = __commonJS({
       static {
         __name(this, "RetryHandler");
       }
-      constructor(opts, { dispatch, handler }) {
+      constructor(opts, { dispatch: dispatch2, handler }) {
         const { retryOptions, ...dispatchOpts } = opts;
         const {
           // Retry scoped
@@ -37930,7 +37945,7 @@ var require_retry_handler = __commonJS({
           throwOnError
         } = retryOptions ?? {};
         this.error = null;
-        this.dispatch = dispatch;
+        this.dispatch = dispatch2;
         this.handler = WrapHandler.wrap(handler);
         this.opts = { ...dispatchOpts, body: wrapRequestBody(opts.body) };
         this.retryOpts = {
@@ -39779,11 +39794,11 @@ var require_mock_utils = __commonJS({
     }
     __name(addMockDispatch, "addMockDispatch");
     function deleteMockDispatch(mockDispatches, key) {
-      const index = mockDispatches.findIndex((dispatch) => {
-        if (!dispatch.consumed) {
+      const index = mockDispatches.findIndex((dispatch2) => {
+        if (!dispatch2.consumed) {
           return false;
         }
-        return matchKey(dispatch, key);
+        return matchKey(dispatch2, key);
       });
       if (index !== -1) {
         mockDispatches.splice(index, 1);
@@ -39911,7 +39926,7 @@ var require_mock_utils = __commonJS({
       const agent = this[kMockAgent];
       const origin = this[kOrigin];
       const originalDispatch = this[kOriginalDispatch];
-      return /* @__PURE__ */ __name(function dispatch(opts, handler) {
+      return /* @__PURE__ */ __name(function dispatch2(opts, handler) {
         if (agent.isMockActive) {
           try {
             mockDispatch.call(this, opts, handler);
@@ -40714,7 +40729,7 @@ var require_mock_agent = __commonJS({
       }
       pendingInterceptors() {
         const mockAgentClients = this[kClients];
-        return Array.from(mockAgentClients.entries()).flatMap(([origin, result2]) => result2.dispatcher[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending);
+        return Array.from(mockAgentClients.entries()).flatMap(([origin, result2]) => result2.dispatcher[kDispatches].map((dispatch2) => ({ ...dispatch2, origin }))).filter(({ pending }) => pending);
       }
       assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
         const pending = this.pendingInterceptors();
@@ -41648,14 +41663,14 @@ var require_redirect_handler = __commonJS({
         if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
           throw new InvalidArgumentError("maxRedirections must be a positive number");
         }
-        const dispatch = dispatcher.dispatch.bind(dispatcher);
-        return (opts, originalHandler) => dispatch(opts, new _RedirectHandler(dispatch, maxRedirections, opts, originalHandler));
+        const dispatch2 = dispatcher.dispatch.bind(dispatcher);
+        return (opts, originalHandler) => dispatch2(opts, new _RedirectHandler(dispatch2, maxRedirections, opts, originalHandler));
       }
-      constructor(dispatch, maxRedirections, opts, handler) {
+      constructor(dispatch2, maxRedirections, opts, handler) {
         if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
           throw new InvalidArgumentError("maxRedirections must be a positive number");
         }
-        this.dispatch = dispatch;
+        this.dispatch = dispatch2;
         this.location = null;
         const { maxRedirections: _, ...cleanOpts } = opts;
         this.opts = cleanOpts;
@@ -41787,15 +41802,15 @@ var require_redirect = __commonJS({
     "use strict";
     var RedirectHandler = require_redirect_handler();
     function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections } = {}) {
-      return (dispatch) => {
+      return (dispatch2) => {
         return /* @__PURE__ */ __name(function Intercept(opts, handler) {
           const { maxRedirections = defaultMaxRedirections, ...rest } = opts;
           if (maxRedirections == null || maxRedirections === 0) {
-            return dispatch(opts, handler);
+            return dispatch2(opts, handler);
           }
           const dispatchOpts = { ...rest };
-          const redirectHandler = new RedirectHandler(dispatch, maxRedirections, dispatchOpts, handler);
-          return dispatch(dispatchOpts, redirectHandler);
+          const redirectHandler = new RedirectHandler(dispatch2, maxRedirections, dispatchOpts, handler);
+          return dispatch2(dispatchOpts, redirectHandler);
         }, "Intercept");
       };
     }
@@ -41880,9 +41895,9 @@ var require_response_error = __commonJS({
       }
     };
     module.exports = () => {
-      return (dispatch) => {
+      return (dispatch2) => {
         return /* @__PURE__ */ __name(function Intercept(opts, handler) {
-          return dispatch(opts, new ResponseErrorHandler(opts, { handler }));
+          return dispatch2(opts, new ResponseErrorHandler(opts, { handler }));
         }, "Intercept");
       };
     };
@@ -41895,15 +41910,15 @@ var require_retry = __commonJS({
     "use strict";
     var RetryHandler = require_retry_handler();
     module.exports = (globalOpts) => {
-      return (dispatch) => {
+      return (dispatch2) => {
         return /* @__PURE__ */ __name(function retryInterceptor(opts, handler) {
-          return dispatch(
+          return dispatch2(
             opts,
             new RetryHandler(
               { ...opts, retryOptions: { ...globalOpts, ...opts.retryOptions } },
               {
                 handler,
-                dispatch
+                dispatch: dispatch2
               }
             )
           );
@@ -41990,11 +42005,11 @@ var require_dump = __commonJS({
     function createDumpInterceptor({ maxSize: defaultMaxSize } = {
       maxSize: 1024 * 1024
     }) {
-      return (dispatch) => {
+      return (dispatch2) => {
         return /* @__PURE__ */ __name(function Intercept(opts, handler) {
           const { dumpMaxSize = defaultMaxSize } = opts;
           const dumpHandler = new DumpHandler({ maxSize: dumpMaxSize, signal: opts.signal }, handler);
-          return dispatch(opts, dumpHandler);
+          return dispatch2(opts, dumpHandler);
         }, "Intercept");
       };
     }
@@ -42329,13 +42344,13 @@ var require_dns = __commonJS({
       #controller = null;
       #newOrigin = null;
       #firstTry = true;
-      constructor(state, { origin, handler, dispatch, newOrigin }, opts) {
+      constructor(state, { origin, handler, dispatch: dispatch2, newOrigin }, opts) {
         super(handler);
         this.#origin = origin;
         this.#newOrigin = newOrigin;
         this.#opts = { ...opts };
         this.#state = state;
-        this.#dispatch = dispatch;
+        this.#dispatch = dispatch2;
       }
       onResponseError(controller, err) {
         switch (err.code) {
@@ -42424,11 +42439,11 @@ var require_dns = __commonJS({
         storage: interceptorOpts?.storage
       };
       const instance = new DNSInstance(opts);
-      return (dispatch) => {
+      return (dispatch2) => {
         return /* @__PURE__ */ __name(function dnsInterceptor(origDispatchOpts, handler) {
           const origin = origDispatchOpts.origin.constructor === URL ? origDispatchOpts.origin : new URL(origDispatchOpts.origin);
           if (isIP(origin.hostname) !== 0) {
-            return dispatch(origDispatchOpts, handler);
+            return dispatch2(origDispatchOpts, handler);
           }
           instance.runLookup(origin, origDispatchOpts, (err, newOrigin) => {
             if (err) {
@@ -42441,10 +42456,10 @@ var require_dns = __commonJS({
               origin: newOrigin.origin,
               headers: withHostHeader(origin.host, origDispatchOpts.headers)
             };
-            dispatch(
+            dispatch2(
               dispatchOpts,
               instance.getHandler(
-                { origin, dispatch, handler, newOrigin },
+                { origin, dispatch: dispatch2, handler, newOrigin },
                 origDispatchOpts
               )
             );
@@ -44465,7 +44480,7 @@ var require_cache3 = __commonJS({
       return now2 <= staleWhileRevalidateExpiry;
     }
     __name(withinStaleWhileRevalidateWindow, "withinStaleWhileRevalidateWindow");
-    function handleUncachedResponse(dispatch, globalOpts, cacheKey, handler, opts, reqCacheControl) {
+    function handleUncachedResponse(dispatch2, globalOpts, cacheKey, handler, opts, reqCacheControl) {
       if (reqCacheControl?.["only-if-cached"]) {
         let aborted3 = false;
         try {
@@ -44493,7 +44508,7 @@ var require_cache3 = __commonJS({
         }
         return true;
       }
-      return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler));
+      return dispatch2(opts, new CacheHandler(globalOpts, cacheKey, handler));
     }
     __name(handleUncachedResponse, "handleUncachedResponse");
     function sendCachedValue(handler, opts, result2, age, context2, isStale2) {
@@ -44551,13 +44566,13 @@ var require_cache3 = __commonJS({
       }
     }
     __name(sendCachedValue, "sendCachedValue");
-    function handleResult(dispatch, globalOpts, cacheKey, handler, opts, reqCacheControl, result2) {
+    function handleResult(dispatch2, globalOpts, cacheKey, handler, opts, reqCacheControl, result2) {
       if (!result2) {
-        return handleUncachedResponse(dispatch, globalOpts, cacheKey, handler, opts, reqCacheControl);
+        return handleUncachedResponse(dispatch2, globalOpts, cacheKey, handler, opts, reqCacheControl);
       }
       const now2 = Date.now();
       if (now2 > result2.deleteAt) {
-        return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler));
+        return dispatch2(opts, new CacheHandler(globalOpts, cacheKey, handler));
       }
       const age = Math.round((now2 - result2.cachedAt) / 1e3);
       const requestMaxAgeExpired = reqCacheControl?.["max-age"] !== void 0 && age >= reqCacheControl["max-age"];
@@ -44565,13 +44580,13 @@ var require_cache3 = __commonJS({
       const revalidate = requestMaxAgeExpired || needsRevalidation(result2, reqCacheControl, opts);
       if (stale || revalidate) {
         if (util.isStream(opts.body) && util.bodyLength(opts.body) !== 0) {
-          return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler));
+          return dispatch2(opts, new CacheHandler(globalOpts, cacheKey, handler));
         }
         if (!revalidate && withinStaleWhileRevalidateWindow(result2, globalOpts.type)) {
           sendCachedValue(handler, opts, result2, age, null, true);
           queueMicrotask(() => {
             const headers2 = makeRevalidationHeaders(opts, result2);
-            dispatch(
+            dispatch2(
               {
                 ...opts,
                 headers: headers2
@@ -44603,7 +44618,7 @@ var require_cache3 = __commonJS({
           }
         }
         const headers = makeRevalidationHeaders(opts, result2);
-        return dispatch(
+        return dispatch2(
           {
             ...opts,
             headers
@@ -44617,7 +44632,7 @@ var require_cache3 = __commonJS({
                       result2.body.on("error", nop).destroy();
                     }
                     deleteCachedValue(globalOpts.store, cacheKey);
-                    return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler));
+                    return dispatch2(opts, new CacheHandler(globalOpts, cacheKey, handler));
                   }
                   if (revalidationResponseUpdatesCacheControl(headers2)) {
                     deleteCachedValue(globalOpts.store, cacheKey);
@@ -44672,10 +44687,10 @@ var require_cache3 = __commonJS({
           safeMethodsToNotCache.push(method);
         }
       }
-      return (dispatch) => {
+      return (dispatch2) => {
         return (opts2, handler) => {
           if (!opts2.origin || arrayIncludes(safeMethodsToNotCache, opts2.method)) {
-            return dispatch(opts2, handler);
+            return dispatch2(opts2, handler);
           }
           if (origins !== void 0) {
             const requestOrigin = opts2.origin.toString().toLowerCase();
@@ -44693,7 +44708,7 @@ var require_cache3 = __commonJS({
               }
             }
             if (!isAllowed) {
-              return dispatch(opts2, handler);
+              return dispatch2(opts2, handler);
             }
           }
           opts2 = {
@@ -44702,13 +44717,13 @@ var require_cache3 = __commonJS({
           };
           const reqCacheControl = opts2.headers?.["cache-control"] ? parseCacheControlHeader(opts2.headers["cache-control"]) : hasPragmaNoCache(opts2.headers) ? { "no-cache": true } : void 0;
           if (reqCacheControl?.["no-store"]) {
-            return dispatch(opts2, handler);
+            return dispatch2(opts2, handler);
           }
           const cacheKey = makeCacheKey(opts2);
           const result2 = store.get(cacheKey);
           if (result2 && typeof result2.then === "function") {
             return result2.then((result3) => handleResult(
-              dispatch,
+              dispatch2,
               globalOpts,
               cacheKey,
               handler,
@@ -44718,7 +44733,7 @@ var require_cache3 = __commonJS({
             ));
           } else {
             return handleResult(
-              dispatch,
+              dispatch2,
               globalOpts,
               cacheKey,
               handler,
@@ -44939,10 +44954,10 @@ var require_decompress = __commonJS({
         );
         warningEmitted = true;
       }
-      return (dispatch) => {
+      return (dispatch2) => {
         return (opts, handler) => {
           const decompressHandler = new DecompressHandler(handler, options);
-          return dispatch(opts, decompressHandler);
+          return dispatch2(opts, decompressHandler);
         };
       };
     }
@@ -45352,10 +45367,10 @@ var require_deduplicate = __commonJS({
       const skipHeaderNamesSet = new Set(skipHeaderNames.map((name) => name.toLowerCase()));
       const excludeHeaderNamesSet = new Set(excludeHeaderNames.map((name) => name.toLowerCase()));
       const pendingRequests = /* @__PURE__ */ new Map();
-      return (dispatch) => {
+      return (dispatch2) => {
         return (opts2, handler) => {
           if (!opts2.origin || methods.includes(opts2.method) === false) {
-            return dispatch(opts2, handler);
+            return dispatch2(opts2, handler);
           }
           opts2 = {
             ...opts2,
@@ -45364,7 +45379,7 @@ var require_deduplicate = __commonJS({
           if (skipHeaderNamesSet.size > 0) {
             for (const headerName of Object.keys(opts2.headers)) {
               if (skipHeaderNamesSet.has(headerName.toLowerCase())) {
-                return dispatch(opts2, handler);
+                return dispatch2(opts2, handler);
               }
             }
           }
@@ -45375,7 +45390,7 @@ var require_deduplicate = __commonJS({
             if (pendingHandler.addWaitingHandler(handler)) {
               return true;
             }
-            return dispatch(opts2, handler);
+            return dispatch2(opts2, handler);
           }
           const deduplicationHandler = new DeduplicationHandler(
             handler,
@@ -45391,7 +45406,7 @@ var require_deduplicate = __commonJS({
           if (pendingRequestsChannel.hasSubscribers) {
             pendingRequestsChannel.publish({ size: pendingRequests.size, key: dedupeKey, type: "added" });
           }
-          return dispatch(opts2, deduplicationHandler);
+          return dispatch2(opts2, deduplicationHandler);
         };
       };
     };
@@ -48451,7 +48466,7 @@ var require_fetch = __commonJS({
         })();
       }
       try {
-        const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody });
+        const { body, status, statusText, headersList, socket } = await dispatch2({ body: requestBody });
         if (socket) {
           response = makeResponse({ status, statusText, headersList, socket });
         } else {
@@ -48548,7 +48563,7 @@ var require_fetch = __commonJS({
       }
       __name(onAborted, "onAborted");
       return response;
-      function dispatch({ body }) {
+      function dispatch2({ body }) {
         const url3 = requestCurrentURL(request);
         const agent = fetchParams.controller.dispatcher;
         const path15 = url3.pathname + url3.search;
@@ -48729,7 +48744,7 @@ var require_fetch = __commonJS({
           }
         ));
       }
-      __name(dispatch, "dispatch");
+      __name(dispatch2, "dispatch");
     }
     __name(httpNetworkFetch, "httpNetworkFetch");
     module.exports = {
@@ -53163,8 +53178,11 @@ function createQueue(config4) {
       const body = await new TypedJsonTransport().deserialize(req.body);
       try {
         const result2 = await handler(body, { attempt, queueName, messageId });
+        if (typeof body === "object" && body !== null && "invoke" in body && body.invoke === true) {
+          return Response.json({ result: result2 });
+        }
         let timeoutSeconds = null;
-        if (typeof result2?.timeoutSeconds === "number") {
+        if (typeof result2 === "object" && result2 !== null && "timeoutSeconds" in result2 && typeof result2.timeoutSeconds === "number") {
           timeoutSeconds = Math.min(result2.timeoutSeconds, LOCAL_QUEUE_MAX_VISIBILITY);
         }
         if (timeoutSeconds != null) {
@@ -61824,7 +61842,7 @@ var version4;
 var init_version3 = __esm({
   "../world-vercel/dist/version.js"() {
     "use strict";
-    version4 = "5.0.0-beta.48";
+    version4 = "5.0.0-beta.49";
   }
 });
 
@@ -61872,7 +61890,7 @@ function deadlineInterceptor(timeoutMs) {
       super.onResponseError(controller, error121);
     }
   }
-  return (dispatch) => (opts, handler) => dispatch(opts, new DeadlineHandler(handler));
+  return (dispatch2) => (opts, handler) => dispatch2(opts, new DeadlineHandler(handler));
 }
 function h2EventsEnabled() {
   return process.env.WORKFLOW_H2_MULTIPLEX !== "0";
@@ -61885,13 +61903,13 @@ function contentLength(headers) {
   const raw = record3["content-length"] ?? record3["Content-Length"];
   return typeof raw === "string" || typeof raw === "number" ? Number(raw) : Number.NaN;
 }
-function h2MultiplexInterceptor(dispatch) {
+function h2MultiplexInterceptor(dispatch2) {
   return (opts, handler) => {
     const body = opts.body;
     const isAsyncIterable = !!body && typeof body !== "string" && !Buffer.isBuffer(body) && typeof body[Symbol.asyncIterator] === "function";
     const length = contentLength(opts.headers);
     if (!isAsyncIterable || !(length >= 0) || length > H2_REBUFFER_MAX_BYTES) {
-      return dispatch({ ...opts, idempotent: true }, handler);
+      return dispatch2({ ...opts, idempotent: true }, handler);
     }
     void (async () => {
       try {
@@ -61899,7 +61917,7 @@ function h2MultiplexInterceptor(dispatch) {
         for await (const chunk of body) {
           chunks.push(Buffer.from(chunk));
         }
-        dispatch({ ...opts, body: Buffer.concat(chunks), idempotent: true }, handler);
+        dispatch2({ ...opts, body: Buffer.concat(chunks), idempotent: true }, handler);
       } catch (error121) {
         handler.onError?.(error121);
       }
@@ -68629,13 +68647,13 @@ var require_functions2 = __commonJS({
       ipAddress: /* @__PURE__ */ __name(() => import_headers.ipAddress, "ipAddress"),
       next: /* @__PURE__ */ __name(() => import_middleware.next, "next"),
       rewrite: /* @__PURE__ */ __name(() => import_middleware.rewrite, "rewrite"),
-      waitUntil: /* @__PURE__ */ __name(() => import_wait_until4.waitUntil, "waitUntil")
+      waitUntil: /* @__PURE__ */ __name(() => import_wait_until5.waitUntil, "waitUntil")
     });
     module.exports = __toCommonJS(src_exports);
     var import_headers = require_headers3();
     var import_get_env = require_get_env2();
     var import_deadline = require_deadline2();
-    var import_wait_until4 = require_wait_until2();
+    var import_wait_until5 = require_wait_until2();
     var import_middleware = require_middleware2();
     var import_cache = require_cache5();
     var import_db_connections = require_db_connections2();
@@ -74767,7 +74785,7 @@ function createQueue2(config4) {
           attempt: metadata.deliveryCount,
           requestId
         });
-        if (typeof result2?.timeoutSeconds === "number") {
+        if (!("invoke" in payload && payload.invoke === true) && typeof result2 === "object" && result2 !== null && "timeoutSeconds" in result2 && typeof result2.timeoutSeconds === "number") {
           const delaySeconds = result2.timeoutSeconds > 0 ? Math.min(result2.timeoutSeconds, MAX_DELAY_SECONDS) : void 0;
           await queue(queueName, payload, { deploymentId, delaySeconds });
         }
@@ -76566,6 +76584,15 @@ function validateWorkflowRunIdTimestamp(id) {
 function assertEventDataWireContractExhaustive() {
 }
 function splitEventDataForV4(data) {
+  if (data.eventType === "attr_set") {
+    try {
+      validateAttributeEventDataSize2(data.eventData);
+    } catch (error121) {
+      if (!(error121 instanceof AttributeValidationError2))
+        throw error121;
+      throw new WorkflowWorldError2(error121.message, { status: 400 });
+    }
+  }
   const eventData = data.eventData ?? {};
   const payloadField = getEventDataPayloadField(data.eventType);
   const meta5 = {};
@@ -76905,6 +76932,7 @@ var init_events3 = __esm({
     "use strict";
     init_dist7();
     init_dist6();
+    init_attributes_validation2();
     init_event_retry();
     init_events_v4();
     init_run_id();
@@ -79864,12 +79892,25 @@ async function awaitEarlierDeliveries(ctx, eventIndex, kind) {
     await new Promise((resolve3) => setTimeout(resolve3, 0));
   }
 }
-function registerDeliveryBarrier(ctx, eventIndex, kind, options = {}) {
+function registerDeliveryBarrier(ctx, eventIndex, kind, options) {
+  let deliveredToWorkflow = false;
+  const deliver = /* @__PURE__ */ __name(() => {
+    if (deliveredToWorkflow) {
+      return false;
+    }
+    deliveredToWorkflow = true;
+    ctx.advanceClock?.(options.deliveredAt);
+    return true;
+  }, "deliver");
   const barriers = ctx.pendingDeliveryBarriers;
   if (!barriers || eventIndex === void 0) {
-    return { markDelivered: /* @__PURE__ */ __name(() => {
-    }, "markDelivered"), arm: /* @__PURE__ */ __name(() => {
-    }, "arm") };
+    return {
+      markDelivered: /* @__PURE__ */ __name(() => {
+        deliver();
+      }, "markDelivered"),
+      arm: /* @__PURE__ */ __name(() => {
+      }, "arm")
+    };
   }
   const install = /* @__PURE__ */ __name((armed) => {
     if (barriers.has(eventIndex)) {
@@ -79897,13 +79938,11 @@ function registerDeliveryBarrier(ctx, eventIndex, kind, options = {}) {
     return entry2;
   }, "install");
   let entry = install(options.armed ?? true);
-  let deliveredToWorkflow = false;
   return {
     markDelivered: /* @__PURE__ */ __name(() => {
-      if (deliveredToWorkflow) {
+      if (!deliver()) {
         return;
       }
-      deliveredToWorkflow = true;
       entry.retire();
     }, "markDelivered"),
     arm: /* @__PURE__ */ __name(() => {
@@ -83812,7 +83851,9 @@ function createCreateAbortController(ctx) {
         if (event.eventType === "hook_received") {
           const rawPayload = event.eventData?.payload;
           const eventIndex = ctx.eventsConsumer.eventIndex;
-          const barrier = registerDeliveryBarrier(ctx, eventIndex, "hook");
+          const barrier = registerDeliveryBarrier(ctx, eventIndex, "hook", {
+            deliveredAt: +event.createdAt
+          });
           const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, "hook");
           ctx.pendingDeliveries++;
           ctx.promiseQueue = ctx.promiseQueue.then(async () => {
@@ -86000,7 +86041,7 @@ var version5;
 var init_version4 = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version5 = "5.0.0-beta.53";
+    version5 = "5.0.0-beta.54";
   }
 });
 
@@ -86471,6 +86512,176 @@ var init_helpers3 = __esm({
   }
 });
 
+// ../core/dist/runtime/invocations.js
+async function handleInvocation(world, runId, requestId, payload) {
+  const parsed = HookInvocationSchema2.safeParse(payload);
+  if (!parsed.success || !requestId)
+    throw new WorkflowWorldError2("Invalid invocation input", {
+      status: 400,
+      code: "INVALID_INPUT"
+    });
+  const input3 = parsed.data;
+  const digest = Buffer.from(await crypto.subtle.digest("SHA-256", input3.payload)).toString("hex");
+  try {
+    const hook = await world.hooks.get(input3.hookId);
+    if (hook.runId !== runId || hook.token !== input3.token)
+      throw new HookNotFoundError2(input3.token);
+    const run3 = await world.runs.get(runId, { resolveData: "none" });
+    if (isTerminalWorkflowRunStatus2(run3.status))
+      throw new HookNotFoundError2(input3.token);
+  } catch (error121) {
+    if (!isHookGone(error121))
+      throw error121;
+    const run3 = await world.runs.get(runId, { resolveData: "none" });
+    if (run3.expiredAt || isTerminalWorkflowRunStatus2(run3.status) && readRunRetention(run3.attributes).mode === "none") {
+      throw new WorkflowWorldError2("Invocation data has expired under the run retention policy", { status: 410, code: "INVOCATION_DATA_EXPIRED" });
+    }
+    if (!world.capabilities?.hookResumeDedup || !await hasResume(world, runId, input3.hookId, requestId)) {
+      throw error121;
+    }
+  }
+  await world.events.create(runId, {
+    eventType: "hook_received",
+    correlationId: input3.hookId,
+    specVersion: SPEC_VERSION_CURRENT2,
+    eventData: { token: input3.token, payload: input3.payload }
+  }, {
+    ...world.capabilities?.hookResumeDedup ? { resumeId: requestId, resumePayloadDigest: digest } : {}
+  });
+  return { status: "accepted" };
+}
+function isHookGone(error121) {
+  return HookNotFoundError2.is(error121) || RunExpiredError2.is(error121) || WorkflowRunNotFoundError2.is(error121);
+}
+async function hasResume(world, runId, hookId, requestId) {
+  let cursor = null;
+  do {
+    const page = await world.events.listByCorrelationId({
+      runId,
+      correlationId: hookId,
+      resolveData: "none",
+      pagination: { limit: 100, ...cursor ? { cursor } : {} }
+    });
+    if (page.data.some((event) => event.eventType === "hook_received" && event.resumeId === requestId))
+      return true;
+    cursor = page.hasMore ? page.cursor : null;
+  } while (cursor);
+  return false;
+}
+function withRunInputs(world) {
+  return (handler) => {
+    const sessions = /* @__PURE__ */ new Map();
+    return async (message, metadata) => {
+      if (HealthCheckPayloadSchema2.safeParse(message).success)
+        return handler(message, metadata);
+      const parsed = WorkflowInvokePayloadSchema2.safeParse(message);
+      if (!world.capabilities?.invoke || !parsed.success || parsed.data.stepId)
+        return handler(message, metadata);
+      const input3 = parsed.data;
+      let session = sessions.get(input3.runId);
+      if (!session) {
+        session = {
+          activity: new RunInputActivity(),
+          admission: Promise.resolve(),
+          references: 0
+        };
+        sessions.set(input3.runId, session);
+      }
+      const current = session;
+      current.references++;
+      try {
+        if (input3.invoke) {
+          if (!input3.requestId)
+            throw new WorkflowRuntimeError2("Invocation requestId is required");
+          const requestId = input3.requestId;
+          const decision = current.admission.then(() => trace5("workflow.invoke.receive", async (span) => {
+            span?.setAttributes({
+              ...WorkflowRunId4(input3.runId),
+              "workflow.invocation.id": requestId
+            });
+            const result2 = await handleInvocation(world, input3.runId, requestId, input3.input);
+            if (result2.status === "accepted")
+              current.activity.notify();
+            return result2;
+          }));
+          current.admission = decision.catch(() => {
+          });
+          return await decision;
+        }
+        if (current.execution)
+          return await current.execution;
+        const execution = handler(message, metadata, current.activity);
+        current.execution = execution;
+        try {
+          return await execution;
+        } finally {
+          if (current.execution === execution)
+            current.execution = void 0;
+        }
+      } finally {
+        current.references--;
+        if (current.references === 0 && sessions.get(input3.runId) === current)
+          sessions.delete(input3.runId);
+      }
+    };
+  };
+}
+var HookInvocationSchema2, HookInvocationResultSchema2, RunInputActivity;
+var init_invocations2 = __esm({
+  "../core/dist/runtime/invocations.js"() {
+    "use strict";
+    init_dist7();
+    init_dist6();
+    init_zod2();
+    init_semantic_conventions2();
+    init_telemetry4();
+    HookInvocationSchema2 = external_exports2.object({
+      type: external_exports2.literal("hook_resume"),
+      version: external_exports2.literal(1),
+      hookId: external_exports2.string(),
+      token: external_exports2.string(),
+      payload: external_exports2.instanceof(Uint8Array)
+    });
+    HookInvocationResultSchema2 = external_exports2.discriminatedUnion("status", [
+      external_exports2.object({ status: external_exports2.literal("accepted") }),
+      external_exports2.object({
+        status: external_exports2.literal("rejected"),
+        code: external_exports2.enum(["HOOK_NOT_FOUND", "INVALID_INPUT"])
+      })
+    ]);
+    __name(handleInvocation, "handleInvocation");
+    __name(isHookGone, "isHookGone");
+    __name(hasResume, "hasResume");
+    RunInputActivity = class {
+      static {
+        __name(this, "RunInputActivity");
+      }
+      revision = 0;
+      listeners = /* @__PURE__ */ new Set();
+      notify() {
+        this.revision++;
+        for (const notify of this.listeners)
+          notify();
+      }
+      async waitForActivity(since, timeoutMs = 100) {
+        if (this.revision !== since)
+          return true;
+        await new Promise((resolve3) => {
+          const finish = /* @__PURE__ */ __name(() => {
+            clearTimeout(timer);
+            this.listeners.delete(finish);
+            resolve3();
+          }, "finish");
+          const timer = setTimeout(finish, timeoutMs);
+          this.listeners.add(finish);
+        });
+        return this.revision !== since;
+      }
+    };
+    __name(withRunInputs, "withRunInputs");
+  }
+});
+
 // ../core/dist/runtime/wait-until.js
 function waitUntil3(promise3) {
   void Promise.resolve().then(() => __toESM(require_functions2(), 1)).then(({ waitUntil: waitUntil4 }) => {
@@ -86687,6 +86898,26 @@ async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hook
         if (originLink) {
           span?.addLink?.(originLink);
         }
+        if (world.capabilities?.invoke === true && !v1Compat && dehydratedPayload instanceof Uint8Array) {
+          if (!world.invoke) {
+            throw new WorkflowRuntimeError2("World advertises invoke without implementing it");
+          }
+          span?.setAttributes({ "workflow.hook.resume_strategy": "invoke" });
+          const result2 = HookInvocationResultSchema2.parse(await world.invoke(hook.runId, {
+            type: "hook_resume",
+            version: 1,
+            hookId: hook.hookId,
+            token: hook.token,
+            payload: dehydratedPayload
+          }, { idempotencyKey: generateResumeId2() }));
+          if (result2.status === "rejected") {
+            if (result2.code === "HOOK_NOT_FOUND")
+              throw new HookNotFoundError2(hook.token);
+            throw new WorkflowRuntimeError2("Executor rejected the hook invocation input");
+          }
+          span?.setAttributes(HookResumeCommitted2(true));
+          return asLazyMetadataHook2(hook);
+        }
         const queueName = getWorkflowQueueName2(resumeContext.workflowName);
         const queueOptions = {
           deploymentId: resumeContext.deploymentId,
@@ -86811,6 +87042,7 @@ var init_resume_hook2 = __esm({
     init_telemetry4();
     init_get_world_lazy2();
     init_helpers3();
+    init_invocations2();
     init_wait_until2();
     generateResumeId2 = monotonicFactory2();
     __name(computeResumePayloadDigest2, "computeResumePayloadDigest");
@@ -87900,6 +88132,11 @@ function createForwardedWritable2({ global: global2, ops, runId, name, key, depl
   return serialize5.writable;
 }
 function getRunReadableStream2(global2, ops, runId, name, startIndex, cryptoKey) {
+  return getLazyReadableStream2((onReadableState) => getExternalRevivers2(global2, ops, runId, cryptoKey, {
+    onReadableState
+  }).ReadableStream({ name, startIndex }));
+}
+function getLazyReadableStream2(reviveReadable, onReadableState) {
   let reader;
   let lockState;
   let lockPollingStarted = false;
@@ -87909,15 +88146,16 @@ function getRunReadableStream2(global2, ops, runId, name, startIndex, cryptoKey)
       async pull(controller) {
         try {
           if (!reader) {
-            const stream = getExternalRevivers2(global2, ops, runId, cryptoKey, {
-              onReadableState: /* @__PURE__ */ __name((state) => {
-                lockState = state;
-              }, "onReadableState")
-            }).ReadableStream({ name, startIndex });
+            const stream = reviveReadable((state) => {
+              lockState = state;
+            });
             reader = stream.getReader();
             if (lockState && !lockPollingStarted) {
               lockPollingStarted = true;
-              pollReadableLock2(userReadable, lockState);
+              if (onReadableState)
+                onReadableState(lockState);
+              else
+                pollReadableLock2(userReadable, lockState);
             }
           }
           const result2 = await reader.read();
@@ -87941,6 +88179,48 @@ function getRunReadableStream2(global2, ops, runId, name, startIndex, cryptoKey)
   return userReadable;
 }
 function getExternalRevivers2(global2 = globalThis, ops, runId, cryptoKey, options) {
+  function reviveReadableStream(value, onReadableState = options?.onReadableState) {
+    if (value.type === "bytes") {
+      const readable2 = new WorkflowServerReadableStream2(runId, value.name, value.startIndex);
+      const state2 = createFlushableState2();
+      ops.push(state2.promise);
+      const { readable: userReadable, writable } = value.framing === "framed-v1" ? getByteUnframingStream2() : new global2.TransformStream();
+      flushablePipe2(readable2, writable, state2).catch(() => {
+      });
+      if (onReadableState)
+        onReadableState(state2);
+      else
+        pollReadableLock2(userReadable, state2);
+      return userReadable;
+    }
+    let keyPromise;
+    const resolveKey = /* @__PURE__ */ __name(() => {
+      keyPromise ??= resolveEncryptionKey2(cryptoKey);
+      return keyPromise;
+    }, "resolveKey");
+    const readable = createReconnectingFramedStream2(runId, value.name, value.startIndex, resolveKey);
+    const transform3 = getDeserializeStream2(getExternalRevivers2(global2, ops, runId, resolveKey, {
+      lazyStreams: options?.lazyStreams,
+      liveAbortSignals: options?.liveAbortSignals
+    }), resolveKey);
+    const state = createFlushableState2();
+    ops.push(state.promise);
+    flushablePipe2(readable, transform3.writable, state).catch(() => {
+    });
+    if (onReadableState)
+      onReadableState(state);
+    else
+      pollReadableLock2(transform3.readable, state);
+    return transform3.readable;
+  }
+  __name(reviveReadableStream, "reviveReadableStream");
+  function reviveAbortSnapshot(value) {
+    const controller = new AbortController();
+    if (value.aborted)
+      controller.abort(value.reason);
+    return controller;
+  }
+  __name(reviveAbortSnapshot, "reviveAbortSnapshot");
   return {
     ...getCommonRevivers4(global2),
     // StepFunction should not be returned from workflows to clients
@@ -87981,36 +88261,7 @@ function getExternalRevivers2(global2 = globalThis, ops, runId, cryptoKey, optio
         const response = new global2.Response(bodyInit);
         return response.body;
       }
-      if (value.type === "bytes") {
-        const readable = new WorkflowServerReadableStream2(runId, value.name, value.startIndex);
-        const state = createFlushableState2();
-        ops.push(state.promise);
-        const { readable: userReadable, writable } = value.framing === "framed-v1" ? getByteUnframingStream2() : new global2.TransformStream();
-        flushablePipe2(readable, writable, state).catch(() => {
-        });
-        if (options?.onReadableState)
-          options.onReadableState(state);
-        else
-          pollReadableLock2(userReadable, state);
-        return userReadable;
-      } else {
-        let keyPromise;
-        const resolveKey = /* @__PURE__ */ __name(() => {
-          keyPromise ??= resolveEncryptionKey2(cryptoKey);
-          return keyPromise;
-        }, "resolveKey");
-        const readable = createReconnectingFramedStream2(runId, value.name, value.startIndex, resolveKey);
-        const transform3 = getDeserializeStream2(getExternalRevivers2(global2, ops, runId, resolveKey), resolveKey);
-        const state = createFlushableState2();
-        ops.push(state.promise);
-        flushablePipe2(readable, transform3.writable, state).catch(() => {
-        });
-        if (options?.onReadableState)
-          options.onReadableState(state);
-        else
-          pollReadableLock2(transform3.readable, state);
-        return transform3.readable;
-      }
+      return options?.lazyStreams ? getLazyReadableStream2((onReadableState) => reviveReadableStream(value, onReadableState), options.onReadableState) : reviveReadableStream(value);
     }, "ReadableStream"),
     WritableStream: /* @__PURE__ */ __name((value) => {
       const targetRunId = typeof value.runId === "string" ? value.runId : runId;
@@ -88025,8 +88276,8 @@ function getExternalRevivers2(global2 = globalThis, ops, runId, cryptoKey, optio
         encryptionPublicKey: value.encryptionPublicKey
       });
     }, "WritableStream"),
-    AbortController: /* @__PURE__ */ __name((value) => reviveAbortController2(value, ops, runId), "AbortController"),
-    AbortSignal: /* @__PURE__ */ __name((value) => reviveAbortSignal2(value, ops, runId), "AbortSignal")
+    AbortController: /* @__PURE__ */ __name((value) => options?.liveAbortSignals === false ? reviveAbortSnapshot(value) : reviveAbortController2(value, ops, runId), "AbortController"),
+    AbortSignal: /* @__PURE__ */ __name((value) => options?.liveAbortSignals === false ? reviveAbortSnapshot(value).signal : reviveAbortSignal2(value, ops, runId), "AbortSignal")
   };
 }
 function getWorkflowRevivers(global2 = globalThis) {
@@ -88902,6 +89153,7 @@ var init_serialization4 = __esm({
     __name(tagForwardedWritableTarget2, "tagForwardedWritableTarget");
     __name(createForwardedWritable2, "createForwardedWritable");
     __name(getRunReadableStream2, "getRunReadableStream");
+    __name(getLazyReadableStream2, "getLazyReadableStream");
     __name(getExternalRevivers2, "getExternalRevivers");
     __name(getWorkflowRevivers, "getWorkflowRevivers");
     __name(getStepRevivers2, "getStepRevivers");
@@ -89153,6 +89405,751 @@ var init_constants3 = __esm({
   }
 });
 
+// ../core/dist/types.js
+import { types as types6 } from "node:util";
+function getErrorName(v) {
+  if (types6.isNativeError(v)) {
+    return v.name;
+  }
+  return "Error";
+}
+function getErrorStack(v) {
+  if (types6.isNativeError(v)) {
+    return v.stack ?? "";
+  }
+  return "";
+}
+function describeErrorLink(value) {
+  if (typeof value !== "object" || value === null) {
+    return String(value);
+  }
+  const { name, message, code: code3 } = value;
+  const label = typeof name === "string" && name ? name : "Error";
+  const text = typeof message === "string" && message ? `${label}: ${message}` : label;
+  return typeof code3 === "string" && code3 && !text.includes(code3) ? `${text} (${code3})` : text;
+}
+function formatErrorCauseChain(value) {
+  const lines = [];
+  const seen = /* @__PURE__ */ new Set();
+  try {
+    for (let current = causeOf(value); current != null && lines.length <= MAX_CAUSE_LINKS; current = causeOf(current)) {
+      if (typeof current !== "object") {
+        lines.push(String(current));
+        break;
+      }
+      if (seen.has(current))
+        break;
+      seen.add(current);
+      lines.push(describeErrorLink(current), ...aggregatedLinks(current));
+    }
+  } catch {
+    lines.push("[unavailable cause]");
+  }
+  return lines.length > MAX_CAUSE_LINKS ? [...lines.slice(0, MAX_CAUSE_LINKS), "\u2026"].join("\n") : lines.join("\n");
+}
+function causeOf(value) {
+  return typeof value === "object" && value !== null ? value.cause : void 0;
+}
+function aggregatedLinks(value) {
+  const errors = value.errors;
+  return Array.isArray(errors) ? errors.slice(0, MAX_CAUSE_LINKS).map(describeErrorLink) : [];
+}
+function isAbortError(value) {
+  return typeof value === "object" && value !== null && "name" in value && value.name === "AbortError" && "message" in value && typeof value.message === "string" && (!("stack" in value) || value.stack === void 0 || typeof value.stack === "string");
+}
+function promoteAbortErrorToFatal(value) {
+  if (!isAbortError(value) || FatalError2.is(value)) {
+    return value;
+  }
+  const fatalError = new FatalError2(`Aborted: ${value.message}`);
+  if (value.stack) {
+    fatalError.stack = value.stack;
+  }
+  return fatalError;
+}
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function normalizeSyncError(v) {
+  if (types6.isNativeError(v)) {
+    return {
+      name: v.name,
+      message: v.message,
+      stack: v.stack ?? ""
+    };
+  }
+  if (typeof v === "string") {
+    return {
+      name: "Error",
+      message: v,
+      stack: ""
+    };
+  }
+  try {
+    return {
+      name: "Error",
+      message: JSON.stringify(v),
+      stack: ""
+    };
+  } catch {
+    return {
+      name: "Error",
+      message: String(v),
+      stack: ""
+    };
+  }
+}
+async function normalizeUnknownError(value) {
+  if (isThenable(value)) {
+    try {
+      const resolved = await value;
+      const normalized = await normalizeUnknownError(resolved);
+      return {
+        ...normalized,
+        message: `Promise rejection: ${normalized.message}`
+      };
+    } catch (rejection) {
+      const normalized = await normalizeUnknownError(rejection);
+      return {
+        ...normalized,
+        message: `Promise rejection: ${normalized.message}`
+      };
+    }
+  }
+  return normalizeSyncError(value);
+}
+var MAX_CAUSE_LINKS;
+var init_types4 = __esm({
+  "../core/dist/types.js"() {
+    "use strict";
+    init_dist7();
+    __name(getErrorName, "getErrorName");
+    __name(getErrorStack, "getErrorStack");
+    MAX_CAUSE_LINKS = 4;
+    __name(describeErrorLink, "describeErrorLink");
+    __name(formatErrorCauseChain, "formatErrorCauseChain");
+    __name(causeOf, "causeOf");
+    __name(aggregatedLinks, "aggregatedLinks");
+    __name(isAbortError, "isAbortError");
+    __name(promoteAbortErrorToFatal, "promoteAbortErrorToFatal");
+    __name(isThenable, "isThenable");
+    __name(normalizeSyncError, "normalizeSyncError");
+    __name(normalizeUnknownError, "normalizeUnknownError");
+  }
+});
+
+// ../core/dist/attribute-changes.js
+var init_attribute_changes = __esm({
+  "../core/dist/attribute-changes.js"() {
+    "use strict";
+    init_dist7();
+    init_attributes_validation2();
+  }
+});
+
+// ../core/dist/runtime/vm-mode.js
+function getWorkflowVmFromEnv2(env = process.env) {
+  const raw = env.WORKFLOW_VM;
+  if (raw === void 0 || raw === "")
+    return void 0;
+  if (WORKFLOW_VMS2.includes(raw)) {
+    return raw;
+  }
+  throw new WorkflowRuntimeError2(`Invalid WORKFLOW_VM value: "${raw}". Expected one of: ${WORKFLOW_VMS2.join(", ")}.`);
+}
+function useQuickJSVm(workflowRun) {
+  const vmFromRun = workflowRun.executionContext?.workflowVm;
+  if (vmFromRun !== void 0) {
+    if (!WORKFLOW_VMS2.includes(vmFromRun)) {
+      throw new WorkflowRuntimeError2(`Invalid executionContext.workflowVm value: "${vmFromRun}". Expected one of: ${WORKFLOW_VMS2.join(", ")}.`);
+    }
+    return vmFromRun === "quickjs";
+  }
+  return getWorkflowVmFromEnv2() === "quickjs";
+}
+var WORKFLOW_VMS2;
+var init_vm_mode = __esm({
+  "../core/dist/runtime/vm-mode.js"() {
+    "use strict";
+    init_dist7();
+    WORKFLOW_VMS2 = ["node", "quickjs"];
+    __name(getWorkflowVmFromEnv2, "getWorkflowVmFromEnv");
+    __name(useQuickJSVm, "useQuickJSVm");
+  }
+});
+
+// ../core/dist/runtime/start.js
+var ulid7, latestNoOpWarning2;
+var init_start = __esm({
+  "../core/dist/runtime/start.js"() {
+    "use strict";
+    init_dist7();
+    init_dist5();
+    init_dist6();
+    init_node2();
+    init_attribute_changes();
+    init_capabilities2();
+    init_classify_error();
+    init_encryption4();
+    init_logger2();
+    init_sealed_box2();
+    init_serialization4();
+    init_context_storage2();
+    init_semantic_conventions2();
+    init_telemetry4();
+    init_version4();
+    init_get_world_lazy2();
+    init_helpers3();
+    init_run();
+    init_vm_mode();
+    init_wait_until2();
+    init_world_compatibility2();
+    ulid7 = monotonicFactory2();
+    latestNoOpWarning2 = globalSingleton2("@workflow/core//latestNoOpWarning", 1, () => ({ warned: false }));
+  }
+});
+
+// ../core/dist/runtime/runs.js
+async function wakeUpRun2(world, runId, options) {
+  try {
+    const run3 = await world.runs.get(runId, { resolveData: "none" });
+    const compatMode = isLegacySpecVersion2(run3.specVersion);
+    const allEvents = [];
+    let cursor = null;
+    do {
+      const eventsResult = await world.events.list({
+        runId,
+        pagination: { sortOrder: "asc", ...cursor ? { cursor } : {} },
+        resolveData: "none"
+      });
+      allEvents.push(...eventsResult.data);
+      cursor = eventsResult.hasMore ? eventsResult.cursor : null;
+    } while (cursor);
+    const waitCreatedEvents = allEvents.filter((event) => event.eventType === "wait_created");
+    const waitCompletedCorrelationIds = new Set(allEvents.filter((event) => event.eventType === "wait_completed").map((event) => event.correlationId));
+    let pendingWaits = waitCreatedEvents.filter((event) => !waitCompletedCorrelationIds.has(event.correlationId));
+    if (options?.correlationIds && options.correlationIds.length > 0) {
+      const targetCorrelationIds = new Set(options.correlationIds);
+      pendingWaits = pendingWaits.filter((event) => event.correlationId && targetCorrelationIds.has(event.correlationId));
+    }
+    const errors = [];
+    let stoppedCount = 0;
+    for (const waitEvent of pendingWaits) {
+      if (!waitEvent.correlationId)
+        continue;
+      const eventData = compatMode ? {
+        eventType: "wait_completed",
+        correlationId: waitEvent.correlationId
+      } : {
+        eventType: "wait_completed",
+        correlationId: waitEvent.correlationId,
+        specVersion: run3.specVersion,
+        eventData: {
+          resumeAt: waitEvent.eventData.resumeAt
+        }
+      };
+      try {
+        await world.events.create(runId, eventData, { v1Compat: compatMode });
+        stoppedCount++;
+      } catch (err) {
+        if (EntityConflictError2.is(err)) {
+          stoppedCount++;
+        } else {
+          errors.push(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    }
+    if (stoppedCount > 0) {
+      await world.queue(getWorkflowQueueName2(run3.workflowName, options?.namespace), {
+        runId
+      }, {
+        deploymentId: run3.deploymentId,
+        specVersion: run3.specVersion ?? SPEC_VERSION_LEGACY2
+      });
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, `Failed to complete ${errors.length}/${pendingWaits.length} pending wait(s) for run ${runId}`);
+    }
+    return { stoppedCount };
+  } catch (err) {
+    if (err instanceof AggregateError) {
+      throw err;
+    }
+    throw new Error(`Failed to wake up run ${runId}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+  }
+}
+var init_runs4 = __esm({
+  "../core/dist/runtime/runs.js"() {
+    "use strict";
+    init_dist7();
+    init_dist6();
+    init_encryption5();
+    init_serialization4();
+    init_helpers3();
+    init_start();
+    __name(wakeUpRun2, "wakeUpRun");
+  }
+});
+
+// ../core/dist/runtime/run.js
+function getReturnValuePollIntervalMs2() {
+  return envNumber2("WORKFLOW_RETURN_VALUE_POLL_INTERVAL_MS", RETURN_VALUE_POLL_INTERVAL_MS2, { integer: true, min: 1 });
+}
+function getReturnValueWaitTimeoutMs2() {
+  return envNumber2("WORKFLOW_RETURN_VALUE_WAIT_MS", RETURN_VALUE_WAIT_TIMEOUT_MS2, { integer: true, min: 1 });
+}
+function getReturnValueMaxLongPolls2() {
+  return envNumber2("WORKFLOW_RETURN_VALUE_MAX_LONG_POLLS", RETURN_VALUE_MAX_LONG_POLLS2, { integer: true, min: 1 });
+}
+function isReturnValueLongPollEnabled2() {
+  const raw = process.env.WORKFLOW_RETURN_VALUE_LONG_POLL;
+  if (raw === void 0 || raw === "")
+    return true;
+  return !(raw === "0" || raw.toLowerCase() === "false");
+}
+var RETURN_VALUE_POLL_INTERVAL_MS2, PAYLOAD_TERMINAL_RUN_STATUSES2, NOT_FOUND_RETRY_DELAYS2, RETURN_VALUE_WAIT_TIMEOUT_MS2, RETURN_VALUE_MAX_LONG_POLLS2, Run2;
+var init_run = __esm({
+  "../core/dist/runtime/run.js"() {
+    "use strict";
+    init_dist7();
+    init_dist12();
+    init_env_config2();
+    init_spec_version2();
+    init_encryption5();
+    init_serialization4();
+    init_util5();
+    init_get_world_lazy2();
+    init_runs4();
+    RETURN_VALUE_POLL_INTERVAL_MS2 = 1e3;
+    PAYLOAD_TERMINAL_RUN_STATUSES2 = /* @__PURE__ */ new Set([
+      "completed",
+      "failed"
+    ]);
+    NOT_FOUND_RETRY_DELAYS2 = [1e3, 3e3, 6e3];
+    __name(getReturnValuePollIntervalMs2, "getReturnValuePollIntervalMs");
+    RETURN_VALUE_WAIT_TIMEOUT_MS2 = 5e4;
+    __name(getReturnValueWaitTimeoutMs2, "getReturnValueWaitTimeoutMs");
+    RETURN_VALUE_MAX_LONG_POLLS2 = 10;
+    __name(getReturnValueMaxLongPolls2, "getReturnValueMaxLongPolls");
+    __name(isReturnValueLongPollEnabled2, "isReturnValueLongPollEnabled");
+    Run2 = class _Run2 {
+      static {
+        __name(this, "Run");
+      }
+      static [WORKFLOW_SERIALIZE2](instance) {
+        return { runId: instance.runId, resilientStart: instance.#resilientStart };
+      }
+      static [WORKFLOW_DESERIALIZE2](data) {
+        return new _Run2(data.runId, { resilientStart: data.resilientStart });
+      }
+      /**
+       * The ID of the workflow run.
+       */
+      runId;
+      /**
+       * The world object.
+       * @internal
+       */
+      #worldPromise;
+      get #lazyWorldPromise() {
+        if (!this.#worldPromise)
+          this.#worldPromise = getWorldLazy2();
+        return this.#worldPromise;
+      }
+      /**
+       * Cached encryption key resolution. Resolved once on first use and
+       * reused for returnValue, getReadable(), etc.
+       * @internal
+       */
+      #encryptionKeyPromise = null;
+      /**
+       * When true, run_created failed and the run may not exist yet (the
+       * resilient start path will create it via run_started). pollReturnValue
+       * retries on WorkflowRunNotFoundError only when this flag is set so
+       * that normal runs fail fast on 404.
+       * @internal
+       */
+      #resilientStart = false;
+      constructor(runId, opts) {
+        this.runId = runId;
+        this.#resilientStart = opts?.resilientStart ?? false;
+      }
+      /**
+       * Resolves and caches the encryption key for this run.
+       * The key is the same for the lifetime of a run, so it only needs
+       * to be resolved once.
+       * @internal
+       */
+      #getEncryptionKey(run3) {
+        if (!this.#encryptionKeyPromise) {
+          this.#encryptionKeyPromise = (async () => {
+            const world = await this.#lazyWorldPromise;
+            const runData = run3 ?? await world.runs.get(this.runId);
+            const rawKey = await world.getEncryptionKeyForRun?.(runData);
+            return rawKey ? await deriveRunPayloadKeys2(rawKey) : void 0;
+          })();
+        }
+        return this.#encryptionKeyPromise;
+      }
+      /**
+       * Defers fetching the run and its encryption key until a readable is first
+       * consumed. The first pull prefetches it so an encrypted first frame can join
+       * the lookup; this also applies to an empty consumed stream.
+       * @internal
+       */
+      #getEncryptionKeyLazily() {
+        return () => this.#getEncryptionKey();
+      }
+      /**
+       * Interrupts pending `sleep()` calls, resuming the workflow early.
+       *
+       * @param options - Optional settings to target specific sleep calls by correlation ID.
+       *   If not provided, all pending sleep calls will be interrupted.
+       * @returns A {@link StopSleepResult} object containing the number of sleep calls that were interrupted.
+       */
+      async wakeUp(options) {
+        "use step";
+        return wakeUpRun2(await this.#lazyWorldPromise, this.runId, options);
+      }
+      /**
+       * Cancels the workflow run.
+       *
+       * @param options - Optional cancellation settings. `cancelReason` records a
+       *   free-text reason (max 512 chars) on the run_cancelled event, surfaced in
+       *   the run detail view.
+       */
+      async cancel(options) {
+        "use step";
+        const world = await this.#lazyWorldPromise;
+        await world.events.create(this.runId, {
+          eventType: "run_cancelled",
+          specVersion: SPEC_VERSION_CURRENT2,
+          ...options?.cancelReason !== void 0 ? { eventData: { cancelReason: options.cancelReason } } : {}
+        });
+      }
+      /**
+       * Whether the workflow run exists.
+       */
+      get exists() {
+        "use step";
+        return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, { resolveData: "none" }).then(() => true).catch((error121) => {
+          if (WorkflowRunNotFoundError2.is(error121)) {
+            return false;
+          }
+          throw error121;
+        }));
+      }
+      /**
+       * The status of the workflow run.
+       */
+      get status() {
+        "use step";
+        return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, { resolveData: "none" }).then((run3) => run3.status));
+      }
+      /**
+       * The return value of the workflow run.
+       * Polls the workflow return value until the workflow run completes.
+       */
+      get returnValue() {
+        "use step";
+        return this.#pollReturnValue();
+      }
+      /**
+       * The name of the workflow.
+       */
+      get workflowName() {
+        "use step";
+        return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, { resolveData: "none" }).then((run3) => run3.workflowName));
+      }
+      /**
+       * The timestamp when the workflow run was created.
+       */
+      get createdAt() {
+        "use step";
+        return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, { resolveData: "none" }).then((run3) => run3.createdAt));
+      }
+      /**
+       * The timestamp when the workflow run started execution.
+       * Returns undefined if the workflow has not started yet.
+       */
+      get startedAt() {
+        "use step";
+        return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, { resolveData: "none" }).then((run3) => run3.startedAt));
+      }
+      /**
+       * The timestamp when the workflow run completed.
+       * Returns undefined if the workflow has not completed yet.
+       */
+      get completedAt() {
+        "use step";
+        return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, { resolveData: "none" }).then((run3) => run3.completedAt));
+      }
+      /**
+       * The readable stream of the workflow run.
+       */
+      get readable() {
+        return this.getReadable();
+      }
+      /**
+       * Retrieves the workflow run's default readable stream, which reads chunks
+       * written to the corresponding writable stream {@link getWritable}.
+       *
+       * The returned stream has an additional {@link WorkflowReadableStream.getTailIndex | getTailIndex()}
+       * helper that returns the index of the last known chunk. This is useful when
+       * building reconnection endpoints that need to inform clients where the
+       * stream starts.
+       *
+       * @param options - The options for the readable stream.
+       * @returns A `WorkflowReadableStream` for the workflow run.
+       */
+      getReadable(options = {}) {
+        "use step";
+        const { ops = [], global: global2 = globalThis, startIndex, namespace } = options;
+        const name = getWorkflowRunStreamId2(this.runId, namespace);
+        const encryptionKey = this.#getEncryptionKeyLazily();
+        const stream = getRunReadableStream2(global2, ops, this.runId, name, startIndex, encryptionKey);
+        const worldPromise = this.#lazyWorldPromise;
+        const runId = this.runId;
+        return Object.assign(stream, {
+          getTailIndex: /* @__PURE__ */ __name(async () => {
+            const world = await worldPromise;
+            const info = await world.streams.getInfo(runId, name);
+            return info.tailIndex;
+          }, "getTailIndex")
+        });
+      }
+      /** The writable stream of the workflow run. */
+      get writable() {
+        return this.getWritable();
+      }
+      /**
+       * Returns a writable that appends to this run's stream.
+       *
+       * Initialization is deferred until the first write. The run must already
+       * exist. The writable may be forwarded through `start()` and into steps, but
+       * grants no read access or additional authorization.
+       *
+       * @remarks
+       * `writer.close()` closes the shared stream. Contributors should call
+       * `releaseLock()`, which also drains pending writes.
+       *
+       * @param options - The writable stream options.
+       */
+      getWritable(options = {}) {
+        "use step";
+        const { ops = [], global: global2 = globalThis, namespace } = options;
+        const name = getWorkflowRunStreamId2(this.runId, namespace);
+        let targetPromise;
+        let writable;
+        const resolveTarget = /* @__PURE__ */ __name(() => {
+          targetPromise ??= this.#getMetadata().then(async (run3) => {
+            const target2 = {
+              key: await getForwardedWritableEncryptionKey2(this.runId, run3.deploymentId, run3.encryptionPublicKey),
+              deploymentId: run3.deploymentId,
+              encryptionPublicKey: run3.encryptionPublicKey
+            };
+            tagForwardedWritableTarget2(writable, target2);
+            return target2;
+          });
+          return targetPromise;
+        }, "resolveTarget");
+        writable = createForwardedWritable2({
+          global: global2,
+          ops,
+          runId: this.runId,
+          name,
+          key: /* @__PURE__ */ __name(() => resolveTarget().then(({ key }) => key), "key")
+        });
+        return writable;
+      }
+      /** Reads metadata, briefly retrying resilient starts. @internal */
+      async #getMetadata() {
+        const world = await this.#lazyWorldPromise;
+        const maxRetries = this.#resilientStart ? NOT_FOUND_RETRY_DELAYS2.length : 0;
+        let attempt = 0;
+        while (true) {
+          try {
+            return await world.runs.get(this.runId, { resolveData: "none" });
+          } catch (error121) {
+            if (!WorkflowRunNotFoundError2.is(error121) || attempt >= maxRetries) {
+              throw error121;
+            }
+            const delay = NOT_FOUND_RETRY_DELAYS2[attempt];
+            attempt++;
+            await new Promise((resolve3) => setTimeout(resolve3, delay));
+          }
+        }
+      }
+      /** @internal */
+      async #resolveTerminalReturnValue(run3) {
+        const expiredAt = run3.expiredAt;
+        if (expiredAt != null && expiredAt <= /* @__PURE__ */ new Date()) {
+          throw new RunExpiredError2(`Run "${this.runId}" ${run3.status === "completed" ? "completed" : `is ${run3.status}`}, but its data expired at ${expiredAt.toISOString()} and is no longer readable.`, this.runId, run3.status, expiredAt);
+        }
+        if (run3.status === "completed") {
+          const encryptionKey = await this.#getEncryptionKey(run3);
+          return await hydrateWorkflowReturnValue2(run3.output, this.runId, encryptionKey);
+        }
+        if (run3.status === "cancelled") {
+          throw new WorkflowRunCancelledError2(this.runId);
+        }
+        if (run3.status === "failed") {
+          const encryptionKey = await this.#getEncryptionKey(run3);
+          let hydratedError;
+          try {
+            hydratedError = await hydrateRunError2(run3.error, this.runId, encryptionKey);
+          } catch {
+            hydratedError = new Error("Failed to hydrate workflow run error");
+          }
+          throw new WorkflowRunFailedError2(this.runId, hydratedError, {
+            errorCode: run3.errorCode
+          });
+        }
+        throw new WorkflowRunNotCompletedError2(this.runId, run3.status);
+      }
+      /**
+       * Polls the workflow return value until the workflow run completes.
+       * @internal
+       * @returns The workflow return value.
+       */
+      async #pollReturnValue() {
+        const world = await this.#lazyWorldPromise;
+        let notFoundRetries = 0;
+        const NOT_FOUND_MAX_RETRIES = this.#resilientStart ? NOT_FOUND_RETRY_DELAYS2.length : 0;
+        const waitForTerminalStatus = isReturnValueLongPollEnabled2() ? world.runs.waitForTerminalStatus?.bind(world.runs) : void 0;
+        let longPolls = 0;
+        const maxLongPolls = getReturnValueMaxLongPolls2();
+        while (true) {
+          const iterationStartedAt = Date.now();
+          try {
+            const useLongPoll = waitForTerminalStatus && longPolls < maxLongPolls;
+            if (useLongPoll)
+              longPolls++;
+            const runMetadata = useLongPoll ? await waitForTerminalStatus(this.runId, {
+              timeoutMs: getReturnValueWaitTimeoutMs2(),
+              resolveData: "none"
+            }) : await world.runs.get(this.runId, {
+              resolveData: "none"
+            });
+            if (runMetadata.status === "cancelled") {
+              throw new WorkflowRunCancelledError2(this.runId);
+            }
+            if (PAYLOAD_TERMINAL_RUN_STATUSES2.has(runMetadata.status)) {
+              const run3 = await world.runs.get(this.runId, {
+                resolveData: "all"
+              });
+              return await this.#resolveTerminalReturnValue(run3);
+            }
+            throw new WorkflowRunNotCompletedError2(this.runId, runMetadata.status);
+          } catch (error121) {
+            if (WorkflowRunNotCompletedError2.is(error121)) {
+              const remainingIntervalMs = getReturnValuePollIntervalMs2() - (Date.now() - iterationStartedAt);
+              if (remainingIntervalMs > 0) {
+                await new Promise((resolve3) => setTimeout(resolve3, remainingIntervalMs));
+              }
+              continue;
+            }
+            if (WorkflowRunNotFoundError2.is(error121) && notFoundRetries < NOT_FOUND_MAX_RETRIES) {
+              const delay = NOT_FOUND_RETRY_DELAYS2[notFoundRetries];
+              notFoundRetries++;
+              await new Promise((resolve3) => setTimeout(resolve3, delay));
+              continue;
+            }
+            throw error121;
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../core/dist/runtime/lifecycle-hooks.js
+function getRegistry3() {
+  if (!Object.hasOwn(globalThis, REGISTRY_KEY)) {
+    Object.defineProperty(globalThis, REGISTRY_KEY, {
+      value: [],
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  return globalThis[REGISTRY_KEY];
+}
+function dispatch(runId, workflowName, event, prepare, invoke) {
+  const registered = getRegistry3().filter((hooks) => hooks[event]);
+  if (registered.length === 0) {
+    return;
+  }
+  safeWaitUntil2(
+    trace5(`workflow.lifecycle.${event}`, async () => {
+      const params = await prepare();
+      for (const hooks of registered) {
+        try {
+          await invoke(hooks, params);
+        } catch (err) {
+          runtimeLogger2.error(`Workflow lifecycle ${event} handler threw`, {
+            workflowRunId: runId,
+            workflowName,
+            errorName: getErrorName(err),
+            errorMessage: err instanceof Error ? err.message : String(err),
+            errorStack: getErrorStack(err)
+          });
+        }
+      }
+    }),
+    // Covers a `prepare()` rejection; handler failures are caught above.
+    (err) => {
+      runtimeLogger2.error(`Workflow lifecycle ${event} dispatch failed`, {
+        workflowRunId: runId,
+        workflowName,
+        errorName: getErrorName(err),
+        errorMessage: err instanceof Error ? err.message : String(err),
+        errorStack: getErrorStack(err)
+      });
+    }
+  );
+}
+function dispatchRunCompletedHooks(runId, workflowName) {
+  dispatch(runId, workflowName, "onRunCompleted", async () => ({ run: new Run2(runId), workflowName }), (hooks, params) => hooks.onRunCompleted?.(params));
+}
+async function hydrateForHandlers(error121, runId, encryptionKey) {
+  try {
+    const ops = [];
+    return await hydrateRunError2(error121, runId, encryptionKey, ops, globalThis, getExternalRevivers2(globalThis, ops, runId, encryptionKey, {
+      lazyStreams: true,
+      liveAbortSignals: false
+    }));
+  } catch {
+    return new Error("Failed to hydrate workflow run error");
+  }
+}
+function dispatchRunFailedHooks(runId, workflowName, error121, encryptionKey, errorCode) {
+  dispatch(runId, workflowName, "onRunFailed", async () => ({
+    run: new Run2(runId),
+    workflowName,
+    error: new WorkflowRunFailedError2(runId, await hydrateForHandlers(error121, runId, encryptionKey), { errorCode })
+  }), (hooks, params) => hooks.onRunFailed?.(params));
+}
+var REGISTRY_KEY;
+var init_lifecycle_hooks = __esm({
+  "../core/dist/runtime/lifecycle-hooks.js"() {
+    "use strict";
+    init_dist7();
+    init_logger2();
+    init_serialization4();
+    init_telemetry4();
+    init_types4();
+    init_run();
+    init_wait_until2();
+    REGISTRY_KEY = /* @__PURE__ */ Symbol.for("@workflow/core//lifecycleHooks");
+    __name(getRegistry3, "getRegistry");
+    __name(dispatch, "dispatch");
+    __name(dispatchRunCompletedHooks, "dispatchRunCompletedHooks");
+    __name(hydrateForHandlers, "hydrateForHandlers");
+    __name(dispatchRunFailedHooks, "dispatchRunFailedHooks");
+  }
+});
+
 // ../core/dist/runtime/replay-budget.js
 async function handleReplayBudgetExhausted(args) {
   const { runId, workflowName, requestId, attempt, limitMs, slotSnapshot } = args;
@@ -89177,14 +90174,17 @@ async function handleReplayBudgetExhausted(args) {
   });
   const getEncryptionKey = memoizeEncryptionKey(world, runId);
   const timeoutErr = new FatalError2(`Workflow replay exceeded maximum duration (${limitMs / 1e3}s) after ${attempt} attempts`);
+  const encryptionKey = await getEncryptionKey();
+  const dehydratedError = await dehydrateRunError(timeoutErr, runId, encryptionKey);
   await world.events.create(runId, {
     eventType: "run_failed",
     specVersion: SPEC_VERSION_CURRENT2,
     eventData: {
-      error: await dehydrateRunError(timeoutErr, runId, await getEncryptionKey()),
+      error: dehydratedError,
       errorCode: RUN_ERROR_CODES2.REPLAY_TIMEOUT
     }
   }, { requestId, ...slotSnapshot });
+  dispatchRunFailedHooks(runId, workflowName, dehydratedError, encryptionKey, RUN_ERROR_CODES2.REPLAY_TIMEOUT);
 }
 var ReplayBudget, ReplayTimeoutRetryError;
 var init_replay_budget = __esm({
@@ -89197,6 +90197,7 @@ var init_replay_budget = __esm({
     init_serialization4();
     init_constants3();
     init_helpers3();
+    init_lifecycle_hooks();
     init_world();
     ReplayBudget = class {
       static {
@@ -89452,139 +90453,6 @@ var init_run_id_time = __esm({
   }
 });
 
-// ../core/dist/types.js
-import { types as types6 } from "node:util";
-function getErrorName(v) {
-  if (types6.isNativeError(v)) {
-    return v.name;
-  }
-  return "Error";
-}
-function getErrorStack(v) {
-  if (types6.isNativeError(v)) {
-    return v.stack ?? "";
-  }
-  return "";
-}
-function describeErrorLink(value) {
-  if (typeof value !== "object" || value === null) {
-    return String(value);
-  }
-  const { name, message, code: code3 } = value;
-  const label = typeof name === "string" && name ? name : "Error";
-  const text = typeof message === "string" && message ? `${label}: ${message}` : label;
-  return typeof code3 === "string" && code3 && !text.includes(code3) ? `${text} (${code3})` : text;
-}
-function formatErrorCauseChain(value) {
-  const lines = [];
-  const seen = /* @__PURE__ */ new Set();
-  try {
-    for (let current = causeOf(value); current != null && lines.length <= MAX_CAUSE_LINKS; current = causeOf(current)) {
-      if (typeof current !== "object") {
-        lines.push(String(current));
-        break;
-      }
-      if (seen.has(current))
-        break;
-      seen.add(current);
-      lines.push(describeErrorLink(current), ...aggregatedLinks(current));
-    }
-  } catch {
-    lines.push("[unavailable cause]");
-  }
-  return lines.length > MAX_CAUSE_LINKS ? [...lines.slice(0, MAX_CAUSE_LINKS), "\u2026"].join("\n") : lines.join("\n");
-}
-function causeOf(value) {
-  return typeof value === "object" && value !== null ? value.cause : void 0;
-}
-function aggregatedLinks(value) {
-  const errors = value.errors;
-  return Array.isArray(errors) ? errors.slice(0, MAX_CAUSE_LINKS).map(describeErrorLink) : [];
-}
-function isAbortError(value) {
-  return typeof value === "object" && value !== null && "name" in value && value.name === "AbortError" && "message" in value && typeof value.message === "string" && (!("stack" in value) || value.stack === void 0 || typeof value.stack === "string");
-}
-function promoteAbortErrorToFatal(value) {
-  if (!isAbortError(value) || FatalError2.is(value)) {
-    return value;
-  }
-  const fatalError = new FatalError2(`Aborted: ${value.message}`);
-  if (value.stack) {
-    fatalError.stack = value.stack;
-  }
-  return fatalError;
-}
-function isThenable(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function normalizeSyncError(v) {
-  if (types6.isNativeError(v)) {
-    return {
-      name: v.name,
-      message: v.message,
-      stack: v.stack ?? ""
-    };
-  }
-  if (typeof v === "string") {
-    return {
-      name: "Error",
-      message: v,
-      stack: ""
-    };
-  }
-  try {
-    return {
-      name: "Error",
-      message: JSON.stringify(v),
-      stack: ""
-    };
-  } catch {
-    return {
-      name: "Error",
-      message: String(v),
-      stack: ""
-    };
-  }
-}
-async function normalizeUnknownError(value) {
-  if (isThenable(value)) {
-    try {
-      const resolved = await value;
-      const normalized = await normalizeUnknownError(resolved);
-      return {
-        ...normalized,
-        message: `Promise rejection: ${normalized.message}`
-      };
-    } catch (rejection) {
-      const normalized = await normalizeUnknownError(rejection);
-      return {
-        ...normalized,
-        message: `Promise rejection: ${normalized.message}`
-      };
-    }
-  }
-  return normalizeSyncError(value);
-}
-var MAX_CAUSE_LINKS;
-var init_types4 = __esm({
-  "../core/dist/types.js"() {
-    "use strict";
-    init_dist7();
-    __name(getErrorName, "getErrorName");
-    __name(getErrorStack, "getErrorStack");
-    MAX_CAUSE_LINKS = 4;
-    __name(describeErrorLink, "describeErrorLink");
-    __name(formatErrorCauseChain, "formatErrorCauseChain");
-    __name(causeOf, "causeOf");
-    __name(aggregatedLinks, "aggregatedLinks");
-    __name(isAbortError, "isAbortError");
-    __name(promoteAbortErrorToFatal, "promoteAbortErrorToFatal");
-    __name(isThenable, "isThenable");
-    __name(normalizeSyncError, "normalizeSyncError");
-    __name(normalizeUnknownError, "normalizeUnknownError");
-  }
-});
-
 // ../core/dist/runtime/get-port-lazy.js
 import { createRequire as createRequire3 } from "node:module";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
@@ -90602,12 +91470,12 @@ var init_step_single_flight = __esm({
 
 // ../core/dist/runtime/wait-continuation.js
 function getWaitContinuationDispatch(timeoutSeconds, waitCorrelationId, now2 = Date.now(), attempt = 0) {
-  const dispatch = waitContinuationDispatchForAttemptZero(timeoutSeconds, waitCorrelationId, now2);
+  const dispatch2 = waitContinuationDispatchForAttemptZero(timeoutSeconds, waitCorrelationId, now2);
   if (attempt <= 0)
-    return dispatch;
+    return dispatch2;
   return {
-    delaySeconds: dispatch.delaySeconds,
-    idempotencyKey: `${dispatch.idempotencyKey}:a${attempt}`
+    delaySeconds: dispatch2.delaySeconds,
+    idempotencyKey: `${dispatch2.idempotencyKey}:a${attempt}`
   };
 }
 function waitContinuationDispatchForAttemptZero(timeoutSeconds, waitCorrelationId, now2) {
@@ -97201,6 +98069,40 @@ async function startQuickJSWorkflow(options) {
       }
     }
     serde.installProcessEnv(process.env);
+    const historicalAttributeIds = /* @__PURE__ */ new Set();
+    for (const event of events) {
+      if (event.eventType === "attr_set" && event.correlationId !== void 0) {
+        historicalAttributeIds.add(event.correlationId);
+      }
+    }
+    {
+      const env_5 = { stack: [], error: void 0, hasError: false };
+      try {
+        const validateAttributeWrite = __addDisposableResource3(env_5, vm.newFunction("__validateAttributeWrite", (correlationId, changes, allowReservedAttributes) => {
+          if (historicalAttributeIds.has(correlationId.toString())) {
+            return vm.undefined;
+          }
+          try {
+            validateAttributeEventDataSize2({
+              changes: vm.dump(changes),
+              writer: { type: "workflow" },
+              ...allowReservedAttributes.toBoolean() ? { allowReservedAttributes: true } : {}
+            });
+          } catch (err) {
+            if (!(err instanceof AttributeValidationError2))
+              throw err;
+            return vm.newString(err.message);
+          }
+          return vm.undefined;
+        }), false);
+        vm.setProp(vm.global, "__validateAttributeWrite", validateAttributeWrite);
+      } catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+      } finally {
+        __disposeResources3(env_5);
+      }
+    }
     if (!baselineSnapshot) {
       try {
         vm.evalCode(workflowCode2, workflowId || "workflow.js").dispose();
@@ -97277,8 +98179,11 @@ async function startQuickJSWorkflow(options) {
       let maxIterations = 100;
       let madeProgress;
       do {
-        madeProgress = await processEvents(vm, serde, events, advanceClock, options.encryptionKey);
         let batch;
+        do {
+          batch = vm.executePendingJobs();
+        } while (batch > 0);
+        madeProgress = await processEvents(vm, serde, events, advanceClock, options.encryptionKey);
         do {
           batch = vm.executePendingJobs();
           if (batch > 0)
@@ -97292,7 +98197,7 @@ async function startQuickJSWorkflow(options) {
         });
       }
     }
-    return makeLiveSession(vm, serde, interruptBudget, advanceClock, options.encryptionKey);
+    return makeLiveSession(vm, serde, interruptBudget, advanceClock, historicalAttributeIds, options.encryptionKey);
   }
   __name(runWorkflowInVM, "runWorkflowInVM");
 }
@@ -97306,7 +98211,7 @@ function makeSettledSession(result2) {
     }, "dispose")
   };
 }
-function makeLiveSession(vm, serde, interruptBudget, advanceClock, encryptionKey) {
+function makeLiveSession(vm, serde, interruptBudget, advanceClock, historicalAttributeIds, encryptionKey) {
   const result2 = checkWorkflowState(vm, serde, { keepAliveOnSuspend: true });
   let alive = !!result2.suspended;
   const session = {
@@ -97316,11 +98221,19 @@ function makeLiveSession(vm, serde, interruptBudget, advanceClock, encryptionKey
         throw new Error("QuickJS workflow session is not alive \u2014 continueWithEvents is only valid while suspended");
       }
       interruptBudget.start = Date.now();
+      for (const event of newEvents) {
+        if (event.eventType === "attr_set" && event.correlationId !== void 0) {
+          historicalAttributeIds.add(event.correlationId);
+        }
+      }
       let maxIterations = 100;
       let madeProgress;
       do {
-        madeProgress = await processEvents(vm, serde, newEvents, advanceClock, encryptionKey);
         let batch;
+        do {
+          batch = vm.executePendingJobs();
+        } while (batch > 0);
+        madeProgress = await processEvents(vm, serde, newEvents, advanceClock, encryptionKey);
         do {
           batch = vm.executePendingJobs();
           if (batch > 0)
@@ -97695,9 +98608,9 @@ function ensurePendingByteCache(vm) {
   return cache;
 }
 function dumpPendingOps(vm, serde, filterExpr, byteCache) {
-  const env_5 = { stack: [], error: void 0, hasError: false };
+  const env_6 = { stack: [], error: void 0, hasError: false };
   try {
-    const projected = __addDisposableResource3(env_5, vm.evalCode(`(function(){
+    const projected = __addDisposableResource3(env_6, vm.evalCode(`(function(){
     var ops = ${filterExpr};
     globalThis.__rawFields = [];
     // Settled ops \u2014 created, resolver-less, no abort in flight \u2014 are
@@ -97736,7 +98649,7 @@ function dumpPendingOps(vm, serde, filterExpr, byteCache) {
         }
       }
     }
-    const rawFields = __addDisposableResource3(env_5, vm.evalCode("globalThis.__rawFields"), false);
+    const rawFields = __addDisposableResource3(env_6, vm.evalCode("globalThis.__rawFields"), false);
     for (const op of plainOps) {
       const rawIndices = op.__rawIndices ?? {};
       delete op.__rawIndices;
@@ -97747,9 +98660,9 @@ function dumpPendingOps(vm, serde, filterExpr, byteCache) {
         const cacheKey = `${op.correlationId}:${field}`;
         let bytes = byteCache?.get(cacheKey);
         if (!bytes) {
-          const env_6 = { stack: [], error: void 0, hasError: false };
+          const env_7 = { stack: [], error: void 0, hasError: false };
           try {
-            const valueHandle = __addDisposableResource3(env_6, rawFields.getProp(String(index)), false);
+            const valueHandle = __addDisposableResource3(env_7, rawFields.getProp(String(index)), false);
             try {
               bytes = serde.serialize(valueHandle);
             } catch (err) {
@@ -97761,11 +98674,11 @@ function dumpPendingOps(vm, serde, filterExpr, byteCache) {
               throw err;
             }
             byteCache?.set(cacheKey, bytes);
-          } catch (e_5) {
-            env_6.error = e_5;
-            env_6.hasError = true;
+          } catch (e_6) {
+            env_7.error = e_6;
+            env_7.hasError = true;
           } finally {
-            __disposeResources3(env_6);
+            __disposeResources3(env_7);
           }
         }
         op[field] = bytes;
@@ -97773,11 +98686,11 @@ function dumpPendingOps(vm, serde, filterExpr, byteCache) {
     }
     vm.evalCode("delete globalThis.__rawFields").dispose();
     return plainOps;
-  } catch (e_6) {
-    env_5.error = e_6;
-    env_5.hasError = true;
+  } catch (e_7) {
+    env_6.error = e_7;
+    env_6.hasError = true;
   } finally {
-    __disposeResources3(env_5);
+    __disposeResources3(env_6);
   }
 }
 function collectDrainOperations(vm, serde) {
@@ -97815,13 +98728,13 @@ function collectDrainOperations(vm, serde) {
 }
 function checkWorkflowState(vm, serde, opts = {}) {
   {
-    const env_7 = { stack: [], error: void 0, hasError: false };
+    const env_8 = { stack: [], error: void 0, hasError: false };
     try {
-      const done = __addDisposableResource3(env_7, vm.evalCode("globalThis.__workflowDone === true"), false);
+      const done = __addDisposableResource3(env_8, vm.evalCode("globalThis.__workflowDone === true"), false);
       if (done.toBoolean()) {
-        const env_8 = { stack: [], error: void 0, hasError: false };
+        const env_9 = { stack: [], error: void 0, hasError: false };
         try {
-          const h = __addDisposableResource3(env_8, vm.evalCode("globalThis.__workflowResult"), false);
+          const h = __addDisposableResource3(env_9, vm.evalCode("globalThis.__workflowResult"), false);
           const resultBytes = serde.serialize(h);
           const drainOperations = collectDrainOperations(vm, serde);
           vm.dispose();
@@ -97831,42 +98744,42 @@ function checkWorkflowState(vm, serde, opts = {}) {
               ...drainOperations.length > 0 ? { drainOperations } : {}
             }
           };
-        } catch (e_7) {
-          env_8.error = e_7;
-          env_8.hasError = true;
+        } catch (e_8) {
+          env_9.error = e_8;
+          env_9.hasError = true;
         } finally {
-          __disposeResources3(env_8);
+          __disposeResources3(env_9);
         }
       }
-    } catch (e_8) {
-      env_7.error = e_8;
-      env_7.hasError = true;
+    } catch (e_9) {
+      env_8.error = e_9;
+      env_8.hasError = true;
     } finally {
-      __disposeResources3(env_7);
+      __disposeResources3(env_8);
     }
   }
   {
-    const env_9 = { stack: [], error: void 0, hasError: false };
+    const env_10 = { stack: [], error: void 0, hasError: false };
     try {
-      const h = __addDisposableResource3(env_9, vm.evalCode("globalThis.__workflowError"), false);
+      const h = __addDisposableResource3(env_10, vm.evalCode("globalThis.__workflowError"), false);
       if (!h.isUndefined) {
         const errorObj = h.isString ? h.toString() : (() => {
-          const env_12 = { stack: [], error: void 0, hasError: false };
+          const env_13 = { stack: [], error: void 0, hasError: false };
           try {
-            const plain = __addDisposableResource3(env_12, vm.evalCode("(function(e){return {message: e.message, stack: e.stack, name: e.name};})(globalThis.__workflowError)"), false);
+            const plain = __addDisposableResource3(env_13, vm.evalCode("(function(e){return {message: e.message, stack: e.stack, name: e.name};})(globalThis.__workflowError)"), false);
             return vm.dump(plain);
-          } catch (e_12) {
-            env_12.error = e_12;
-            env_12.hasError = true;
+          } catch (e_13) {
+            env_13.error = e_13;
+            env_13.hasError = true;
           } finally {
-            __disposeResources3(env_12);
+            __disposeResources3(env_13);
           }
         })();
         let valueBytes;
         if (!h.isString) {
-          const env_10 = { stack: [], error: void 0, hasError: false };
+          const env_11 = { stack: [], error: void 0, hasError: false };
           try {
-            const rawValue = __addDisposableResource3(env_10, h.getProp("value"), false);
+            const rawValue = __addDisposableResource3(env_11, h.getProp("value"), false);
             try {
               valueBytes = serde.serialize(rawValue);
             } catch (serializeErr) {
@@ -97874,11 +98787,11 @@ function checkWorkflowState(vm, serde, opts = {}) {
                 message: serializeErr instanceof Error ? serializeErr.message : String(serializeErr)
               });
             }
-          } catch (e_9) {
-            env_10.error = e_9;
-            env_10.hasError = true;
+          } catch (e_10) {
+            env_11.error = e_10;
+            env_11.hasError = true;
           } finally {
-            __disposeResources3(env_10);
+            __disposeResources3(env_11);
           }
         }
         const failed = typeof errorObj === "string" ? { message: errorObj } : {
@@ -97901,17 +98814,17 @@ function checkWorkflowState(vm, serde, opts = {}) {
           }
         };
       }
-    } catch (e_10) {
-      env_9.error = e_10;
-      env_9.hasError = true;
+    } catch (e_11) {
+      env_10.error = e_11;
+      env_10.hasError = true;
     } finally {
-      __disposeResources3(env_9);
+      __disposeResources3(env_10);
     }
   }
   {
-    const env_11 = { stack: [], error: void 0, hasError: false };
+    const env_12 = { stack: [], error: void 0, hasError: false };
     try {
-      const h = __addDisposableResource3(env_11, vm.evalCode("Object.keys(globalThis.__resolvers).length > 0 || globalThis.__pending.some(function(p){return!p.hasCreatedEvent;})"), false);
+      const h = __addDisposableResource3(env_12, vm.evalCode("Object.keys(globalThis.__resolvers).length > 0 || globalThis.__pending.some(function(p){return!p.hasCreatedEvent;})"), false);
       if (vm.dump(h)) {
         const pendingOps = dumpPendingOps(vm, serde, `globalThis.__pending.filter(function(p){return!!globalThis.__resolvers[p.correlationId] || !p.hasCreatedEvent || p.abortRequested;})`, ensurePendingByteCache(vm));
         if (!opts.keepAliveOnSuspend)
@@ -97922,11 +98835,11 @@ function checkWorkflowState(vm, serde, opts = {}) {
           }
         };
       }
-    } catch (e_11) {
-      env_11.error = e_11;
-      env_11.hasError = true;
+    } catch (e_12) {
+      env_12.error = e_12;
+      env_12.hasError = true;
     } finally {
-      __disposeResources3(env_11);
+      __disposeResources3(env_12);
     }
   }
   vm.dispose();
@@ -97963,6 +98876,7 @@ var init_quickjs_runtime = __esm({
     init_dist7();
     init_dist5();
     init_dist6();
+    init_attributes_validation2();
     init_nanoid();
     init_dist13();
     import_seedrandom2 = __toESM(require_seedrandom2(), 1);
@@ -98586,18 +99500,28 @@ globalThis[Symbol.for("WORKFLOW_CREATE_HOOK")] = function(options) {
 };
 
 // setAttributes \u2014 attaches plaintext metadata to the current run.
-// Validation happens in library code (normalizeAttributeChanges) before
+// Per-change validation happens in library code (normalizeAttributeChanges) before
 // this dispatcher is invoked, so "changes" is already normalized. The
 // returned promise resolves when the matching attr_set event is
 // observed during event processing \u2014 mirroring the node:vm engine's
 // createSetAttributes (attribute-dispatcher.ts).
+// Baseline hydrate placeholder; module-scope calls draw a ULID and disable snapshots.
+globalThis.__validateAttributeWrite = function() {};
 globalThis[Symbol.for("WORKFLOW_SET_ATTRIBUTES")] = function(changes, options) {
   var correlationId = "attr_" + globalThis.__generateUlid();
+  var allowReservedAttributes = !!(options && options.allowReservedAttributes);
+  var validationError = globalThis.__validateAttributeWrite(correlationId, changes, allowReservedAttributes);
+  if (validationError !== undefined) {
+    var error = new Error(validationError);
+    error.name = "FatalError";
+    error.fatal = true;
+    return Promise.reject(error);
+  }
   globalThis.__pending.push({
     type: "attribute",
     correlationId: correlationId,
     changes: changes,
-    allowReservedAttributes: !!(options && options.allowReservedAttributes),
+    allowReservedAttributes: allowReservedAttributes,
     hasCreatedEvent: false,
   });
   return new Promise(function(resolve, reject) {
@@ -99738,6 +100662,7 @@ async function runWorkflowWithQuickJS(params) {
         }
       });
       wfdiag("exit_completed", { result: "run_completed_written" });
+      dispatchRunCompletedHooks(runId, workflowName);
     } catch (err) {
       if (EntityConflictError2.is(err) || RunExpiredError2.is(err)) {
         runtimeLogger2.warn("Workflow already finished, skipping run_completed", { workflowRunId: runId });
@@ -99948,6 +100873,7 @@ async function runWorkflowWithQuickJS(params) {
       });
       throw err;
     }
+    dispatchRunFailedHooks(runId, workflowName, dehydratedError, encryptionKey, errorCode);
     wfdiag("exit_failed", { result: "run_failed_written" });
   }
 }
@@ -99967,6 +100893,7 @@ var init_quickjs_entrypoint = __esm({
     init_constants3();
     init_get_port_lazy();
     init_helpers3();
+    init_lifecycle_hooks();
     init_quickjs_log_view();
     init_quickjs_runtime();
     init_replay_budget();
@@ -125560,6 +126487,13 @@ var init_zod = __esm2({
     init_external();
   }
 });
+function validateAttributeEventDataSize(eventData) {
+  const bytes = textEncoder.encode(JSON.stringify(eventData)).length;
+  if (bytes > ATTRIBUTE_EVENT_DATA_MAX_BYTES) {
+    throw new AttributeValidationError(`Attribute eventData exceeds limit ${ATTRIBUTE_EVENT_DATA_MAX_BYTES} UTF-8 JSON bytes (received ${bytes} bytes). Split the changes into smaller setAttributes() calls.`);
+  }
+}
+__name(validateAttributeEventDataSize, "validateAttributeEventDataSize");
 function assertValidAttributeKey(key, allowReservedAttributes) {
   if (typeof key !== "string") {
     throw new AttributeValidationError(`Attribute key must be a string, got ${typeof key}`);
@@ -125622,6 +126556,7 @@ var RETENTION_ATTRIBUTE;
 var ATTRIBUTE_KEY_MAX_LENGTH;
 var ATTRIBUTE_VALUE_MAX_BYTES;
 var ATTRIBUTE_MAX_PER_RUN;
+var ATTRIBUTE_EVENT_DATA_MAX_BYTES;
 var textEncoder;
 var AttributeValidationError;
 var init_attributes_validation = __esm2({
@@ -125634,6 +126569,7 @@ var init_attributes_validation = __esm2({
     ATTRIBUTE_KEY_MAX_LENGTH = 256;
     ATTRIBUTE_VALUE_MAX_BYTES = 256;
     ATTRIBUTE_MAX_PER_RUN = 64;
+    ATTRIBUTE_EVENT_DATA_MAX_BYTES = 8192;
     textEncoder = new TextEncoder();
     AttributeValidationError = class extends Error {
       static {
@@ -125647,6 +126583,7 @@ var init_attributes_validation = __esm2({
         this.name = "AttributeValidationError";
       }
     };
+    __name2(validateAttributeEventDataSize, "validateAttributeEventDataSize");
     __name2(assertValidAttributeKey, "assertValidAttributeKey");
     __name2(assertValidAttributeValue, "assertValidAttributeValue");
     __name2(attributeCountDelta, "attributeCountDelta");
@@ -126731,6 +127668,11 @@ var init_queue = __esm2({
     }));
     WorkflowInvokePayloadSchema = external_exports.compile(external_exports.object({
       runId: external_exports.string(),
+      /** Process this input and return the handler's result as response data. */
+      invoke: external_exports.literal(true).optional(),
+      /** Identifies one input across retries, separately from the queue delivery ID. */
+      requestId: external_exports.string().optional(),
+      input: external_exports.unknown().optional(),
       traceCarrier: TraceCarrierSchema.optional(),
       requestedAt: external_exports.coerce.date().optional(),
       /**
@@ -133422,7 +134364,7 @@ var version2;
 var init_version = __esm2({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.53";
+    version2 = "5.0.0-beta.54";
   }
 });
 function getWorkflowQueueName(workflowName, namespace) {
@@ -133609,6 +134551,37 @@ var init_helpers = __esm2({
     __name2(healthCheck, "healthCheck");
   }
 });
+var HookInvocationSchema;
+var HookInvocationResultSchema;
+var init_invocations = __esm2({
+  "../core/dist/runtime/invocations.js"() {
+    "use strict";
+    init_dist2();
+    init_dist4();
+    init_zod();
+    init_semantic_conventions();
+    init_telemetry();
+    HookInvocationSchema = external_exports.object({
+      type: external_exports.literal("hook_resume"),
+      version: external_exports.literal(1),
+      hookId: external_exports.string(),
+      token: external_exports.string(),
+      payload: external_exports.instanceof(Uint8Array)
+    });
+    HookInvocationResultSchema = external_exports.discriminatedUnion("status", [
+      external_exports.object({
+        status: external_exports.literal("accepted")
+      }),
+      external_exports.object({
+        status: external_exports.literal("rejected"),
+        code: external_exports.enum([
+          "HOOK_NOT_FOUND",
+          "INVALID_INPUT"
+        ])
+      })
+    ]);
+  }
+});
 var require_headers = __commonJS2({
   "../../node_modules/.pnpm/@vercel+functions@3.8.0_@aws-sdk+credential-provider-web-identity@3.972.49_ws@8.20.0/node_modules/@vercel/functions/headers.js"(exports, module) {
     "use strict";
@@ -138808,6 +139781,29 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
         if (originLink) {
           span?.addLink?.(originLink);
         }
+        if (world.capabilities?.invoke === true && !v1Compat && dehydratedPayload instanceof Uint8Array) {
+          if (!world.invoke) {
+            throw new WorkflowRuntimeError("World advertises invoke without implementing it");
+          }
+          span?.setAttributes({
+            "workflow.hook.resume_strategy": "invoke"
+          });
+          const result2 = HookInvocationResultSchema.parse(await world.invoke(hook.runId, {
+            type: "hook_resume",
+            version: 1,
+            hookId: hook.hookId,
+            token: hook.token,
+            payload: dehydratedPayload
+          }, {
+            idempotencyKey: generateResumeId()
+          }));
+          if (result2.status === "rejected") {
+            if (result2.code === "HOOK_NOT_FOUND") throw new HookNotFoundError(hook.token);
+            throw new WorkflowRuntimeError("Executor rejected the hook invocation input");
+          }
+          span?.setAttributes(HookResumeCommitted(true));
+          return asLazyMetadataHook(hook);
+        }
         const queueName = getWorkflowQueueName(resumeContext.workflowName);
         const queueOptions = {
           deploymentId: resumeContext.deploymentId,
@@ -138948,6 +139944,7 @@ var init_resume_hook = __esm2({
     init_telemetry();
     init_get_world_lazy();
     init_helpers();
+    init_invocations();
     init_wait_until();
     generateResumeId = monotonicFactory();
     __name2(computeResumePayloadDigest, "computeResumePayloadDigest");
@@ -140021,6 +141018,15 @@ function createForwardedWritable({ global: global2, ops, runId, name, key, deplo
 }
 __name(createForwardedWritable, "createForwardedWritable");
 function getRunReadableStream(global2, ops, runId, name, startIndex, cryptoKey) {
+  return getLazyReadableStream((onReadableState) => getExternalRevivers(global2, ops, runId, cryptoKey, {
+    onReadableState
+  }).ReadableStream({
+    name,
+    startIndex
+  }));
+}
+__name(getRunReadableStream, "getRunReadableStream");
+function getLazyReadableStream(reviveReadable, onReadableState) {
   let reader;
   let lockState;
   let lockPollingStarted = false;
@@ -140030,18 +141036,14 @@ function getRunReadableStream(global2, ops, runId, name, startIndex, cryptoKey)
       async pull(controller) {
         try {
           if (!reader) {
-            const stream = getExternalRevivers(global2, ops, runId, cryptoKey, {
-              onReadableState: /* @__PURE__ */ __name2((state) => {
-                lockState = state;
-              }, "onReadableState")
-            }).ReadableStream({
-              name,
-              startIndex
+            const stream = reviveReadable((state) => {
+              lockState = state;
             });
             reader = stream.getReader();
             if (lockState && !lockPollingStarted) {
               lockPollingStarted = true;
-              pollReadableLock(userReadable, lockState);
+              if (onReadableState) onReadableState(lockState);
+              else pollReadableLock(userReadable, lockState);
             }
           }
           const result2 = await reader.read();
@@ -140064,8 +141066,47 @@ function getRunReadableStream(global2, ops, runId, name, startIndex, cryptoKey)
   );
   return userReadable;
 }
-__name(getRunReadableStream, "getRunReadableStream");
+__name(getLazyReadableStream, "getLazyReadableStream");
 function getExternalRevivers(global2 = globalThis, ops, runId, cryptoKey, options) {
+  function reviveReadableStream(value, onReadableState = options?.onReadableState) {
+    if (value.type === "bytes") {
+      const readable2 = new WorkflowServerReadableStream(runId, value.name, value.startIndex);
+      const state2 = createFlushableState();
+      ops.push(state2.promise);
+      const { readable: userReadable, writable } = value.framing === "framed-v1" ? getByteUnframingStream() : new global2.TransformStream();
+      flushablePipe(readable2, writable, state2).catch(() => {
+      });
+      if (onReadableState) onReadableState(state2);
+      else pollReadableLock(userReadable, state2);
+      return userReadable;
+    }
+    let keyPromise;
+    const resolveKey = /* @__PURE__ */ __name2(() => {
+      keyPromise ??= resolveEncryptionKey(cryptoKey);
+      return keyPromise;
+    }, "resolveKey");
+    const readable = createReconnectingFramedStream(runId, value.name, value.startIndex, resolveKey);
+    const transform22 = getDeserializeStream(getExternalRevivers(global2, ops, runId, resolveKey, {
+      lazyStreams: options?.lazyStreams,
+      liveAbortSignals: options?.liveAbortSignals
+    }), resolveKey);
+    const state = createFlushableState();
+    ops.push(state.promise);
+    flushablePipe(readable, transform22.writable, state).catch(() => {
+    });
+    if (onReadableState) onReadableState(state);
+    else pollReadableLock(transform22.readable, state);
+    return transform22.readable;
+  }
+  __name(reviveReadableStream, "reviveReadableStream");
+  __name2(reviveReadableStream, "reviveReadableStream");
+  function reviveAbortSnapshot(value) {
+    const controller = new AbortController();
+    if (value.aborted) controller.abort(value.reason);
+    return controller;
+  }
+  __name(reviveAbortSnapshot, "reviveAbortSnapshot");
+  __name2(reviveAbortSnapshot, "reviveAbortSnapshot");
   return {
     ...getCommonRevivers2(global2),
     // StepFunction should not be returned from workflows to clients
@@ -140106,32 +141147,7 @@ function getExternalRevivers(global2 = globalThis, ops, runId, cryptoKey, option
         const response = new global2.Response(bodyInit);
         return response.body;
       }
-      if (value.type === "bytes") {
-        const readable = new WorkflowServerReadableStream(runId, value.name, value.startIndex);
-        const state = createFlushableState();
-        ops.push(state.promise);
-        const { readable: userReadable, writable } = value.framing === "framed-v1" ? getByteUnframingStream() : new global2.TransformStream();
-        flushablePipe(readable, writable, state).catch(() => {
-        });
-        if (options?.onReadableState) options.onReadableState(state);
-        else pollReadableLock(userReadable, state);
-        return userReadable;
-      } else {
-        let keyPromise;
-        const resolveKey = /* @__PURE__ */ __name2(() => {
-          keyPromise ??= resolveEncryptionKey(cryptoKey);
-          return keyPromise;
-        }, "resolveKey");
-        const readable = createReconnectingFramedStream(runId, value.name, value.startIndex, resolveKey);
-        const transform22 = getDeserializeStream(getExternalRevivers(global2, ops, runId, resolveKey), resolveKey);
-        const state = createFlushableState();
-        ops.push(state.promise);
-        flushablePipe(readable, transform22.writable, state).catch(() => {
-        });
-        if (options?.onReadableState) options.onReadableState(state);
-        else pollReadableLock(transform22.readable, state);
-        return transform22.readable;
-      }
+      return options?.lazyStreams ? getLazyReadableStream((onReadableState) => reviveReadableStream(value, onReadableState), options.onReadableState) : reviveReadableStream(value);
     }, "ReadableStream"),
     WritableStream: /* @__PURE__ */ __name2((value) => {
       const targetRunId = typeof value.runId === "string" ? value.runId : runId;
@@ -140146,8 +141162,8 @@ function getExternalRevivers(global2 = globalThis, ops, runId, cryptoKey, option
         encryptionPublicKey: value.encryptionPublicKey
       });
     }, "WritableStream"),
-    AbortController: /* @__PURE__ */ __name2((value) => reviveAbortController(value, ops, runId), "AbortController"),
-    AbortSignal: /* @__PURE__ */ __name2((value) => reviveAbortSignal(value, ops, runId), "AbortSignal")
+    AbortController: /* @__PURE__ */ __name2((value) => options?.liveAbortSignals === false ? reviveAbortSnapshot(value) : reviveAbortController(value, ops, runId), "AbortController"),
+    AbortSignal: /* @__PURE__ */ __name2((value) => options?.liveAbortSignals === false ? reviveAbortSnapshot(value).signal : reviveAbortSignal(value, ops, runId), "AbortSignal")
   };
 }
 __name(getExternalRevivers, "getExternalRevivers");
@@ -140874,6 +141890,7 @@ var init_serialization2 = __esm2({
     __name2(tagForwardedWritableTarget, "tagForwardedWritableTarget");
     __name2(createForwardedWritable, "createForwardedWritable");
     __name2(getRunReadableStream, "getRunReadableStream");
+    __name2(getLazyReadableStream, "getLazyReadableStream");
     __name2(getExternalRevivers, "getExternalRevivers");
     __name2(getStepRevivers, "getStepRevivers");
     __name2(dehydrateWorkflowArguments, "dehydrateWorkflowArguments");
@@ -141011,7 +142028,7 @@ init_dist4();
 init_node();
 init_dist2();
 init_attributes_validation();
-function normalizeAttributeChanges(attrs, options = {}) {
+function normalizeAttributeChanges(attrs, options = {}, writer) {
   if (attrs === null || typeof attrs !== "object" || Array.isArray(attrs)) {
     throw new FatalError(`setAttributes requires a plain object, got ${attrs === null ? "null" : Array.isArray(attrs) ? "array" : typeof attrs}`);
   }
@@ -141025,6 +142042,15 @@ function normalizeAttributeChanges(attrs, options = {}) {
     validateAttributeChanges(changes, {
       allowReservedAttributes
     });
+    if (writer) {
+      validateAttributeEventDataSize({
+        changes,
+        writer,
+        ...allowReservedAttributes ? {
+          allowReservedAttributes: true
+        } : {}
+      });
+    }
   } catch (err) {
     if (err instanceof AttributeValidationError) {
       throw new FatalError(err.message);
@@ -141375,7 +142401,7 @@ __name2(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.53//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.54//start");
 async function wakeUpRun(world, runId, options) {
   try {
     const run22 = await world.runs.get(runId, {
@@ -141637,27 +142663,35 @@ var Run = class _Run {
    * The name of the workflow.
    */
   get workflowName() {
-    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId).then((run22) => run22.workflowName));
+    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, {
+      resolveData: "none"
+    }).then((run22) => run22.workflowName));
   }
   /**
    * The timestamp when the workflow run was created.
    */
   get createdAt() {
-    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId).then((run22) => run22.createdAt));
+    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, {
+      resolveData: "none"
+    }).then((run22) => run22.createdAt));
   }
   /**
    * The timestamp when the workflow run started execution.
    * Returns undefined if the workflow has not started yet.
    */
   get startedAt() {
-    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId).then((run22) => run22.startedAt));
+    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, {
+      resolveData: "none"
+    }).then((run22) => run22.startedAt));
   }
   /**
    * The timestamp when the workflow run completed.
    * Returns undefined if the workflow has not completed yet.
    */
   get completedAt() {
-    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId).then((run22) => run22.completedAt));
+    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, {
+      resolveData: "none"
+    }).then((run22) => run22.completedAt));
   }
   /**
    * The readable stream of the workflow run.
@@ -141842,7 +142876,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.54//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);
@@ -141851,7 +142885,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.54//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);
@@ -141860,7 +142894,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.54//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);
@@ -141869,7 +142903,7 @@ var Run = class _Run {
     value: "getWritable",
     configurable: true
   });
-})(Run.prototype["getWritable"], "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#getWritable");
+})(Run.prototype["getWritable"], "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#getWritable");
 (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);
@@ -141878,7 +142912,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//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);
@@ -141887,7 +142921,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//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);
@@ -141896,7 +142930,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//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);
@@ -141905,7 +142939,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//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);
@@ -141914,7 +142948,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//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);
@@ -141923,7 +142957,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//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);
@@ -141932,7 +142966,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.53//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//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);
@@ -141942,7 +142976,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.53//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.54//Run");
 async function fetch2(...args) {
   return globalThis.fetch(...args);
 }
@@ -142698,6 +143732,7 @@ init_logger2();
 init_serialization4();
 init_semantic_conventions2();
 init_constants3();
+init_lifecycle_hooks();
 var MAX_REROUTE_DELAY_SECONDS = 8;
 var CONTINUE = { outcome: "continue" };
 function result(outcome, pinnedDeploymentId, attempts) {
@@ -142711,7 +143746,7 @@ function result(outcome, pinnedDeploymentId, attempts) {
   };
 }
 __name(result, "result");
-async function guardDeploymentAffinity({ world, run: run3, requestId, retryCount = 0, reenqueue, isDeploymentUnavailableError, beforeStop }) {
+async function guardDeploymentAffinity({ world, run: run3, workflowName, requestId, retryCount = 0, reenqueue, isDeploymentUnavailableError, beforeStop }) {
   if (world.capabilities?.deploymentAffinity !== true) {
     return CONTINUE;
   }
@@ -142731,17 +143766,16 @@ async function guardDeploymentAffinity({ world, run: run3, requestId, retryCount
   const failRun = /* @__PURE__ */ __name(async (recoveryAttempts, cause) => {
     const error121 = new WorkflowDeploymentMismatchError(run3.runId, run3.deploymentId, currentDeploymentId, { recoveryAttempts, cause });
     try {
+      const dehydratedError = await dehydrateRunError(error121, run3.runId, void 0, void 0, (run3.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2);
       await world.events.create(run3.runId, {
         eventType: "run_failed",
         specVersion: SPEC_VERSION_CURRENT2,
         eventData: {
-          // Unencrypted (undefined key): see the note on
-          // `guardDeploymentAffinity`. dehydrate/hydrate are self-describing,
-          // so this reads back without a key.
-          error: await dehydrateRunError(error121, run3.runId, void 0, void 0, (run3.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
+          error: dehydratedError,
           errorCode: RUN_ERROR_CODES2.DEPLOYMENT_MISMATCH
         }
       }, { requestId });
+      dispatchRunFailedHooks(run3.runId, workflowName, dehydratedError, void 0, RUN_ERROR_CODES2.DEPLOYMENT_MISMATCH);
     } catch (failError) {
       if (!EntityConflictError2.is(failError) && !RunExpiredError2.is(failError)) {
         throw failError;
@@ -142780,6 +143814,8 @@ __name(guardDeploymentAffinity, "guardDeploymentAffinity");
 
 // ../core/dist/runtime.js
 init_helpers3();
+init_invocations2();
+init_lifecycle_hooks();
 init_replay_budget();
 init_replay_recovery_reporter();
 init_resume_latency();
@@ -143714,32 +144750,8 @@ function isWorldValidationFailure(err) {
 }
 __name(isWorldValidationFailure, "isWorldValidationFailure");
 
-// ../core/dist/runtime/vm-mode.js
-init_dist7();
-var WORKFLOW_VMS2 = ["node", "quickjs"];
-function getWorkflowVmFromEnv2(env = process.env) {
-  const raw = env.WORKFLOW_VM;
-  if (raw === void 0 || raw === "")
-    return void 0;
-  if (WORKFLOW_VMS2.includes(raw)) {
-    return raw;
-  }
-  throw new WorkflowRuntimeError2(`Invalid WORKFLOW_VM value: "${raw}". Expected one of: ${WORKFLOW_VMS2.join(", ")}.`);
-}
-__name(getWorkflowVmFromEnv2, "getWorkflowVmFromEnv");
-function useQuickJSVm(workflowRun) {
-  const vmFromRun = workflowRun.executionContext?.workflowVm;
-  if (vmFromRun !== void 0) {
-    if (!WORKFLOW_VMS2.includes(vmFromRun)) {
-      throw new WorkflowRuntimeError2(`Invalid executionContext.workflowVm value: "${vmFromRun}". Expected one of: ${WORKFLOW_VMS2.join(", ")}.`);
-    }
-    return vmFromRun === "quickjs";
-  }
-  return getWorkflowVmFromEnv2() === "quickjs";
-}
-__name(useQuickJSVm, "useQuickJSVm");
-
 // ../core/dist/runtime.js
+init_vm_mode();
 init_wait_continuation();
 init_world();
 init_serialization4();
@@ -143898,7 +144910,9 @@ function createUseStep(ctx) {
         if (event.eventType === "step_failed") {
           ctx.invocationsQueue.delete(event.correlationId);
           const eventIndex = ctx.eventsConsumer.eventIndex;
-          const barrier = registerDeliveryBarrier(ctx, eventIndex, "step");
+          const barrier = registerDeliveryBarrier(ctx, eventIndex, "step", {
+            deliveredAt: +event.createdAt
+          });
           let rejection;
           const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, "step");
           ctx.pendingDeliveries++;
@@ -143927,7 +144941,9 @@ function createUseStep(ctx) {
           const completedEventId = event.eventId;
           const serializedResult = event.eventData.result;
           const eventIndex = ctx.eventsConsumer.eventIndex;
-          const barrier = registerDeliveryBarrier(ctx, eventIndex, "step");
+          const barrier = registerDeliveryBarrier(ctx, eventIndex, "step", {
+            deliveredAt: +event.createdAt
+          });
           let outcome;
           const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, "step");
           ctx.pendingDeliveries++;
@@ -144591,12 +145607,26 @@ init_abort_controller2();
 // ../core/dist/workflow/attribute-dispatcher.js
 init_dist7();
 init_dist5();
+init_attributes_validation2();
 init_events_consumer2();
 init_private2();
 function createSetAttributes(ctx) {
   return /* @__PURE__ */ __name(async function setAttributes(changes, options = {}) {
     const { promise: promise3, resolve: resolve3 } = withResolvers2();
     const correlationId = `attr_${ctx.generateUlid()}`;
+    try {
+      validateAttributeEventDataSize2({
+        changes,
+        writer: { type: "workflow" },
+        ...options.allowReservedAttributes === true ? { allowReservedAttributes: true } : {}
+      });
+    } catch (error121) {
+      if (!(error121 instanceof AttributeValidationError2))
+        throw error121;
+      const persisted = ctx.eventsConsumer.events.some((event) => event.eventType === "attr_set" && event.correlationId === correlationId);
+      if (!persisted)
+        throw new FatalError2(error121.message);
+    }
     const queueItem = {
       type: "attribute",
       correlationId,
@@ -144685,6 +145715,26 @@ function createCreateHook(ctx) {
     let hasConflict = false;
     let conflictErrorRef = null;
     let conflictRunRef = null;
+    let registrationDelivered = Promise.resolve();
+    function deliverRegistration(deliveredAt, settle) {
+      const eventIndex = ctx.eventsConsumer.eventIndex;
+      const barrier = registerDeliveryBarrier(ctx, eventIndex, "hook", {
+        deliveredAt
+      });
+      const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, "hook");
+      registrationDelivered = ctx.promiseQueue.then(() => earlierDelivered).then(() => {
+        barrier.markDelivered();
+        settle();
+      });
+    }
+    __name(deliverRegistration, "deliverRegistration");
+    function afterRegistration(settle) {
+      const delivered = registrationDelivered;
+      ctx.promiseQueue = ctx.promiseQueue.then(() => {
+        void delivered.then(settle);
+      });
+    }
+    __name(afterRegistration, "afterRegistration");
     const seenResumeIds = /* @__PURE__ */ new Set();
     webhookLogger2.debug("Hook consumer setup", { correlationId, token });
     ctx.eventsConsumer.subscribe((event) => {
@@ -144714,7 +145764,7 @@ function createCreateHook(ctx) {
         hasCreated = true;
         const pendingGetConflictPromises = getConflictPromises.slice();
         getConflictPromises.length = 0;
-        ctx.promiseQueue = ctx.promiseQueue.then(() => {
+        deliverRegistration(+event.createdAt, () => {
           for (const resolver2 of pendingGetConflictPromises) {
             resolver2.resolve(null);
           }
@@ -144732,7 +145782,7 @@ function createCreateHook(ctx) {
         promises.length = 0;
         const pendingGetConflictPromises = getConflictPromises.slice();
         getConflictPromises.length = 0;
-        ctx.promiseQueue = ctx.promiseQueue.then(() => {
+        deliverRegistration(+event.createdAt, () => {
           for (const resolver2 of pendingPromises) {
             resolver2.reject(conflictError);
           }
@@ -144757,7 +145807,8 @@ function createCreateHook(ctx) {
         const eventIndex = ctx.eventsConsumer.eventIndex;
         const hasWaitingConsumer = promises.length > 0;
         const barrier = registerDeliveryBarrier(ctx, eventIndex, "hook", {
-          armed: hasWaitingConsumer
+          armed: hasWaitingConsumer,
+          deliveredAt: +event.createdAt
         });
         if (hasWaitingConsumer) {
           const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, "hook");
@@ -144829,7 +145880,7 @@ function createCreateHook(ctx) {
     function createHookPromise() {
       const resolvers = withResolvers2();
       if (hasConflict && conflictErrorRef) {
-        ctx.promiseQueue = ctx.promiseQueue.then(() => {
+        afterRegistration(() => {
           resolvers.reject(conflictErrorRef);
         });
         return resolvers.promise;
@@ -144850,13 +145901,13 @@ function createCreateHook(ctx) {
     function createGetConflictPromise() {
       const resolvers = withResolvers2();
       if (hasCreated) {
-        ctx.promiseQueue = ctx.promiseQueue.then(() => {
+        afterRegistration(() => {
           resolvers.resolve(null);
         });
         return resolvers.promise;
       }
       if (hasConflict) {
-        ctx.promiseQueue = ctx.promiseQueue.then(() => {
+        afterRegistration(() => {
           if (conflictRunRef) {
             resolvers.resolve(conflictRunRef);
           } else {
@@ -144972,7 +146023,9 @@ function createSleep(ctx) {
         }
         ctx.invocationsQueue.delete(correlationId);
         const eventIndex = ctx.eventsConsumer.eventIndex;
-        const barrier = registerDeliveryBarrier(ctx, eventIndex, "wait");
+        const barrier = registerDeliveryBarrier(ctx, eventIndex, "wait", {
+          deliveredAt: +event.createdAt
+        });
         const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, "wait");
         const queueAtCompletion = ctx.promiseQueue;
         void queueAtCompletion.then(() => earlierDelivered).then(() => {
@@ -145141,14 +146194,13 @@ async function createWorkflowSessionInner({ workflowCode: workflowCode2, workflo
   const promiseQueueHolder = { current: Promise.resolve() };
   const deliveryIdleHolder = { current: /* @__PURE__ */ __name(() => true, "current") };
   let clock = fixedTimestamp;
+  const advanceClock = /* @__PURE__ */ __name((at) => {
+    if (at > clock) {
+      clock = at;
+      updateTimestamp(at);
+    }
+  }, "advanceClock");
   const eventsConsumer = new EventsConsumer(events, {
-    onConsumedEvent: /* @__PURE__ */ __name((event) => {
-      const at = +event.createdAt;
-      if (at > clock) {
-        clock = at;
-        updateTimestamp(at);
-      }
-    }, "onConsumedEvent"),
     onUnconsumedEvent: /* @__PURE__ */ __name((event) => {
       onWorkflowError(new ReplayDivergenceError(`Replay could not consume event: eventType=${event.eventType}, correlationId=${event.correlationId}, eventId=${event.eventId}. ${describeDivergenceContext(event, workflowContext.invocationsQueue, eventsConsumer)}`, { eventId: event.eventId }));
     }, "onUnconsumedEvent"),
@@ -145201,6 +146253,7 @@ async function createWorkflowSessionInner({ workflowCode: workflowCode2, workflo
     pendingDeliveries: 0,
     suspensionGeneration: 0,
     pendingDeliveryBarriers: /* @__PURE__ */ new Map(),
+    advanceClock,
     replayPayloadCache
   };
   deliveryIdleHolder.current = () => isDeliveryIdle(workflowContext);
@@ -145735,481 +146788,9 @@ __name(createWorkflowSessionInner, "createWorkflowSessionInner");
 init_global2();
 init_helpers3();
 init_resume_hook2();
-
-// ../core/dist/runtime/run.js
-init_dist7();
-init_dist12();
-init_env_config2();
-init_spec_version2();
-init_encryption5();
-init_serialization4();
-init_util5();
-init_get_world_lazy2();
-
-// ../core/dist/runtime/runs.js
-init_dist7();
-init_dist6();
-init_encryption5();
-init_serialization4();
-init_helpers3();
-
-// ../core/dist/runtime/start.js
-init_dist7();
-init_dist5();
-init_dist6();
-init_node2();
-
-// ../core/dist/attribute-changes.js
-init_dist7();
-init_attributes_validation2();
-
-// ../core/dist/runtime/start.js
-init_capabilities2();
-init_classify_error();
-init_encryption4();
-init_logger2();
-init_sealed_box2();
-init_serialization4();
-init_context_storage2();
-init_semantic_conventions2();
-init_telemetry4();
-init_version4();
-init_get_world_lazy2();
-init_helpers3();
-init_wait_until2();
-init_world_compatibility2();
-var ulid7 = monotonicFactory2();
-var latestNoOpWarning2 = globalSingleton2("@workflow/core//latestNoOpWarning", 1, () => ({ warned: false }));
-
-// ../core/dist/runtime/runs.js
-async function wakeUpRun2(world, runId, options) {
-  try {
-    const run3 = await world.runs.get(runId, { resolveData: "none" });
-    const compatMode = isLegacySpecVersion2(run3.specVersion);
-    const allEvents = [];
-    let cursor = null;
-    do {
-      const eventsResult = await world.events.list({
-        runId,
-        pagination: { sortOrder: "asc", ...cursor ? { cursor } : {} },
-        resolveData: "none"
-      });
-      allEvents.push(...eventsResult.data);
-      cursor = eventsResult.hasMore ? eventsResult.cursor : null;
-    } while (cursor);
-    const waitCreatedEvents = allEvents.filter((event) => event.eventType === "wait_created");
-    const waitCompletedCorrelationIds = new Set(allEvents.filter((event) => event.eventType === "wait_completed").map((event) => event.correlationId));
-    let pendingWaits = waitCreatedEvents.filter((event) => !waitCompletedCorrelationIds.has(event.correlationId));
-    if (options?.correlationIds && options.correlationIds.length > 0) {
-      const targetCorrelationIds = new Set(options.correlationIds);
-      pendingWaits = pendingWaits.filter((event) => event.correlationId && targetCorrelationIds.has(event.correlationId));
-    }
-    const errors = [];
-    let stoppedCount = 0;
-    for (const waitEvent of pendingWaits) {
-      if (!waitEvent.correlationId)
-        continue;
-      const eventData = compatMode ? {
-        eventType: "wait_completed",
-        correlationId: waitEvent.correlationId
-      } : {
-        eventType: "wait_completed",
-        correlationId: waitEvent.correlationId,
-        specVersion: run3.specVersion,
-        eventData: {
-          resumeAt: waitEvent.eventData.resumeAt
-        }
-      };
-      try {
-        await world.events.create(runId, eventData, { v1Compat: compatMode });
-        stoppedCount++;
-      } catch (err) {
-        if (EntityConflictError2.is(err)) {
-          stoppedCount++;
-        } else {
-          errors.push(err instanceof Error ? err : new Error(String(err)));
-        }
-      }
-    }
-    if (stoppedCount > 0) {
-      await world.queue(getWorkflowQueueName2(run3.workflowName, options?.namespace), {
-        runId
-      }, {
-        deploymentId: run3.deploymentId,
-        specVersion: run3.specVersion ?? SPEC_VERSION_LEGACY2
-      });
-    }
-    if (errors.length > 0) {
-      throw new AggregateError(errors, `Failed to complete ${errors.length}/${pendingWaits.length} pending wait(s) for run ${runId}`);
-    }
-    return { stoppedCount };
-  } catch (err) {
-    if (err instanceof AggregateError) {
-      throw err;
-    }
-    throw new Error(`Failed to wake up run ${runId}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
-  }
-}
-__name(wakeUpRun2, "wakeUpRun");
-
-// ../core/dist/runtime/run.js
-var RETURN_VALUE_POLL_INTERVAL_MS2 = 1e3;
-var PAYLOAD_TERMINAL_RUN_STATUSES2 = /* @__PURE__ */ new Set([
-  "completed",
-  "failed"
-]);
-var NOT_FOUND_RETRY_DELAYS2 = [1e3, 3e3, 6e3];
-function getReturnValuePollIntervalMs2() {
-  return envNumber2("WORKFLOW_RETURN_VALUE_POLL_INTERVAL_MS", RETURN_VALUE_POLL_INTERVAL_MS2, { integer: true, min: 1 });
-}
-__name(getReturnValuePollIntervalMs2, "getReturnValuePollIntervalMs");
-var RETURN_VALUE_WAIT_TIMEOUT_MS2 = 5e4;
-function getReturnValueWaitTimeoutMs2() {
-  return envNumber2("WORKFLOW_RETURN_VALUE_WAIT_MS", RETURN_VALUE_WAIT_TIMEOUT_MS2, { integer: true, min: 1 });
-}
-__name(getReturnValueWaitTimeoutMs2, "getReturnValueWaitTimeoutMs");
-var RETURN_VALUE_MAX_LONG_POLLS2 = 10;
-function getReturnValueMaxLongPolls2() {
-  return envNumber2("WORKFLOW_RETURN_VALUE_MAX_LONG_POLLS", RETURN_VALUE_MAX_LONG_POLLS2, { integer: true, min: 1 });
-}
-__name(getReturnValueMaxLongPolls2, "getReturnValueMaxLongPolls");
-function isReturnValueLongPollEnabled2() {
-  const raw = process.env.WORKFLOW_RETURN_VALUE_LONG_POLL;
-  if (raw === void 0 || raw === "")
-    return true;
-  return !(raw === "0" || raw.toLowerCase() === "false");
-}
-__name(isReturnValueLongPollEnabled2, "isReturnValueLongPollEnabled");
-var Run2 = class _Run2 {
-  static {
-    __name(this, "Run");
-  }
-  static [WORKFLOW_SERIALIZE2](instance) {
-    return { runId: instance.runId, resilientStart: instance.#resilientStart };
-  }
-  static [WORKFLOW_DESERIALIZE2](data) {
-    return new _Run2(data.runId, { resilientStart: data.resilientStart });
-  }
-  /**
-   * The ID of the workflow run.
-   */
-  runId;
-  /**
-   * The world object.
-   * @internal
-   */
-  #worldPromise;
-  get #lazyWorldPromise() {
-    if (!this.#worldPromise)
-      this.#worldPromise = getWorldLazy2();
-    return this.#worldPromise;
-  }
-  /**
-   * Cached encryption key resolution. Resolved once on first use and
-   * reused for returnValue, getReadable(), etc.
-   * @internal
-   */
-  #encryptionKeyPromise = null;
-  /**
-   * When true, run_created failed and the run may not exist yet (the
-   * resilient start path will create it via run_started). pollReturnValue
-   * retries on WorkflowRunNotFoundError only when this flag is set so
-   * that normal runs fail fast on 404.
-   * @internal
-   */
-  #resilientStart = false;
-  constructor(runId, opts) {
-    this.runId = runId;
-    this.#resilientStart = opts?.resilientStart ?? false;
-  }
-  /**
-   * Resolves and caches the encryption key for this run.
-   * The key is the same for the lifetime of a run, so it only needs
-   * to be resolved once.
-   * @internal
-   */
-  #getEncryptionKey(run3) {
-    if (!this.#encryptionKeyPromise) {
-      this.#encryptionKeyPromise = (async () => {
-        const world = await this.#lazyWorldPromise;
-        const runData = run3 ?? await world.runs.get(this.runId);
-        const rawKey = await world.getEncryptionKeyForRun?.(runData);
-        return rawKey ? await deriveRunPayloadKeys2(rawKey) : void 0;
-      })();
-    }
-    return this.#encryptionKeyPromise;
-  }
-  /**
-   * Defers fetching the run and its encryption key until a readable is first
-   * consumed. The first pull prefetches it so an encrypted first frame can join
-   * the lookup; this also applies to an empty consumed stream.
-   * @internal
-   */
-  #getEncryptionKeyLazily() {
-    return () => this.#getEncryptionKey();
-  }
-  /**
-   * Interrupts pending `sleep()` calls, resuming the workflow early.
-   *
-   * @param options - Optional settings to target specific sleep calls by correlation ID.
-   *   If not provided, all pending sleep calls will be interrupted.
-   * @returns A {@link StopSleepResult} object containing the number of sleep calls that were interrupted.
-   */
-  async wakeUp(options) {
-    "use step";
-    return wakeUpRun2(await this.#lazyWorldPromise, this.runId, options);
-  }
-  /**
-   * Cancels the workflow run.
-   *
-   * @param options - Optional cancellation settings. `cancelReason` records a
-   *   free-text reason (max 512 chars) on the run_cancelled event, surfaced in
-   *   the run detail view.
-   */
-  async cancel(options) {
-    "use step";
-    const world = await this.#lazyWorldPromise;
-    await world.events.create(this.runId, {
-      eventType: "run_cancelled",
-      specVersion: SPEC_VERSION_CURRENT2,
-      ...options?.cancelReason !== void 0 ? { eventData: { cancelReason: options.cancelReason } } : {}
-    });
-  }
-  /**
-   * Whether the workflow run exists.
-   */
-  get exists() {
-    "use step";
-    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, { resolveData: "none" }).then(() => true).catch((error121) => {
-      if (WorkflowRunNotFoundError2.is(error121)) {
-        return false;
-      }
-      throw error121;
-    }));
-  }
-  /**
-   * The status of the workflow run.
-   */
-  get status() {
-    "use step";
-    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId, { resolveData: "none" }).then((run3) => run3.status));
-  }
-  /**
-   * The return value of the workflow run.
-   * Polls the workflow return value until the workflow run completes.
-   */
-  get returnValue() {
-    "use step";
-    return this.#pollReturnValue();
-  }
-  /**
-   * The name of the workflow.
-   */
-  get workflowName() {
-    "use step";
-    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId).then((run3) => run3.workflowName));
-  }
-  /**
-   * The timestamp when the workflow run was created.
-   */
-  get createdAt() {
-    "use step";
-    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId).then((run3) => run3.createdAt));
-  }
-  /**
-   * The timestamp when the workflow run started execution.
-   * Returns undefined if the workflow has not started yet.
-   */
-  get startedAt() {
-    "use step";
-    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId).then((run3) => run3.startedAt));
-  }
-  /**
-   * The timestamp when the workflow run completed.
-   * Returns undefined if the workflow has not completed yet.
-   */
-  get completedAt() {
-    "use step";
-    return this.#lazyWorldPromise.then((world) => world.runs.get(this.runId).then((run3) => run3.completedAt));
-  }
-  /**
-   * The readable stream of the workflow run.
-   */
-  get readable() {
-    return this.getReadable();
-  }
-  /**
-   * Retrieves the workflow run's default readable stream, which reads chunks
-   * written to the corresponding writable stream {@link getWritable}.
-   *
-   * The returned stream has an additional {@link WorkflowReadableStream.getTailIndex | getTailIndex()}
-   * helper that returns the index of the last known chunk. This is useful when
-   * building reconnection endpoints that need to inform clients where the
-   * stream starts.
-   *
-   * @param options - The options for the readable stream.
-   * @returns A `WorkflowReadableStream` for the workflow run.
-   */
-  getReadable(options = {}) {
-    "use step";
-    const { ops = [], global: global2 = globalThis, startIndex, namespace } = options;
-    const name = getWorkflowRunStreamId2(this.runId, namespace);
-    const encryptionKey = this.#getEncryptionKeyLazily();
-    const stream = getRunReadableStream2(global2, ops, this.runId, name, startIndex, encryptionKey);
-    const worldPromise = this.#lazyWorldPromise;
-    const runId = this.runId;
-    return Object.assign(stream, {
-      getTailIndex: /* @__PURE__ */ __name(async () => {
-        const world = await worldPromise;
-        const info = await world.streams.getInfo(runId, name);
-        return info.tailIndex;
-      }, "getTailIndex")
-    });
-  }
-  /** The writable stream of the workflow run. */
-  get writable() {
-    return this.getWritable();
-  }
-  /**
-   * Returns a writable that appends to this run's stream.
-   *
-   * Initialization is deferred until the first write. The run must already
-   * exist. The writable may be forwarded through `start()` and into steps, but
-   * grants no read access or additional authorization.
-   *
-   * @remarks
-   * `writer.close()` closes the shared stream. Contributors should call
-   * `releaseLock()`, which also drains pending writes.
-   *
-   * @param options - The writable stream options.
-   */
-  getWritable(options = {}) {
-    "use step";
-    const { ops = [], global: global2 = globalThis, namespace } = options;
-    const name = getWorkflowRunStreamId2(this.runId, namespace);
-    let targetPromise;
-    let writable;
-    const resolveTarget = /* @__PURE__ */ __name(() => {
-      targetPromise ??= this.#getMetadata().then(async (run3) => {
-        const target2 = {
-          key: await getForwardedWritableEncryptionKey2(this.runId, run3.deploymentId, run3.encryptionPublicKey),
-          deploymentId: run3.deploymentId,
-          encryptionPublicKey: run3.encryptionPublicKey
-        };
-        tagForwardedWritableTarget2(writable, target2);
-        return target2;
-      });
-      return targetPromise;
-    }, "resolveTarget");
-    writable = createForwardedWritable2({
-      global: global2,
-      ops,
-      runId: this.runId,
-      name,
-      key: /* @__PURE__ */ __name(() => resolveTarget().then(({ key }) => key), "key")
-    });
-    return writable;
-  }
-  /** Reads metadata, briefly retrying resilient starts. @internal */
-  async #getMetadata() {
-    const world = await this.#lazyWorldPromise;
-    const maxRetries = this.#resilientStart ? NOT_FOUND_RETRY_DELAYS2.length : 0;
-    let attempt = 0;
-    while (true) {
-      try {
-        return await world.runs.get(this.runId, { resolveData: "none" });
-      } catch (error121) {
-        if (!WorkflowRunNotFoundError2.is(error121) || attempt >= maxRetries) {
-          throw error121;
-        }
-        const delay = NOT_FOUND_RETRY_DELAYS2[attempt];
-        attempt++;
-        await new Promise((resolve3) => setTimeout(resolve3, delay));
-      }
-    }
-  }
-  /** @internal */
-  async #resolveTerminalReturnValue(run3) {
-    const expiredAt = run3.expiredAt;
-    if (expiredAt != null && expiredAt <= /* @__PURE__ */ new Date()) {
-      throw new RunExpiredError2(`Run "${this.runId}" ${run3.status === "completed" ? "completed" : `is ${run3.status}`}, but its data expired at ${expiredAt.toISOString()} and is no longer readable.`, this.runId, run3.status, expiredAt);
-    }
-    if (run3.status === "completed") {
-      const encryptionKey = await this.#getEncryptionKey(run3);
-      return await hydrateWorkflowReturnValue2(run3.output, this.runId, encryptionKey);
-    }
-    if (run3.status === "cancelled") {
-      throw new WorkflowRunCancelledError2(this.runId);
-    }
-    if (run3.status === "failed") {
-      const encryptionKey = await this.#getEncryptionKey(run3);
-      let hydratedError;
-      try {
-        hydratedError = await hydrateRunError2(run3.error, this.runId, encryptionKey);
-      } catch {
-        hydratedError = new Error("Failed to hydrate workflow run error");
-      }
-      throw new WorkflowRunFailedError2(this.runId, hydratedError, {
-        errorCode: run3.errorCode
-      });
-    }
-    throw new WorkflowRunNotCompletedError2(this.runId, run3.status);
-  }
-  /**
-   * Polls the workflow return value until the workflow run completes.
-   * @internal
-   * @returns The workflow return value.
-   */
-  async #pollReturnValue() {
-    const world = await this.#lazyWorldPromise;
-    let notFoundRetries = 0;
-    const NOT_FOUND_MAX_RETRIES = this.#resilientStart ? NOT_FOUND_RETRY_DELAYS2.length : 0;
-    const waitForTerminalStatus = isReturnValueLongPollEnabled2() ? world.runs.waitForTerminalStatus?.bind(world.runs) : void 0;
-    let longPolls = 0;
-    const maxLongPolls = getReturnValueMaxLongPolls2();
-    while (true) {
-      const iterationStartedAt = Date.now();
-      try {
-        const useLongPoll = waitForTerminalStatus && longPolls < maxLongPolls;
-        if (useLongPoll)
-          longPolls++;
-        const runMetadata = useLongPoll ? await waitForTerminalStatus(this.runId, {
-          timeoutMs: getReturnValueWaitTimeoutMs2(),
-          resolveData: "none"
-        }) : await world.runs.get(this.runId, {
-          resolveData: "none"
-        });
-        if (runMetadata.status === "cancelled") {
-          throw new WorkflowRunCancelledError2(this.runId);
-        }
-        if (PAYLOAD_TERMINAL_RUN_STATUSES2.has(runMetadata.status)) {
-          const run3 = await world.runs.get(this.runId, {
-            resolveData: "all"
-          });
-          return await this.#resolveTerminalReturnValue(run3);
-        }
-        throw new WorkflowRunNotCompletedError2(this.runId, runMetadata.status);
-      } catch (error121) {
-        if (WorkflowRunNotCompletedError2.is(error121)) {
-          const remainingIntervalMs = getReturnValuePollIntervalMs2() - (Date.now() - iterationStartedAt);
-          if (remainingIntervalMs > 0) {
-            await new Promise((resolve3) => setTimeout(resolve3, remainingIntervalMs));
-          }
-          continue;
-        }
-        if (WorkflowRunNotFoundError2.is(error121) && notFoundRetries < NOT_FOUND_MAX_RETRIES) {
-          const delay = NOT_FOUND_RETRY_DELAYS2[notFoundRetries];
-          notFoundRetries++;
-          await new Promise((resolve3) => setTimeout(resolve3, delay));
-          continue;
-        }
-        throw error121;
-      }
-    }
-  }
-};
-
-// ../core/dist/runtime.js
+init_run();
+init_runs4();
+init_start();
 init_world();
 function clampMaxEvents(serverValue) {
   const override = getMaxEventsOverride();
@@ -146273,19 +146854,23 @@ function isStepMissingError(err) {
   return /step/i.test(err.message) && /not found/i.test(err.message);
 }
 __name(isStepMissingError, "isStepMissingError");
-async function recordFatalRunError({ world, workflowRun, runId, requestId, err, errorCode, logMessage }) {
+async function recordFatalRunError({ world, workflowRun, runId, workflowName, requestId, err, errorCode, logMessage }) {
   runtimeLogger2.error(logMessage, {
     workflowRunId: runId,
     errorCode,
     error: err instanceof Error ? err.message : String(err)
   });
+  let encryptionKey;
+  let dehydratedError;
   try {
     const getEncryptionKey = memoizeEncryptionKey(world, workflowRun ?? runId);
+    encryptionKey = await getEncryptionKey();
+    dehydratedError = await dehydrateRunError(err, runId, encryptionKey, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2);
     await world.events.create(runId, {
       eventType: "run_failed",
       specVersion: SPEC_VERSION_CURRENT2,
       eventData: {
-        error: await dehydrateRunError(err, runId, await getEncryptionKey(), globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
+        error: dehydratedError,
         errorCode
       }
     }, { requestId });
@@ -146303,6 +146888,7 @@ async function recordFatalRunError({ world, workflowRun, runId, requestId, err,
     }
     throw failErr;
   }
+  dispatchRunFailedHooks(runId, workflowName, dehydratedError, encryptionKey, errorCode);
 }
 __name(recordFatalRunError, "recordFatalRunError");
 function findRecordedTerminalRunEvent(events, runId) {
@@ -146353,7 +146939,7 @@ function openHookAndWaitState(events) {
   return { openHook: hooks.size > 0, openWait: waits.size > 0 };
 }
 __name(openHookAndWaitState, "openHookAndWaitState");
-function getRetentionDecision({ suspension, serializationBlockerCount, hookContinuation = false }) {
+function getRetentionDecision({ suspension, serializationBlockerCount, hookContinuation = false, invocationContinuation = false }) {
   if (!isVmRetentionEnabled()) {
     return { retain: false, reason: "disabled" };
   }
@@ -146366,7 +146952,7 @@ function getRetentionDecision({ suspension, serializationBlockerCount, hookConti
   if (hookContinuation) {
     return { retain: true };
   }
-  if (suspension.stepCount === 0 && suspension.attributeCount === 0) {
+  if (!invocationContinuation && suspension.stepCount === 0 && suspension.attributeCount === 0) {
     return { retain: false, reason: "no_replay_driver" };
   }
   return { retain: true };
@@ -146425,7 +147011,7 @@ function workflowEntrypoint(workflowCode2, options) {
   setWorkflowBasePath(options?.basePath);
   const namespace = resolveQueueNamespace2(options?.namespace);
   const workflowPrefix = getQueueTopicPrefix2("workflow", namespace);
-  const handler = /* @__PURE__ */ __name((worldHandlers) => worldHandlers.createQueueHandler(workflowPrefix, async (message_, metadata) => {
+  const handler = /* @__PURE__ */ __name((worldHandlers) => worldHandlers.createQueueHandler(workflowPrefix, withRunInputs(worldHandlers)(async (message_, metadata, activity) => {
     const handlerEnteredAtMs = Date.now();
     const healthCheck3 = parseHealthCheckPayload(message_);
     if (healthCheck3) {
@@ -146456,14 +147042,17 @@ function workflowEntrypoint(workflowCode2, options) {
         const world = await getWorld();
         const getEncryptionKey = memoizeEncryptionKey(world, runId);
         const err = new FatalError2(`Workflow exceeded maximum queue deliveries (${metadata.attempt}/${maxQueueDeliveries})`);
+        const encryptionKey = await getEncryptionKey();
+        const dehydratedError = await dehydrateRunError(err, runId, encryptionKey);
         await world.events.create(runId, {
           eventType: "run_failed",
           specVersion: SPEC_VERSION_CURRENT2,
           eventData: {
-            error: await dehydrateRunError(err, runId, await getEncryptionKey()),
+            error: dehydratedError,
             errorCode: RUN_ERROR_CODES2.MAX_DELIVERIES_EXCEEDED
           }
         }, { requestId });
+        dispatchRunFailedHooks(runId, workflowName, dehydratedError, encryptionKey, RUN_ERROR_CODES2.MAX_DELIVERIES_EXCEEDED);
       } catch (err) {
         if (EntityConflictError2.is(err) || RunExpiredError2.is(err)) {
           return;
@@ -146621,6 +147210,7 @@ function workflowEntrypoint(workflowCode2, options) {
               world,
               workflowRun,
               runId,
+              workflowName,
               requestId,
               err,
               errorCode,
@@ -146735,6 +147325,7 @@ function workflowEntrypoint(workflowCode2, options) {
             const { outcome, spanAttributes } = await guardDeploymentAffinity({
               world,
               run: run3,
+              workflowName,
               requestId,
               retryCount: deploymentMismatchRetryCount,
               beforeStop,
@@ -146893,6 +147484,14 @@ function workflowEntrypoint(workflowCode2, options) {
               if (stepResult.type === "throttled") {
                 return { timeoutSeconds: stepResult.timeoutSeconds };
               }
+              if (world.capabilities?.invoke && stepResult.type !== "gone") {
+                await queueMessage(world, getWorkflowQueueName2(workflowName, namespace), {
+                  runId,
+                  traceCarrier: await nextTraceCarrier(),
+                  requestedAt: /* @__PURE__ */ new Date()
+                });
+                return;
+              }
               if (stepResult.type === "completed" && stepResult.hasPendingOps) {
                 await queueMessage(world, getWorkflowQueueName2(workflowName, namespace), {
                   runId,
@@ -146976,6 +147575,7 @@ function workflowEntrypoint(workflowCode2, options) {
                 world,
                 workflowRun,
                 runId,
+                workflowName,
                 requestId,
                 err,
                 errorCode,
@@ -147304,6 +147904,7 @@ function workflowEntrypoint(workflowCode2, options) {
           const continuedHookIds = /* @__PURE__ */ new Set();
           const publishedStepCorrelationIds = /* @__PURE__ */ new Set();
           while (true) {
+            const invocationRevision = activity?.revision ?? 0;
             loopIteration++;
             if (replayBudget.isExhausted()) {
               await handleReplayBudgetExhausted({
@@ -147530,6 +148131,7 @@ function workflowEntrypoint(workflowCode2, options) {
                 }
                 throw err;
               }
+              dispatchRunCompletedHooks(runId, workflowName);
               span?.setAttributes({
                 ...WorkflowRunStatus2("completed")
               });
@@ -147613,13 +148215,17 @@ function workflowEntrypoint(workflowCode2, options) {
                     errorName: suspensionError.name,
                     errorMessage: suspensionError.message
                   });
+                  let failureKey;
+                  let dehydratedError;
                   try {
                     await awaitRunReady();
+                    failureKey = await encryptionKey.value;
+                    dehydratedError = await dehydrateRunError(suspensionError, runId, failureKey, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2);
                     await createEvent({
                       eventType: "run_failed",
                       specVersion: SPEC_VERSION_CURRENT2,
                       eventData: {
-                        error: await dehydrateRunError(suspensionError, runId, await encryptionKey.value, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
+                        error: dehydratedError,
                         errorCode
                       }
                     }, { requestId });
@@ -147633,6 +148239,7 @@ function workflowEntrypoint(workflowCode2, options) {
                     }
                     throw failErr;
                   }
+                  dispatchRunFailedHooks(runId, workflowName, dehydratedError, failureKey, errorCode);
                   span?.setAttributes({
                     ...WorkflowRunStatus2("failed"),
                     ...WorkflowErrorCode2(errorCode),
@@ -147652,7 +148259,8 @@ function workflowEntrypoint(workflowCode2, options) {
                   // This suspension committed the event a hook's
                   // own awaiter is parked on; the continuation
                   // below drives the next iteration in-process.
-                  hookContinuation: suspensionResult.hasAwaitedHookCreation || suspensionResult.hasHookConflict
+                  hookContinuation: suspensionResult.hasAwaitedHookCreation || suspensionResult.hasHookConflict,
+                  invocationContinuation: activity !== void 0
                 }) : void 0;
                 if (retentionDecision?.retain === false) {
                   retainedSession = null;
@@ -147861,6 +148469,10 @@ function workflowEntrypoint(workflowCode2, options) {
                     }
                     return await reinvoke(0);
                   }
+                  if (activity && Date.now() - invocationStartTime < noInlineReplayAfterMs && await activity.waitForActivity(invocationRevision)) {
+                    eventLog = nextEventLogLoad(eventLog);
+                    continue;
+                  }
                   return;
                 }
                 const openHookWaitState = openHookWait.value;
@@ -148185,13 +148797,17 @@ function workflowEntrypoint(workflowCode2, options) {
                 if (types9.isNativeError(terminalError) && errorStack) {
                   terminalError.stack = errorStack;
                 }
+                let failureKey;
+                let dehydratedError;
                 try {
                   await awaitRunReady();
+                  failureKey = await encryptionKey.value;
+                  dehydratedError = await dehydrateRunError(terminalError, runId, failureKey, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2);
                   await createEvent({
                     eventType: "run_failed",
                     specVersion: SPEC_VERSION_CURRENT2,
                     eventData: {
-                      error: await dehydrateRunError(terminalError, runId, await encryptionKey.value, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
+                      error: dehydratedError,
                       errorCode
                     }
                   }, {
@@ -148218,6 +148834,7 @@ function workflowEntrypoint(workflowCode2, options) {
                   }
                   throw failErr;
                 }
+                dispatchRunFailedHooks(runId, workflowName, dehydratedError, failureKey, errorCode);
                 span?.setAttributes({
                   ...WorkflowRunStatus2("failed"),
                   ...WorkflowErrorCode2(errorCode),
@@ -148232,7 +148849,7 @@ function workflowEntrypoint(workflowCode2, options) {
         });
       });
     });
-  }), "handler");
+  })), "handler");
   let cachedHandler;
   let invocationCount = 0;
   const entrypointCreatedAt = Date.now();
@@ -149119,11 +149736,11 @@ var Run = class _Run {
     return this.getWritable();
   }
 };
-Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.53//Run#wakeUp");
-Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.53//Run#cancel");
-Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.53//Run#getReadable");
-Run.prototype["getWritable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.53//Run#getWritable");
-var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.53//Run#exists");
+Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#wakeUp");
+Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#cancel");
+Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#getReadable");
+Run.prototype["getWritable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#getWritable");
+var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#exists");
 Object.defineProperty(Run.prototype, "exists", {
   get() {
     return __step_Run$exists.call(this);
@@ -149131,7 +149748,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.53//Run#status");
+var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#status");
 Object.defineProperty(Run.prototype, "status", {
   get() {
     return __step_Run$status.call(this);
@@ -149139,7 +149756,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.53//Run#returnValue");
+var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#returnValue");
 Object.defineProperty(Run.prototype, "returnValue", {
   get() {
     return __step_Run$returnValue.call(this);
@@ -149147,7 +149764,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.53//Run#workflowName");
+var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#workflowName");
 Object.defineProperty(Run.prototype, "workflowName", {
   get() {
     return __step_Run$workflowName.call(this);
@@ -149155,7 +149772,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.53//Run#createdAt");
+var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#createdAt");
 Object.defineProperty(Run.prototype, "createdAt", {
   get() {
     return __step_Run$createdAt.call(this);
@@ -149163,7 +149780,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.53//Run#startedAt");
+var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#startedAt");
 Object.defineProperty(Run.prototype, "startedAt", {
   get() {
     return __step_Run$startedAt.call(this);
@@ -149171,7 +149788,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.53//Run#completedAt");
+var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#completedAt");
 Object.defineProperty(Run.prototype, "completedAt", {
   get() {
     return __step_Run$completedAt.call(this);
@@ -149188,7 +149805,7 @@ Object.defineProperty(Run.prototype, "completedAt", {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.53//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.54//Run");
 
 // ../core/dist/workflow/create-hook.js
 aliasSerializationClass(RUN_CLASS_ID, Run);
@@ -156784,7 +157401,7 @@ globalThis.__private_workflows.set("workflow//./workflows/inline-execution//hook
 var latestNoOpWarning = globalSingleton("@workflow/core//latestNoOpWarning", 1, () => ({
   warned: false
 }));
-var start = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/start@5.0.0-beta.53//start");
+var start = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/start@5.0.0-beta.54//start");
 
 // workflows/lineage.ts
 var noop = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//./workflows/lineage//noop");