@workflow/world-testing 5.0.0-beta.48 → 5.0.0-beta.49

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

@@ -709,10 +709,10 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema) {
   return mergeDefs2(schema._zod.def);
 }
-function getElementAtPath2(obj, path14) {
-  if (!path14)
+function getElementAtPath2(obj, path15) {
+  if (!path15)
     return obj;
-  return path14.reduce((acc, key) => acc?.[key], obj);
+  return path15.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1024,11 +1024,11 @@ function aborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path14, issues) {
+function prefixIssues2(path15, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path14);
+    iss.path.unshift(path15);
     return iss;
   });
 }
@@ -1327,7 +1327,7 @@ function formatError2(error95, mapper = (issue3) => issue3.message) {
 }
 function treeifyError2(error95, mapper = (issue3) => issue3.message) {
   const result2 = { errors: [] };
-  const processError = /* @__PURE__ */ __name((error96, path14 = []) => {
+  const processError = /* @__PURE__ */ __name((error96, path15 = []) => {
     var _a4, _b;
     for (const issue3 of error96.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
@@ -1337,7 +1337,7 @@ function treeifyError2(error95, mapper = (issue3) => issue3.message) {
       } else if (issue3.code === "invalid_element") {
         processError({ issues: issue3.issues }, issue3.path);
       } else {
-        const fullpath = [...path14, ...issue3.path];
+        const fullpath = [...path15, ...issue3.path];
         if (fullpath.length === 0) {
           result2.errors.push(mapper(issue3));
           continue;
@@ -1369,8 +1369,8 @@ function treeifyError2(error95, mapper = (issue3) => issue3.message) {
 }
 function toDotPath2(_path) {
   const segs = [];
-  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path14) {
+  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path15) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14425,13 +14425,13 @@ function resolveRef2(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path14 = ref.slice(1).split("/").filter(Boolean);
-  if (path14.length === 0) {
+  const path15 = ref.slice(1).split("/").filter(Boolean);
+  if (path15.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path14[0] === defsKey) {
-    const key = path14[1];
+  if (path15[0] === defsKey) {
+    const key = path15[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15203,6 +15203,24 @@ var init_zod2 = __esm({
 });
 
 // ../world/dist/attributes-validation.js
+function readRunRetention(attributes) {
+  const raw = attributes?.[RETENTION_ATTRIBUTE2];
+  if (raw === void 0) {
+    return { mode: "default", wellFormed: false, unsupported: false };
+  }
+  if (RETENTION_INTEGER_PATTERN.test(raw)) {
+    return raw === RETENTION_ZERO ? { mode: "none", raw, wellFormed: true, unsupported: false } : { mode: "default", raw, wellFormed: true, unsupported: true };
+  }
+  return {
+    mode: "default",
+    raw,
+    wellFormed: false,
+    unsupported: raw !== RETENTION_DEFAULT
+  };
+}
+function purgesUserDataOnFinish(attributes) {
+  return readRunRetention(attributes).mode === "none";
+}
 function assertValidAttributeKey2(key, allowReservedAttributes) {
   if (typeof key !== "string") {
     throw new AttributeValidationError2(`Attribute key must be a string, got ${typeof key}`);
@@ -15266,13 +15284,19 @@ function applyAttributeChanges(existing, changes) {
   }
   return next2;
 }
-var RESERVED_ATTRIBUTE_KEY_PREFIX2, ROOT_RUN_ID_ATTRIBUTE2, PARENT_RUN_ID_ATTRIBUTE2, ATTRIBUTE_KEY_MAX_LENGTH2, ATTRIBUTE_VALUE_MAX_BYTES2, ATTRIBUTE_MAX_PER_RUN2, 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, textEncoder3, AttributeValidationError2;
 var init_attributes_validation2 = __esm({
   "../world/dist/attributes-validation.js"() {
     "use strict";
     RESERVED_ATTRIBUTE_KEY_PREFIX2 = "$";
     ROOT_RUN_ID_ATTRIBUTE2 = `${RESERVED_ATTRIBUTE_KEY_PREFIX2}rootRunId`;
     PARENT_RUN_ID_ATTRIBUTE2 = `${RESERVED_ATTRIBUTE_KEY_PREFIX2}parentRunId`;
+    RETENTION_ATTRIBUTE2 = `${RESERVED_ATTRIBUTE_KEY_PREFIX2}retention`;
+    RETENTION_ZERO = "0";
+    RETENTION_DEFAULT = "default";
+    RETENTION_INTEGER_PATTERN = /^(?:0|[1-9]\d*)$/;
+    __name(readRunRetention, "readRunRetention");
+    __name(purgesUserDataOnFinish, "purgesUserDataOnFinish");
     ATTRIBUTE_KEY_MAX_LENGTH2 = 256;
     ATTRIBUTE_VALUE_MAX_BYTES2 = 256;
     ATTRIBUTE_MAX_PER_RUN2 = 64;
@@ -17133,6 +17157,9 @@ __export(dist_exports, {
   QueuePayloadSchema: () => QueuePayloadSchema2,
   QueuePrefix: () => QueuePrefix2,
   RESERVED_ATTRIBUTE_KEY_PREFIX: () => RESERVED_ATTRIBUTE_KEY_PREFIX2,
+  RETENTION_ATTRIBUTE: () => RETENTION_ATTRIBUTE2,
+  RETENTION_DEFAULT: () => RETENTION_DEFAULT,
+  RETENTION_ZERO: () => RETENTION_ZERO,
   ROOT_RUN_ID_ATTRIBUTE: () => ROOT_RUN_ID_ATTRIBUTE2,
   RUN_ENTITY_KEY: () => RUN_ENTITY_KEY,
   RUN_EVENT_TYPES: () => RUN_EVENT_TYPES2,
@@ -17197,6 +17224,8 @@ __export(dist_exports, {
   isWaitEventType: () => isWaitEventType,
   mintedSpecVersion: () => mintedSpecVersion,
   parseQueueName: () => parseQueueName,
+  purgesUserDataOnFinish: () => purgesUserDataOnFinish,
+  readRunRetention: () => readRunRetention,
   reenqueueActiveRuns: () => reenqueueActiveRuns,
   requireEventSlot: () => requireEventSlot,
   requiresNewerWorld: () => requiresNewerWorld,
@@ -17630,8 +17659,14 @@ Caused by: ${options.cause.stack}`;
       static {
         __name(this, "RunExpiredError");
       }
-      constructor(message) {
-        super(message);
+      runId;
+      runStatus;
+      expiredAt;
+      constructor(message, runId, runStatus, expiredAt) {
+        super(message, { status: 410, code: "run-expired" });
+        this.runId = runId;
+        this.runStatus = runStatus;
+        this.expiredAt = expiredAt;
         this.name = "RunExpiredError";
       }
       static is(value) {
@@ -18374,7 +18409,7 @@ async function write(filePath, data, opts) {
 }
 async function readJSON(filePath, decoder6) {
   try {
-    const content = await fs.readFile(filePath, "utf-8");
+    const content = await withWindowsRetry(() => fs.readFile(filePath, "utf-8"));
     return decoder6.parse(JSON.parse(content, jsonReviver));
   } catch (error95) {
     if (error95.code === "ENOENT")
@@ -22367,14 +22402,14 @@ var require_util = __commonJS({
         }
         const port = url3.port != null ? url3.port : url3.protocol === "https:" ? 443 : 80;
         let origin = url3.origin != null ? url3.origin : `${url3.protocol || ""}//${url3.hostname || ""}:${port}`;
-        let path14 = url3.path != null ? url3.path : `${url3.pathname || ""}${url3.search || ""}`;
+        let path15 = url3.path != null ? url3.path : `${url3.pathname || ""}${url3.search || ""}`;
         if (origin[origin.length - 1] === "/") {
           origin = origin.slice(0, origin.length - 1);
         }
-        if (path14 && path14[0] !== "/") {
-          path14 = `/${path14}`;
+        if (path15 && path15[0] !== "/") {
+          path15 = `/${path15}`;
         }
-        return new URL(`${origin}${path14}`);
+        return new URL(`${origin}${path15}`);
       }
       if (!isHttpOrHttpsPrefixed(url3.origin || url3.protocol)) {
         throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
@@ -23234,9 +23269,9 @@ var require_diagnostics = __commonJS({
         "undici:client:sendHeaders",
         (evt) => {
           const {
-            request: { method, path: path14, origin }
+            request: { method, path: path15, origin }
           } = evt;
-          debugLog2("sending request to %s %s%s", method, origin, path14);
+          debugLog2("sending request to %s %s%s", method, origin, path15);
         }
       );
     }
@@ -23255,14 +23290,14 @@ var require_diagnostics = __commonJS({
         "undici:request:headers",
         (evt) => {
           const {
-            request: { method, path: path14, origin },
+            request: { method, path: path15, origin },
             response: { statusCode }
           } = evt;
           debugLog2(
             "received response to %s %s%s - HTTP %d",
             method,
             origin,
-            path14,
+            path15,
             statusCode
           );
         }
@@ -23271,23 +23306,23 @@ var require_diagnostics = __commonJS({
         "undici:request:trailers",
         (evt) => {
           const {
-            request: { method, path: path14, origin }
+            request: { method, path: path15, origin }
           } = evt;
-          debugLog2("trailers received from %s %s%s", method, origin, path14);
+          debugLog2("trailers received from %s %s%s", method, origin, path15);
         }
       );
       diagnosticsChannel.subscribe(
         "undici:request:error",
         (evt) => {
           const {
-            request: { method, path: path14, origin },
+            request: { method, path: path15, origin },
             error: error95
           } = evt;
           debugLog2(
             "request to %s %s%s errored - %s",
             method,
             origin,
-            path14,
+            path15,
             error95.message
           );
         }
@@ -23408,7 +23443,7 @@ var require_request = __commonJS({
         __name(this, "Request");
       }
       constructor(origin, {
-        path: path14,
+        path: path15,
         method,
         body,
         headers,
@@ -23425,11 +23460,11 @@ var require_request = __commonJS({
         maxRedirections,
         typeOfService
       }, handler) {
-        if (typeof path14 !== "string") {
+        if (typeof path15 !== "string") {
           throw new InvalidArgumentError("path must be a string");
-        } else if (path14[0] !== "/" && !(path14.startsWith("http://") || path14.startsWith("https://")) && method !== "CONNECT") {
+        } else if (path15[0] !== "/" && !(path15.startsWith("http://") || path15.startsWith("https://")) && method !== "CONNECT") {
           throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.test(path14)) {
+        } else if (invalidPathRegex.test(path15)) {
           throw new InvalidArgumentError("invalid request path");
         }
         if (typeof method !== "string") {
@@ -23504,7 +23539,7 @@ var require_request = __commonJS({
         this.completed = false;
         this.aborted = false;
         this.upgrade = upgrade || null;
-        this.path = query ? serializePathWithQuery(path14, query) : path14;
+        this.path = query ? serializePathWithQuery(path15, query) : path15;
         this.origin = origin;
         this.protocol = getProtocolFromUrlString(origin);
         this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
@@ -28842,7 +28877,7 @@ var require_client_h1 = __commonJS({
     }
     __name(shouldSendContentLength, "shouldSendContentLength");
     function writeH1(client, request) {
-      const { method, path: path14, host, upgrade, blocking, reset } = request;
+      const { method, path: path15, host, upgrade, blocking, reset } = request;
       let { body, headers, contentLength: contentLength2 } = request;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       if (util.isFormDataLike(body)) {
@@ -28920,7 +28955,7 @@ var require_client_h1 = __commonJS({
       if (socket.setTypeOfService) {
         socket.setTypeOfService(request.typeOfService);
       }
-      let header = `${method} ${path14} HTTP/1.1\r
+      let header = `${method} ${path15} HTTP/1.1\r
 `;
       if (typeof host === "string") {
         header += `host: ${host}\r
@@ -29599,7 +29634,7 @@ var require_client_h2 = __commonJS({
     function writeH2(client, request) {
       const requestTimeout = request.bodyTimeout ?? client[kBodyTimeout];
       const session = client[kHTTP2Session];
-      const { method, path: path14, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request;
+      const { method, path: path15, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request;
       let { body } = request;
       if (upgrade != null && upgrade !== "websocket") {
         util.errorRequest(client, request, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
@@ -29667,7 +29702,7 @@ var require_client_h2 = __commonJS({
           }
           headers[HTTP2_HEADER_METHOD] = "CONNECT";
           headers[HTTP2_HEADER_PROTOCOL] = "websocket";
-          headers[HTTP2_HEADER_PATH] = path14;
+          headers[HTTP2_HEADER_PATH] = path15;
           if (protocol === "ws:" || protocol === "wss:") {
             headers[HTTP2_HEADER_SCHEME] = protocol === "ws:" ? "http" : "https";
           } else {
@@ -29708,7 +29743,7 @@ var require_client_h2 = __commonJS({
         stream.setTimeout(requestTimeout);
         return true;
       }
-      headers[HTTP2_HEADER_PATH] = path14;
+      headers[HTTP2_HEADER_PATH] = path15;
       headers[HTTP2_HEADER_SCHEME] = protocol === "http:" ? "http" : "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
       if (body && typeof body.read === "function") {
@@ -32112,10 +32147,10 @@ var require_proxy_agent = __commonJS({
         };
         const {
           origin,
-          path: path14 = "/",
+          path: path15 = "/",
           headers = {}
         } = opts;
-        opts.path = origin + path14;
+        opts.path = origin + path15;
         if (!("host" in headers) && !("Host" in headers)) {
           const { host } = new URL(origin);
           headers.host = host;
@@ -34272,21 +34307,21 @@ var require_mock_utils = __commonJS({
       return normalizedQp;
     }
     __name(normalizeSearchParams, "normalizeSearchParams");
-    function safeUrl(path14) {
-      if (typeof path14 !== "string") {
-        return path14;
+    function safeUrl(path15) {
+      if (typeof path15 !== "string") {
+        return path15;
       }
-      const pathSegments = path14.split("?", 3);
+      const pathSegments = path15.split("?", 3);
       if (pathSegments.length !== 2) {
-        return path14;
+        return path15;
       }
       const qp = new URLSearchParams(pathSegments.pop());
       qp.sort();
       return [...pathSegments, qp.toString()].join("?");
     }
     __name(safeUrl, "safeUrl");
-    function matchKey(mockDispatch2, { path: path14, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path14);
+    function matchKey(mockDispatch2, { path: path15, method, body, headers }) {
+      const pathMatch = matchValue(mockDispatch2.path, path15);
       const methodMatch = matchValue(mockDispatch2.method, method);
       const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
       const headersMatch = matchHeaders(mockDispatch2, headers);
@@ -34313,8 +34348,8 @@ var require_mock_utils = __commonJS({
       const basePath = key.query ? serializePathWithQuery(key.path, key.query) : key.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
       const resolvedPathWithoutTrailingSlash = removeTrailingSlash(resolvedPath);
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path14, ignoreTrailingSlash }) => {
-        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path14)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path14), resolvedPath);
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path15, ignoreTrailingSlash }) => {
+        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path15)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path15), resolvedPath);
       });
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
@@ -34356,20 +34391,20 @@ var require_mock_utils = __commonJS({
       }
     }
     __name(deleteMockDispatch, "deleteMockDispatch");
-    function removeTrailingSlash(path14) {
-      while (path14.endsWith("/")) {
-        path14 = path14.slice(0, -1);
+    function removeTrailingSlash(path15) {
+      while (path15.endsWith("/")) {
+        path15 = path15.slice(0, -1);
       }
-      if (path14.length === 0) {
-        path14 = "/";
+      if (path15.length === 0) {
+        path15 = "/";
       }
-      return path14;
+      return path15;
     }
     __name(removeTrailingSlash, "removeTrailingSlash");
     function buildKey(opts) {
-      const { path: path14, method, body, headers, query } = opts;
+      const { path: path15, method, body, headers, query } = opts;
       return {
-        path: path14,
+        path: path15,
         method,
         body,
         headers,
@@ -35096,10 +35131,10 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path14, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+          ({ method, path: path15, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
-            Path: path14,
+            Path: path15,
             "Status code": statusCode,
             Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
             Invocations: timesInvoked,
@@ -35184,9 +35219,9 @@ var require_mock_agent = __commonJS({
         const acceptNonStandardSearchParameters = this[kMockAgentAcceptsNonStandardSearchParameters];
         const dispatchOpts = { ...opts };
         if (acceptNonStandardSearchParameters && dispatchOpts.path) {
-          const [path14, searchParams] = dispatchOpts.path.split("?");
+          const [path15, searchParams] = dispatchOpts.path.split("?");
           const normalizedSearchParams = normalizeSearchParams(searchParams, acceptNonStandardSearchParameters);
-          dispatchOpts.path = `${path14}?${normalizedSearchParams}`;
+          dispatchOpts.path = `${path15}?${normalizedSearchParams}`;
         }
         return this[kAgent].dispatch(dispatchOpts, handler);
       }
@@ -35599,12 +35634,12 @@ var require_snapshot_recorder = __commonJS({
        * @return {Promise<void>} - Resolves when snapshots are loaded
        */
       async loadSnapshots(filePath) {
-        const path14 = filePath || this.#snapshotPath;
-        if (!path14) {
+        const path15 = filePath || this.#snapshotPath;
+        if (!path15) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile3(resolve3(path14), "utf8");
+          const data = await readFile3(resolve3(path15), "utf8");
           const parsed = JSON.parse(data);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -35618,7 +35653,7 @@ var require_snapshot_recorder = __commonJS({
           if (error95.code === "ENOENT") {
             this.#snapshots.clear();
           } else {
-            throw new UndiciError(`Failed to load snapshots from ${path14}`, { cause: error95 });
+            throw new UndiciError(`Failed to load snapshots from ${path15}`, { cause: error95 });
           }
         }
       }
@@ -35629,11 +35664,11 @@ var require_snapshot_recorder = __commonJS({
        * @returns {Promise<void>} - Resolves when snapshots are saved
        */
       async saveSnapshots(filePath) {
-        const path14 = filePath || this.#snapshotPath;
-        if (!path14) {
+        const path15 = filePath || this.#snapshotPath;
+        if (!path15) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
-        const resolvedPath = resolve3(path14);
+        const resolvedPath = resolve3(path15);
         await mkdir2(dirname2(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash3, snapshot]) => ({
           hash: hash3,
@@ -36279,15 +36314,15 @@ var require_redirect_handler = __commonJS({
           return;
         }
         const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
-        const path14 = search ? `${pathname}${search}` : pathname;
-        const redirectUrlString = `${origin}${path14}`;
+        const path15 = search ? `${pathname}${search}` : pathname;
+        const redirectUrlString = `${origin}${path15}`;
         for (const historyUrl of this.history) {
           if (historyUrl.toString() === redirectUrlString) {
             throw new InvalidArgumentError(`Redirect loop detected. Cannot redirect to ${origin}. This typically happens when using a Client or Pool with cross-origin redirects. Use an Agent for cross-origin redirects.`);
           }
         }
         this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
-        this.opts.path = path14;
+        this.opts.path = path15;
         this.opts.origin = origin;
         this.opts.query = null;
       }
@@ -36374,9 +36409,9 @@ var require_redirect = __commonJS({
 var require_response_error = __commonJS({
   "../../node_modules/.pnpm/undici@7.29.0/node_modules/undici/lib/interceptor/response-error.js"(exports, module) {
     "use strict";
-    var DecoratorHandler = require_decorator_handler();
+    var DecoratorHandler2 = require_decorator_handler();
     var { ResponseError } = require_errors();
-    var ResponseErrorHandler = class extends DecoratorHandler {
+    var ResponseErrorHandler = class extends DecoratorHandler2 {
       static {
         __name(this, "ResponseErrorHandler");
       }
@@ -36484,8 +36519,8 @@ var require_dump = __commonJS({
   "../../node_modules/.pnpm/undici@7.29.0/node_modules/undici/lib/interceptor/dump.js"(exports, module) {
     "use strict";
     var { InvalidArgumentError, RequestAbortedError } = require_errors();
-    var DecoratorHandler = require_decorator_handler();
-    var DumpHandler = class extends DecoratorHandler {
+    var DecoratorHandler2 = require_decorator_handler();
+    var DumpHandler = class extends DecoratorHandler2 {
       static {
         __name(this, "DumpHandler");
       }
@@ -36575,7 +36610,7 @@ var require_dns = __commonJS({
     "use strict";
     var { isIP } = __require("node:net");
     var { lookup } = __require("node:dns");
-    var DecoratorHandler = require_decorator_handler();
+    var DecoratorHandler2 = require_decorator_handler();
     var { InvalidArgumentError, InformationalError } = require_errors();
     var maxInt = Math.pow(2, 31) - 1;
     function hasSafeIterator(headers) {
@@ -36884,7 +36919,7 @@ var require_dns = __commonJS({
         return new DNSDispatchHandler(this, meta5, opts);
       }
     };
-    var DNSDispatchHandler = class extends DecoratorHandler {
+    var DNSDispatchHandler = class extends DecoratorHandler2 {
       static {
         __name(this, "DNSDispatchHandler");
       }
@@ -38113,10 +38148,10 @@ var require_cache_handler = __commonJS({
       return locationUrl.pathname + locationUrl.search;
     }
     __name(getSameOriginPath, "getSameOriginPath");
-    function deleteCachedUri(store, cacheKey, path14) {
+    function deleteCachedUri(store, cacheKey, path15) {
       deleteCachedValue(store, {
         ...cacheKey,
-        path: path14
+        path: path15
       });
       for (let i = 0; i < util.safeHTTPMethods.length; i++) {
         const method = util.safeHTTPMethods[i];
@@ -38124,7 +38159,7 @@ var require_cache_handler = __commonJS({
           deleteCachedValue(store, {
             ...cacheKey,
             method,
-            path: path14
+            path: path15
           });
         }
       }
@@ -38136,9 +38171,9 @@ var require_cache_handler = __commonJS({
       }
       const values = Array.isArray(headerValue) ? headerValue : [headerValue];
       for (let i = 0; i < values.length; i++) {
-        const path14 = getSameOriginPath(cacheKey, values[i]);
-        if (path14 !== void 0) {
-          deleteCachedUri(store, cacheKey, path14);
+        const path15 = getSameOriginPath(cacheKey, values[i]);
+        if (path15 !== void 0) {
+          deleteCachedUri(store, cacheKey, path15);
         }
       }
     }
@@ -39305,7 +39340,7 @@ var require_decompress = __commonJS({
     "use strict";
     var { createInflate, createGunzip, createBrotliDecompress, createZstdDecompress } = __require("node:zlib");
     var { pipeline } = __require("node:stream");
-    var DecoratorHandler = require_decorator_handler();
+    var DecoratorHandler2 = require_decorator_handler();
     var { runtimeFeatures } = require_runtime_features();
     var supportedEncodings = {
       gzip: createGunzip,
@@ -39324,7 +39359,7 @@ var require_decompress = __commonJS({
       /** @type {boolean} */
       false
     );
-    var DecompressHandler = class extends DecoratorHandler {
+    var DecompressHandler = class extends DecoratorHandler2 {
       static {
         __name(this, "DecompressHandler");
       }
@@ -43117,11 +43152,11 @@ var require_fetch = __commonJS({
       function dispatch({ body }) {
         const url3 = requestCurrentURL(request);
         const agent = fetchParams.controller.dispatcher;
-        const path14 = url3.pathname + url3.search;
+        const path15 = url3.pathname + url3.search;
         const hasTrailingQuestionMark = url3.search.length === 0 && url3.href[url3.href.length - url3.hash.length - 1] === "?";
         return new Promise((resolve3, reject) => agent.dispatch(
           {
-            path: hasTrailingQuestionMark ? `${path14}?` : path14,
+            path: hasTrailingQuestionMark ? `${path15}?` : path15,
             origin: url3.origin,
             method: request.method,
             body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
@@ -44081,9 +44116,9 @@ var require_util4 = __commonJS({
       }
     }
     __name(validateCookieValue, "validateCookieValue");
-    function validateCookiePath(path14) {
-      for (let i = 0; i < path14.length; ++i) {
-        const code3 = path14.charCodeAt(i);
+    function validateCookiePath(path15) {
+      for (let i = 0; i < path15.length; ++i) {
+        const code3 = path15.charCodeAt(i);
         if (code3 < 32 || // exclude CTLs (0-31)
         code3 > 126 || // exclude DEL and non-ascii
         code3 === 59) {
@@ -47345,7 +47380,7 @@ var require_undici = __commonJS({
     var mockErrors = require_mock_errors();
     var RetryHandler = require_retry_handler();
     var { getGlobalDispatcher, setGlobalDispatcher } = require_global2();
-    var DecoratorHandler = require_decorator_handler();
+    var DecoratorHandler2 = require_decorator_handler();
     var RedirectHandler = require_redirect_handler();
     Object.assign(Dispatcher.prototype, api);
     module.exports.Dispatcher = Dispatcher;
@@ -47360,7 +47395,7 @@ var require_undici = __commonJS({
     module.exports.RetryAgent = RetryAgent2;
     module.exports.H2CClient = H2CClient;
     module.exports.RetryHandler = RetryHandler;
-    module.exports.DecoratorHandler = DecoratorHandler;
+    module.exports.DecoratorHandler = DecoratorHandler2;
     module.exports.RedirectHandler = RedirectHandler;
     module.exports.interceptors = {
       redirect: require_redirect(),
@@ -47399,11 +47434,11 @@ var require_undici = __commonJS({
           if (typeof opts.path !== "string") {
             throw new InvalidArgumentError("invalid opts.path");
           }
-          let path14 = opts.path;
+          let path15 = opts.path;
           if (!opts.path.startsWith("/")) {
-            path14 = `/${path14}`;
+            path15 = `/${path15}`;
           }
-          url3 = new URL(util.parseOrigin(url3).origin + path14);
+          url3 = new URL(util.parseOrigin(url3).origin + path15);
         } else {
           if (!opts) {
             opts = typeof url3 === "object" ? url3 : {};
@@ -47866,14 +47901,14 @@ var require_polyfills = __commonJS({
       fs9.fstatSync = statFixSync(fs9.fstatSync);
       fs9.lstatSync = statFixSync(fs9.lstatSync);
       if (fs9.chmod && !fs9.lchmod) {
-        fs9.lchmod = function(path14, mode, cb) {
+        fs9.lchmod = function(path15, mode, cb) {
           if (cb) process.nextTick(cb);
         };
         fs9.lchmodSync = function() {
         };
       }
       if (fs9.chown && !fs9.lchown) {
-        fs9.lchown = function(path14, uid, gid, cb) {
+        fs9.lchown = function(path15, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
         fs9.lchownSync = function() {
@@ -47942,9 +47977,9 @@ var require_polyfills = __commonJS({
         };
       })(fs9.readSync);
       function patchLchmod(fs10) {
-        fs10.lchmod = function(path14, mode, callback) {
+        fs10.lchmod = function(path15, mode, callback) {
           fs10.open(
-            path14,
+            path15,
             constants2.O_WRONLY | constants2.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -47960,8 +47995,8 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs10.lchmodSync = function(path14, mode) {
-          var fd = fs10.openSync(path14, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
+        fs10.lchmodSync = function(path15, mode) {
+          var fd = fs10.openSync(path15, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -47983,8 +48018,8 @@ var require_polyfills = __commonJS({
       __name(patchLchmod, "patchLchmod");
       function patchLutimes(fs10) {
         if (constants2.hasOwnProperty("O_SYMLINK") && fs10.futimes) {
-          fs10.lutimes = function(path14, at, mt, cb) {
-            fs10.open(path14, constants2.O_SYMLINK, function(er, fd) {
+          fs10.lutimes = function(path15, at, mt, cb) {
+            fs10.open(path15, constants2.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -47996,8 +48031,8 @@ var require_polyfills = __commonJS({
               });
             });
           };
-          fs10.lutimesSync = function(path14, at, mt) {
-            var fd = fs10.openSync(path14, constants2.O_SYMLINK);
+          fs10.lutimesSync = function(path15, at, mt) {
+            var fd = fs10.openSync(path15, constants2.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -48125,11 +48160,11 @@ var require_legacy_streams = __commonJS({
         ReadStream,
         WriteStream
       };
-      function ReadStream(path14, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path14, options);
+      function ReadStream(path15, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path15, options);
         Stream.call(this);
         var self2 = this;
-        this.path = path14;
+        this.path = path15;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -48175,10 +48210,10 @@ var require_legacy_streams = __commonJS({
         });
       }
       __name(ReadStream, "ReadStream");
-      function WriteStream(path14, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path14, options);
+      function WriteStream(path15, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path15, options);
         Stream.call(this);
-        this.path = path14;
+        this.path = path15;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -48328,14 +48363,14 @@ var require_graceful_fs = __commonJS({
       fs10.createWriteStream = createWriteStream;
       var fs$readFile = fs10.readFile;
       fs10.readFile = readFile3;
-      function readFile3(path14, options, cb) {
+      function readFile3(path15, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path14, options, cb);
-        function go$readFile(path15, options2, cb2, startTime) {
-          return fs$readFile(path15, options2, function(err) {
+        return go$readFile(path15, options, cb);
+        function go$readFile(path16, options2, cb2, startTime) {
+          return fs$readFile(path16, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path15, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path16, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -48347,14 +48382,14 @@ var require_graceful_fs = __commonJS({
       __name(readFile3, "readFile");
       var fs$writeFile = fs10.writeFile;
       fs10.writeFile = writeFile2;
-      function writeFile2(path14, data, options, cb) {
+      function writeFile2(path15, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path14, data, options, cb);
-        function go$writeFile(path15, data2, options2, cb2, startTime) {
-          return fs$writeFile(path15, data2, options2, function(err) {
+        return go$writeFile(path15, data, options, cb);
+        function go$writeFile(path16, data2, options2, cb2, startTime) {
+          return fs$writeFile(path16, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path15, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path16, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -48367,14 +48402,14 @@ var require_graceful_fs = __commonJS({
       var fs$appendFile = fs10.appendFile;
       if (fs$appendFile)
         fs10.appendFile = appendFile;
-      function appendFile(path14, data, options, cb) {
+      function appendFile(path15, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path14, data, options, cb);
-        function go$appendFile(path15, data2, options2, cb2, startTime) {
-          return fs$appendFile(path15, data2, options2, function(err) {
+        return go$appendFile(path15, data, options, cb);
+        function go$appendFile(path16, data2, options2, cb2, startTime) {
+          return fs$appendFile(path16, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path15, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path16, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -48409,31 +48444,31 @@ var require_graceful_fs = __commonJS({
       var fs$readdir = fs10.readdir;
       fs10.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir2(path14, options, cb) {
+      function readdir2(path15, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? /* @__PURE__ */ __name(function go$readdir2(path15, options2, cb2, startTime) {
-          return fs$readdir(path15, fs$readdirCallback(
-            path15,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? /* @__PURE__ */ __name(function go$readdir2(path16, options2, cb2, startTime) {
+          return fs$readdir(path16, fs$readdirCallback(
+            path16,
             options2,
             cb2,
             startTime
           ));
-        }, "go$readdir") : /* @__PURE__ */ __name(function go$readdir2(path15, options2, cb2, startTime) {
-          return fs$readdir(path15, options2, fs$readdirCallback(
-            path15,
+        }, "go$readdir") : /* @__PURE__ */ __name(function go$readdir2(path16, options2, cb2, startTime) {
+          return fs$readdir(path16, options2, fs$readdirCallback(
+            path16,
             options2,
             cb2,
             startTime
           ));
         }, "go$readdir");
-        return go$readdir(path14, options, cb);
-        function fs$readdirCallback(path15, options2, cb2, startTime) {
+        return go$readdir(path15, options, cb);
+        function fs$readdirCallback(path16, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path15, options2, cb2],
+                [path16, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -48506,7 +48541,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path14, options) {
+      function ReadStream(path15, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -48528,7 +48563,7 @@ var require_graceful_fs = __commonJS({
         });
       }
       __name(ReadStream$open, "ReadStream$open");
-      function WriteStream(path14, options) {
+      function WriteStream(path15, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -48548,24 +48583,24 @@ var require_graceful_fs = __commonJS({
         });
       }
       __name(WriteStream$open, "WriteStream$open");
-      function createReadStream(path14, options) {
-        return new fs10.ReadStream(path14, options);
+      function createReadStream(path15, options) {
+        return new fs10.ReadStream(path15, options);
       }
       __name(createReadStream, "createReadStream");
-      function createWriteStream(path14, options) {
-        return new fs10.WriteStream(path14, options);
+      function createWriteStream(path15, options) {
+        return new fs10.WriteStream(path15, options);
       }
       __name(createWriteStream, "createWriteStream");
       var fs$open = fs10.open;
       fs10.open = open3;
-      function open3(path14, flags, mode, cb) {
+      function open3(path15, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path14, flags, mode, cb);
-        function go$open(path15, flags2, mode2, cb2, startTime) {
-          return fs$open(path15, flags2, mode2, function(err, fd) {
+        return go$open(path15, flags, mode, cb);
+        function go$open(path16, flags2, mode2, cb2, startTime) {
+          return fs$open(path16, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path15, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path16, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -49103,7 +49138,7 @@ var require_mtime_precision = __commonJS({
 var require_lockfile = __commonJS({
   "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
     "use strict";
-    var path14 = __require("path");
+    var path15 = __require("path");
     var fs9 = require_graceful_fs();
     var retry = require_retry3();
     var onExit = require_signal_exit();
@@ -49115,7 +49150,7 @@ var require_lockfile = __commonJS({
     __name(getLockFile, "getLockFile");
     function resolveCanonicalPath(file3, options, callback) {
       if (!options.realpath) {
-        return callback(null, path14.resolve(file3));
+        return callback(null, path15.resolve(file3));
       }
       options.fs.realpath(file3, callback);
     }
@@ -50204,8 +50239,550 @@ var init_hooks_storage = __esm({
   }
 });
 
-// ../world-local/dist/storage/run-status-signal.js
+// ../world-local/dist/streamer.js
 import { EventEmitter } from "node:events";
+import fs4 from "node:fs/promises";
+import path7 from "node:path";
+function isEofByte(byte) {
+  return byte === EOF_MARKER;
+}
+function serializeChunk(chunk) {
+  const eofByte = Buffer.from([chunk.eof ? EOF_MARKER : 0]);
+  return Buffer.concat([eofByte, chunk.chunk]);
+}
+function isEofChunk(serialized) {
+  return isEofByte(serialized[0]);
+}
+function deserializeChunk(serialized) {
+  const eof = isEofChunk(serialized);
+  const chunk = Buffer.from(serialized.subarray(1));
+  return { eof, chunk };
+}
+async function listChunkEntries(chunksDir) {
+  try {
+    return await fs4.readdir(chunksDir);
+  } catch (error95) {
+    if (error95.code === "ENOENT")
+      return [];
+    throw error95;
+  }
+}
+function addChunkFilesByExtension(extMap, entries, sourceExtension, fileExtension = sourceExtension, include = () => true) {
+  for (const entry of entries) {
+    if (!entry.endsWith(sourceExtension))
+      continue;
+    const file3 = entry.slice(0, -sourceExtension.length);
+    if (include(file3))
+      extMap.set(file3, fileExtension);
+  }
+}
+function chunkDirForStream(chunksBaseDir, name) {
+  assertSafeEntityId("streamName", name);
+  return path7.join(chunksBaseDir, name);
+}
+async function listChunkFilesForStream(chunksBaseDir, name, tag) {
+  const dir = chunkDirForStream(chunksBaseDir, name);
+  const entries = await listChunkEntries(dir);
+  const extMap = /* @__PURE__ */ new Map();
+  addChunkFilesByExtension(extMap, entries, ".json");
+  addChunkFilesByExtension(extMap, entries, ".bin", ".bin", tag ? (file3) => !file3.endsWith(`.${tag}`) : void 0);
+  if (tag) {
+    const taggedExtension = `.${tag}.bin`;
+    addChunkFilesByExtension(extMap, entries, taggedExtension);
+  }
+  const files = [...extMap.keys()].sort();
+  return { files, extMap, dir };
+}
+async function purgeRunStreamData(basedir, runId, tag) {
+  const chunksBaseDir = path7.join(basedir, "streams", "chunks");
+  const tagSuffix = tag ? `.${tag}` : "";
+  let names;
+  try {
+    assertSafeEntityId("runId", runId);
+    const mapping = await readJSONWithFallback(basedir, "streams/runs", runId, RunStreamsSchema, tag);
+    names = mapping?.streams ?? [];
+  } catch (error95) {
+    logStreamPurgeFailure(`streams of ${runId}`, error95);
+    return;
+  }
+  for (const name of names) {
+    try {
+      const dir = chunkDirForStream(chunksBaseDir, name);
+      await write(path7.join(dir, `${PURGED_STREAM_TOMBSTONE_ID}${tagSuffix}.bin`), serializeChunk({ chunk: Buffer.from([]), eof: true }), { overwrite: true });
+      for (const entry of await listChunkEntries(dir)) {
+        if (entry.startsWith(PURGED_STREAM_TOMBSTONE_ID))
+          continue;
+        if (!entry.endsWith(".bin") && !entry.endsWith(".json"))
+          continue;
+        await withWindowsRetry(() => fs4.unlink(path7.join(dir, entry))).catch((error95) => {
+          if (error95.code !== "ENOENT")
+            logStreamPurgeFailure(entry, error95);
+        });
+      }
+    } catch (error95) {
+      logStreamPurgeFailure(name, error95);
+    }
+  }
+}
+function logStreamPurgeFailure(target2, error95) {
+  console.warn(`[world-local] Failed to purge stream data for ${target2}:`, error95 instanceof Error ? error95.message : error95);
+}
+function createStreamer(basedir, tag) {
+  const tagSuffix = tag ? `.${tag}` : "";
+  const streamEmitter = new EventEmitter();
+  const registeredStreams = /* @__PURE__ */ new Set();
+  async function registerStreamForRun(runId, streamName) {
+    assertSafeEntityId("runId", runId);
+    assertSafeEntityId("streamName", streamName);
+    const cacheKey = `${runId}:${streamName}`;
+    if (registeredStreams.has(cacheKey)) {
+      return;
+    }
+    const runStreamsPath = taggedPath(basedir, "streams/runs", runId, tag);
+    const existing = await readJSONWithFallback(basedir, "streams/runs", runId, RunStreamsSchema, tag);
+    const streams = existing?.streams ?? [];
+    if (!streams.includes(streamName)) {
+      streams.push(streamName);
+      await writeJSON(runStreamsPath, { streams }, { overwrite: true });
+    }
+    registeredStreams.add(cacheKey);
+  }
+  __name(registerStreamForRun, "registerStreamForRun");
+  function toBuffer(chunk) {
+    if (typeof chunk === "string") {
+      return Buffer.from(new TextEncoder().encode(chunk));
+    } else if (chunk instanceof Buffer) {
+      return chunk;
+    } else {
+      return Buffer.from(chunk);
+    }
+  }
+  __name(toBuffer, "toBuffer");
+  return {
+    streams: {
+      async write(_runId, name, chunk) {
+        const chunkId = `chnk_${monotonicUlid2()}`;
+        const runId = await _runId;
+        await registerStreamForRun(runId, name);
+        const chunkBuffer = toBuffer(chunk);
+        const serialized = serializeChunk({
+          chunk: chunkBuffer,
+          eof: false
+        });
+        const chunkPath = path7.join(chunkDirForStream(path7.join(basedir, "streams", "chunks"), name), `${chunkId}${tagSuffix}.bin`);
+        await write(chunkPath, serialized);
+        const chunkData = Uint8Array.from(chunkBuffer);
+        streamEmitter.emit(`chunk:${name}`, {
+          streamName: name,
+          chunkData,
+          chunkId
+        });
+      },
+      async writeMulti(_runId, name, chunks) {
+        if (chunks.length === 0)
+          return;
+        const chunkIds2 = chunks.map(() => `chnk_${monotonicUlid2()}`);
+        const runId = await _runId;
+        await registerStreamForRun(runId, name);
+        const chunkBuffers = chunks.map((chunk) => toBuffer(chunk));
+        const writePromises = chunkBuffers.map(async (chunkBuffer, i) => {
+          const chunkId = chunkIds2[i];
+          const serialized = serializeChunk({
+            chunk: chunkBuffer,
+            eof: false
+          });
+          const chunkPath = path7.join(chunkDirForStream(path7.join(basedir, "streams", "chunks"), name), `${chunkId}${tagSuffix}.bin`);
+          await write(chunkPath, serialized);
+          return {
+            chunkId,
+            chunkData: Uint8Array.from(chunkBuffer)
+          };
+        });
+        for (const writePromise of writePromises) {
+          const { chunkId, chunkData } = await writePromise;
+          streamEmitter.emit(`chunk:${name}`, {
+            streamName: name,
+            chunkData,
+            chunkId
+          });
+        }
+      },
+      async close(_runId, name) {
+        const chunkId = `chnk_${monotonicUlid2()}`;
+        const runId = await _runId;
+        await registerStreamForRun(runId, name);
+        const chunkPath = path7.join(chunkDirForStream(path7.join(basedir, "streams", "chunks"), name), `${chunkId}${tagSuffix}.bin`);
+        await write(chunkPath, serializeChunk({ chunk: Buffer.from([]), eof: true }));
+        streamEmitter.emit(`close:${name}`, { streamName: name });
+      },
+      async list(runId) {
+        assertSafeEntityId("runId", runId);
+        const data = await readJSONWithFallback(basedir, "streams/runs", runId, RunStreamsSchema, tag);
+        return data?.streams ?? [];
+      },
+      async getChunks(_runId, name, options) {
+        const limit = options?.limit ?? 100;
+        const chunksBaseDir = path7.join(basedir, "streams", "chunks");
+        const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name, tag);
+        let startIndex = 0;
+        if (options?.cursor) {
+          try {
+            const decoded = JSON.parse(Buffer.from(options.cursor, "base64").toString("utf-8"));
+            startIndex = decoded.i;
+          } catch {
+            startIndex = 0;
+          }
+        }
+        let streamDone = false;
+        const resultChunks = [];
+        let dataIndex = 0;
+        for (const file3 of chunkFiles) {
+          const ext2 = fileExtMap.get(file3) ?? ".bin";
+          const filePath = path7.join(chunksDir, `${file3}${ext2}`);
+          if (dataIndex < startIndex) {
+            if (isEofByte(await readFirstByte(filePath))) {
+              streamDone = true;
+              break;
+            }
+            dataIndex++;
+            continue;
+          }
+          if (resultChunks.length >= limit) {
+            if (isEofByte(await readFirstByte(filePath))) {
+              streamDone = true;
+            } else {
+              dataIndex++;
+            }
+            break;
+          }
+          const chunk = deserializeChunk(await readBuffer(filePath));
+          if (chunk.eof) {
+            streamDone = true;
+            break;
+          }
+          resultChunks.push({
+            index: dataIndex,
+            data: Uint8Array.from(chunk.chunk)
+          });
+          dataIndex++;
+        }
+        const hasMore = !streamDone && dataIndex > startIndex + resultChunks.length;
+        const nextIndex = startIndex + resultChunks.length;
+        const nextCursor = hasMore ? Buffer.from(JSON.stringify({ i: nextIndex })).toString("base64") : null;
+        return {
+          data: resultChunks,
+          cursor: nextCursor,
+          hasMore,
+          done: streamDone
+        };
+      },
+      async getInfo(_runId, name) {
+        const chunksBaseDir = path7.join(basedir, "streams", "chunks");
+        const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name, tag);
+        let streamDone = false;
+        let dataCount = 0;
+        for (const file3 of chunkFiles) {
+          const ext2 = fileExtMap.get(file3) ?? ".bin";
+          if (isEofByte(await readFirstByte(path7.join(chunksDir, `${file3}${ext2}`)))) {
+            streamDone = true;
+            break;
+          }
+          dataCount++;
+        }
+        return { tailIndex: dataCount - 1, done: streamDone };
+      },
+      async get(_runId, name, startIndex = 0) {
+        const chunksBaseDir = path7.join(basedir, "streams", "chunks");
+        let teardown = /* @__PURE__ */ __name(() => {
+        }, "teardown");
+        let pollInterval = null;
+        let streamClosed = false;
+        return new ReadableStream({
+          async start(controller) {
+            const deliveredChunkIds = /* @__PURE__ */ new Set();
+            const bufferedEventChunks = [];
+            let isReadingFromDisk = true;
+            let pendingClose = false;
+            const chunkListener = /* @__PURE__ */ __name((event) => {
+              if (event.chunkData.byteLength === 0) {
+                deliveredChunkIds.add(event.chunkId);
+                return;
+              }
+              if (isReadingFromDisk) {
+                deliveredChunkIds.add(event.chunkId);
+                bufferedEventChunks.push({
+                  chunkId: event.chunkId,
+                  chunkData: Uint8Array.from(event.chunkData)
+                });
+              } else if (!deliveredChunkIds.has(event.chunkId)) {
+                deliveredChunkIds.add(event.chunkId);
+                controller.enqueue(Uint8Array.from(event.chunkData));
+              }
+            }, "chunkListener");
+            const closeListener = /* @__PURE__ */ __name(() => {
+              if (isReadingFromDisk) {
+                pendingClose = true;
+                return;
+              }
+              streamClosed = true;
+              teardown();
+              try {
+                controller.close();
+              } catch {
+              }
+            }, "closeListener");
+            teardown = /* @__PURE__ */ __name(() => {
+              streamEmitter.off(`chunk:${name}`, chunkListener);
+              streamEmitter.off(`close:${name}`, closeListener);
+              if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+              }
+            }, "teardown");
+            streamEmitter.on(`chunk:${name}`, chunkListener);
+            streamEmitter.on(`close:${name}`, closeListener);
+            const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name, tag);
+            let dataChunkCount = chunkFiles.length;
+            if (typeof startIndex === "number" && startIndex < 0 && chunkFiles.length > 0) {
+              const lastFile = chunkFiles[chunkFiles.length - 1];
+              const lastExt = fileExtMap.get(lastFile) ?? ".bin";
+              if (isEofByte(await readFirstByte(path7.join(chunksDir, `${lastFile}${lastExt}`)))) {
+                dataChunkCount--;
+              }
+            }
+            const resolvedStartIndex = typeof startIndex === "number" && startIndex < 0 ? Math.max(0, dataChunkCount + startIndex) : startIndex;
+            let isComplete = false;
+            for (let i = resolvedStartIndex; i < chunkFiles.length; i++) {
+              const file3 = chunkFiles[i];
+              const chunkId = file3;
+              if (deliveredChunkIds.has(chunkId)) {
+                continue;
+              }
+              const ext2 = fileExtMap.get(file3) ?? ".bin";
+              const chunk = deserializeChunk(await readBuffer(path7.join(chunksDir, `${file3}${ext2}`)));
+              if (chunk?.eof === true) {
+                isComplete = true;
+                break;
+              }
+              deliveredChunkIds.add(chunkId);
+              if (chunk.chunk.byteLength) {
+                controller.enqueue(Uint8Array.from(chunk.chunk));
+              }
+            }
+            isReadingFromDisk = false;
+            bufferedEventChunks.sort((a, b) => a.chunkId.localeCompare(b.chunkId));
+            for (const buffered of bufferedEventChunks) {
+              controller.enqueue(Uint8Array.from(buffered.chunkData));
+            }
+            if (isComplete) {
+              streamClosed = true;
+              teardown();
+              try {
+                controller.close();
+              } catch {
+              }
+              return;
+            }
+            if (pendingClose) {
+              streamClosed = true;
+              teardown();
+              try {
+                controller.close();
+              } catch {
+              }
+              return;
+            }
+            for (let i = 0; i < resolvedStartIndex && i < chunkFiles.length; i++) {
+              deliveredChunkIds.add(chunkFiles[i]);
+            }
+            if (streamClosed) {
+              teardown();
+              return;
+            }
+            let isPolling = false;
+            pollInterval = setInterval(async () => {
+              if (isPolling)
+                return;
+              isPolling = true;
+              try {
+                const { files: currentFiles, extMap: currentExtMap } = await listChunkFilesForStream(chunksBaseDir, name, tag);
+                for (const file3 of currentFiles) {
+                  const chunkId = file3;
+                  if (deliveredChunkIds.has(chunkId))
+                    continue;
+                  deliveredChunkIds.add(chunkId);
+                  const ext2 = currentExtMap.get(file3) ?? ".bin";
+                  const chunk = deserializeChunk(await readBuffer(path7.join(chunksDir, `${file3}${ext2}`)));
+                  if (chunk?.eof === true) {
+                    streamClosed = true;
+                    teardown();
+                    try {
+                      controller.close();
+                    } catch {
+                    }
+                    return;
+                  }
+                  if (streamClosed)
+                    return;
+                  if (chunk.chunk.byteLength) {
+                    controller.enqueue(Uint8Array.from(chunk.chunk));
+                  }
+                }
+              } catch (err) {
+                if (!(err instanceof Error && "code" in err)) {
+                  console.error("[world-local] Unexpected polling error:", err);
+                }
+              } finally {
+                isPolling = false;
+              }
+            }, 100);
+          },
+          cancel() {
+            streamClosed = true;
+            teardown();
+          }
+        });
+      }
+    }
+  };
+}
+var chunkIds, monotonicUlid2, RunStreamsSchema, EOF_MARKER, PURGED_STREAM_TOMBSTONE_ID;
+var init_streamer = __esm({
+  "../world-local/dist/streamer.js"() {
+    "use strict";
+    init_dist5();
+    init_node2();
+    init_zod2();
+    init_fs();
+    chunkIds = globalSingleton2("@workflow/world-local//streamerMonotonicUlid", 1, () => ({ next: monotonicFactory2(() => Math.random()) }));
+    monotonicUlid2 = /* @__PURE__ */ __name((seedTime) => chunkIds.next(seedTime), "monotonicUlid");
+    RunStreamsSchema = external_exports2.object({
+      streams: external_exports2.array(external_exports2.string())
+    });
+    EOF_MARKER = 1;
+    __name(isEofByte, "isEofByte");
+    __name(serializeChunk, "serializeChunk");
+    __name(isEofChunk, "isEofChunk");
+    __name(deserializeChunk, "deserializeChunk");
+    __name(listChunkEntries, "listChunkEntries");
+    __name(addChunkFilesByExtension, "addChunkFilesByExtension");
+    __name(chunkDirForStream, "chunkDirForStream");
+    __name(listChunkFilesForStream, "listChunkFilesForStream");
+    PURGED_STREAM_TOMBSTONE_ID = `chnk_${"0".repeat(26)}`;
+    __name(purgeRunStreamData, "purgeRunStreamData");
+    __name(logStreamPurgeFailure, "logStreamPurgeFailure");
+    __name(createStreamer, "createStreamer");
+  }
+});
+
+// ../world-local/dist/storage/run-retention.js
+import path8 from "node:path";
+function purgesUserDataOnFinish2(attributes) {
+  const retention = readRunRetention(attributes);
+  if (retention.unsupported) {
+    console.warn(`[world-local] Ignoring unrecognized ${RETENTION_ATTRIBUTE2} value ${JSON.stringify(retention.raw)}; keeping the run's data.`);
+  }
+  return retention.mode === "none";
+}
+function withRunPayloadsPurged(run3, purgedAt) {
+  return {
+    ...run3,
+    input: void 0,
+    output: void 0,
+    error: void 0,
+    expiredAt: purgedAt
+  };
+}
+async function purgeRunEntityData(basedir, runId, tag) {
+  await Promise.all([
+    scrubEntityFiles(path8.join(basedir, "steps"), runId, (step) => {
+      step.input = void 0;
+      step.output = void 0;
+      step.error = void 0;
+    }),
+    scrubEntityFiles(path8.join(basedir, "events"), runId, (event) => {
+      const eventData = event.eventData;
+      if (!eventData || typeof eventData !== "object")
+        return;
+      for (const field of getEventDataRefFields(String(event.eventType))) {
+        delete eventData[field];
+      }
+    }),
+    scrubHookMetadata(basedir, runId),
+    purgeRunStreamData(basedir, runId, tag)
+  ]);
+}
+async function scrubEntityFiles(directory, runId, scrub) {
+  let fileIds;
+  try {
+    fileIds = await listJSONFiles(directory);
+  } catch (error95) {
+    logPurgeFailure(directory, error95);
+    return;
+  }
+  for (const fileId of fileIds) {
+    if (!fileId.startsWith(`${runId}-`))
+      continue;
+    const filePath = path8.join(directory, `${fileId}.json`);
+    try {
+      const raw = await readJSON(filePath, RawEntitySchema);
+      if (!raw)
+        continue;
+      scrub(raw);
+      await writeJSON(filePath, raw, { overwrite: true });
+    } catch (error95) {
+      logPurgeFailure(filePath, error95);
+    }
+  }
+}
+async function scrubHookMetadata(basedir, runId) {
+  let markers;
+  try {
+    await ensureHookIndexes(basedir);
+    markers = await listHookByRunMarkers(basedir, runId);
+  } catch (error95) {
+    logPurgeFailure(`hooks of ${runId}`, error95);
+    return;
+  }
+  for (const marker of markers) {
+    if (!marker.hookId)
+      continue;
+    try {
+      const hookPath = taggedPath(basedir, "hooks", marker.hookId, marker.tag);
+      const hook = await readJSON(hookPath, RawEntitySchema);
+      if (!hook || hook.runId !== runId)
+        continue;
+      hook.metadata = void 0;
+      await writeJSON(hookPath, hook, { overwrite: true });
+    } catch (error95) {
+      logPurgeFailure(marker.hookId, error95);
+    }
+  }
+}
+function logPurgeFailure(target2, error95) {
+  console.warn(`[world-local] Failed to purge user data for ${target2}:`, error95 instanceof Error ? error95.message : error95);
+}
+var RawEntitySchema;
+var init_run_retention = __esm({
+  "../world-local/dist/storage/run-retention.js"() {
+    "use strict";
+    init_dist6();
+    init_zod2();
+    init_fs();
+    init_streamer();
+    init_hook_index();
+    __name(purgesUserDataOnFinish2, "purgesUserDataOnFinish");
+    __name(withRunPayloadsPurged, "withRunPayloadsPurged");
+    __name(purgeRunEntityData, "purgeRunEntityData");
+    RawEntitySchema = external_exports2.record(external_exports2.string(), external_exports2.any());
+    __name(scrubEntityFiles, "scrubEntityFiles");
+    __name(scrubHookMetadata, "scrubHookMetadata");
+    __name(logPurgeFailure, "logPurgeFailure");
+  }
+});
+
+// ../world-local/dist/storage/run-status-signal.js
+import { EventEmitter as EventEmitter2 } from "node:events";
 function getRunStatusPollIntervalMs() {
   return envNumber2("WORKFLOW_LOCAL_RUN_STATUS_POLL_INTERVAL_MS", RUN_STATUS_POLL_INTERVAL_MS, { integer: true, min: 1 });
 }
@@ -50237,7 +50814,7 @@ var init_run_status_signal = __esm({
   "../world-local/dist/storage/run-status-signal.js"() {
     "use strict";
     init_dist6();
-    emitter = new EventEmitter();
+    emitter = new EventEmitter2();
     emitter.setMaxListeners(0);
     RUN_STATUS_POLL_INTERVAL_MS = 100;
     __name(getRunStatusPollIntervalMs, "getRunStatusPollIntervalMs");
@@ -50247,7 +50824,7 @@ var init_run_status_signal = __esm({
 });
 
 // ../world-local/dist/storage/legacy.js
-import fs4 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 async function publishLegacyHookReceived(basedir, runId, eventId, serializedEvent, eventPath, currentRun) {
   if (isTerminalWorkflowRunStatus2(currentRun.status) || await isRunTerminalCommitted(basedir, runId)) {
     throw new RunExpiredError2(`Workflow run "${runId}" is already in a terminal state`);
@@ -50263,7 +50840,7 @@ async function publishLegacyHookReceived(basedir, runId, eventId, serializedEven
       throw new RunExpiredError2(`Workflow run "${runId}" is already in a terminal state`);
     }
   } finally {
-    await fs4.unlink(stagedPath).catch(() => {
+    await fs5.unlink(stagedPath).catch(() => {
     });
   }
 }
@@ -50292,13 +50869,18 @@ async function handleLegacyEvent(basedir, runId, data, currentRun, params) {
         updatedAt: now,
         attributes: currentRun.attributes
       };
+      const purged = purgesUserDataOnFinish2(run3.attributes);
+      const stored = purged ? withRunPayloadsPurged(run3, now) : run3;
       const runPath = resolveWithinBase(basedir, "runs", `${runId}.json`);
-      await writeJSON(runPath, run3, { overwrite: true });
+      await writeJSON(runPath, stored, { overwrite: true });
       signalRunTerminal(runId);
       await deleteAllHooksForRun(basedir, runId);
+      if (purged) {
+        await purgeRunEntityData(basedir, runId, void 0);
+      }
       return {
         event: void 0,
-        run: filterRunData(run3, resolveData)
+        run: filterRunData(stored, resolveData)
       };
     }
     case "wait_completed":
@@ -50335,6 +50917,7 @@ var init_legacy = __esm({
     init_filters();
     init_helpers2();
     init_hooks_storage();
+    init_run_retention();
     init_run_status_signal();
     __name(publishLegacyHookReceived, "publishLegacyHookReceived");
     __name(handleLegacyEvent, "handleLegacyEvent");
@@ -50342,7 +50925,7 @@ var init_legacy = __esm({
 });
 
 // ../world-local/dist/storage/runs-storage.js
-import path7 from "node:path";
+import path9 from "node:path";
 function withRunFileLock(key, fn) {
   const prev = runLocks.byKey.get(key);
   const taskBox = {};
@@ -50413,7 +50996,7 @@ function createRunsStorage(basedir, tag) {
     list: /* @__PURE__ */ __name((async (params) => {
       const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
       const result2 = await paginatedFileSystemQuery({
-        directory: path7.join(basedir, "runs"),
+        directory: path9.join(basedir, "runs"),
         schema: WorkflowRunSchema2,
         fileIdFilter: params?.fileIdFilter,
         filter: /* @__PURE__ */ __name((run3) => {
@@ -50498,8 +51081,8 @@ var init_runs_storage = __esm({
 
 // ../world-local/dist/storage/events-storage.js
 import assert3 from "node:assert";
-import fs5 from "node:fs/promises";
-import path8 from "node:path";
+import fs6 from "node:fs/promises";
+import path10 from "node:path";
 function getHookRetentionLimitMs() {
   const days = Number(process.env.WORKFLOW_LOCAL_HOOK_RETENTION_LIMIT_DAYS ?? 30);
   if (!Number.isFinite(days) || days <= 0) {
@@ -50555,7 +51138,7 @@ function eventSortKeyFromFileId(runId, fileId) {
 }
 async function findExistingHookCreatedEventId(basedir, runId, correlationId) {
   const result2 = await paginatedFileSystemQuery({
-    directory: path8.join(basedir, "events"),
+    directory: path10.join(basedir, "events"),
     schema: EventSchema2,
     filePrefix: `${runId}-`,
     filter: /* @__PURE__ */ __name((event) => event.eventType === "hook_created" && event.correlationId === correlationId, "filter"),
@@ -50610,11 +51193,11 @@ function withInProcessLock(locks, key, fn) {
   return task;
 }
 async function deleteAllWaitsForRun(basedir, runId) {
-  const waitsDir = path8.join(basedir, "waits");
+  const waitsDir = path10.join(basedir, "waits");
   const files = await listJSONFiles(waitsDir);
   for (const file3 of files) {
     if (file3.startsWith(`${runId}-`)) {
-      const waitPath = path8.join(waitsDir, `${file3}.json`);
+      const waitPath = path10.join(waitsDir, `${file3}.json`);
       await deleteJSON(waitPath);
     }
   }
@@ -50622,17 +51205,19 @@ async function deleteAllWaitsForRun(basedir, runId) {
 async function writeRunUnderLifecycleLock(basedir, runId, tag, proposed) {
   return withRunFileLock(runId, async () => {
     const fresh = await readJSON(taggedPath(basedir, "runs", runId, tag), WorkflowRunSchema2);
-    const next2 = {
-      ...proposed,
-      attributes: fresh?.attributes ?? proposed.attributes
-    };
+    const attributes = fresh?.attributes ?? proposed.attributes;
+    let next2 = { ...proposed, attributes };
+    const purged = isTerminalWorkflowRunStatus2(next2.status) && purgesUserDataOnFinish2(attributes);
+    if (purged) {
+      next2 = withRunPayloadsPurged(next2, /* @__PURE__ */ new Date());
+    }
     await writeJSON(taggedPath(basedir, "runs", runId, tag), next2, {
       overwrite: true
     });
     if (isTerminalWorkflowRunStatus2(next2.status)) {
       signalRunTerminal(runId);
     }
-    return next2;
+    return { run: next2, purged };
   });
 }
 function createEventsStorage(basedir, tag) {
@@ -50684,7 +51269,7 @@ function createEventsStorage(basedir, tag) {
       taggedPath(basedir, "events", fileId)
     ] : [taggedPath(basedir, "events", fileId)]) {
       try {
-        await fs5.stat(candidate);
+        await fs6.stat(candidate);
         return true;
       } catch (error95) {
         if (error95.code !== "ENOENT") {
@@ -50799,7 +51384,7 @@ function createEventsStorage(basedir, tag) {
   }
   __name(storeEvent, "storeEvent");
   const queryRunEvents = /* @__PURE__ */ __name((runId, pagination) => paginatedFileSystemQuery({
-    directory: path8.join(basedir, "events"),
+    directory: path10.join(basedir, "events"),
     schema: EventSchema2,
     cachedItems: eventCache,
     filePrefix: `${runId}-`,
@@ -51071,6 +51656,7 @@ function createEventsStorage(basedir, tag) {
           event = { ...event, eventData };
         }
         let run3;
+        let runPurged = false;
         let step;
         let hook;
         let wait;
@@ -51134,7 +51720,7 @@ function createEventsStorage(basedir, tag) {
                 maxEvents: getMaxEventsPerRun()
               };
             }
-            run3 = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
+            const written = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
               runId: currentRun.runId,
               deploymentId: currentRun.deploymentId,
               workflowName: currentRun.workflowName,
@@ -51152,11 +51738,13 @@ function createEventsStorage(basedir, tag) {
               attributes: currentRun.attributes,
               encryptionPublicKey: currentRun.encryptionPublicKey
             });
+            run3 = written.run;
+            runPurged = written.purged;
           }
         } else if (data.eventType === "run_completed" && "eventData" in data) {
           const completedData = data.eventData;
           if (currentRun) {
-            run3 = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
+            const written = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
               runId: currentRun.runId,
               deploymentId: currentRun.deploymentId,
               workflowName: currentRun.workflowName,
@@ -51174,6 +51762,8 @@ function createEventsStorage(basedir, tag) {
               attributes: currentRun.attributes,
               encryptionPublicKey: currentRun.encryptionPublicKey
             });
+            run3 = written.run;
+            runPurged = written.purged;
             await Promise.all([
               deleteAllHooksForRun(basedir, effectiveRunId),
               deleteAllWaitsForRun(basedir, effectiveRunId)
@@ -51182,7 +51772,7 @@ function createEventsStorage(basedir, tag) {
         } else if (data.eventType === "run_failed" && "eventData" in data) {
           const failedData = data.eventData;
           if (currentRun) {
-            run3 = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
+            const written = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
               runId: currentRun.runId,
               deploymentId: currentRun.deploymentId,
               workflowName: currentRun.workflowName,
@@ -51201,6 +51791,8 @@ function createEventsStorage(basedir, tag) {
               attributes: currentRun.attributes,
               encryptionPublicKey: currentRun.encryptionPublicKey
             });
+            run3 = written.run;
+            runPurged = written.purged;
             await Promise.all([
               deleteAllHooksForRun(basedir, effectiveRunId),
               deleteAllWaitsForRun(basedir, effectiveRunId)
@@ -51208,7 +51800,7 @@ function createEventsStorage(basedir, tag) {
           }
         } else if (data.eventType === "run_cancelled") {
           if (currentRun) {
-            run3 = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
+            const written = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
               runId: currentRun.runId,
               deploymentId: currentRun.deploymentId,
               workflowName: currentRun.workflowName,
@@ -51226,6 +51818,8 @@ function createEventsStorage(basedir, tag) {
               attributes: currentRun.attributes,
               encryptionPublicKey: currentRun.encryptionPublicKey
             });
+            run3 = written.run;
+            runPurged = written.purged;
             await Promise.all([
               deleteAllHooksForRun(basedir, effectiveRunId),
               deleteAllWaitsForRun(basedir, effectiveRunId)
@@ -51578,7 +52172,7 @@ function createEventsStorage(basedir, tag) {
           }
           const existingWait = await readJSONWithFallback(basedir, "waits", waitCompositeKey, WaitSchema2, tag);
           if (!existingWait) {
-            await fs5.unlink(lockPath).catch(() => {
+            await fs6.unlink(lockPath).catch(() => {
             });
             throw new WorkflowWorldError2(`Wait "${data.correlationId}" not found`);
           }
@@ -51681,6 +52275,10 @@ function createEventsStorage(basedir, tag) {
           await writeHookByRunMarker(basedir, hook.runId, hook.hookId, tag);
           await writeJSON(taggedPath(basedir, "hooks", hook.hookId, tag), hook, hookEntityWriteOptions);
         }
+        if (runPurged) {
+          await purgeRunEntityData(basedir, effectiveRunId, tag);
+          clearRunCache(effectiveRunId);
+        }
         const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
         const filteredEvent = stripEventDataRefs(event, resolveData);
         let eventPage;
@@ -51753,7 +52351,7 @@ function createEventsStorage(basedir, tag) {
       assertSafeEntityId("runId", params.runId);
       const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
       const result2 = await paginatedFileSystemQuery({
-        directory: path8.join(basedir, "events"),
+        directory: path10.join(basedir, "events"),
         schema: EventSchema2,
         cachedItems: eventCache,
         // Scoped to the run's own event files, since a correlation id
@@ -51839,6 +52437,7 @@ var init_events_storage = __esm({
     init_hook_index();
     init_hooks_storage();
     init_legacy();
+    init_run_retention();
     init_run_status_signal();
     init_runs_storage();
     DAY_MS = 24 * 60 * 60 * 1e3;
@@ -51871,7 +52470,7 @@ var init_events_storage = __esm({
 });
 
 // ../world-local/dist/storage/steps-storage.js
-import path9 from "node:path";
+import path11 from "node:path";
 function createStepsStorage(basedir, tag) {
   return {
     get: /* @__PURE__ */ __name((async (runId, stepId, params) => {
@@ -51889,7 +52488,7 @@ function createStepsStorage(basedir, tag) {
       assertSafeEntityId("runId", params.runId);
       const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
       const result2 = await paginatedFileSystemQuery({
-        directory: path9.join(basedir, "steps"),
+        directory: path11.join(basedir, "steps"),
         schema: StepSchema2,
         filePrefix: `${params.runId}-`,
         sortOrder: params.pagination?.sortOrder ?? "desc",
@@ -51958,409 +52557,10 @@ var init_storage2 = __esm({
   }
 });
 
-// ../world-local/dist/streamer.js
-import { EventEmitter as EventEmitter2 } from "node:events";
-import fs6 from "node:fs/promises";
-import path10 from "node:path";
-function isEofByte(byte) {
-  return byte === EOF_MARKER;
-}
-function serializeChunk(chunk) {
-  const eofByte = Buffer.from([chunk.eof ? EOF_MARKER : 0]);
-  return Buffer.concat([eofByte, chunk.chunk]);
-}
-function isEofChunk(serialized) {
-  return isEofByte(serialized[0]);
-}
-function deserializeChunk(serialized) {
-  const eof = isEofChunk(serialized);
-  const chunk = Buffer.from(serialized.subarray(1));
-  return { eof, chunk };
-}
-async function listChunkEntries(chunksDir) {
-  try {
-    return await fs6.readdir(chunksDir);
-  } catch (error95) {
-    if (error95.code === "ENOENT")
-      return [];
-    throw error95;
-  }
-}
-function addChunkFilesByExtension(extMap, entries, sourceExtension, fileExtension = sourceExtension, include = () => true) {
-  for (const entry of entries) {
-    if (!entry.endsWith(sourceExtension))
-      continue;
-    const file3 = entry.slice(0, -sourceExtension.length);
-    if (include(file3))
-      extMap.set(file3, fileExtension);
-  }
-}
-function chunkDirForStream(chunksBaseDir, name) {
-  assertSafeEntityId("streamName", name);
-  return path10.join(chunksBaseDir, name);
-}
-async function listChunkFilesForStream(chunksBaseDir, name, tag) {
-  const dir = chunkDirForStream(chunksBaseDir, name);
-  const entries = await listChunkEntries(dir);
-  const extMap = /* @__PURE__ */ new Map();
-  addChunkFilesByExtension(extMap, entries, ".json");
-  addChunkFilesByExtension(extMap, entries, ".bin", ".bin", tag ? (file3) => !file3.endsWith(`.${tag}`) : void 0);
-  if (tag) {
-    const taggedExtension = `.${tag}.bin`;
-    addChunkFilesByExtension(extMap, entries, taggedExtension);
-  }
-  const files = [...extMap.keys()].sort();
-  return { files, extMap, dir };
-}
-function createStreamer(basedir, tag) {
-  const tagSuffix = tag ? `.${tag}` : "";
-  const streamEmitter = new EventEmitter2();
-  const registeredStreams = /* @__PURE__ */ new Set();
-  async function registerStreamForRun(runId, streamName) {
-    assertSafeEntityId("runId", runId);
-    assertSafeEntityId("streamName", streamName);
-    const cacheKey = `${runId}:${streamName}`;
-    if (registeredStreams.has(cacheKey)) {
-      return;
-    }
-    const runStreamsPath = taggedPath(basedir, "streams/runs", runId, tag);
-    const existing = await readJSONWithFallback(basedir, "streams/runs", runId, RunStreamsSchema, tag);
-    const streams = existing?.streams ?? [];
-    if (!streams.includes(streamName)) {
-      streams.push(streamName);
-      await writeJSON(runStreamsPath, { streams }, { overwrite: true });
-    }
-    registeredStreams.add(cacheKey);
-  }
-  __name(registerStreamForRun, "registerStreamForRun");
-  function toBuffer(chunk) {
-    if (typeof chunk === "string") {
-      return Buffer.from(new TextEncoder().encode(chunk));
-    } else if (chunk instanceof Buffer) {
-      return chunk;
-    } else {
-      return Buffer.from(chunk);
-    }
-  }
-  __name(toBuffer, "toBuffer");
-  return {
-    streams: {
-      async write(_runId, name, chunk) {
-        const chunkId = `chnk_${monotonicUlid2()}`;
-        const runId = await _runId;
-        await registerStreamForRun(runId, name);
-        const chunkBuffer = toBuffer(chunk);
-        const serialized = serializeChunk({
-          chunk: chunkBuffer,
-          eof: false
-        });
-        const chunkPath = path10.join(chunkDirForStream(path10.join(basedir, "streams", "chunks"), name), `${chunkId}${tagSuffix}.bin`);
-        await write(chunkPath, serialized);
-        const chunkData = Uint8Array.from(chunkBuffer);
-        streamEmitter.emit(`chunk:${name}`, {
-          streamName: name,
-          chunkData,
-          chunkId
-        });
-      },
-      async writeMulti(_runId, name, chunks) {
-        if (chunks.length === 0)
-          return;
-        const chunkIds2 = chunks.map(() => `chnk_${monotonicUlid2()}`);
-        const runId = await _runId;
-        await registerStreamForRun(runId, name);
-        const chunkBuffers = chunks.map((chunk) => toBuffer(chunk));
-        const writePromises = chunkBuffers.map(async (chunkBuffer, i) => {
-          const chunkId = chunkIds2[i];
-          const serialized = serializeChunk({
-            chunk: chunkBuffer,
-            eof: false
-          });
-          const chunkPath = path10.join(chunkDirForStream(path10.join(basedir, "streams", "chunks"), name), `${chunkId}${tagSuffix}.bin`);
-          await write(chunkPath, serialized);
-          return {
-            chunkId,
-            chunkData: Uint8Array.from(chunkBuffer)
-          };
-        });
-        for (const writePromise of writePromises) {
-          const { chunkId, chunkData } = await writePromise;
-          streamEmitter.emit(`chunk:${name}`, {
-            streamName: name,
-            chunkData,
-            chunkId
-          });
-        }
-      },
-      async close(_runId, name) {
-        const chunkId = `chnk_${monotonicUlid2()}`;
-        const runId = await _runId;
-        await registerStreamForRun(runId, name);
-        const chunkPath = path10.join(chunkDirForStream(path10.join(basedir, "streams", "chunks"), name), `${chunkId}${tagSuffix}.bin`);
-        await write(chunkPath, serializeChunk({ chunk: Buffer.from([]), eof: true }));
-        streamEmitter.emit(`close:${name}`, { streamName: name });
-      },
-      async list(runId) {
-        assertSafeEntityId("runId", runId);
-        const data = await readJSONWithFallback(basedir, "streams/runs", runId, RunStreamsSchema, tag);
-        return data?.streams ?? [];
-      },
-      async getChunks(_runId, name, options) {
-        const limit = options?.limit ?? 100;
-        const chunksBaseDir = path10.join(basedir, "streams", "chunks");
-        const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name, tag);
-        let startIndex = 0;
-        if (options?.cursor) {
-          try {
-            const decoded = JSON.parse(Buffer.from(options.cursor, "base64").toString("utf-8"));
-            startIndex = decoded.i;
-          } catch {
-            startIndex = 0;
-          }
-        }
-        let streamDone = false;
-        const resultChunks = [];
-        let dataIndex = 0;
-        for (const file3 of chunkFiles) {
-          const ext2 = fileExtMap.get(file3) ?? ".bin";
-          const filePath = path10.join(chunksDir, `${file3}${ext2}`);
-          if (dataIndex < startIndex) {
-            if (isEofByte(await readFirstByte(filePath))) {
-              streamDone = true;
-              break;
-            }
-            dataIndex++;
-            continue;
-          }
-          if (resultChunks.length >= limit) {
-            if (isEofByte(await readFirstByte(filePath))) {
-              streamDone = true;
-            } else {
-              dataIndex++;
-            }
-            break;
-          }
-          const chunk = deserializeChunk(await readBuffer(filePath));
-          if (chunk.eof) {
-            streamDone = true;
-            break;
-          }
-          resultChunks.push({
-            index: dataIndex,
-            data: Uint8Array.from(chunk.chunk)
-          });
-          dataIndex++;
-        }
-        const hasMore = !streamDone && dataIndex > startIndex + resultChunks.length;
-        const nextIndex = startIndex + resultChunks.length;
-        const nextCursor = hasMore ? Buffer.from(JSON.stringify({ i: nextIndex })).toString("base64") : null;
-        return {
-          data: resultChunks,
-          cursor: nextCursor,
-          hasMore,
-          done: streamDone
-        };
-      },
-      async getInfo(_runId, name) {
-        const chunksBaseDir = path10.join(basedir, "streams", "chunks");
-        const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name, tag);
-        let streamDone = false;
-        let dataCount = 0;
-        for (const file3 of chunkFiles) {
-          const ext2 = fileExtMap.get(file3) ?? ".bin";
-          if (isEofByte(await readFirstByte(path10.join(chunksDir, `${file3}${ext2}`)))) {
-            streamDone = true;
-            break;
-          }
-          dataCount++;
-        }
-        return { tailIndex: dataCount - 1, done: streamDone };
-      },
-      async get(_runId, name, startIndex = 0) {
-        const chunksBaseDir = path10.join(basedir, "streams", "chunks");
-        let teardown = /* @__PURE__ */ __name(() => {
-        }, "teardown");
-        let pollInterval = null;
-        let streamClosed = false;
-        return new ReadableStream({
-          async start(controller) {
-            const deliveredChunkIds = /* @__PURE__ */ new Set();
-            const bufferedEventChunks = [];
-            let isReadingFromDisk = true;
-            let pendingClose = false;
-            const chunkListener = /* @__PURE__ */ __name((event) => {
-              if (event.chunkData.byteLength === 0) {
-                deliveredChunkIds.add(event.chunkId);
-                return;
-              }
-              if (isReadingFromDisk) {
-                deliveredChunkIds.add(event.chunkId);
-                bufferedEventChunks.push({
-                  chunkId: event.chunkId,
-                  chunkData: Uint8Array.from(event.chunkData)
-                });
-              } else if (!deliveredChunkIds.has(event.chunkId)) {
-                deliveredChunkIds.add(event.chunkId);
-                controller.enqueue(Uint8Array.from(event.chunkData));
-              }
-            }, "chunkListener");
-            const closeListener = /* @__PURE__ */ __name(() => {
-              if (isReadingFromDisk) {
-                pendingClose = true;
-                return;
-              }
-              streamClosed = true;
-              teardown();
-              try {
-                controller.close();
-              } catch {
-              }
-            }, "closeListener");
-            teardown = /* @__PURE__ */ __name(() => {
-              streamEmitter.off(`chunk:${name}`, chunkListener);
-              streamEmitter.off(`close:${name}`, closeListener);
-              if (pollInterval) {
-                clearInterval(pollInterval);
-                pollInterval = null;
-              }
-            }, "teardown");
-            streamEmitter.on(`chunk:${name}`, chunkListener);
-            streamEmitter.on(`close:${name}`, closeListener);
-            const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name, tag);
-            let dataChunkCount = chunkFiles.length;
-            if (typeof startIndex === "number" && startIndex < 0 && chunkFiles.length > 0) {
-              const lastFile = chunkFiles[chunkFiles.length - 1];
-              const lastExt = fileExtMap.get(lastFile) ?? ".bin";
-              if (isEofByte(await readFirstByte(path10.join(chunksDir, `${lastFile}${lastExt}`)))) {
-                dataChunkCount--;
-              }
-            }
-            const resolvedStartIndex = typeof startIndex === "number" && startIndex < 0 ? Math.max(0, dataChunkCount + startIndex) : startIndex;
-            let isComplete = false;
-            for (let i = resolvedStartIndex; i < chunkFiles.length; i++) {
-              const file3 = chunkFiles[i];
-              const chunkId = file3;
-              if (deliveredChunkIds.has(chunkId)) {
-                continue;
-              }
-              const ext2 = fileExtMap.get(file3) ?? ".bin";
-              const chunk = deserializeChunk(await readBuffer(path10.join(chunksDir, `${file3}${ext2}`)));
-              if (chunk?.eof === true) {
-                isComplete = true;
-                break;
-              }
-              deliveredChunkIds.add(chunkId);
-              if (chunk.chunk.byteLength) {
-                controller.enqueue(Uint8Array.from(chunk.chunk));
-              }
-            }
-            isReadingFromDisk = false;
-            bufferedEventChunks.sort((a, b) => a.chunkId.localeCompare(b.chunkId));
-            for (const buffered of bufferedEventChunks) {
-              controller.enqueue(Uint8Array.from(buffered.chunkData));
-            }
-            if (isComplete) {
-              streamClosed = true;
-              teardown();
-              try {
-                controller.close();
-              } catch {
-              }
-              return;
-            }
-            if (pendingClose) {
-              streamClosed = true;
-              teardown();
-              try {
-                controller.close();
-              } catch {
-              }
-              return;
-            }
-            for (let i = 0; i < resolvedStartIndex && i < chunkFiles.length; i++) {
-              deliveredChunkIds.add(chunkFiles[i]);
-            }
-            if (streamClosed) {
-              teardown();
-              return;
-            }
-            let isPolling = false;
-            pollInterval = setInterval(async () => {
-              if (isPolling)
-                return;
-              isPolling = true;
-              try {
-                const { files: currentFiles, extMap: currentExtMap } = await listChunkFilesForStream(chunksBaseDir, name, tag);
-                for (const file3 of currentFiles) {
-                  const chunkId = file3;
-                  if (deliveredChunkIds.has(chunkId))
-                    continue;
-                  deliveredChunkIds.add(chunkId);
-                  const ext2 = currentExtMap.get(file3) ?? ".bin";
-                  const chunk = deserializeChunk(await readBuffer(path10.join(chunksDir, `${file3}${ext2}`)));
-                  if (chunk?.eof === true) {
-                    streamClosed = true;
-                    teardown();
-                    try {
-                      controller.close();
-                    } catch {
-                    }
-                    return;
-                  }
-                  if (streamClosed)
-                    return;
-                  if (chunk.chunk.byteLength) {
-                    controller.enqueue(Uint8Array.from(chunk.chunk));
-                  }
-                }
-              } catch (err) {
-                if (!(err instanceof Error && "code" in err)) {
-                  console.error("[world-local] Unexpected polling error:", err);
-                }
-              } finally {
-                isPolling = false;
-              }
-            }, 100);
-          },
-          cancel() {
-            streamClosed = true;
-            teardown();
-          }
-        });
-      }
-    }
-  };
-}
-var chunkIds, monotonicUlid2, RunStreamsSchema, EOF_MARKER;
-var init_streamer = __esm({
-  "../world-local/dist/streamer.js"() {
-    "use strict";
-    init_dist5();
-    init_node2();
-    init_zod2();
-    init_fs();
-    chunkIds = globalSingleton2("@workflow/world-local//streamerMonotonicUlid", 1, () => ({ next: monotonicFactory2(() => Math.random()) }));
-    monotonicUlid2 = /* @__PURE__ */ __name((seedTime) => chunkIds.next(seedTime), "monotonicUlid");
-    RunStreamsSchema = external_exports2.object({
-      streams: external_exports2.array(external_exports2.string())
-    });
-    EOF_MARKER = 1;
-    __name(isEofByte, "isEofByte");
-    __name(serializeChunk, "serializeChunk");
-    __name(isEofChunk, "isEofChunk");
-    __name(deserializeChunk, "deserializeChunk");
-    __name(listChunkEntries, "listChunkEntries");
-    __name(addChunkFilesByExtension, "addChunkFilesByExtension");
-    __name(chunkDirForStream, "chunkDirForStream");
-    __name(listChunkFilesForStream, "listChunkFilesForStream");
-    __name(createStreamer, "createStreamer");
-  }
-});
-
 // ../world-local/dist/index.js
 import { promises as fs7 } from "node:fs";
 import { rm } from "node:fs/promises";
-import path11 from "node:path";
+import path12 from "node:path";
 function createWorld(args) {
   const definedArgs = args ? Object.fromEntries(Object.entries(args).filter(([, value]) => value !== void 0)) : {};
   const mergedConfig = { ...config3.value, ...definedArgs };
@@ -52410,13 +52610,13 @@ function createWorld(args) {
       clearStorageCache();
       if (tag) {
         const basedir = mergedConfig.dataDir;
-        const hooksDir = path11.join(basedir, "hooks");
+        const hooksDir = path12.join(basedir, "hooks");
         const taggedHookFiles = await listTaggedFiles(hooksDir, tag);
         const { HookSchema: HookSchema3 } = await Promise.resolve().then(() => (init_dist6(), dist_exports));
         await Promise.all(taggedHookFiles.map(async (hookFile) => {
-          const hook = await readJSON(path11.join(hooksDir, hookFile), HookSchema3);
+          const hook = await readJSON(path12.join(hooksDir, hookFile), HookSchema3);
           if (hook?.token) {
-            await deleteJSON(path11.join(hooksDir, "tokens", `${hashToken(hook.token)}.json`));
+            await deleteJSON(path12.join(hooksDir, "tokens", `${hashToken(hook.token)}.json`));
             await deleteJSON(hookRecoveryMarkerPath(basedir, hook.token, hook.runId, hook.hookId));
           }
         }));
@@ -52430,12 +52630,12 @@ function createWorld(args) {
           "streams/runs"
         ];
         await Promise.all(entityDirs.map(async (dir) => {
-          const fullDir = path11.join(basedir, dir);
+          const fullDir = path12.join(basedir, dir);
           const files = await listTaggedFiles(fullDir, tag);
-          await Promise.all(files.map((f) => deleteJSON(path11.join(fullDir, f))));
+          await Promise.all(files.map((f) => deleteJSON(path12.join(fullDir, f))));
         }));
         for (const indexDir of ["token-index", "id-index"]) {
-          const fullIndexDir = path11.join(basedir, "hooks", indexDir);
+          const fullIndexDir = path12.join(basedir, "hooks", indexDir);
           let keyDirEntries;
           try {
             keyDirEntries = await fs7.readdir(fullIndexDir, {
@@ -52445,14 +52645,14 @@ function createWorld(args) {
             keyDirEntries = [];
           }
           await Promise.all(keyDirEntries.filter((entry) => entry.isDirectory()).map(async (entry) => {
-            const keyDir = path11.join(fullIndexDir, entry.name);
+            const keyDir = path12.join(fullIndexDir, entry.name);
             const taggedEntryFiles = await listTaggedFiles(keyDir, tag);
-            await Promise.all(taggedEntryFiles.map((f) => deleteJSON(path11.join(keyDir, f))));
+            await Promise.all(taggedEntryFiles.map((f) => deleteJSON(path12.join(keyDir, f))));
           }));
         }
-        await fs7.rm(path11.join(basedir, ".locks"), { recursive: true, force: true }).catch(() => {
+        await fs7.rm(path12.join(basedir, ".locks"), { recursive: true, force: true }).catch(() => {
         });
-        const chunksDir = path11.join(basedir, "streams", "chunks");
+        const chunksDir = path12.join(basedir, "streams", "chunks");
         let streamDirEntries;
         try {
           streamDirEntries = await fs7.readdir(chunksDir, {
@@ -52462,9 +52662,9 @@ function createWorld(args) {
           streamDirEntries = [];
         }
         await Promise.all(streamDirEntries.filter((entry) => entry.isDirectory()).map(async (entry) => {
-          const streamChunkDir = path11.join(chunksDir, entry.name);
+          const streamChunkDir = path12.join(chunksDir, entry.name);
           const taggedBinFiles = await listTaggedFilesByExtension(streamChunkDir, tag, ".bin");
-          await Promise.all(taggedBinFiles.map((f) => fs7.unlink(path11.join(streamChunkDir, f)).catch(() => {
+          await Promise.all(taggedBinFiles.map((f) => fs7.unlink(path12.join(streamChunkDir, f)).catch(() => {
           })));
         }));
         clearCreatedFilesCache();
@@ -52616,7 +52816,7 @@ var require_token_io = __commonJS({
     });
     module.exports = __toCommonJS(token_io_exports);
     var import_path = __toESM3(__require("path"));
-    var import_fs11 = __toESM3(__require("fs"));
+    var import_fs12 = __toESM3(__require("fs"));
     var import_os = __toESM3(__require("os"));
     var import_token_error = require_token_error();
     function findRootDir() {
@@ -52624,7 +52824,7 @@ var require_token_io = __commonJS({
         let dir = process.cwd();
         while (dir !== import_path.default.dirname(dir)) {
           const pkgPath = import_path.default.join(dir, ".vercel");
-          if (import_fs11.default.existsSync(pkgPath)) {
+          if (import_fs12.default.existsSync(pkgPath)) {
             return dir;
           }
           dir = import_path.default.dirname(dir);
@@ -52698,7 +52898,7 @@ var require_auth_config = __commonJS({
     });
     module.exports = __toCommonJS(auth_config_exports);
     var fs9 = __toESM3(__require("fs"));
-    var path14 = __toESM3(__require("path"));
+    var path15 = __toESM3(__require("path"));
     var import_token_util = require_token_util();
     function getAuthConfigPath() {
       const dataDir = (0, import_token_util.getVercelDataDir)();
@@ -52707,7 +52907,7 @@ var require_auth_config = __commonJS({
           `Unable to find Vercel CLI data directory. Your platform: ${process.platform}. Supported: darwin, linux, win32.`
         );
       }
-      return path14.join(dataDir, "auth.json");
+      return path15.join(dataDir, "auth.json");
     }
     __name(getAuthConfigPath, "getAuthConfigPath");
     function readAuthConfig() {
@@ -52728,7 +52928,7 @@ var require_auth_config = __commonJS({
     __name(readAuthConfig, "readAuthConfig");
     function writeAuthConfig(config4) {
       const authPath = getAuthConfigPath();
-      const authDir = path14.dirname(authPath);
+      const authDir = path15.dirname(authPath);
       if (!fs9.existsSync(authDir)) {
         fs9.mkdirSync(authDir, { mode: 504, recursive: true });
       }
@@ -52934,7 +53134,7 @@ var require_token_util = __commonJS({
       saveToken: /* @__PURE__ */ __name(() => saveToken, "saveToken")
     });
     module.exports = __toCommonJS(token_util_exports);
-    var path14 = __toESM3(__require("path"));
+    var path15 = __toESM3(__require("path"));
     var fs9 = __toESM3(__require("fs"));
     var import_token_error = require_token_error();
     var import_token_io = require_token_io();
@@ -52947,7 +53147,7 @@ var require_token_util = __commonJS({
       if (!dataDir) {
         return null;
       }
-      return path14.join(dataDir, vercelFolder);
+      return path15.join(dataDir, vercelFolder);
     }
     __name(getVercelDataDir, "getVercelDataDir");
     async function getVercelToken2(options) {
@@ -53027,7 +53227,7 @@ var require_token_util = __commonJS({
           "Unable to find project root directory. Have you linked your project with `vc link?`"
         );
       }
-      const prjPath = path14.join(dir, ".vercel", "project.json");
+      const prjPath = path15.join(dir, ".vercel", "project.json");
       if (!fs9.existsSync(prjPath)) {
         throw new import_token_error.VercelOidcTokenError(
           "project.json not found, have you linked your project with `vc link?`"
@@ -53049,9 +53249,9 @@ var require_token_util = __commonJS({
           "Unable to find user data directory. Please reach out to Vercel support."
         );
       }
-      const tokenPath = path14.join(dir, "com.vercel.token", `${projectId}.json`);
+      const tokenPath = path15.join(dir, "com.vercel.token", `${projectId}.json`);
       const tokenJson = JSON.stringify(token);
-      fs9.mkdirSync(path14.dirname(tokenPath), { mode: 504, recursive: true });
+      fs9.mkdirSync(path15.dirname(tokenPath), { mode: 504, recursive: true });
       fs9.writeFileSync(tokenPath, tokenJson);
       fs9.chmodSync(tokenPath, 432);
       return;
@@ -53064,7 +53264,7 @@ var require_token_util = __commonJS({
           "Unable to find user data directory. Please reach out to Vercel support."
         );
       }
-      const tokenPath = path14.join(dir, "com.vercel.token", `${projectId}.json`);
+      const tokenPath = path15.join(dir, "com.vercel.token", `${projectId}.json`);
       if (!fs9.existsSync(tokenPath)) {
         return null;
       }
@@ -55646,16 +55846,16 @@ var require_filesystem = __commonJS({
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync2 = /* @__PURE__ */ __name((path14) => {
-      const fd = fs9.openSync(path14, "r");
+    var readFileSync2 = /* @__PURE__ */ __name((path15) => {
+      const fd = fs9.openSync(path15, "r");
       const buffer3 = Buffer.alloc(MAX_LENGTH);
       const bytesRead = fs9.readSync(fd, buffer3, 0, MAX_LENGTH, 0);
       fs9.close(fd, () => {
       });
       return buffer3.subarray(0, bytesRead);
     }, "readFileSync");
-    var readFile3 = /* @__PURE__ */ __name((path14) => new Promise((resolve3, reject) => {
-      fs9.open(path14, "r", (err, fd) => {
+    var readFile3 = /* @__PURE__ */ __name((path15) => new Promise((resolve3, reject) => {
+      fs9.open(path15, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
@@ -55774,11 +55974,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     }, "familyFromCommand");
-    var familyFromInterpreterPath = /* @__PURE__ */ __name((path14) => {
-      if (path14) {
-        if (path14.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = /* @__PURE__ */ __name((path15) => {
+      if (path15) {
+        if (path15.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path14.includes("/ld-linux-")) {
+        } else if (path15.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -55825,8 +56025,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile3(SELF_PATH);
-        const path14 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path14);
+        const path15 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path15);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -55838,8 +56038,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync2(SELF_PATH);
-        const path14 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path14);
+        const path15 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path15);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -55973,7 +56173,7 @@ var require_detect_libc = __commonJS({
 var require_node_gyp_build_optional_packages = __commonJS({
   "../../node_modules/.pnpm/node-gyp-build-optional-packages@5.1.1/node_modules/node-gyp-build-optional-packages/index.js"(exports, module) {
     var fs9 = __require("fs");
-    var path14 = __require("path");
+    var path15 = __require("path");
     var url3 = __require("url");
     var vars = process.config && process.config.variables || {};
     var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
@@ -55997,30 +56197,30 @@ var require_node_gyp_build_optional_packages = __commonJS({
     }
     __name(load, "load");
     load.path = function(dir) {
-      dir = path14.resolve(dir || ".");
+      dir = path15.resolve(dir || ".");
       var packageName = "";
       try {
         if (typeof __webpack_require__ === "function")
-          packageName = __non_webpack_require__(path14.join(dir, "package.json")).name;
+          packageName = __non_webpack_require__(path15.join(dir, "package.json")).name;
         else
-          packageName = __require(path14.join(dir, "package.json")).name;
+          packageName = __require(path15.join(dir, "package.json")).name;
         var varName = packageName.toUpperCase().replace(/-/g, "_") + "_PREBUILD";
         if (process.env[varName]) dir = process.env[varName];
       } catch (err) {
       }
       if (!prebuildsOnly) {
-        var release = getFirst(path14.join(dir, "build/Release"), matchBuild);
+        var release = getFirst(path15.join(dir, "build/Release"), matchBuild);
         if (release) return release;
-        var debug = getFirst(path14.join(dir, "build/Debug"), matchBuild);
+        var debug = getFirst(path15.join(dir, "build/Debug"), matchBuild);
         if (debug) return debug;
       }
       var prebuild = resolve3(dir);
       if (prebuild) return prebuild;
-      var nearby = resolve3(path14.dirname(process.execPath));
+      var nearby = resolve3(path15.dirname(process.execPath));
       if (nearby) return nearby;
       var platformPackage = (packageName[0] == "@" ? "" : "@" + packageName + "/") + packageName + "-" + platform + "-" + arch;
       try {
-        var prebuildPackage = path14.dirname(__require("module").createRequire(url3.pathToFileURL(path14.join(dir, "package.json"))).resolve(platformPackage));
+        var prebuildPackage = path15.dirname(__require("module").createRequire(url3.pathToFileURL(path15.join(dir, "package.json"))).resolve(platformPackage));
         return resolveFile(prebuildPackage);
       } catch (error95) {
       }
@@ -56039,17 +56239,17 @@ var require_node_gyp_build_optional_packages = __commonJS({
       ].filter(Boolean).join(" ");
       throw new Error("No native build was found for " + target2 + "\n    attempted loading from: " + dir + " and package: " + platformPackage + "\n");
       function resolve3(dir2) {
-        var tuples = readdirSync(path14.join(dir2, "prebuilds")).map(parseTuple);
+        var tuples = readdirSync(path15.join(dir2, "prebuilds")).map(parseTuple);
         var tuple3 = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
         if (!tuple3) return;
-        return resolveFile(path14.join(dir2, "prebuilds", tuple3.name));
+        return resolveFile(path15.join(dir2, "prebuilds", tuple3.name));
       }
       __name(resolve3, "resolve");
       function resolveFile(prebuilds) {
         var parsed = readdirSync(prebuilds).map(parseTags);
         var candidates = parsed.filter(matchTags(runtime, abi));
         var winner = candidates.sort(compareTags(runtime))[0];
-        if (winner) return path14.join(prebuilds, winner.file);
+        if (winner) return path15.join(prebuilds, winner.file);
       }
       __name(resolveFile, "resolveFile");
     };
@@ -56063,7 +56263,7 @@ var require_node_gyp_build_optional_packages = __commonJS({
     __name(readdirSync, "readdirSync");
     function getFirst(dir, filter2) {
       var files = readdirSync(dir).filter(filter2);
-      return files[0] && path14.join(dir, files[0]);
+      return files[0] && path15.join(dir, files[0]);
     }
     __name(getFirst, "getFirst");
     function matchBuild(name) {
@@ -56209,11 +56409,56 @@ var version4;
 var init_version3 = __esm({
   "../world-vercel/dist/version.js"() {
     "use strict";
-    version4 = "5.0.0-beta.44";
+    version4 = "5.0.0-beta.45";
   }
 });
 
 // ../world-vercel/dist/http-client.js
+function getQueueAgentOptions2() {
+  const timeoutMs = getQueueRequestTimeoutMs();
+  return {
+    ...DEFAULT_AGENT_OPTIONS,
+    connections: envNumber2("WORKFLOW_VERCEL_QUEUE_CONNECTIONS", QUEUE_AGENT_CONNECTIONS, { integer: true, min: 1, max: 1024 }),
+    headersTimeout: timeoutMs,
+    bodyTimeout: timeoutMs
+  };
+}
+function deadlineInterceptor(timeoutMs) {
+  class DeadlineHandler extends ForwardingHandler {
+    static {
+      __name(this, "DeadlineHandler");
+    }
+    #expired = false;
+    #controller;
+    #timer;
+    constructor(handler) {
+      super(handler);
+      this.#timer = setTimeout(() => {
+        this.#expired = true;
+        this.#abort();
+      }, timeoutMs);
+      this.#timer.unref?.();
+    }
+    #abort() {
+      this.#controller?.abort(new Error(`Queue request exceeded its ${timeoutMs}ms deadline`));
+    }
+    onRequestStart(controller, context2) {
+      this.#controller = controller;
+      super.onRequestStart(controller, context2);
+      if (this.#expired)
+        this.#abort();
+    }
+    onResponseEnd(controller, trailers) {
+      clearTimeout(this.#timer);
+      super.onResponseEnd(controller, trailers);
+    }
+    onResponseError(controller, error95) {
+      clearTimeout(this.#timer);
+      super.onResponseError(controller, error95);
+    }
+  }
+  return (dispatch) => (opts, handler) => dispatch(opts, new DeadlineHandler(handler));
+}
 function h2EventsEnabled() {
   return process.env.WORKFLOW_H2_MULTIPLEX !== "0";
 }
@@ -56326,7 +56571,7 @@ function getDispatcher(config4) {
   return resolveDispatcher(config4, getDefaultDispatcher);
 }
 function getQueueDispatcher(config4) {
-  return config4?.dispatcher ?? getDefaultDispatcher();
+  return resolveDispatcher(config4, getDefaultQueueDispatcher);
 }
 function getEventsDispatcher(config4) {
   return resolveDispatcher(config4, () => eventsRecycler.get());
@@ -56359,6 +56604,13 @@ function withBoundLifecycle(agent, composed) {
 function createStreamDispatcher(retryOptions, agentOverrides) {
   return new import_undici2.RetryAgent(new import_undici2.Agent({ ...STREAM_AGENT_OPTIONS, ...agentOverrides }), retryOptions);
 }
+function createQueueDispatcher() {
+  return new import_undici2.RetryAgent(new import_undici2.Agent(getQueueAgentOptions2()).compose(deadlineInterceptor(getQueueRequestTimeoutMs())), RETRY_AGENT_OPTIONS);
+}
+function getDefaultQueueDispatcher() {
+  pools.queueDispatcher ??= createQueueDispatcher();
+  return pools.queueDispatcher;
+}
 function getDefaultDispatcher() {
   pools.dispatcher ??= makeRetryDispatcher(DEFAULT_AGENT_OPTIONS, RETRY_AGENT_OPTIONS);
   return pools.dispatcher;
@@ -56371,7 +56623,7 @@ function getDefaultStreamCloseDispatcher() {
   pools.streamCloseDispatcher ??= createStreamDispatcher(STREAM_CLOSE_RETRY_OPTIONS);
   return pools.streamCloseDispatcher;
 }
-var import_undici2, pools, BASE_AGENT_OPTIONS, NODE_HTTP_HEADERS_TIMEOUT_MS, NODE_HTTP_BODY_TIMEOUT_MS, H2_MAX_IN_FLIGHT_STREAMS, H2_STREAM_WINDOW_BYTES, H2_CONNECTION_WINDOW_BYTES, DEFAULT_AGENT_OPTIONS, EVENTS_AGENT_OPTIONS, EVENTS_AGENT_OPTIONS_NO_H2, STREAM_AGENT_OPTIONS, RETRY_AGENT_OPTIONS, STREAM_RETRY_OPTIONS, STREAM_CLOSE_RETRY_OPTIONS, H2_REBUFFER_MAX_BYTES, EVENTS_RECYCLE_AFTER_CONSECUTIVE_FAILURES, RECYCLE_MIN_INTERVAL_MS, RETIRED_CLOSE_DELAY_MS, RETIRED_DESTROY_DELAY_MS, RECYCLABLE_ERROR_CODES, MAX_CAUSE_DEPTH, eventsRecycler;
+var import_undici2, pools, BASE_AGENT_OPTIONS, NODE_HTTP_HEADERS_TIMEOUT_MS, NODE_HTTP_BODY_TIMEOUT_MS, H2_MAX_IN_FLIGHT_STREAMS, H2_STREAM_WINDOW_BYTES, H2_CONNECTION_WINDOW_BYTES, DEFAULT_AGENT_OPTIONS, QUEUE_AGENT_CONNECTIONS, QUEUE_REQUEST_TIMEOUT_MS, getQueueRequestTimeoutMs, ForwardingHandler, EVENTS_AGENT_OPTIONS, EVENTS_AGENT_OPTIONS_NO_H2, STREAM_AGENT_OPTIONS, RETRY_AGENT_OPTIONS, STREAM_RETRY_OPTIONS, STREAM_CLOSE_RETRY_OPTIONS, H2_REBUFFER_MAX_BYTES, EVENTS_RECYCLE_AFTER_CONSECUTIVE_FAILURES, RECYCLE_MIN_INTERVAL_MS, RETIRED_CLOSE_DELAY_MS, RETIRED_DESTROY_DELAY_MS, RECYCLABLE_ERROR_CODES, MAX_CAUSE_DEPTH, eventsRecycler;
 var init_http_client = __esm({
   "../world-vercel/dist/http-client.js"() {
     "use strict";
@@ -56382,6 +56634,7 @@ var init_http_client = __esm({
     init_version3();
     pools = globalSingleton2("@workflow/world-vercel//httpPools", 1, () => ({
       dispatcher: void 0,
+      queueDispatcher: void 0,
       streamDispatcher: void 0,
       streamCloseDispatcher: void 0,
       nodeHttpAgents: void 0
@@ -56402,6 +56655,16 @@ var init_http_client = __esm({
       // head-of-line blocking that deadlocks the webhook respondWith mechanism.
       pipelining: 1
     };
+    QUEUE_AGENT_CONNECTIONS = 64;
+    QUEUE_REQUEST_TIMEOUT_MS = 3e4;
+    getQueueRequestTimeoutMs = /* @__PURE__ */ __name(() => envNumber2("WORKFLOW_VERCEL_QUEUE_TIMEOUT_MS", QUEUE_REQUEST_TIMEOUT_MS, {
+      integer: true,
+      min: 5e3,
+      max: 12e4
+    }), "getQueueRequestTimeoutMs");
+    __name(getQueueAgentOptions2, "getQueueAgentOptions");
+    ForwardingHandler = import_undici2.DecoratorHandler;
+    __name(deadlineInterceptor, "deadlineInterceptor");
     EVENTS_AGENT_OPTIONS = {
       ...BASE_AGENT_OPTIONS,
       allowH2: true,
@@ -56483,6 +56746,8 @@ var init_http_client = __esm({
     __name(createEventsDispatcher, "createEventsDispatcher");
     __name(withBoundLifecycle, "withBoundLifecycle");
     __name(createStreamDispatcher, "createStreamDispatcher");
+    __name(createQueueDispatcher, "createQueueDispatcher");
+    __name(getDefaultQueueDispatcher, "getDefaultQueueDispatcher");
     __name(getDefaultDispatcher, "getDefaultDispatcher");
     __name(getDefaultStreamDispatcher, "getDefaultStreamDispatcher");
     __name(getDefaultStreamCloseDispatcher, "getDefaultStreamCloseDispatcher");
@@ -64566,7 +64831,7 @@ var init_escape = __esm({
 });
 
 // ../../node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/index.js
-var minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path12, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
+var minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path13, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
 var init_esm4 = __esm({
   "../../node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/index.js"() {
     init_esm3();
@@ -64635,11 +64900,11 @@ var init_esm4 = __esm({
       return (f) => f.length === len && f !== "." && f !== "..";
     }, "qmarksTestNoExtDot");
     defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-    path12 = {
+    path13 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    sep = defaultPlatform === "win32" ? path12.win32.sep : path12.posix.sep;
+    sep = defaultPlatform === "win32" ? path13.win32.sep : path13.posix.sep;
     minimatch.sep = sep;
     GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
@@ -65471,7 +65736,7 @@ var require_picocolors = __commonJS({
 // ../../node_modules/.pnpm/@vercel+queue@0.5.0_@opentelemetry+api@1.9.1/node_modules/@vercel/queue/dist/index.mjs
 import * as fs8 from "fs";
 import * as net from "net";
-import * as path13 from "path";
+import * as path14 from "path";
 async function streamToBuffer(stream) {
   let totalLength = 0;
   const reader = stream.getReader();
@@ -65700,7 +65965,7 @@ function getDevRouteMappings() {
     return g[ROUTE_MAPPINGS_KEY] ?? null;
   }
   try {
-    const vercelJsonPath = path13.join(process.cwd(), "vercel.json");
+    const vercelJsonPath = path14.join(process.cwd(), "vercel.json");
     if (!fs8.existsSync(vercelJsonPath)) {
       g[ROUTE_MAPPINGS_KEY] = null;
       return null;
@@ -65767,7 +66032,7 @@ function findMappingsForFile(absolutePath) {
   const cwd = process.cwd();
   let relative2;
   try {
-    relative2 = path13.relative(cwd, absolutePath);
+    relative2 = path14.relative(cwd, absolutePath);
   } catch {
     return [];
   }
@@ -65803,8 +66068,8 @@ function parseFrameFilePath(line) {
 function getSdkPackageDir() {
   if (_sdkPackageDir) return _sdkPackageDir;
   try {
-    const thisDir = typeof __dirname !== "undefined" ? __dirname : path13.dirname(new URL(import.meta.url).pathname);
-    _sdkPackageDir = path13.resolve(thisDir, "..");
+    const thisDir = typeof __dirname !== "undefined" ? __dirname : path14.dirname(new URL(import.meta.url).pathname);
+    _sdkPackageDir = path14.resolve(thisDir, "..");
   } catch {
     _sdkPackageDir = "";
   }
@@ -65818,7 +66083,7 @@ function extractCallerFilePath() {
   for (const line of lines) {
     const fp = parseFrameFilePath(line);
     if (!fp) continue;
-    const absolute = path13.isAbsolute(fp) ? fp : path13.resolve(process.cwd(), fp);
+    const absolute = path14.isAbsolute(fp) ? fp : path14.resolve(process.cwd(), fp);
     let realFp;
     try {
       realFp = fs8.realpathSync(absolute);
@@ -65838,7 +66103,7 @@ function getHandlerRegistry() {
   return g[HANDLER_REGISTRY_KEY];
 }
 function registerHandlerForFile(filePath, handler, client, options) {
-  const absolutePath = path13.isAbsolute(filePath) ? filePath : path13.resolve(process.cwd(), filePath);
+  const absolutePath = path14.isAbsolute(filePath) ? filePath : path14.resolve(process.cwd(), filePath);
   const fileMappings = findMappingsForFile(absolutePath);
   if (fileMappings.length === 0) return false;
   const registry3 = getHandlerRegistry();
@@ -65885,7 +66150,7 @@ function registerDevHandler(handler, client, options, _testCallerPath) {
     const cwd = process.cwd();
     let relative2;
     try {
-      relative2 = path13.relative(cwd, callerPath).replace(/\\/g, "/");
+      relative2 = path14.relative(cwd, callerPath).replace(/\\/g, "/");
     } catch {
       relative2 = callerPath;
     }
@@ -66032,7 +66297,7 @@ async function ensureHandlersLoaded(topicName, options = {}) {
       continue;
     }
     if (!alreadyRegistered) {
-      const absolutePath = path13.resolve(process.cwd(), route.filePath);
+      const absolutePath = path14.resolve(process.cwd(), route.filePath);
       try {
         await importAtRuntime(absolutePath);
       } catch (error95) {
@@ -70335,9 +70600,9 @@ async function readRun(id, params, config4) {
   searchParams.set("remoteRefBehavior", remoteRefBehavior);
   if (waitMs !== void 0)
     searchParams.set("waitMs", String(waitMs));
-  const path14 = waitMs === void 0 ? "" : "/status";
+  const path15 = waitMs === void 0 ? "" : "/status";
   const queryString = searchParams.toString();
-  const endpoint = `/v2/runs/${encodeURIComponent(id)}${path14}${queryString ? `?${queryString}` : ""}`;
+  const endpoint = `/v2/runs/${encodeURIComponent(id)}${path15}${queryString ? `?${queryString}` : ""}`;
   const run3 = await makeRequest({
     endpoint,
     options: { method: "GET", ...signal ? { signal } : {} },
@@ -71008,6 +71273,44 @@ var init_storage3 = __esm({
   }
 });
 
+// ../world-vercel/dist/stream-chunks.js
+function normalizeStreamChunks(chunks) {
+  const encoder4 = new TextEncoder();
+  return chunks.map((chunk) => typeof chunk === "string" ? encoder4.encode(chunk) : chunk);
+}
+function encodeMultiChunks(chunks) {
+  return encodeNormalizedMultiChunks(normalizeStreamChunks(chunks));
+}
+function encodeNormalizedMultiChunks(binaryChunks) {
+  let totalSize = 0;
+  for (const binary of binaryChunks) {
+    totalSize += 4 + binary.length;
+    if (totalSize > 4294967295) {
+      throw new RangeError(`encoded stream chunks exceed the u32 body-length limit: ${totalSize} bytes`);
+    }
+  }
+  const result2 = new Uint8Array(totalSize);
+  const view = new DataView(result2.buffer);
+  let offset = 0;
+  for (const binary of binaryChunks) {
+    view.setUint32(offset, binary.length, false);
+    offset += 4;
+    result2.set(binary, offset);
+    offset += binary.length;
+  }
+  return result2;
+}
+var MAX_CHUNKS_PER_STREAM_WRITE;
+var init_stream_chunks = __esm({
+  "../world-vercel/dist/stream-chunks.js"() {
+    "use strict";
+    MAX_CHUNKS_PER_STREAM_WRITE = 1e3;
+    __name(normalizeStreamChunks, "normalizeStreamChunks");
+    __name(encodeMultiChunks, "encodeMultiChunks");
+    __name(encodeNormalizedMultiChunks, "encodeNormalizedMultiChunks");
+  }
+});
+
 // ../world-vercel/dist/streamer.js
 function getStreamUrl(name, runId, httpConfig) {
   return new URL(`${httpConfig.baseUrl}/v2/runs/${encodeURIComponent(runId)}/stream/${encodeURIComponent(name)}`);
@@ -71048,26 +71351,6 @@ function createStreamRequestError(operation, url3, response, text) {
   ];
   return new StreamError2(`Stream ${operation} failed: HTTP ${response.status} (${context2.join("; ")}): ${text}`, { url: url3.toString(), status: response.status });
 }
-function encodeMultiChunks(chunks) {
-  const encoder4 = new TextEncoder();
-  const binaryChunks = [];
-  let totalSize = 0;
-  for (const chunk of chunks) {
-    const binary = typeof chunk === "string" ? encoder4.encode(chunk) : chunk;
-    binaryChunks.push(binary);
-    totalSize += 4 + binary.length;
-  }
-  const result2 = new Uint8Array(totalSize);
-  const view = new DataView(result2.buffer);
-  let offset = 0;
-  for (const binary of binaryChunks) {
-    view.setUint32(offset, binary.length, false);
-    offset += 4;
-    result2.set(binary, offset);
-    offset += binary.length;
-  }
-  return result2;
-}
 function createStreamer2(config4) {
   return {
     streams: {
@@ -71252,9 +71535,11 @@ var init_streamer2 = __esm({
     init_zod2();
     init_http_client();
     init_http_core();
+    init_stream_chunks();
     init_telemetry3();
     init_utils4();
-    MAX_CHUNKS_PER_REQUEST = 1e3;
+    init_stream_chunks();
+    MAX_CHUNKS_PER_REQUEST = MAX_CHUNKS_PER_STREAM_WRITE;
     getMaxChunksPerRequest = /* @__PURE__ */ __name(() => envNumber2("WORKFLOW_MAX_CHUNKS_PER_REQUEST", MAX_CHUNKS_PER_REQUEST, {
       integer: true,
       min: 1
@@ -71265,7 +71550,6 @@ var init_streamer2 = __esm({
     __name(createStreamReadError, "createStreamReadError");
     __name(toStreamError, "toStreamError");
     __name(createStreamRequestError, "createStreamRequestError");
-    __name(encodeMultiChunks, "encodeMultiChunks");
     StreamInfoResponseSchema = external_exports2.object({
       tailIndex: external_exports2.number(),
       done: external_exports2.boolean()
@@ -78891,7 +79175,7 @@ var version5;
 var init_version4 = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version5 = "5.0.0-beta.48";
+    version5 = "5.0.0-beta.49";
   }
 });
 
@@ -80673,6 +80957,42 @@ async function getForwardedWritableEncryptionKey2(runId, deploymentId, encryptio
   const rawKey = deploymentId ? await world.getEncryptionKeyForRun(runId, { deploymentId }) : await world.getEncryptionKeyForRun(await world.runs.get(runId));
   return rawKey ? await importKey2(rawKey, ["encrypt"]) : void 0;
 }
+function tagForwardedWritableTarget2(writable, { deploymentId, encryptionPublicKey }) {
+  if (typeof deploymentId === "string") {
+    Object.defineProperty(writable, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL2, {
+      value: deploymentId,
+      writable: false
+    });
+  }
+  if (typeof encryptionPublicKey === "string") {
+    Object.defineProperty(writable, STREAM_SERVER_PUBLIC_KEY_SYMBOL2, {
+      value: encryptionPublicKey,
+      writable: false
+    });
+  }
+}
+function createForwardedWritable2({ global: global2, ops, runId, name, key, deploymentId, encryptionPublicKey, runReadyBarrier }) {
+  const serialize5 = getSerializeStream2(getExternalReducers2(global2, ops, runId, key), key);
+  const serverWritable = new WorkflowServerWritableStream2(runId, name, runReadyBarrier);
+  const state = createFlushableState2();
+  ops.push(state.promise);
+  flushablePipe2(serialize5.readable, serverWritable, state).catch(() => {
+  });
+  pollWritableLock2(serialize5.writable, state);
+  Object.defineProperty(serialize5.writable, STREAM_NAME_SYMBOL2, {
+    value: name,
+    writable: false
+  });
+  Object.defineProperty(serialize5.writable, STREAM_SERVER_RUN_ID_SYMBOL2, {
+    value: runId,
+    writable: false
+  });
+  tagForwardedWritableTarget2(serialize5.writable, {
+    deploymentId,
+    encryptionPublicKey
+  });
+  return serialize5.writable;
+}
 function getRunReadableStream2(global2, ops, runId, name, startIndex, cryptoKey) {
   let reader;
   let lockState;
@@ -80789,34 +81109,15 @@ function getExternalRevivers2(global2 = globalThis, ops, runId, cryptoKey, optio
     WritableStream: /* @__PURE__ */ __name((value) => {
       const targetRunId = typeof value.runId === "string" ? value.runId : runId;
       const targetKey = targetRunId === runId ? cryptoKey : getForwardedWritableEncryptionKey2(targetRunId, value.deploymentId, value.encryptionPublicKey);
-      const serialize5 = getSerializeStream2(getExternalReducers2(global2, ops, targetRunId, targetKey), targetKey);
-      const serverWritable = new WorkflowServerWritableStream2(targetRunId, value.name);
-      const state = createFlushableState2();
-      ops.push(state.promise);
-      flushablePipe2(serialize5.readable, serverWritable, state).catch(() => {
-      });
-      pollWritableLock2(serialize5.writable, state);
-      Object.defineProperty(serialize5.writable, STREAM_NAME_SYMBOL2, {
-        value: value.name,
-        writable: false
-      });
-      Object.defineProperty(serialize5.writable, STREAM_SERVER_RUN_ID_SYMBOL2, {
-        value: targetRunId,
-        writable: false
+      return createForwardedWritable2({
+        global: global2,
+        ops,
+        runId: targetRunId,
+        name: value.name,
+        key: targetKey,
+        deploymentId: value.deploymentId,
+        encryptionPublicKey: value.encryptionPublicKey
       });
-      if (typeof value.deploymentId === "string") {
-        Object.defineProperty(serialize5.writable, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL2, {
-          value: value.deploymentId,
-          writable: false
-        });
-      }
-      if (typeof value.encryptionPublicKey === "string") {
-        Object.defineProperty(serialize5.writable, STREAM_SERVER_PUBLIC_KEY_SYMBOL2, {
-          value: value.encryptionPublicKey,
-          writable: false
-        });
-      }
-      return serialize5.writable;
     }, "WritableStream"),
     AbortController: /* @__PURE__ */ __name((value) => reviveAbortController2(value, ops, runId), "AbortController"),
     AbortSignal: /* @__PURE__ */ __name((value) => reviveAbortSignal2(value, ops, runId), "AbortSignal")
@@ -81465,6 +81766,12 @@ var init_serialization4 = __esm({
             pendingRunReady = void 0;
           }
         }, "ensureRunReady");
+        const writerId = `wrtr_${defaultUlid2()}`;
+        const writeSessionPromise = ensureRunReady().then(async () => {
+          const world = await worldPromise;
+          return world.streams.createWriteSession?.(runId, name, { writerId });
+        });
+        let nextChunkSeq = 0;
         let buffer3 = [];
         let bufferBytes = 0;
         let inFlightChunks = 0;
@@ -81507,14 +81814,18 @@ var init_serialization4 = __esm({
         const sendGroup = /* @__PURE__ */ __name(async (group, bytes, groupT0) => {
           await ensureRunReady();
           const world = await worldPromise;
+          const session = await writeSessionPromise;
           const dispatchAt = Date.now();
-          if (typeof world.streams.writeMulti === "function" && group.length > 1) {
+          if (session) {
+            await session.write(nextChunkSeq, group);
+          } else if (typeof world.streams.writeMulti === "function" && group.length > 1) {
             await world.streams.writeMulti(runId, name, group);
           } else {
             for (const chunk of group) {
               await world.streams.write(runId, name, chunk);
             }
           }
+          nextChunkSeq += group.length;
           if (groupT0 !== void 0) {
             recordStreamWriteFlush2(groupT0, dispatchAt, runId, name, group.length, bytes, Date.now() - dispatchAt);
           }
@@ -81629,8 +81940,13 @@ var init_serialization4 = __esm({
             await drain();
             await ensureRunReady();
             const world = await worldPromise;
+            const session = await writeSessionPromise;
             const closeStart = Date.now();
-            await world.streams.close(runId, name);
+            if (session) {
+              await session.close();
+            } else {
+              await world.streams.close(runId, name);
+            }
             recordStreamClose2(closeStart, runId, name);
           },
           async abort(reason) {
@@ -81646,6 +81962,8 @@ var init_serialization4 = __esm({
             bufferBytes = 0;
             sinkError ??= reason ?? new Error("Stream aborted");
             rejectWaiters(sinkError);
+            const session = await writeSessionPromise.catch(() => void 0);
+            await session?.dispose?.();
           }
         });
         Object.defineProperty(this, STREAM_DRAIN_SYMBOL2, {
@@ -81671,6 +81989,8 @@ var init_serialization4 = __esm({
     __name(reviveAbortSignal2, "reviveAbortSignal");
     __name(getCommonRevivers4, "getCommonRevivers");
     __name(getForwardedWritableEncryptionKey2, "getForwardedWritableEncryptionKey");
+    __name(tagForwardedWritableTarget2, "tagForwardedWritableTarget");
+    __name(createForwardedWritable2, "createForwardedWritable");
     __name(getRunReadableStream2, "getRunReadableStream");
     __name(getExternalRevivers2, "getExternalRevivers");
     __name(getWorkflowRevivers, "getWorkflowRevivers");
@@ -83481,16 +83801,16 @@ function parseAbsoluteUrl(input) {
 }
 function parseFileUrl(input) {
   const match2 = fileRegex.exec(input);
-  const path14 = match2[2];
-  return makeUrl("file:", "", match2[1] || "", "", isAbsolutePath(path14) ? path14 : "/" + path14, match2[3] || "", match2[4] || "");
+  const path15 = match2[2];
+  return makeUrl("file:", "", match2[1] || "", "", isAbsolutePath(path15) ? path15 : "/" + path15, match2[3] || "", match2[4] || "");
 }
-function makeUrl(scheme, user, host, port, path14, query, hash3) {
+function makeUrl(scheme, user, host, port, path15, query, hash3) {
   return {
     scheme,
     user,
     host,
     port,
-    path: path14,
+    path: path15,
     query,
     hash: hash3,
     type: 7
@@ -83520,11 +83840,11 @@ function parseUrl(input) {
   url3.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
   return url3;
 }
-function stripPathFilename(path14) {
-  if (path14.endsWith("/.."))
-    return path14;
-  const index = path14.lastIndexOf("/");
-  return path14.slice(0, index + 1);
+function stripPathFilename(path15) {
+  if (path15.endsWith("/.."))
+    return path15;
+  const index = path15.lastIndexOf("/");
+  return path15.slice(0, index + 1);
 }
 function mergePaths(url3, base) {
   normalizePath(base, base.type);
@@ -83562,14 +83882,14 @@ function normalizePath(url3, type) {
     pieces[pointer++] = piece;
     positive++;
   }
-  let path14 = "";
+  let path15 = "";
   for (let i = 1; i < pointer; i++) {
-    path14 += "/" + pieces[i];
+    path15 += "/" + pieces[i];
   }
-  if (!path14 || addTrailingSlash && !path14.endsWith("/..")) {
-    path14 += "/";
+  if (!path15 || addTrailingSlash && !path15.endsWith("/..")) {
+    path15 += "/";
   }
-  url3.path = path14;
+  url3.path = path15;
 }
 function resolve2(input, base) {
   if (!input && !base)
@@ -83610,13 +83930,13 @@ function resolve2(input, base) {
     case 3:
       return queryHash;
     case 4: {
-      const path14 = url3.path.slice(1);
-      if (!path14)
+      const path15 = url3.path.slice(1);
+      if (!path15)
         return queryHash || ".";
-      if (isRelative(base || input) && !isRelative(path14)) {
-        return "./" + path14 + queryHash;
+      if (isRelative(base || input) && !isRelative(path15)) {
+        return "./" + path15 + queryHash;
       }
-      return path14 + queryHash;
+      return path15 + queryHash;
     }
     case 5:
       return url3.path + queryHash;
@@ -83647,10 +83967,10 @@ var init_resolve_uri = __esm({
 });
 
 // ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
-function stripFilename(path14) {
-  if (!path14) return "";
-  const index = path14.lastIndexOf("/");
-  return path14.slice(0, index + 1);
+function stripFilename(path15) {
+  if (!path15) return "";
+  const index = path15.lastIndexOf("/");
+  return path15.slice(0, index + 1);
 }
 function resolver(mapUrl, sourceRoot) {
   const from = stripFilename(mapUrl);
@@ -93181,8 +93501,17 @@ Caused by: ${options.cause.stack}`;
       static {
         __name2(this, "RunExpiredError");
       }
-      constructor(message) {
-        super(message);
+      runId;
+      runStatus;
+      expiredAt;
+      constructor(message, runId, runStatus, expiredAt) {
+        super(message, {
+          status: 410,
+          code: "run-expired"
+        });
+        this.runId = runId;
+        this.runStatus = runStatus;
+        this.expiredAt = expiredAt;
         this.name = "RunExpiredError";
       }
       static is(value) {
@@ -95791,9 +96120,9 @@ function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
 __name(cloneDef, "cloneDef");
-function getElementAtPath(obj, path14) {
-  if (!path14) return obj;
-  return path14.reduce((acc, key) => acc?.[key], obj);
+function getElementAtPath(obj, path15) {
+  if (!path15) return obj;
+  return path15.reduce((acc, key) => acc?.[key], obj);
 }
 __name(getElementAtPath, "getElementAtPath");
 function promiseAllObject(promisesObj) {
@@ -96133,11 +96462,11 @@ function aborted(x, startIndex = 0) {
   return false;
 }
 __name(aborted, "aborted");
-function prefixIssues(path14, issues) {
+function prefixIssues(path15, issues) {
   return issues.map((iss) => {
     var _a22;
     (_a22 = iss).path ?? (_a22.path = []);
-    iss.path.unshift(path14);
+    iss.path.unshift(path15);
     return iss;
   });
 }
@@ -96511,7 +96840,7 @@ function treeifyError(error482, mapper = (issue22) => issue22.message) {
   const result2 = {
     errors: []
   };
-  const processError = /* @__PURE__ */ __name2((error492, path14 = []) => {
+  const processError = /* @__PURE__ */ __name2((error492, path15 = []) => {
     var _a22, _b;
     for (const issue22 of error492.issues) {
       if (issue22.code === "invalid_union" && issue22.errors.length) {
@@ -96528,7 +96857,7 @@ function treeifyError(error482, mapper = (issue22) => issue22.message) {
         }, issue22.path);
       } else {
         const fullpath = [
-          ...path14,
+          ...path15,
           ...issue22.path
         ];
         if (fullpath.length === 0) {
@@ -96567,8 +96896,8 @@ function treeifyError(error482, mapper = (issue22) => issue22.message) {
 __name(treeifyError, "treeifyError");
 function toDotPath(_path) {
   const segs = [];
-  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path14) {
+  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path15) {
     if (typeof seg === "number") segs.push(`[${seg}]`);
     else if (typeof seg === "symbol") segs.push(`[${JSON.stringify(String(seg))}]`);
     else if (/[^\w$]/.test(seg)) segs.push(`[${JSON.stringify(seg)}]`);
@@ -110922,13 +111251,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path14 = ref.slice(1).split("/").filter(Boolean);
-  if (path14.length === 0) {
+  const path15 = ref.slice(1).split("/").filter(Boolean);
+  if (path15.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path14[0] === defsKey) {
-    const key = path14[1];
+  if (path15[0] === defsKey) {
+    const key = path15[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -111781,6 +112110,7 @@ __name(validateAttributeChanges, "validateAttributeChanges");
 var RESERVED_ATTRIBUTE_KEY_PREFIX;
 var ROOT_RUN_ID_ATTRIBUTE;
 var PARENT_RUN_ID_ATTRIBUTE;
+var RETENTION_ATTRIBUTE;
 var ATTRIBUTE_KEY_MAX_LENGTH;
 var ATTRIBUTE_VALUE_MAX_BYTES;
 var ATTRIBUTE_MAX_PER_RUN;
@@ -111792,6 +112122,7 @@ var init_attributes_validation = __esm2({
     RESERVED_ATTRIBUTE_KEY_PREFIX = "$";
     ROOT_RUN_ID_ATTRIBUTE = `${RESERVED_ATTRIBUTE_KEY_PREFIX}rootRunId`;
     PARENT_RUN_ID_ATTRIBUTE = `${RESERVED_ATTRIBUTE_KEY_PREFIX}parentRunId`;
+    RETENTION_ATTRIBUTE = `${RESERVED_ATTRIBUTE_KEY_PREFIX}retention`;
     ATTRIBUTE_KEY_MAX_LENGTH = 256;
     ATTRIBUTE_VALUE_MAX_BYTES = 256;
     ATTRIBUTE_MAX_PER_RUN = 64;
@@ -119529,7 +119860,7 @@ var version2;
 var init_version = __esm2({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.48";
+    version2 = "5.0.0-beta.49";
   }
 });
 function getWorkflowQueueName(workflowName, namespace) {
@@ -126053,6 +126384,44 @@ async function getForwardedWritableEncryptionKey(runId, deploymentId, encryption
   ]) : void 0;
 }
 __name(getForwardedWritableEncryptionKey, "getForwardedWritableEncryptionKey");
+function tagForwardedWritableTarget(writable, { deploymentId, encryptionPublicKey }) {
+  if (typeof deploymentId === "string") {
+    Object.defineProperty(writable, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL, {
+      value: deploymentId,
+      writable: false
+    });
+  }
+  if (typeof encryptionPublicKey === "string") {
+    Object.defineProperty(writable, STREAM_SERVER_PUBLIC_KEY_SYMBOL, {
+      value: encryptionPublicKey,
+      writable: false
+    });
+  }
+}
+__name(tagForwardedWritableTarget, "tagForwardedWritableTarget");
+function createForwardedWritable({ global: global2, ops, runId, name, key, deploymentId, encryptionPublicKey, runReadyBarrier }) {
+  const serialize32 = getSerializeStream(getExternalReducers(global2, ops, runId, key), key);
+  const serverWritable = new WorkflowServerWritableStream(runId, name, runReadyBarrier);
+  const state = createFlushableState();
+  ops.push(state.promise);
+  flushablePipe(serialize32.readable, serverWritable, state).catch(() => {
+  });
+  pollWritableLock(serialize32.writable, state);
+  Object.defineProperty(serialize32.writable, STREAM_NAME_SYMBOL, {
+    value: name,
+    writable: false
+  });
+  Object.defineProperty(serialize32.writable, STREAM_SERVER_RUN_ID_SYMBOL, {
+    value: runId,
+    writable: false
+  });
+  tagForwardedWritableTarget(serialize32.writable, {
+    deploymentId,
+    encryptionPublicKey
+  });
+  return serialize32.writable;
+}
+__name(createForwardedWritable, "createForwardedWritable");
 function getRunReadableStream(global2, ops, runId, name, startIndex, cryptoKey) {
   let reader;
   let lockState;
@@ -126169,34 +126538,15 @@ function getExternalRevivers(global2 = globalThis, ops, runId, cryptoKey, option
     WritableStream: /* @__PURE__ */ __name2((value) => {
       const targetRunId = typeof value.runId === "string" ? value.runId : runId;
       const targetKey = targetRunId === runId ? cryptoKey : getForwardedWritableEncryptionKey(targetRunId, value.deploymentId, value.encryptionPublicKey);
-      const serialize32 = getSerializeStream(getExternalReducers(global2, ops, targetRunId, targetKey), targetKey);
-      const serverWritable = new WorkflowServerWritableStream(targetRunId, value.name);
-      const state = createFlushableState();
-      ops.push(state.promise);
-      flushablePipe(serialize32.readable, serverWritable, state).catch(() => {
-      });
-      pollWritableLock(serialize32.writable, state);
-      Object.defineProperty(serialize32.writable, STREAM_NAME_SYMBOL, {
-        value: value.name,
-        writable: false
+      return createForwardedWritable({
+        global: global2,
+        ops,
+        runId: targetRunId,
+        name: value.name,
+        key: targetKey,
+        deploymentId: value.deploymentId,
+        encryptionPublicKey: value.encryptionPublicKey
       });
-      Object.defineProperty(serialize32.writable, STREAM_SERVER_RUN_ID_SYMBOL, {
-        value: targetRunId,
-        writable: false
-      });
-      if (typeof value.deploymentId === "string") {
-        Object.defineProperty(serialize32.writable, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL, {
-          value: value.deploymentId,
-          writable: false
-        });
-      }
-      if (typeof value.encryptionPublicKey === "string") {
-        Object.defineProperty(serialize32.writable, STREAM_SERVER_PUBLIC_KEY_SYMBOL, {
-          value: value.encryptionPublicKey,
-          writable: false
-        });
-      }
-      return serialize32.writable;
     }, "WritableStream"),
     AbortController: /* @__PURE__ */ __name2((value) => reviveAbortController(value, ops, runId), "AbortController"),
     AbortSignal: /* @__PURE__ */ __name2((value) => reviveAbortSignal(value, ops, runId), "AbortSignal")
@@ -126696,6 +127046,14 @@ var init_serialization2 = __esm2({
             pendingRunReady = void 0;
           }
         }, "ensureRunReady");
+        const writerId = `wrtr_${defaultUlid()}`;
+        const writeSessionPromise = ensureRunReady().then(async () => {
+          const world = await worldPromise;
+          return world.streams.createWriteSession?.(runId, name, {
+            writerId
+          });
+        });
+        let nextChunkSeq = 0;
         let buffer22 = [];
         let bufferBytes = 0;
         let inFlightChunks = 0;
@@ -126741,14 +127099,18 @@ var init_serialization2 = __esm2({
         const sendGroup = /* @__PURE__ */ __name2(async (group, bytes, groupT0) => {
           await ensureRunReady();
           const world = await worldPromise;
+          const session = await writeSessionPromise;
           const dispatchAt = Date.now();
-          if (typeof world.streams.writeMulti === "function" && group.length > 1) {
+          if (session) {
+            await session.write(nextChunkSeq, group);
+          } else if (typeof world.streams.writeMulti === "function" && group.length > 1) {
             await world.streams.writeMulti(runId, name, group);
           } else {
             for (const chunk of group) {
               await world.streams.write(runId, name, chunk);
             }
           }
+          nextChunkSeq += group.length;
           if (groupT0 !== void 0) {
             recordStreamWriteFlush(groupT0, dispatchAt, runId, name, group.length, bytes, Date.now() - dispatchAt);
           }
@@ -126859,8 +127221,13 @@ var init_serialization2 = __esm2({
             await drain();
             await ensureRunReady();
             const world = await worldPromise;
+            const session = await writeSessionPromise;
             const closeStart = Date.now();
-            await world.streams.close(runId, name);
+            if (session) {
+              await session.close();
+            } else {
+              await world.streams.close(runId, name);
+            }
             recordStreamClose(closeStart, runId, name);
           },
           async abort(reason) {
@@ -126876,6 +127243,8 @@ var init_serialization2 = __esm2({
             bufferBytes = 0;
             sinkError ??= reason ?? new Error("Stream aborted");
             rejectWaiters(sinkError);
+            const session = await writeSessionPromise.catch(() => void 0);
+            await session?.dispose?.();
           }
         });
         Object.defineProperty(this, STREAM_DRAIN_SYMBOL, {
@@ -126900,6 +127269,8 @@ var init_serialization2 = __esm2({
     __name2(reviveAbortSignal, "reviveAbortSignal");
     __name2(getCommonRevivers2, "getCommonRevivers");
     __name2(getForwardedWritableEncryptionKey, "getForwardedWritableEncryptionKey");
+    __name2(tagForwardedWritableTarget, "tagForwardedWritableTarget");
+    __name2(createForwardedWritable, "createForwardedWritable");
     __name2(getRunReadableStream, "getRunReadableStream");
     __name2(getExternalRevivers, "getExternalRevivers");
     __name2(getStepRevivers, "getStepRevivers");
@@ -127129,6 +127500,7 @@ __name2(getWorkflowVmFromEnv, "getWorkflowVmFromEnv");
 init_wait_until();
 init_world_compatibility();
 var CROSS_DEPLOYMENT_CAPABILITY_PROBE_TIMEOUT_MS = 2e3;
+var RETENTION_ZERO_ATTRIBUTE_VALUE = "0";
 var ulid3 = monotonicFactory();
 function resolveLineageAttributes() {
   const store = contextStorage.getStore();
@@ -127234,14 +127606,27 @@ async function start(workflow, argsOrOptions, options) {
           value
         ]));
       }
+      let retentionAttribute;
+      if (opts.experimental_retention !== void 0 && opts.experimental_retention !== "default") {
+        if (opts.experimental_retention !== 0) {
+          throw new WorkflowRuntimeError(`start({ experimental_retention }) must be 0 or 'default'; received ${JSON.stringify(opts.experimental_retention)}.`);
+        }
+        if (specVersion < SPEC_VERSION_SUPPORTS_ATTRIBUTES) {
+          throw new WorkflowRuntimeError("start({ experimental_retention }) requires a World that supports spec version 4 or later.");
+        }
+        retentionAttribute = {
+          [RETENTION_ATTRIBUTE]: RETENTION_ZERO_ATTRIBUTE_VALUE
+        };
+      }
       const lineage = specVersion >= SPEC_VERSION_SUPPORTS_ATTRIBUTES ? resolveLineageAttributes() : void 0;
-      const runAttributes = lineage ? {
+      const runAttributes = lineage || retentionAttribute ? {
         ...lineage,
-        ...attributes
+        ...attributes,
+        ...retentionAttribute
       } : attributes;
       const attributeSeed = runAttributes ? {
         attributes: runAttributes,
-        ...allowReservedAttributes || lineage != null ? {
+        ...allowReservedAttributes || lineage != null || retentionAttribute != null ? {
           allowReservedAttributes: true
         } : {}
       } : {};
@@ -127388,7 +127773,7 @@ __name2(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.48//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.49//start");
 async function wakeUpRun(world, runId, options) {
   try {
     const run22 = await world.runs.get(runId, {
@@ -127476,6 +127861,11 @@ var PAYLOAD_TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set([
   "completed",
   "failed"
 ]);
+var NOT_FOUND_RETRY_DELAYS = [
+  1e3,
+  3e3,
+  6e3
+];
 function getReturnValuePollIntervalMs() {
   return envNumber("WORKFLOW_RETURN_VALUE_POLL_INTERVAL_MS", RETURN_VALUE_POLL_INTERVAL_MS, {
     integer: true,
@@ -127700,8 +128090,75 @@ var Run = class _Run {
       }, "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 = {}) {
+    const { ops = [], global: global2 = globalThis, namespace } = options;
+    const name = getWorkflowRunStreamId(this.runId, namespace);
+    let targetPromise;
+    let writable;
+    const resolveTarget = /* @__PURE__ */ __name2(() => {
+      targetPromise ??= this.#getMetadata().then(async (run22) => {
+        const target2 = {
+          key: await getForwardedWritableEncryptionKey(this.runId, run22.deploymentId, run22.encryptionPublicKey),
+          deploymentId: run22.deploymentId,
+          encryptionPublicKey: run22.encryptionPublicKey
+        };
+        tagForwardedWritableTarget(writable, target2);
+        return target2;
+      });
+      return targetPromise;
+    }, "resolveTarget");
+    writable = createForwardedWritable({
+      global: global2,
+      ops,
+      runId: this.runId,
+      name,
+      key: /* @__PURE__ */ __name2(() => 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_DELAYS.length : 0;
+    let attempt = 0;
+    while (true) {
+      try {
+        return await world.runs.get(this.runId, {
+          resolveData: "none"
+        });
+      } catch (error482) {
+        if (!WorkflowRunNotFoundError.is(error482) || attempt >= maxRetries) {
+          throw error482;
+        }
+        const delay = NOT_FOUND_RETRY_DELAYS[attempt];
+        attempt++;
+        await new Promise((resolve3) => setTimeout(resolve3, delay));
+      }
+    }
+  }
   /** @internal */
   async #resolveTerminalReturnValue(run22) {
+    const expiredAt = run22.expiredAt;
+    if (expiredAt != null && expiredAt <= /* @__PURE__ */ new Date()) {
+      throw new RunExpiredError(`Run "${this.runId}" ${run22.status === "completed" ? "completed" : `is ${run22.status}`}, but its data expired at ${expiredAt.toISOString()} and is no longer readable.`, this.runId, run22.status, expiredAt);
+    }
     if (run22.status === "completed") {
       const encryptionKey = await this.#getEncryptionKey(run22);
       return await hydrateWorkflowReturnValue(run22.output, this.runId, encryptionKey);
@@ -127731,12 +128188,7 @@ var Run = class _Run {
   async #pollReturnValue() {
     const world = await this.#lazyWorldPromise;
     let notFoundRetries = 0;
-    const NOT_FOUND_MAX_RETRIES = this.#resilientStart ? 3 : 0;
-    const NOT_FOUND_DELAYS = [
-      1e3,
-      3e3,
-      6e3
-    ];
+    const NOT_FOUND_MAX_RETRIES = this.#resilientStart ? NOT_FOUND_RETRY_DELAYS.length : 0;
     const waitForTerminalStatus = isReturnValueLongPollEnabled() ? world.runs.waitForTerminalStatus?.bind(world.runs) : void 0;
     let longPolls = 0;
     const maxLongPolls = getReturnValueMaxLongPolls();
@@ -127770,7 +128222,7 @@ var Run = class _Run {
           continue;
         }
         if (WorkflowRunNotFoundError.is(error482) && notFoundRetries < NOT_FOUND_MAX_RETRIES) {
-          const delay = NOT_FOUND_DELAYS[notFoundRetries];
+          const delay = NOT_FOUND_RETRY_DELAYS[notFoundRetries];
           notFoundRetries++;
           await new Promise((resolve3) => setTimeout(resolve3, delay));
           continue;
@@ -127788,7 +128240,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
@@ -127797,7 +128249,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
@@ -127806,7 +128258,16 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
+  __wf_fn.stepId = __wf_id;
+  Object.defineProperty(__wf_fn, "name", {
+    value: "getWritable",
+    configurable: true
+  });
+})(Run.prototype["getWritable"], "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
@@ -127815,7 +128276,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
@@ -127824,7 +128285,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
@@ -127833,7 +128294,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
@@ -127842,7 +128303,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
@@ -127851,7 +128312,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
@@ -127860,7 +128321,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
@@ -127869,7 +128330,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.49//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);
@@ -127879,7 +128340,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.48//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.49//Run");
 async function fetch2(...args) {
   return globalThis.fetch(...args);
 }
@@ -128117,8 +128578,8 @@ function defineHook({ schema } = {}) {
       }
       if (result2.issues) {
         const lines = result2.issues.map((issue22) => {
-          const path14 = issue22.path?.map((segment) => typeof segment === "object" && segment !== null ? String(segment.key) : String(segment)).join(".");
-          return path14 ? `  at "${path14}": ${issue22.message}` : `  ${issue22.message}`;
+          const path15 = issue22.path?.map((segment) => typeof segment === "object" && segment !== null ? String(segment.key) : String(segment)).join(".");
+          return path15 ? `  at "${path15}": ${issue22.message}` : `  ${issue22.message}`;
         });
         throw new Error(`Hook payload did not match the defined schema:
 ${lines.join("\n")}`);
@@ -131741,6 +132202,7 @@ 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 });
 }
@@ -131948,8 +132410,74 @@ var Run2 = class _Run2 {
       }, "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 (error95) {
+        if (!WorkflowRunNotFoundError2.is(error95) || attempt >= maxRetries) {
+          throw error95;
+        }
+        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);
@@ -131979,8 +132507,7 @@ var Run2 = class _Run2 {
   async #pollReturnValue() {
     const world = await this.#lazyWorldPromise;
     let notFoundRetries = 0;
-    const NOT_FOUND_MAX_RETRIES = this.#resilientStart ? 3 : 0;
-    const NOT_FOUND_DELAYS = [1e3, 3e3, 6e3];
+    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();
@@ -132015,7 +132542,7 @@ var Run2 = class _Run2 {
           continue;
         }
         if (WorkflowRunNotFoundError2.is(error95) && notFoundRetries < NOT_FOUND_MAX_RETRIES) {
-          const delay = NOT_FOUND_DELAYS[notFoundRetries];
+          const delay = NOT_FOUND_RETRY_DELAYS2[notFoundRetries];
           notFoundRetries++;
           await new Promise((resolve3) => setTimeout(resolve3, delay));
           continue;
@@ -134845,11 +135372,16 @@ var Run = class _Run {
   get readable() {
     return this.getReadable();
   }
+  /** The writable stream of the workflow run. */
+  get writable() {
+    return this.getWritable();
+  }
 };
-Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.48//Run#wakeUp");
-Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.48//Run#cancel");
-Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.48//Run#getReadable");
-var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.48//Run#exists");
+Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#wakeUp");
+Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#cancel");
+Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#getReadable");
+Run.prototype["getWritable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#getWritable");
+var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#exists");
 Object.defineProperty(Run.prototype, "exists", {
   get() {
     return __step_Run$exists.call(this);
@@ -134857,7 +135389,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.48//Run#status");
+var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#status");
 Object.defineProperty(Run.prototype, "status", {
   get() {
     return __step_Run$status.call(this);
@@ -134865,7 +135397,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.48//Run#returnValue");
+var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#returnValue");
 Object.defineProperty(Run.prototype, "returnValue", {
   get() {
     return __step_Run$returnValue.call(this);
@@ -134873,7 +135405,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.48//Run#workflowName");
+var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#workflowName");
 Object.defineProperty(Run.prototype, "workflowName", {
   get() {
     return __step_Run$workflowName.call(this);
@@ -134881,7 +135413,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.48//Run#createdAt");
+var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#createdAt");
 Object.defineProperty(Run.prototype, "createdAt", {
   get() {
     return __step_Run$createdAt.call(this);
@@ -134889,7 +135421,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.48//Run#startedAt");
+var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#startedAt");
 Object.defineProperty(Run.prototype, "startedAt", {
   get() {
     return __step_Run$startedAt.call(this);
@@ -134897,7 +135429,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.48//Run#completedAt");
+var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.49//Run#completedAt");
 Object.defineProperty(Run.prototype, "completedAt", {
   get() {
     return __step_Run$completedAt.call(this);
@@ -134914,7 +135446,7 @@ Object.defineProperty(Run.prototype, "completedAt", {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.48//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.49//Run");
 
 // ../core/dist/workflow/create-hook.js
 aliasSerializationClass(RUN_CLASS_ID, Run);
@@ -134946,6 +135478,7 @@ __name(defineHook, "defineHook");
 var RESERVED_ATTRIBUTE_KEY_PREFIX = "$";
 var ROOT_RUN_ID_ATTRIBUTE = \`\${RESERVED_ATTRIBUTE_KEY_PREFIX}rootRunId\`;
 var PARENT_RUN_ID_ATTRIBUTE = \`\${RESERVED_ATTRIBUTE_KEY_PREFIX}parentRunId\`;
+var RETENTION_ATTRIBUTE = \`\${RESERVED_ATTRIBUTE_KEY_PREFIX}retention\`;
 var textEncoder = new TextEncoder();
 
 // ../core/dist/workflow/writable-stream.js
@@ -139544,7 +140077,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.48//start");
+var start = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/start@5.0.0-beta.49//start");
 
 // workflows/lineage.ts
 var noop = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//./workflows/lineage//noop");