@workflow/web 5.0.0-beta.48 → 5.0.0-beta.49

package/build/server/assets/{app-CeZRs20L.js → app-BktG_kyr.js}

@@ -13,7 +13,7 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
-var _a2, _b, _c, _d, _listeners, _onabort, _reader, _root, _hasMagic, _uflag, _parts, _parent, _parentIndex, _negs, _filledNegs, _options, _toString, _emptyExt, _AST_instances, fillNegs_fn, _AST_static, parseAST_fn, canAdoptWithSpace_fn, canAdopt_fn, canAdoptType_fn, adoptWithSpace_fn, adopt_fn, canUsurpType_fn, canUsurp_fn, usurp_fn, flatten_fn, partsToRegExp_fn, parseGlob_fn, _Minimatch_instances, matchGlobstar_fn, matchGlobStarBodySections_fn, matchOne_fn, _worldPromise, _Run_instances, lazyWorldPromise_get, _encryptionKeyPromise, _resilientStart, getEncryptionKey_fn, getEncryptionKeyLazily_fn, resolveTerminalReturnValue_fn, pollReturnValue_fn;
+var _a2, _b, _c, _d, _listeners, _onabort, _reader, _root, _hasMagic, _uflag, _parts, _parent, _parentIndex, _negs, _filledNegs, _options, _toString, _emptyExt, _AST_instances, fillNegs_fn, _AST_static, parseAST_fn, canAdoptWithSpace_fn, canAdopt_fn, canAdoptType_fn, adoptWithSpace_fn, adopt_fn, canUsurpType_fn, canUsurp_fn, usurp_fn, flatten_fn, partsToRegExp_fn, parseGlob_fn, _Minimatch_instances, matchGlobstar_fn, matchGlobStarBodySections_fn, matchOne_fn, _worldPromise, _Run_instances, lazyWorldPromise_get, _encryptionKeyPromise, _resilientStart, getEncryptionKey_fn, getEncryptionKeyLazily_fn, getMetadata_fn, resolveTerminalReturnValue_fn, pollReturnValue_fn;
 import { createRequire as __wkfCreateRequire } from "node:module";
 if (typeof require === "undefined") {
   globalThis.require = __wkfCreateRequire(import.meta.url);
@@ -56873,6 +56873,25 @@ const z$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty(
 const RESERVED_ATTRIBUTE_KEY_PREFIX = "$";
 const ROOT_RUN_ID_ATTRIBUTE = `${RESERVED_ATTRIBUTE_KEY_PREFIX}rootRunId`;
 const PARENT_RUN_ID_ATTRIBUTE = `${RESERVED_ATTRIBUTE_KEY_PREFIX}parentRunId`;
+const RETENTION_ATTRIBUTE = `${RESERVED_ATTRIBUTE_KEY_PREFIX}retention`;
+const RETENTION_ZERO = "0";
+const RETENTION_DEFAULT = "default";
+const RETENTION_INTEGER_PATTERN = /^(?:0|[1-9]\d*)$/;
+function readRunRetention(attributes) {
+  const raw2 = attributes == null ? void 0 : attributes[RETENTION_ATTRIBUTE];
+  if (raw2 === void 0) {
+    return { mode: "default", wellFormed: false, unsupported: false };
+  }
+  if (RETENTION_INTEGER_PATTERN.test(raw2)) {
+    return raw2 === RETENTION_ZERO ? { mode: "none", raw: raw2, wellFormed: true, unsupported: false } : { mode: "default", raw: raw2, wellFormed: true, unsupported: true };
+  }
+  return {
+    mode: "default",
+    raw: raw2,
+    wellFormed: false,
+    unsupported: raw2 !== RETENTION_DEFAULT
+  };
+}
 const ATTRIBUTE_KEY_MAX_LENGTH = 256;
 const ATTRIBUTE_VALUE_MAX_BYTES = 256;
 const ATTRIBUTE_MAX_PER_RUN = 64;
@@ -59668,8 +59687,14 @@ class EntityConflictError extends WorkflowWorldError {
   }
 }
 class RunExpiredError extends WorkflowWorldError {
-  constructor(message2) {
-    super(message2);
+  constructor(message2, runId, runStatus, expiredAt) {
+    super(message2, { status: 410, code: "run-expired" });
+    __publicField(this, "runId");
+    __publicField(this, "runStatus");
+    __publicField(this, "expiredAt");
+    this.runId = runId;
+    this.runStatus = runStatus;
+    this.expiredAt = expiredAt;
     this.name = "RunExpiredError";
   }
   static is(value) {
@@ -61082,7 +61107,7 @@ function replaceEncryptedAndExpiredWithMarkers(resource) {
 }
 async function hydrateResourceIOAsync(resource, key) {
   const { hydrateDataWithKey: hydrateDataWithKey2, deriveRunPayloadKeys: deriveRunPayloadKeys2 } = await Promise.resolve().then(() => serializationFormat);
-  const { ensureZstdDecoderRegistered } = await import("./zstd-browser-decoder-DJTnP4ZA.js");
+  const { ensureZstdDecoderRegistered } = await import("./zstd-browser-decoder-BhzrSkhl.js");
   ensureZstdDecoderRegistered();
   const cryptoKey = key ? await deriveRunPayloadKeys2(key) : void 0;
   const revivers = getRevivers();
@@ -92021,7 +92046,7 @@ var tn = f("block", "before:content-[counter(line)]", "before:inline-block", "be
 var et = ({ className: e, language: t, style: o, isIncomplete: n, ...s2 }) => jsxRuntimeExports.jsx("div", { className: f("my-4 flex w-full flex-col gap-2 rounded-xl border border-border bg-sidebar p-2", e), "data-incomplete": n || void 0, "data-language": t, "data-streamdown": "code-block", style: { contentVisibility: "auto", containIntrinsicSize: "auto 200px", ...o }, ...s2 });
 var Se = reactExports.createContext({ code: "" }), de = () => reactExports.useContext(Se);
 var ot = ({ language: e }) => jsxRuntimeExports.jsx("div", { className: "flex h-8 items-center text-muted-foreground text-xs", "data-language": e, "data-streamdown": "code-block-header", children: jsxRuntimeExports.jsx("span", { className: "ml-1 font-mono lowercase", children: e }) });
-var cn$1 = /\n+$/, dn = reactExports.lazy(() => import("./highlighted-body-B3W2YXNL-jO_hupW2.js").then((e) => ({ default: e.HighlightedCodeBlockBody }))), rt = ({ code: e, language: t, className: o, children: n, isIncomplete: s2 = false, ...r2 }) => {
+var cn$1 = /\n+$/, dn = reactExports.lazy(() => import("./highlighted-body-B3W2YXNL-B3n-nCiA.js").then((e) => ({ default: e.HighlightedCodeBlockBody }))), rt = ({ code: e, language: t, className: o, children: n, isIncomplete: s2 = false, ...r2 }) => {
   let i = reactExports.useMemo(() => e.replace(cn$1, ""), [e]), c = reactExports.useMemo(() => ({ bg: "transparent", fg: "inherit", tokens: i.split(`
 `).map((a2) => [{ content: a2, color: "inherit", bgColor: "transparent", htmlStyle: {}, offset: 0 }]) }), [i]);
   return jsxRuntimeExports.jsx(Se.Provider, { value: { code: e }, children: jsxRuntimeExports.jsxs(et, { isIncomplete: s2, language: t, children: [jsxRuntimeExports.jsx(ot, { language: t }), n ? jsxRuntimeExports.jsx("div", { className: "pointer-events-none sticky top-2 z-10 -mt-10 flex h-8 items-center justify-end", children: jsxRuntimeExports.jsx("div", { className: "pointer-events-auto flex shrink-0 items-center gap-2 rounded-md border border-sidebar bg-sidebar/80 px-1.5 py-1 supports-[backdrop-filter]:bg-sidebar/70 supports-[backdrop-filter]:backdrop-blur", "data-streamdown": "code-block-actions", children: n }) }) : null, jsxRuntimeExports.jsx(reactExports.Suspense, { fallback: jsxRuntimeExports.jsx(Qe, { className: o, language: t, result: c, ...r2 }), children: jsxRuntimeExports.jsx(dn, { className: o, code: i, language: t, raw: c, ...r2 }) })] }) });
@@ -92343,7 +92368,7 @@ var Dt = ({ children: e, className: t, onDownload: o, onError: n }) => {
   }, []), jsxRuntimeExports.jsxs("div", { className: "relative", ref: i, children: [jsxRuntimeExports.jsx("button", { className: f("cursor-pointer p-1 text-muted-foreground transition-all hover:text-foreground disabled:cursor-not-allowed disabled:opacity-50", t), disabled: c, onClick: () => r2(!s2), title: "Download table", type: "button", children: e != null ? e : jsxRuntimeExports.jsx(Z, { size: 14 }) }), s2 ? jsxRuntimeExports.jsxs("div", { className: "absolute top-full right-0 z-10 mt-1 min-w-[120px] overflow-hidden rounded-md border border-border bg-background shadow-lg", children: [jsxRuntimeExports.jsx("button", { className: "w-full px-3 py-2 text-left text-sm transition-colors hover:bg-muted/40", onClick: () => a2("csv"), title: "Download table as CSV", type: "button", children: "CSV" }), jsxRuntimeExports.jsx("button", { className: "w-full px-3 py-2 text-left text-sm transition-colors hover:bg-muted/40", onClick: () => a2("markdown"), title: "Download table as Markdown", type: "button", children: "Markdown" })] }) : null] });
 };
 var Vt = ({ children: e, className: t, showControls: o, ...n }) => jsxRuntimeExports.jsxs("div", { className: "my-4 flex flex-col gap-2 rounded-lg border border-border bg-sidebar p-2", "data-streamdown": "table-wrapper", children: [o ? jsxRuntimeExports.jsxs("div", { className: "flex items-center justify-end gap-1", children: [jsxRuntimeExports.jsx(Ht, {}), jsxRuntimeExports.jsx(Dt, {})] }) : null, jsxRuntimeExports.jsx("div", { className: "border-collapse overflow-x-auto overscroll-y-auto rounded-md border border-border bg-background", children: jsxRuntimeExports.jsx("table", { className: f("w-full divide-y divide-border", t), "data-streamdown": "table", ...n, children: e }) })] });
-var Jn = reactExports.lazy(() => import("./mermaid-3ZIDBTTL-2Pe4e_TP.js").then((e) => ({ default: e.Mermaid }))), Kn = /language-([^\s]+)/;
+var Jn = reactExports.lazy(() => import("./mermaid-3ZIDBTTL-CG8N1j_9.js").then((e) => ({ default: e.Mermaid }))), Kn = /language-([^\s]+)/;
 function ke(e, t) {
   if (!(e != null && e.position || t != null && t.position)) return true;
   if (!(e != null && e.position && (t != null && t.position))) return false;
@@ -103416,6 +103441,13 @@ class WorkflowServerWritableStream extends WritableStream {
         pendingRunReady = void 0;
       }
     };
+    const writerId = `wrtr_${defaultUlid()}`;
+    const writeSessionPromise = ensureRunReady().then(async () => {
+      var _a3, _b2;
+      const world = await worldPromise;
+      return (_b2 = (_a3 = world.streams).createWriteSession) == null ? void 0 : _b2.call(_a3, runId, name2, { writerId });
+    });
+    let nextChunkSeq = 0;
     let buffer2 = [];
     let bufferBytes = 0;
     let inFlightChunks = 0;
@@ -103458,14 +103490,18 @@ class WorkflowServerWritableStream extends WritableStream {
     const sendGroup = 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, name2, group);
       } else {
         for (const chunk of group) {
           await world.streams.write(runId, name2, chunk);
         }
       }
+      nextChunkSeq += group.length;
       if (groupT0 !== void 0) {
         recordStreamWriteFlush(groupT0, dispatchAt, runId, name2, group.length, bytes, Date.now() - dispatchAt);
       }
@@ -103580,11 +103616,17 @@ class WorkflowServerWritableStream extends WritableStream {
         await drain();
         await ensureRunReady();
         const world = await worldPromise;
+        const session = await writeSessionPromise;
         const closeStart = Date.now();
-        await world.streams.close(runId, name2);
+        if (session) {
+          await session.close();
+        } else {
+          await world.streams.close(runId, name2);
+        }
         recordStreamClose(closeStart, runId, name2);
       },
       async abort(reason) {
+        var _a3;
         try {
           await drain();
         } catch {
@@ -103597,6 +103639,8 @@ class WorkflowServerWritableStream extends WritableStream {
         bufferBytes = 0;
         sinkError ?? (sinkError = reason ?? new Error("Stream aborted"));
         rejectWaiters(sinkError);
+        const session = await writeSessionPromise.catch(() => void 0);
+        await ((_a3 = session == null ? void 0 : session.dispose) == null ? void 0 : _a3.call(session));
       }
     });
     Object.defineProperty(this, STREAM_DRAIN_SYMBOL, {
@@ -104071,6 +104115,42 @@ async function getForwardedWritableEncryptionKey(runId, deploymentId, encryption
   const rawKey = deploymentId ? await world.getEncryptionKeyForRun(runId, { deploymentId }) : await world.getEncryptionKeyForRun(await world.runs.get(runId));
   return rawKey ? await importKey(rawKey, ["encrypt"]) : void 0;
 }
+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
+    });
+  }
+}
+function createForwardedWritable({ global: global2, ops, runId, name: name2, key, deploymentId, encryptionPublicKey, runReadyBarrier }) {
+  const serialize2 = getSerializeStream(getExternalReducers(global2, ops, runId, key), key);
+  const serverWritable = new WorkflowServerWritableStream(runId, name2, runReadyBarrier);
+  const state = createFlushableState();
+  ops.push(state.promise);
+  flushablePipe(serialize2.readable, serverWritable, state).catch(() => {
+  });
+  pollWritableLock(serialize2.writable, state);
+  Object.defineProperty(serialize2.writable, STREAM_NAME_SYMBOL, {
+    value: name2,
+    writable: false
+  });
+  Object.defineProperty(serialize2.writable, STREAM_SERVER_RUN_ID_SYMBOL, {
+    value: runId,
+    writable: false
+  });
+  tagForwardedWritableTarget(serialize2.writable, {
+    deploymentId,
+    encryptionPublicKey
+  });
+  return serialize2.writable;
+}
 function getRunReadableStream(global2, ops, runId, name2, startIndex, cryptoKey) {
   let reader;
   let lockState;
@@ -104187,34 +104267,15 @@ function getExternalRevivers(global2 = globalThis, ops, runId, cryptoKey, option
     WritableStream: (value) => {
       const targetRunId = typeof value.runId === "string" ? value.runId : runId;
       const targetKey = targetRunId === runId ? cryptoKey : getForwardedWritableEncryptionKey(targetRunId, value.deploymentId, value.encryptionPublicKey);
-      const serialize2 = getSerializeStream(getExternalReducers(global2, ops, targetRunId, targetKey), targetKey);
-      const serverWritable = new WorkflowServerWritableStream(targetRunId, value.name);
-      const state = createFlushableState();
-      ops.push(state.promise);
-      flushablePipe(serialize2.readable, serverWritable, state).catch(() => {
-      });
-      pollWritableLock(serialize2.writable, state);
-      Object.defineProperty(serialize2.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(serialize2.writable, STREAM_SERVER_RUN_ID_SYMBOL, {
-        value: targetRunId,
-        writable: false
-      });
-      if (typeof value.deploymentId === "string") {
-        Object.defineProperty(serialize2.writable, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL, {
-          value: value.deploymentId,
-          writable: false
-        });
-      }
-      if (typeof value.encryptionPublicKey === "string") {
-        Object.defineProperty(serialize2.writable, STREAM_SERVER_PUBLIC_KEY_SYMBOL, {
-          value: value.encryptionPublicKey,
-          writable: false
-        });
-      }
-      return serialize2.writable;
     },
     AbortController: (value) => reviveAbortController(value, ops, runId),
     AbortSignal: (value) => reviveAbortSignal(value, ops, runId)
@@ -104671,7 +104732,7 @@ globalSingleton("@workflow/core//envWarnings", 1, () => ({
   maxInlineStepsValues: /* @__PURE__ */ new Set(),
   maxEventsValues: /* @__PURE__ */ new Set()
 }));
-const version$1 = "5.0.0-beta.48";
+const version$1 = "5.0.0-beta.49";
 const DEFAULT_HEALTH_CHECK_TIMEOUT = 3e4;
 const SAFE_WORKFLOW_NAME_PATTERN = /^[a-zA-Z0-9_\-./@]+$/;
 function getWorkflowQueueName(workflowName, namespace2) {
@@ -105306,7 +105367,7 @@ async function write(filePath, data, opts) {
 }
 async function readJSON(filePath, decoder2) {
   try {
-    const content2 = await promises.readFile(filePath, "utf-8");
+    const content2 = await withWindowsRetry(() => promises.readFile(filePath, "utf-8"));
     return decoder2.parse(JSON.parse(content2, jsonReviver));
   } catch (error2) {
     if (error2.code === "ENOENT")
@@ -132248,7 +132309,7 @@ function envTimeoutMs(name2, fallback) {
   const parsed = Number.parseInt(raw2, 10);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
 }
-function getQueueAgentOptions() {
+function getQueueAgentOptions$1() {
   return {
     bodyTimeout: envTimeoutMs("WORKFLOW_LOCAL_BODY_TIMEOUT_MS", DEFAULT_BODY_TIMEOUT_MS),
     connections: 1e3,
@@ -132271,7 +132332,7 @@ function isDetachedArrayBufferQueueError(error2) {
   return false;
 }
 function createQueue$2(config2) {
-  const agentOptions = getQueueAgentOptions();
+  const agentOptions = getQueueAgentOptions$1();
   const nodeHttpAgents = isNodeHttpEnabled() ? createNodeHttpAgents({
     maxSockets: agentOptions.connections,
     keepAliveMs: agentOptions.keepAliveTimeout
@@ -134704,6 +134765,500 @@ async function deleteAllHooksForRun(basedir, runId) {
     await deleteHookByRunMarkerFile(basedir, marker.fileId);
   }
 }
+const chunkIds = globalSingleton("@workflow/world-local//streamerMonotonicUlid", 1, () => ({ next: monotonicFactory(() => Math.random()) }));
+const monotonicUlid = (seedTime) => chunkIds.next(seedTime);
+const RunStreamsSchema = object$1({
+  streams: array$1(string$3())
+});
+const EOF_MARKER = 1;
+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 fs$1.readdir(chunksDir);
+  } catch (error2) {
+    if (error2.code === "ENOENT")
+      return [];
+    throw error2;
+  }
+}
+function addChunkFilesByExtension(extMap, entries, sourceExtension, fileExtension = sourceExtension, include = () => true) {
+  for (const entry2 of entries) {
+    if (!entry2.endsWith(sourceExtension))
+      continue;
+    const file2 = entry2.slice(0, -sourceExtension.length);
+    if (include(file2))
+      extMap.set(file2, fileExtension);
+  }
+}
+function chunkDirForStream(chunksBaseDir, name2) {
+  assertSafeEntityId("streamName", name2);
+  return path$3.join(chunksBaseDir, name2);
+}
+async function listChunkFilesForStream(chunksBaseDir, name2, tag) {
+  const dir = chunkDirForStream(chunksBaseDir, name2);
+  const entries = await listChunkEntries(dir);
+  const extMap = /* @__PURE__ */ new Map();
+  addChunkFilesByExtension(extMap, entries, ".json");
+  addChunkFilesByExtension(extMap, entries, ".bin", ".bin", tag ? (file2) => !file2.endsWith(`.${tag}`) : void 0);
+  if (tag) {
+    const taggedExtension = `.${tag}.bin`;
+    addChunkFilesByExtension(extMap, entries, taggedExtension);
+  }
+  const files = [...extMap.keys()].sort();
+  return { files, extMap, dir };
+}
+const PURGED_STREAM_TOMBSTONE_ID = `chnk_${"0".repeat(26)}`;
+async function purgeRunStreamData(basedir, runId, tag) {
+  const chunksBaseDir = path$3.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 == null ? void 0 : mapping.streams) ?? [];
+  } catch (error2) {
+    logStreamPurgeFailure(`streams of ${runId}`, error2);
+    return;
+  }
+  for (const name2 of names) {
+    try {
+      const dir = chunkDirForStream(chunksBaseDir, name2);
+      await write(path$3.join(dir, `${PURGED_STREAM_TOMBSTONE_ID}${tagSuffix}.bin`), serializeChunk({ chunk: Buffer.from([]), eof: true }), { overwrite: true });
+      for (const entry2 of await listChunkEntries(dir)) {
+        if (entry2.startsWith(PURGED_STREAM_TOMBSTONE_ID))
+          continue;
+        if (!entry2.endsWith(".bin") && !entry2.endsWith(".json"))
+          continue;
+        await withWindowsRetry(() => fs$1.unlink(path$3.join(dir, entry2))).catch((error2) => {
+          if (error2.code !== "ENOENT")
+            logStreamPurgeFailure(entry2, error2);
+        });
+      }
+    } catch (error2) {
+      logStreamPurgeFailure(name2, error2);
+    }
+  }
+}
+function logStreamPurgeFailure(target2, error2) {
+  console.warn(`[world-local] Failed to purge stream data for ${target2}:`, error2 instanceof Error ? error2.message : error2);
+}
+function createStreamer$1(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 == null ? void 0 : existing.streams) ?? [];
+    if (!streams.includes(streamName)) {
+      streams.push(streamName);
+      await writeJSON(runStreamsPath, { streams }, { overwrite: true });
+    }
+    registeredStreams.add(cacheKey);
+  }
+  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);
+    }
+  }
+  return {
+    streams: {
+      async write(_runId, name2, chunk) {
+        const chunkId = `chnk_${monotonicUlid()}`;
+        const runId = await _runId;
+        await registerStreamForRun(runId, name2);
+        const chunkBuffer = toBuffer(chunk);
+        const serialized = serializeChunk({
+          chunk: chunkBuffer,
+          eof: false
+        });
+        const chunkPath = path$3.join(chunkDirForStream(path$3.join(basedir, "streams", "chunks"), name2), `${chunkId}${tagSuffix}.bin`);
+        await write(chunkPath, serialized);
+        const chunkData = Uint8Array.from(chunkBuffer);
+        streamEmitter.emit(`chunk:${name2}`, {
+          streamName: name2,
+          chunkData,
+          chunkId
+        });
+      },
+      async writeMulti(_runId, name2, chunks) {
+        if (chunks.length === 0)
+          return;
+        const chunkIds2 = chunks.map(() => `chnk_${monotonicUlid()}`);
+        const runId = await _runId;
+        await registerStreamForRun(runId, name2);
+        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 = path$3.join(chunkDirForStream(path$3.join(basedir, "streams", "chunks"), name2), `${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:${name2}`, {
+            streamName: name2,
+            chunkData,
+            chunkId
+          });
+        }
+      },
+      async close(_runId, name2) {
+        const chunkId = `chnk_${monotonicUlid()}`;
+        const runId = await _runId;
+        await registerStreamForRun(runId, name2);
+        const chunkPath = path$3.join(chunkDirForStream(path$3.join(basedir, "streams", "chunks"), name2), `${chunkId}${tagSuffix}.bin`);
+        await write(chunkPath, serializeChunk({ chunk: Buffer.from([]), eof: true }));
+        streamEmitter.emit(`close:${name2}`, { streamName: name2 });
+      },
+      async list(runId) {
+        assertSafeEntityId("runId", runId);
+        const data = await readJSONWithFallback(basedir, "streams/runs", runId, RunStreamsSchema, tag);
+        return (data == null ? void 0 : data.streams) ?? [];
+      },
+      async getChunks(_runId, name2, options) {
+        const limit = (options == null ? void 0 : options.limit) ?? 100;
+        const chunksBaseDir = path$3.join(basedir, "streams", "chunks");
+        const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name2, tag);
+        let startIndex = 0;
+        if (options == null ? void 0 : 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 file2 of chunkFiles) {
+          const ext2 = fileExtMap.get(file2) ?? ".bin";
+          const filePath = path$3.join(chunksDir, `${file2}${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, name2) {
+        const chunksBaseDir = path$3.join(basedir, "streams", "chunks");
+        const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name2, tag);
+        let streamDone = false;
+        let dataCount = 0;
+        for (const file2 of chunkFiles) {
+          const ext2 = fileExtMap.get(file2) ?? ".bin";
+          if (isEofByte(await readFirstByte(path$3.join(chunksDir, `${file2}${ext2}`)))) {
+            streamDone = true;
+            break;
+          }
+          dataCount++;
+        }
+        return { tailIndex: dataCount - 1, done: streamDone };
+      },
+      async get(_runId, name2, startIndex = 0) {
+        const chunksBaseDir = path$3.join(basedir, "streams", "chunks");
+        let 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 = (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));
+              }
+            };
+            const closeListener = () => {
+              if (isReadingFromDisk) {
+                pendingClose = true;
+                return;
+              }
+              streamClosed = true;
+              teardown();
+              try {
+                controller.close();
+              } catch {
+              }
+            };
+            teardown = () => {
+              streamEmitter.off(`chunk:${name2}`, chunkListener);
+              streamEmitter.off(`close:${name2}`, closeListener);
+              if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+              }
+            };
+            streamEmitter.on(`chunk:${name2}`, chunkListener);
+            streamEmitter.on(`close:${name2}`, closeListener);
+            const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name2, 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(path$3.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 file2 = chunkFiles[i];
+              const chunkId = file2;
+              if (deliveredChunkIds.has(chunkId)) {
+                continue;
+              }
+              const ext2 = fileExtMap.get(file2) ?? ".bin";
+              const chunk = deserializeChunk(await readBuffer(path$3.join(chunksDir, `${file2}${ext2}`)));
+              if ((chunk == null ? void 0 : chunk.eof) === true) {
+                isComplete = true;
+                break;
+              }
+              deliveredChunkIds.add(chunkId);
+              if (chunk.chunk.byteLength) {
+                controller.enqueue(Uint8Array.from(chunk.chunk));
+              }
+            }
+            isReadingFromDisk = false;
+            bufferedEventChunks.sort((a2, b2) => a2.chunkId.localeCompare(b2.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, name2, tag);
+                for (const file2 of currentFiles) {
+                  const chunkId = file2;
+                  if (deliveredChunkIds.has(chunkId))
+                    continue;
+                  deliveredChunkIds.add(chunkId);
+                  const ext2 = currentExtMap.get(file2) ?? ".bin";
+                  const chunk = deserializeChunk(await readBuffer(path$3.join(chunksDir, `${file2}${ext2}`)));
+                  if ((chunk == null ? void 0 : 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();
+          }
+        });
+      }
+    }
+  };
+}
+function purgesUserDataOnFinish(attributes) {
+  const retention = readRunRetention(attributes);
+  if (retention.unsupported) {
+    console.warn(`[world-local] Ignoring unrecognized ${RETENTION_ATTRIBUTE} value ${JSON.stringify(retention.raw)}; keeping the run's data.`);
+  }
+  return retention.mode === "none";
+}
+function withRunPayloadsPurged(run2, purgedAt) {
+  return {
+    ...run2,
+    input: void 0,
+    output: void 0,
+    error: void 0,
+    expiredAt: purgedAt
+  };
+}
+async function purgeRunEntityData(basedir, runId, tag) {
+  await Promise.all([
+    scrubEntityFiles(path$3.join(basedir, "steps"), runId, (step) => {
+      step.input = void 0;
+      step.output = void 0;
+      step.error = void 0;
+    }),
+    scrubEntityFiles(path$3.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)
+  ]);
+}
+const RawEntitySchema = record(string$3(), any());
+async function scrubEntityFiles(directory, runId, scrub) {
+  let fileIds;
+  try {
+    fileIds = await listJSONFiles(directory);
+  } catch (error2) {
+    logPurgeFailure(directory, error2);
+    return;
+  }
+  for (const fileId of fileIds) {
+    if (!fileId.startsWith(`${runId}-`))
+      continue;
+    const filePath = path$3.join(directory, `${fileId}.json`);
+    try {
+      const raw2 = await readJSON(filePath, RawEntitySchema);
+      if (!raw2)
+        continue;
+      scrub(raw2);
+      await writeJSON(filePath, raw2, { overwrite: true });
+    } catch (error2) {
+      logPurgeFailure(filePath, error2);
+    }
+  }
+}
+async function scrubHookMetadata(basedir, runId) {
+  let markers;
+  try {
+    await ensureHookIndexes(basedir);
+    markers = await listHookByRunMarkers(basedir, runId);
+  } catch (error2) {
+    logPurgeFailure(`hooks of ${runId}`, error2);
+    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 (error2) {
+      logPurgeFailure(marker.hookId, error2);
+    }
+  }
+}
+function logPurgeFailure(target2, error2) {
+  console.warn(`[world-local] Failed to purge user data for ${target2}:`, error2 instanceof Error ? error2.message : error2);
+}
 const emitter = new EventEmitter();
 emitter.setMaxListeners(0);
 const RUN_STATUS_POLL_INTERVAL_MS = 100;
@@ -134777,13 +135332,18 @@ async function handleLegacyEvent(basedir, runId, data, currentRun, params) {
         updatedAt: now2,
         attributes: currentRun.attributes
       };
+      const purged = purgesUserDataOnFinish(run2.attributes);
+      const stored = purged ? withRunPayloadsPurged(run2, now2) : run2;
       const runPath = resolveWithinBase(basedir, "runs", `${runId}.json`);
-      await writeJSON(runPath, run2, { 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$1(run2, resolveData)
+        run: filterRunData$1(stored, resolveData)
       };
     }
     case "wait_completed":
@@ -135083,17 +135643,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), WorkflowRunSchema);
-    const next2 = {
-      ...proposed,
-      attributes: (fresh == null ? void 0 : fresh.attributes) ?? proposed.attributes
-    };
+    const attributes = (fresh == null ? void 0 : fresh.attributes) ?? proposed.attributes;
+    let next2 = { ...proposed, attributes };
+    const purged = isTerminalWorkflowRunStatus(next2.status) && purgesUserDataOnFinish(attributes);
+    if (purged) {
+      next2 = withRunPayloadsPurged(next2, /* @__PURE__ */ new Date());
+    }
     await writeJSON(taggedPath(basedir, "runs", runId, tag), next2, {
       overwrite: true
     });
     if (isTerminalWorkflowRunStatus(next2.status)) {
       signalRunTerminal(runId);
     }
-    return next2;
+    return { run: next2, purged };
   });
 }
 function createEventsStorage(basedir, tag) {
@@ -135520,6 +136082,7 @@ function createEventsStorage(basedir, tag) {
           event = { ...event, eventData };
         }
         let run2;
+        let runPurged = false;
         let step;
         let hook;
         let wait;
@@ -135583,7 +136146,7 @@ function createEventsStorage(basedir, tag) {
                 maxEvents: getMaxEventsPerRun()
               };
             }
-            run2 = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
+            const written = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
               runId: currentRun.runId,
               deploymentId: currentRun.deploymentId,
               workflowName: currentRun.workflowName,
@@ -135601,11 +136164,13 @@ function createEventsStorage(basedir, tag) {
               attributes: currentRun.attributes,
               encryptionPublicKey: currentRun.encryptionPublicKey
             });
+            run2 = written.run;
+            runPurged = written.purged;
           }
         } else if (data.eventType === "run_completed" && "eventData" in data) {
           const completedData = data.eventData;
           if (currentRun) {
-            run2 = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
+            const written = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
               runId: currentRun.runId,
               deploymentId: currentRun.deploymentId,
               workflowName: currentRun.workflowName,
@@ -135623,6 +136188,8 @@ function createEventsStorage(basedir, tag) {
               attributes: currentRun.attributes,
               encryptionPublicKey: currentRun.encryptionPublicKey
             });
+            run2 = written.run;
+            runPurged = written.purged;
             await Promise.all([
               deleteAllHooksForRun(basedir, effectiveRunId),
               deleteAllWaitsForRun(basedir, effectiveRunId)
@@ -135631,7 +136198,7 @@ function createEventsStorage(basedir, tag) {
         } else if (data.eventType === "run_failed" && "eventData" in data) {
           const failedData = data.eventData;
           if (currentRun) {
-            run2 = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
+            const written = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
               runId: currentRun.runId,
               deploymentId: currentRun.deploymentId,
               workflowName: currentRun.workflowName,
@@ -135650,6 +136217,8 @@ function createEventsStorage(basedir, tag) {
               attributes: currentRun.attributes,
               encryptionPublicKey: currentRun.encryptionPublicKey
             });
+            run2 = written.run;
+            runPurged = written.purged;
             await Promise.all([
               deleteAllHooksForRun(basedir, effectiveRunId),
               deleteAllWaitsForRun(basedir, effectiveRunId)
@@ -135657,7 +136226,7 @@ function createEventsStorage(basedir, tag) {
           }
         } else if (data.eventType === "run_cancelled") {
           if (currentRun) {
-            run2 = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
+            const written = await writeRunUnderLifecycleLock(basedir, effectiveRunId, tag, {
               runId: currentRun.runId,
               deploymentId: currentRun.deploymentId,
               workflowName: currentRun.workflowName,
@@ -135675,6 +136244,8 @@ function createEventsStorage(basedir, tag) {
               attributes: currentRun.attributes,
               encryptionPublicKey: currentRun.encryptionPublicKey
             });
+            run2 = written.run;
+            runPurged = written.purged;
             await Promise.all([
               deleteAllHooksForRun(basedir, effectiveRunId),
               deleteAllWaitsForRun(basedir, effectiveRunId)
@@ -136128,6 +136699,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 == null ? void 0 : params.resolveData) ?? DEFAULT_RESOLVE_DATA_OPTION$1;
         const filteredEvent = stripEventDataRefs(event, resolveData);
         let eventPage;
@@ -136326,379 +136901,6 @@ function createStorage$1(basedir, tag) {
     clearCache: () => events2.clearCache()
   };
 }
-const chunkIds = globalSingleton("@workflow/world-local//streamerMonotonicUlid", 1, () => ({ next: monotonicFactory(() => Math.random()) }));
-const monotonicUlid = (seedTime) => chunkIds.next(seedTime);
-const RunStreamsSchema = object$1({
-  streams: array$1(string$3())
-});
-const EOF_MARKER = 1;
-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 fs$1.readdir(chunksDir);
-  } catch (error2) {
-    if (error2.code === "ENOENT")
-      return [];
-    throw error2;
-  }
-}
-function addChunkFilesByExtension(extMap, entries, sourceExtension, fileExtension = sourceExtension, include = () => true) {
-  for (const entry2 of entries) {
-    if (!entry2.endsWith(sourceExtension))
-      continue;
-    const file2 = entry2.slice(0, -sourceExtension.length);
-    if (include(file2))
-      extMap.set(file2, fileExtension);
-  }
-}
-function chunkDirForStream(chunksBaseDir, name2) {
-  assertSafeEntityId("streamName", name2);
-  return path$3.join(chunksBaseDir, name2);
-}
-async function listChunkFilesForStream(chunksBaseDir, name2, tag) {
-  const dir = chunkDirForStream(chunksBaseDir, name2);
-  const entries = await listChunkEntries(dir);
-  const extMap = /* @__PURE__ */ new Map();
-  addChunkFilesByExtension(extMap, entries, ".json");
-  addChunkFilesByExtension(extMap, entries, ".bin", ".bin", tag ? (file2) => !file2.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$1(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 == null ? void 0 : existing.streams) ?? [];
-    if (!streams.includes(streamName)) {
-      streams.push(streamName);
-      await writeJSON(runStreamsPath, { streams }, { overwrite: true });
-    }
-    registeredStreams.add(cacheKey);
-  }
-  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);
-    }
-  }
-  return {
-    streams: {
-      async write(_runId, name2, chunk) {
-        const chunkId = `chnk_${monotonicUlid()}`;
-        const runId = await _runId;
-        await registerStreamForRun(runId, name2);
-        const chunkBuffer = toBuffer(chunk);
-        const serialized = serializeChunk({
-          chunk: chunkBuffer,
-          eof: false
-        });
-        const chunkPath = path$3.join(chunkDirForStream(path$3.join(basedir, "streams", "chunks"), name2), `${chunkId}${tagSuffix}.bin`);
-        await write(chunkPath, serialized);
-        const chunkData = Uint8Array.from(chunkBuffer);
-        streamEmitter.emit(`chunk:${name2}`, {
-          streamName: name2,
-          chunkData,
-          chunkId
-        });
-      },
-      async writeMulti(_runId, name2, chunks) {
-        if (chunks.length === 0)
-          return;
-        const chunkIds2 = chunks.map(() => `chnk_${monotonicUlid()}`);
-        const runId = await _runId;
-        await registerStreamForRun(runId, name2);
-        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 = path$3.join(chunkDirForStream(path$3.join(basedir, "streams", "chunks"), name2), `${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:${name2}`, {
-            streamName: name2,
-            chunkData,
-            chunkId
-          });
-        }
-      },
-      async close(_runId, name2) {
-        const chunkId = `chnk_${monotonicUlid()}`;
-        const runId = await _runId;
-        await registerStreamForRun(runId, name2);
-        const chunkPath = path$3.join(chunkDirForStream(path$3.join(basedir, "streams", "chunks"), name2), `${chunkId}${tagSuffix}.bin`);
-        await write(chunkPath, serializeChunk({ chunk: Buffer.from([]), eof: true }));
-        streamEmitter.emit(`close:${name2}`, { streamName: name2 });
-      },
-      async list(runId) {
-        assertSafeEntityId("runId", runId);
-        const data = await readJSONWithFallback(basedir, "streams/runs", runId, RunStreamsSchema, tag);
-        return (data == null ? void 0 : data.streams) ?? [];
-      },
-      async getChunks(_runId, name2, options) {
-        const limit = (options == null ? void 0 : options.limit) ?? 100;
-        const chunksBaseDir = path$3.join(basedir, "streams", "chunks");
-        const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name2, tag);
-        let startIndex = 0;
-        if (options == null ? void 0 : 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 file2 of chunkFiles) {
-          const ext2 = fileExtMap.get(file2) ?? ".bin";
-          const filePath = path$3.join(chunksDir, `${file2}${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, name2) {
-        const chunksBaseDir = path$3.join(basedir, "streams", "chunks");
-        const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name2, tag);
-        let streamDone = false;
-        let dataCount = 0;
-        for (const file2 of chunkFiles) {
-          const ext2 = fileExtMap.get(file2) ?? ".bin";
-          if (isEofByte(await readFirstByte(path$3.join(chunksDir, `${file2}${ext2}`)))) {
-            streamDone = true;
-            break;
-          }
-          dataCount++;
-        }
-        return { tailIndex: dataCount - 1, done: streamDone };
-      },
-      async get(_runId, name2, startIndex = 0) {
-        const chunksBaseDir = path$3.join(basedir, "streams", "chunks");
-        let 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 = (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));
-              }
-            };
-            const closeListener = () => {
-              if (isReadingFromDisk) {
-                pendingClose = true;
-                return;
-              }
-              streamClosed = true;
-              teardown();
-              try {
-                controller.close();
-              } catch {
-              }
-            };
-            teardown = () => {
-              streamEmitter.off(`chunk:${name2}`, chunkListener);
-              streamEmitter.off(`close:${name2}`, closeListener);
-              if (pollInterval) {
-                clearInterval(pollInterval);
-                pollInterval = null;
-              }
-            };
-            streamEmitter.on(`chunk:${name2}`, chunkListener);
-            streamEmitter.on(`close:${name2}`, closeListener);
-            const { files: chunkFiles, extMap: fileExtMap, dir: chunksDir } = await listChunkFilesForStream(chunksBaseDir, name2, 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(path$3.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 file2 = chunkFiles[i];
-              const chunkId = file2;
-              if (deliveredChunkIds.has(chunkId)) {
-                continue;
-              }
-              const ext2 = fileExtMap.get(file2) ?? ".bin";
-              const chunk = deserializeChunk(await readBuffer(path$3.join(chunksDir, `${file2}${ext2}`)));
-              if ((chunk == null ? void 0 : chunk.eof) === true) {
-                isComplete = true;
-                break;
-              }
-              deliveredChunkIds.add(chunkId);
-              if (chunk.chunk.byteLength) {
-                controller.enqueue(Uint8Array.from(chunk.chunk));
-              }
-            }
-            isReadingFromDisk = false;
-            bufferedEventChunks.sort((a2, b2) => a2.chunkId.localeCompare(b2.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, name2, tag);
-                for (const file2 of currentFiles) {
-                  const chunkId = file2;
-                  if (deliveredChunkIds.has(chunkId))
-                    continue;
-                  deliveredChunkIds.add(chunkId);
-                  const ext2 = currentExtMap.get(file2) ?? ".bin";
-                  const chunk = deserializeChunk(await readBuffer(path$3.join(chunksDir, `${file2}${ext2}`)));
-                  if ((chunk == null ? void 0 : 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();
-          }
-        });
-      }
-    }
-  };
-}
 function createWorld$2(args) {
   const definedArgs = args ? Object.fromEntries(Object.entries(args).filter(([, value]) => value !== void 0)) : {};
   const mergedConfig = { ...config.value, ...definedArgs };
@@ -136750,7 +136952,7 @@ function createWorld$2(args) {
         const basedir = mergedConfig.dataDir;
         const hooksDir = path$3.join(basedir, "hooks");
         const taggedHookFiles = await listTaggedFiles(hooksDir, tag);
-        const { HookSchema: HookSchema2 } = await import("./index-DshIaniU.js");
+        const { HookSchema: HookSchema2 } = await import("./index-SGZlzYCB.js");
         await Promise.all(taggedHookFiles.map(async (hookFile) => {
           const hook = await readJSON(path$3.join(hooksDir, hookFile), HookSchema2);
           if (hook == null ? void 0 : hook.token) {
@@ -136933,8 +137135,8 @@ function requireGetVercelOidcToken() {
     }
     try {
       const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
-        await import("./token-util-BMRcW3Qd.js").then((n) => n.t),
-        await import("./token-DAVWictz.js").then((n) => n.t)
+        await import("./token-util-C4igRPyO.js").then((n) => n.t),
+        await import("./token-tFJ2cDc9.js").then((n) => n.t)
       ]);
       if (!token || isExpired(getTokenPayload(token), options == null ? void 0 : options.expirationBufferMs)) {
         await refreshToken(options);
@@ -137497,9 +137699,10 @@ function requireDist() {
   return dist;
 }
 var distExports = requireDist();
-const version = "5.0.0-beta.44";
+const version = "5.0.0-beta.45";
 const pools = globalSingleton("@workflow/world-vercel//httpPools", 1, () => ({
   dispatcher: void 0,
+  queueDispatcher: void 0,
   streamDispatcher: void 0,
   streamCloseDispatcher: void 0,
   nodeHttpAgents: void 0
@@ -137520,6 +137723,64 @@ const DEFAULT_AGENT_OPTIONS = {
   // head-of-line blocking that deadlocks the webhook respondWith mechanism.
   pipelining: 1
 };
+const QUEUE_AGENT_CONNECTIONS = 64;
+const QUEUE_REQUEST_TIMEOUT_MS = 3e4;
+const getQueueRequestTimeoutMs = () => envNumber("WORKFLOW_VERCEL_QUEUE_TIMEOUT_MS", QUEUE_REQUEST_TIMEOUT_MS, {
+  integer: true,
+  min: 5e3,
+  max: 12e4
+});
+function getQueueAgentOptions() {
+  const timeoutMs = getQueueRequestTimeoutMs();
+  return {
+    ...DEFAULT_AGENT_OPTIONS,
+    connections: envNumber("WORKFLOW_VERCEL_QUEUE_CONNECTIONS", QUEUE_AGENT_CONNECTIONS, { integer: true, min: 1, max: 1024 }),
+    headersTimeout: timeoutMs,
+    bodyTimeout: timeoutMs
+  };
+}
+const ForwardingHandler = undiciExports.DecoratorHandler;
+function deadlineInterceptor(timeoutMs) {
+  var _expired, _controller, _timer, _DeadlineHandler_instances, abort_fn;
+  class DeadlineHandler extends ForwardingHandler {
+    constructor(handler) {
+      var _a3, _b2;
+      super(handler);
+      __privateAdd(this, _DeadlineHandler_instances);
+      __privateAdd(this, _expired, false);
+      __privateAdd(this, _controller);
+      __privateAdd(this, _timer);
+      __privateSet(this, _timer, setTimeout(() => {
+        __privateSet(this, _expired, true);
+        __privateMethod(this, _DeadlineHandler_instances, abort_fn).call(this);
+      }, timeoutMs));
+      (_b2 = (_a3 = __privateGet(this, _timer)).unref) == null ? void 0 : _b2.call(_a3);
+    }
+    onRequestStart(controller, context) {
+      __privateSet(this, _controller, controller);
+      super.onRequestStart(controller, context);
+      if (__privateGet(this, _expired))
+        __privateMethod(this, _DeadlineHandler_instances, abort_fn).call(this);
+    }
+    onResponseEnd(controller, trailers) {
+      clearTimeout(__privateGet(this, _timer));
+      super.onResponseEnd(controller, trailers);
+    }
+    onResponseError(controller, error2) {
+      clearTimeout(__privateGet(this, _timer));
+      super.onResponseError(controller, error2);
+    }
+  }
+  _expired = new WeakMap();
+  _controller = new WeakMap();
+  _timer = new WeakMap();
+  _DeadlineHandler_instances = new WeakSet();
+  abort_fn = function() {
+    var _a3;
+    (_a3 = __privateGet(this, _controller)) == null ? void 0 : _a3.abort(new Error(`Queue request exceeded its ${timeoutMs}ms deadline`));
+  };
+  return (dispatch2) => (opts, handler) => dispatch2(opts, new DeadlineHandler(handler));
+}
 const EVENTS_AGENT_OPTIONS = {
   ...BASE_AGENT_OPTIONS,
   allowH2: true,
@@ -137699,7 +137960,7 @@ function getDispatcher(config2) {
   return resolveDispatcher(config2, getDefaultDispatcher);
 }
 function getQueueDispatcher(config2) {
-  return (config2 == null ? void 0 : config2.dispatcher) ?? getDefaultDispatcher();
+  return resolveDispatcher(config2, getDefaultQueueDispatcher);
 }
 function getEventsDispatcher(config2) {
   return resolveDispatcher(config2, () => eventsRecycler.get());
@@ -137732,6 +137993,13 @@ function withBoundLifecycle(agent2, composed) {
 function createStreamDispatcher(retryOptions, agentOverrides) {
   return new undiciExports.RetryAgent(new undiciExports.Agent({ ...STREAM_AGENT_OPTIONS, ...agentOverrides }), retryOptions);
 }
+function createQueueDispatcher() {
+  return new undiciExports.RetryAgent(new undiciExports.Agent(getQueueAgentOptions()).compose(deadlineInterceptor(getQueueRequestTimeoutMs())), RETRY_AGENT_OPTIONS);
+}
+function getDefaultQueueDispatcher() {
+  pools.queueDispatcher ?? (pools.queueDispatcher = createQueueDispatcher());
+  return pools.queueDispatcher;
+}
 function getDefaultDispatcher() {
   pools.dispatcher ?? (pools.dispatcher = makeRetryDispatcher(DEFAULT_AGENT_OPTIONS, RETRY_AGENT_OPTIONS));
   return pools.dispatcher;
@@ -139020,7 +139288,7 @@ function createGetEncryptionKeyForRun(projectId, teamId, token, dispatcher2) {
   };
 }
 async function getDeadline() {
-  const { getDeadline: getDeadline2 } = await import("./index-dJuvq1GP.js").then((n) => n.i);
+  const { getDeadline: getDeadline2 } = await import("./index-EldBi9Vs.js").then((n) => n.i);
   return getDeadline2();
 }
 const WORKFLOW_SERVER_SERVICE = {
@@ -143973,7 +144241,7 @@ const wsEventsChannelForInvocation = (runId, config2) => {
     open() {
       if (!runId || !isWsEventsTransportEnabled())
         return;
-      claim = import("./ws-transport-Dv7yY5un.js").then(({ openWsChannel }) => openWsChannel(runId, config2)).catch(() => void 0);
+      claim = import("./ws-transport-DUA3rYTp.js").then(({ openWsChannel }) => openWsChannel(runId, config2)).catch(() => void 0);
     },
     /**
      * Awaited, unlike the open: work scheduled after the handler returns is not
@@ -145188,7 +145456,7 @@ function wsReplyStatus(reply, endpoint) {
   return status;
 }
 async function postEventFrameOverWs(input, config2) {
-  const { resolveWsTransport } = await import("./ws-transport-Dv7yY5un.js");
+  const { resolveWsTransport } = await import("./ws-transport-DUA3rYTp.js");
   const { runId } = input;
   const resolved = resolveWsTransport(runId, config2);
   if (!resolved)
@@ -146125,7 +146393,34 @@ function createStorage(config2) {
     hooks: instrumentObject("world.hooks", storage.hooks)
   };
 }
-const MAX_CHUNKS_PER_REQUEST = 1e3;
+const MAX_CHUNKS_PER_STREAM_WRITE = 1e3;
+function normalizeStreamChunks(chunks) {
+  const encoder2 = new TextEncoder();
+  return chunks.map((chunk) => typeof chunk === "string" ? encoder2.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 result = new Uint8Array(totalSize);
+  const view = new DataView(result.buffer);
+  let offset2 = 0;
+  for (const binary of binaryChunks) {
+    view.setUint32(offset2, binary.length, false);
+    offset2 += 4;
+    result.set(binary, offset2);
+    offset2 += binary.length;
+  }
+  return result;
+}
+const MAX_CHUNKS_PER_REQUEST = MAX_CHUNKS_PER_STREAM_WRITE;
 const getMaxChunksPerRequest = () => envNumber("WORKFLOW_MAX_CHUNKS_PER_REQUEST", MAX_CHUNKS_PER_REQUEST, {
   integer: true,
   min: 1
@@ -146169,26 +146464,6 @@ function createStreamRequestError(operation, url2, response2, text2) {
   ];
   return new StreamError(`Stream ${operation} failed: HTTP ${response2.status} (${context.join("; ")}): ${text2}`, { url: url2.toString(), status: response2.status });
 }
-function encodeMultiChunks(chunks) {
-  const encoder2 = new TextEncoder();
-  const binaryChunks = [];
-  let totalSize = 0;
-  for (const chunk of chunks) {
-    const binary = typeof chunk === "string" ? encoder2.encode(chunk) : chunk;
-    binaryChunks.push(binary);
-    totalSize += 4 + binary.length;
-  }
-  const result = new Uint8Array(totalSize);
-  const view = new DataView(result.buffer);
-  let offset2 = 0;
-  for (const binary of binaryChunks) {
-    view.setUint32(offset2, binary.length, false);
-    offset2 += 4;
-    result.set(binary, offset2);
-    offset2 += binary.length;
-  }
-  return result;
-}
 const StreamInfoResponseSchema = object$1({
   tailIndex: number$3(),
   done: boolean$3()
@@ -146555,7 +146830,7 @@ globalSingleton("@workflow/core//devServerPort", 1, () => ({
   inFlight: void 0
 }));
 function waitUntil(promise2) {
-  void import("./index-dJuvq1GP.js").then((n) => n.i).then(({ waitUntil: waitUntil2 }) => {
+  void import("./index-EldBi9Vs.js").then((n) => n.i).then(({ waitUntil: waitUntil2 }) => {
     waitUntil2(promise2);
   });
 }
@@ -149567,6 +149842,7 @@ function normalizeAttributeChanges(attrs, options = {}) {
   return changes;
 }
 const CROSS_DEPLOYMENT_CAPABILITY_PROBE_TIMEOUT_MS = 2e3;
+const RETENTION_ZERO_ATTRIBUTE_VALUE = "0";
 const ulid = monotonicFactory();
 function resolveLineageAttributes() {
   var _a3;
@@ -149665,11 +149941,23 @@ async function start$1(workflow, argsOrOptions, options) {
         });
         attributes = Object.fromEntries(changes.map(({ key, value }) => [key, 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 ? { ...lineage, ...attributes } : attributes;
+      const runAttributes = lineage || retentionAttribute ? { ...lineage, ...attributes, ...retentionAttribute } : attributes;
       const attributeSeed = runAttributes ? {
         attributes: runAttributes,
-        ...allowReservedAttributes || lineage != null ? { allowReservedAttributes: true } : {}
+        ...allowReservedAttributes || lineage != null || retentionAttribute != null ? { allowReservedAttributes: true } : {}
       } : {};
       if (opts.replayedFromRunId !== void 0 && !workflowRunIdSchema.safeParse(opts.replayedFromRunId).success) {
         throw new WorkflowRuntimeError(`replayedFromRunId must be a run ID (wrun_<ulid>); received ${JSON.stringify(String(opts.replayedFromRunId).slice(0, 64))}.`);
@@ -149975,6 +150263,7 @@ const PAYLOAD_TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set([
   "completed",
   "failed"
 ]);
+const NOT_FOUND_RETRY_DELAYS = [1e3, 3e3, 6e3];
 function getReturnValuePollIntervalMs() {
   return envNumber("WORKFLOW_RETURN_VALUE_POLL_INTERVAL_MS", RETURN_VALUE_POLL_INTERVAL_MS, { integer: true, min: 1 });
 }
@@ -150145,6 +150434,50 @@ const _Run = class _Run {
       }
     });
   }
+  /** 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: namespace2 } = options;
+    const name2 = getWorkflowRunStreamId(this.runId, namespace2);
+    let targetPromise;
+    let writable;
+    const resolveTarget = () => {
+      targetPromise ?? (targetPromise = __privateMethod(this, _Run_instances, getMetadata_fn).call(this).then(async (run2) => {
+        const target2 = {
+          key: await getForwardedWritableEncryptionKey(this.runId, run2.deploymentId, run2.encryptionPublicKey),
+          deploymentId: run2.deploymentId,
+          encryptionPublicKey: run2.encryptionPublicKey
+        };
+        tagForwardedWritableTarget(writable, target2);
+        return target2;
+      }));
+      return targetPromise;
+    };
+    writable = createForwardedWritable({
+      global: global2,
+      ops,
+      runId: this.runId,
+      name: name2,
+      key: () => resolveTarget().then(({ key }) => key)
+    });
+    return writable;
+  }
 };
 _worldPromise = new WeakMap();
 _Run_instances = new WeakSet();
@@ -150182,7 +150515,28 @@ getEncryptionKey_fn = function(run2) {
 getEncryptionKeyLazily_fn = function() {
   return () => __privateMethod(this, _Run_instances, getEncryptionKey_fn).call(this);
 };
+getMetadata_fn = async function() {
+  const world = await __privateGet(this, _Run_instances, lazyWorldPromise_get);
+  const maxRetries = __privateGet(this, _resilientStart) ? NOT_FOUND_RETRY_DELAYS.length : 0;
+  let attempt = 0;
+  while (true) {
+    try {
+      return await world.runs.get(this.runId, { resolveData: "none" });
+    } catch (error2) {
+      if (!WorkflowRunNotFoundError.is(error2) || attempt >= maxRetries) {
+        throw error2;
+      }
+      const delay = NOT_FOUND_RETRY_DELAYS[attempt];
+      attempt++;
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
+    }
+  }
+};
 resolveTerminalReturnValue_fn = async function(run2) {
+  const expiredAt = run2.expiredAt;
+  if (expiredAt != null && expiredAt <= /* @__PURE__ */ new Date()) {
+    throw new RunExpiredError(`Run "${this.runId}" ${run2.status === "completed" ? "completed" : `is ${run2.status}`}, but its data expired at ${expiredAt.toISOString()} and is no longer readable.`, this.runId, run2.status, expiredAt);
+  }
   if (run2.status === "completed") {
     const encryptionKey = await __privateMethod(this, _Run_instances, getEncryptionKey_fn).call(this, run2);
     return await hydrateWorkflowReturnValue(run2.output, this.runId, encryptionKey);
@@ -150208,8 +150562,7 @@ pollReturnValue_fn = async function() {
   var _a3;
   const world = await __privateGet(this, _Run_instances, lazyWorldPromise_get);
   let notFoundRetries = 0;
-  const NOT_FOUND_MAX_RETRIES = __privateGet(this, _resilientStart) ? 3 : 0;
-  const NOT_FOUND_DELAYS = [1e3, 3e3, 6e3];
+  const NOT_FOUND_MAX_RETRIES = __privateGet(this, _resilientStart) ? NOT_FOUND_RETRY_DELAYS.length : 0;
   const waitForTerminalStatus = isReturnValueLongPollEnabled() ? (_a3 = world.runs.waitForTerminalStatus) == null ? void 0 : _a3.bind(world.runs) : void 0;
   let longPolls = 0;
   const maxLongPolls = getReturnValueMaxLongPolls();
@@ -150244,7 +150597,7 @@ pollReturnValue_fn = async function() {
         continue;
       }
       if (WorkflowRunNotFoundError.is(error2) && notFoundRetries < NOT_FOUND_MAX_RETRIES) {
-        const delay = NOT_FOUND_DELAYS[notFoundRetries];
+        const delay = NOT_FOUND_RETRY_DELAYS[notFoundRetries];
         notFoundRetries++;
         await new Promise((resolve2) => setTimeout(resolve2, delay));
         continue;
@@ -173601,7 +173954,7 @@ function createFetchHandler(basename2 = "/") {
   return (request2) => handler(request2, loadContext);
 }
 export {
-  SPEC_VERSION_CURRENT as $,
+  RUN_ENTITY_KEY as $,
   ANALYTICS_EVENTS_GET_MANY_LIMIT as A,
   BULK_CANCEL_MAX_RUN_IDS as B,
   CHILD_ENTITY_CREATION_EVENT_TYPES as C,
@@ -173625,104 +173978,108 @@ export {
   QueuePayloadSchema as U,
   QueuePrefix as V,
   RESERVED_ATTRIBUTE_KEY_PREFIX as W,
-  ROOT_RUN_ID_ATTRIBUTE as X,
-  RUN_ENTITY_KEY as Y,
-  RunInputSchema as Z,
-  SEALED_LOG_ENV_VAR as _,
+  RETENTION_ATTRIBUTE as X,
+  RETENTION_DEFAULT as Y,
+  RETENTION_ZERO as Z,
+  ROOT_RUN_ID_ATTRIBUTE as _,
   ANALYTICS_MAX_ATTRIBUTE_FILTERS as a,
-  workflowRunIdSchema as a$,
-  SPEC_VERSION_LEGACY as a0,
-  SPEC_VERSION_MAX_SUPPORTED as a1,
-  SPEC_VERSION_SUPPORTS_ATTRIBUTES as a2,
-  SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT as a3,
-  SPEC_VERSION_SUPPORTS_COMPRESSION as a4,
-  SPEC_VERSION_SUPPORTS_SEALED_LOG as a5,
-  SPEC_VERSION_SUPPORTS_SLOT_IDENTITY as a6,
-  STEP_EVENT_TYPES as a7,
-  SerializedDataSchema as a8,
-  StepSchema as a9,
-  getMaxEventsPerRun as aA,
-  getQueueTopicPrefix as aB,
-  isChildEntityCreationEvent as aC,
-  isChildEntityCreationEventType as aD,
-  isHookEventRequiringExistence as aE,
-  isHookLifecycleEventType as aF,
-  isLegacySpecVersion as aG,
-  isNodeHttpEnabled as aH,
-  isSealedNoopEvent$1 as aI,
-  isSlotBody as aJ,
-  isSlotEventId as aK,
-  isStepEventType as aL,
-  isTerminalRunEventType as aM,
-  isTerminalStepEventType as aN,
-  isTerminalStepStatus as aO,
-  isTerminalWorkflowRunStatus as aP,
-  isWaitEventType as aQ,
-  mintedSpecVersion as aR,
-  parseQueueName as aS,
-  reenqueueActiveRuns as aT,
-  requiresNewerWorld as aU,
-  resolveQueueNamespace as aV,
-  slotToEventId as aW,
-  stripEventDataRefs as aX,
-  ulidToDate as aY,
-  validateAttributeChanges as aZ,
-  validateUlidTimestamp as a_,
-  StepStatusSchema as aa,
-  StructuredErrorSchema as ab,
-  TERMINAL_EVENT_CLASSES as ac,
-  TERMINAL_RUN_EVENT_TYPES as ad,
-  TERMINAL_STEP_EVENT_TYPES as ae,
-  TERMINAL_STEP_STATUSES as af,
-  TERMINAL_WORKFLOW_RUN_STATUSES as ag,
-  TerminalRunEventTypeSchema as ah,
-  TerminalStepStatusSchema as ai,
-  TerminalWorkflowRunStatusSchema as aj,
-  ValidQueueName as ak,
-  WAIT_EVENT_TYPES as al,
-  WaitSchema as am,
-  WaitStatusSchema as an,
-  WorkflowInvokePayloadSchema as ao,
-  WorkflowRunBaseSchema as ap,
-  WorkflowRunSchema as aq,
-  WorkflowRunStatusSchema as ar,
-  applyAttributeChanges as as,
-  classifyEntityEvent as at,
-  entityEventClass as au,
-  envFlag as av,
-  envNumber as aw,
-  eventIdToSlot as ax,
-  getEventDataPayloadField as ay,
-  getEventDataRefFields as az,
+  stripEventDataRefs as a$,
+  RunInputSchema as a0,
+  SEALED_LOG_ENV_VAR as a1,
+  SPEC_VERSION_CURRENT as a2,
+  SPEC_VERSION_LEGACY as a3,
+  SPEC_VERSION_MAX_SUPPORTED as a4,
+  SPEC_VERSION_SUPPORTS_ATTRIBUTES as a5,
+  SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT as a6,
+  SPEC_VERSION_SUPPORTS_COMPRESSION as a7,
+  SPEC_VERSION_SUPPORTS_SEALED_LOG as a8,
+  SPEC_VERSION_SUPPORTS_SLOT_IDENTITY as a9,
+  eventIdToSlot as aA,
+  getEventDataPayloadField as aB,
+  getEventDataRefFields as aC,
+  getMaxEventsPerRun as aD,
+  getQueueTopicPrefix as aE,
+  isChildEntityCreationEvent as aF,
+  isChildEntityCreationEventType as aG,
+  isHookEventRequiringExistence as aH,
+  isHookLifecycleEventType as aI,
+  isLegacySpecVersion as aJ,
+  isNodeHttpEnabled as aK,
+  isSealedNoopEvent$1 as aL,
+  isSlotBody as aM,
+  isSlotEventId as aN,
+  isStepEventType as aO,
+  isTerminalRunEventType as aP,
+  isTerminalStepEventType as aQ,
+  isTerminalStepStatus as aR,
+  isTerminalWorkflowRunStatus as aS,
+  isWaitEventType as aT,
+  mintedSpecVersion as aU,
+  parseQueueName as aV,
+  readRunRetention as aW,
+  reenqueueActiveRuns as aX,
+  requiresNewerWorld as aY,
+  resolveQueueNamespace as aZ,
+  slotToEventId as a_,
+  STEP_EVENT_TYPES as aa,
+  SerializedDataSchema as ab,
+  StepSchema as ac,
+  StepStatusSchema as ad,
+  StructuredErrorSchema as ae,
+  TERMINAL_EVENT_CLASSES as af,
+  TERMINAL_RUN_EVENT_TYPES as ag,
+  TERMINAL_STEP_EVENT_TYPES as ah,
+  TERMINAL_STEP_STATUSES as ai,
+  TERMINAL_WORKFLOW_RUN_STATUSES as aj,
+  TerminalRunEventTypeSchema as ak,
+  TerminalStepStatusSchema as al,
+  TerminalWorkflowRunStatusSchema as am,
+  ValidQueueName as an,
+  WAIT_EVENT_TYPES as ao,
+  WaitSchema as ap,
+  WaitStatusSchema as aq,
+  WorkflowInvokePayloadSchema as ar,
+  WorkflowRunBaseSchema as as,
+  WorkflowRunSchema as at,
+  WorkflowRunStatusSchema as au,
+  applyAttributeChanges as av,
+  classifyEntityEvent as aw,
+  entityEventClass as ax,
+  envFlag as ay,
+  envNumber as az,
   ANALYTICS_PAGE_LIMIT as b,
-  reactExports as b0,
-  R as b1,
-  Ks as b2,
-  jsxRuntimeExports as b3,
-  Qe as b4,
-  registerZstdDecoder as b5,
-  isWsEventsTransportEnabled as b6,
-  debugLog as b7,
-  getHttpUrl as b8,
-  globalSingleton as b9,
-  version as ba,
-  getHttpConfig as bb,
-  headersToRecord as bc,
-  getRequestTimeoutMs as bd,
-  injectTraceContextIntoHeaders as be,
-  withHttpClientSpan as bf,
-  ErrorType as bg,
-  WorkflowWsReconnectAttempt as bh,
-  NetworkProtocolName as bi,
-  WorkflowEventsTransport as bj,
-  distExports as bk,
-  decodeFrames as bl,
-  getDefaultExportFromCjs as bm,
-  requireTokenUtil as bn,
-  requireTokenError as bo,
-  getAugmentedNamespace as bp,
-  app as bq,
-  createFetchHandler as br,
+  ulidToDate as b0,
+  validateAttributeChanges as b1,
+  validateUlidTimestamp as b2,
+  workflowRunIdSchema as b3,
+  reactExports as b4,
+  R as b5,
+  Ks as b6,
+  jsxRuntimeExports as b7,
+  Qe as b8,
+  registerZstdDecoder as b9,
+  isWsEventsTransportEnabled as ba,
+  debugLog as bb,
+  getHttpUrl as bc,
+  globalSingleton as bd,
+  version as be,
+  getHttpConfig as bf,
+  headersToRecord as bg,
+  getRequestTimeoutMs as bh,
+  injectTraceContextIntoHeaders as bi,
+  withHttpClientSpan as bj,
+  ErrorType as bk,
+  WorkflowWsReconnectAttempt as bl,
+  NetworkProtocolName as bm,
+  WorkflowEventsTransport as bn,
+  distExports as bo,
+  decodeFrames as bp,
+  getDefaultExportFromCjs as bq,
+  requireTokenUtil as br,
+  requireTokenError as bs,
+  getAugmentedNamespace as bt,
+  app as bu,
+  createFetchHandler as bv,
   ANALYTICS_RUN_SCOPED_PAGE_LIMIT as c,
   ATTRIBUTE_KEY_MAX_LENGTH as d,
   ATTRIBUTE_MAX_PER_RUN as e,