@workflow/core 5.0.0-beta.5 → 5.0.0-beta.51

package/dist/flushable-stream.js

@@ -1,5 +1,60 @@
 import { WorkflowRuntimeError } from '@workflow/errors';
 import { withResolvers } from '@workflow/utils';
+import { envNumber } from '@workflow/world/env-config';
+import { STREAM_DRAIN_SYMBOL } from './symbols.js';
+/**
+ * Flow-control knob: upper bound on chunks read-but-not-yet-durably-written
+ * while coalescing. Once this many chunks are outstanding the producer stops
+ * reading until the consumer drains a batch, so a fast producer paired with a
+ * slow server can't grow the in-memory queue without bound. Override:
+ * `WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS`.
+ *
+ * This is deliberately distinct from the per-request batch caps below: this
+ * bounds how much is *buffered*, those bound how much goes out in one
+ * `writeMulti`. Raising this must never let a single request exceed a wire
+ * limit, since batch sizing enforces that independently.
+ */
+export const MAX_INFLIGHT_CHUNKS = 1000;
+export const getMaxInflightChunks = () => envNumber('WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS', MAX_INFLIGHT_CHUNKS, {
+    integer: true,
+    min: 1,
+});
+/**
+ * Wire limit: maximum number of chunks in a single coalesced `writeMulti`.
+ * The server enforces a per-multi-write chunk cap (1,000 today); a batch is
+ * split at this bound so it can never be rejected wholesale, independently of
+ * the backpressure knob above. Override: `WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH`.
+ */
+export const MAX_CHUNKS_PER_BATCH = 1000;
+export const getMaxChunksPerBatch = () => envNumber('WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH', MAX_CHUNKS_PER_BATCH, {
+    integer: true,
+    min: 1,
+});
+/**
+ * Wire limit: maximum cumulative bytes in a single coalesced `writeMulti`.
+ * Chunk *count* alone is not enough: 1,000 small chunks are ~100KB but 1,000
+ * file-sized chunks can be hundreds of MB, which platform request-body limits
+ * reject long before the count cap matters. A batch is split once adding the
+ * next chunk would exceed this (a single chunk larger than the cap still goes
+ * out alone). Default 1 MiB. Override: `WORKFLOW_STREAM_MAX_BYTES_PER_BATCH`.
+ */
+export const MAX_BYTES_PER_BATCH = 1024 * 1024;
+export const getMaxBytesPerBatch = () => envNumber('WORKFLOW_STREAM_MAX_BYTES_PER_BATCH', MAX_BYTES_PER_BATCH, {
+    integer: true,
+    min: 1,
+});
+/**
+ * Buffer bound (bytes) for the server writable's group-commit buffer, the
+ * byte-denominated counterpart of {@link MAX_INFLIGHT_CHUNKS}. `write()`
+ * blocks once this much data is buffered-but-not-durable, so a fast producer
+ * of large chunks can't grow client memory without bound. Default 8 MiB
+ * (eight request-sized groups). Override: `WORKFLOW_STREAM_MAX_BUFFERED_BYTES`.
+ */
+export const MAX_BUFFERED_BYTES = 8 * 1024 * 1024;
+export const getMaxBufferedBytes = () => envNumber('WORKFLOW_STREAM_MAX_BUFFERED_BYTES', MAX_BUFFERED_BYTES, {
+    integer: true,
+    min: 1,
+});
 /**
  * Polling interval (in ms) for lock release detection.
  *
@@ -13,19 +68,31 @@ import { withResolvers } from '@workflow/utils';
  * after each step body returns, so a coarser interval (the previous 100ms)
  * adds visible per-step latency to streaming workflows. With a uniformly
  * distributed offset between step return and the next tick, the expected
- * wait is half the interval — so 10ms means ~5ms average wait per step
+ * wait is half the interval, so 10ms means ~5ms average wait per step
  * instead of ~50ms. The per-tick work is `writable.locked` plus a
  * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more
  * ticks during a stream's lifetime is not measurable in practice.
  */
 export const LOCK_POLL_INTERVAL_MS = 10;
+/** Effective lock-poll interval. Override: `WORKFLOW_LOCK_POLL_INTERVAL_MS`. */
+const getLockPollIntervalMs = () => envNumber('WORKFLOW_LOCK_POLL_INTERVAL_MS', LOCK_POLL_INTERVAL_MS, {
+    integer: true,
+    min: 1,
+});
 export function createFlushableState() {
-    return {
+    const state = {
         ...withResolvers(),
         pendingOps: 0,
+        producedFrames: 0,
+        acceptedFrames: 0,
+        frameWaiters: [],
         doneResolved: false,
         streamEnded: false,
     };
+    // The runtime awaits this promise after user code returns. Observe early
+    // stream failures now so they do not become unhandled rejections first.
+    state.promise.catch(() => { });
+    return state;
 }
 /**
  * Checks if a WritableStream is unlocked (user released lock) vs closed.
@@ -82,6 +149,167 @@ function isReadableUnlockedNotClosed(readable) {
     }
     return true;
 }
+/**
+ * Settle the flushable completion after the sink's durability barrier.
+ *
+ * Lock release means the producer is done *writing*; with a group-commit
+ * sink, accepted chunks may still be client-buffered or in a request that is
+ * in flight. Awaiting the barrier here keeps the completion's meaning
+ * ("everything written so far is durable") identical to the pre-batching
+ * behavior where each write() was individually durable.
+ */
+function resolveAfterDrain(state) {
+    const barrier = state.drainBarrier;
+    if (!barrier) {
+        state.resolve();
+        return;
+    }
+    barrier().then(() => state.resolve(), (err) => state.reject(err));
+}
+/** Record a frame synchronously when its producer emits it into this pipe. */
+function markFlushableFrameProduced(state) {
+    state.producedFrames++;
+}
+/**
+ * Capture a step-end producer watermark, wait until the pipe has handed every
+ * frame through that watermark to its sink, then await the sink's durability
+ * barrier. Unlike {@link FlushableStreamState.promise}, this never waits for a
+ * user writer lock to be released.
+ */
+export async function drainFlushableSnapshot(state) {
+    const drainBeforeThrow = async (error) => {
+        // A later frame can fail after an earlier frame was early-acked by the
+        // group-commit sink. Keep the earlier accepted prefix durable before
+        // surfacing the producer error, matching flushablePipe's failure path.
+        await state.drainBarrier?.().catch(() => { });
+        throw error;
+    };
+    const target = state.producedFrames;
+    if (state.acceptedFrames < target) {
+        if (state.pipeError !== undefined) {
+            return drainBeforeThrow(state.pipeError);
+        }
+        try {
+            await new Promise((resolve, reject) => {
+                state.frameWaiters.push({ target, resolve, reject });
+            });
+        }
+        catch (error) {
+            return drainBeforeThrow(error);
+        }
+    }
+    if (state.pipeError !== undefined) {
+        return drainBeforeThrow(state.pipeError);
+    }
+    await state.drainBarrier?.();
+}
+/**
+ * Mark byte-stream chunks at the producer side of a flushable pipe. Serialized
+ * streams should instead use `getSerializeStream`'s synchronous output hook.
+ */
+/**
+ * Wrap the user-facing producer boundary of a flushable writable. A completed
+ * write through this handle has a sequence number before step-end snapshots,
+ * while the original writable remains the input to the serialization pipe.
+ */
+export function trackFlushableWritable(writable, state, WritableStreamConstructor = WritableStream) {
+    const targetWriter = writable.getWriter();
+    const checkpoint = Symbol('workflow-stream-release-checkpoint');
+    let trackedController;
+    const tracked = new WritableStreamConstructor({
+        start(controller) {
+            trackedController = controller;
+        },
+        async write(chunk) {
+            if (chunk === checkpoint)
+                return;
+            markFlushableFrameProduced(state);
+            await targetWriter.write(chunk);
+        },
+        async close() {
+            state.userWritableClosing = true;
+            try {
+                await targetWriter.close();
+            }
+            finally {
+                targetWriter.releaseLock();
+            }
+        },
+        async abort(reason) {
+            try {
+                await targetWriter.abort(reason);
+            }
+            finally {
+                targetWriter.releaseLock();
+            }
+        },
+    });
+    // A downstream sink can fail after its early-acknowledged write has already
+    // resolved. Forward that terminal error into the public writable even while
+    // its producer is idle, so native pipeTo() rejects and cancels its source.
+    targetWriter.closed.catch((error) => {
+        trackedController.error(error);
+    });
+    let settlement;
+    state.settleReleasedWrites = () => {
+        state.releaseSettlementArmed = true;
+        if (settlement)
+            return settlement;
+        if (tracked.locked)
+            return Promise.resolve(false);
+        if (state.userWritableClosing) {
+            settlement = state.promise.then(() => true);
+            return settlement;
+        }
+        let checkpointWriter;
+        try {
+            checkpointWriter = tracked.getWriter();
+        }
+        catch {
+            // Closed/errored streams settle through the pipe's normal completion.
+            return Promise.resolve(false);
+        }
+        settlement = (async () => {
+            try {
+                // Native writable ordering puts this behind writes queued by the
+                // released writer, including write promises it did not await.
+                try {
+                    await checkpointWriter.write(checkpoint);
+                }
+                catch (checkpointError) {
+                    // A close can move from requested to terminal between getWriter()
+                    // and write(). Its normal pipe completion already drains the sink;
+                    // an errored pipe rejects here with its actual failure instead.
+                    try {
+                        await state.promise;
+                        return true;
+                    }
+                    catch (pipeError) {
+                        throw pipeError ?? checkpointError;
+                    }
+                }
+                await drainFlushableSnapshot(state);
+                if (!state.doneResolved) {
+                    state.doneResolved = true;
+                    state.resolve();
+                }
+                return true;
+            }
+            catch (error) {
+                if (!state.doneResolved) {
+                    state.doneResolved = true;
+                    state.reject(error);
+                }
+                throw error;
+            }
+            finally {
+                checkpointWriter.releaseLock();
+            }
+        })();
+        return settlement;
+    };
+    return tracked;
+}
 /**
  * Polls a WritableStream to check if the user has released their lock.
  * Resolves the done promise when lock is released and no pending ops remain.
@@ -104,14 +332,25 @@ export function pollWritableLock(writable, state) {
             state.writablePollingInterval = undefined;
             return;
         }
+        if (state.settleReleasedWrites) {
+            if ((!state.deferReleaseSettlement || state.releaseSettlementArmed) &&
+                !writable.locked) {
+                clearInterval(intervalId);
+                state.writablePollingInterval = undefined;
+                void state.settleReleasedWrites().catch(() => {
+                    // Failure is surfaced through state.promise.
+                });
+            }
+            return;
+        }
         // Check if lock is released (not closed) and no pending ops
         if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {
             state.doneResolved = true;
-            state.resolve();
             clearInterval(intervalId);
             state.writablePollingInterval = undefined;
+            resolveAfterDrain(state);
         }
-    }, LOCK_POLL_INTERVAL_MS);
+    }, getLockPollIntervalMs());
     state.writablePollingInterval = intervalId;
 }
 /**
@@ -139,11 +378,11 @@ export function pollReadableLock(readable, state) {
         // Check if lock is released (not closed) and no pending ops
         if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {
             state.doneResolved = true;
-            state.resolve();
             clearInterval(intervalId);
             state.readablePollingInterval = undefined;
+            resolveAfterDrain(state);
         }
-    }, LOCK_POLL_INTERVAL_MS);
+    }, getLockPollIntervalMs());
     state.readablePollingInterval = intervalId;
 }
 /**
@@ -157,7 +396,29 @@ export function pollReadableLock(readable, state) {
  * @param state - The flushable state tracker
  * @returns Promise that resolves when stream ends (not when done promise resolves)
  */
-export async function flushablePipe(source, sink, state) {
+export function flushablePipe(source, sink, state) {
+    // Batching lives in the sink (`WorkflowServerWritableStream` group-commits
+    // its buffer), so this pipe is a plain per-chunk pump regardless of path:
+    // its only responsibilities are lock-release completion and durability
+    // tracking. Group-commit sinks ack write() on buffer entry; adopt their
+    // durability barrier so the lock-release completion still means
+    // "everything written is durable" (see resolveAfterDrain).
+    const drain = sink[STREAM_DRAIN_SYMBOL];
+    if (typeof drain === 'function') {
+        state.drainBarrier = drain;
+    }
+    return flushablePipePerChunk(source, sink, state);
+}
+/**
+ * The pump behind {@link flushablePipe}: awaits each `writer.write()` before
+ * reading the next chunk. Against a group-commit sink, write() acks on buffer
+ * entry, so this loop feeds the sink as fast as the producer emits (bounded
+ * by the sink's buffer bound) and batching happens inside the sink; against a
+ * plain sink each write is individually durable, as before. The source-done
+ * path closes the sink, which drains it, so completion always implies
+ * durability.
+ */
+async function flushablePipePerChunk(source, sink, state) {
     const reader = source.getReader();
     const writer = sink.getWriter();
     let cancelReason;
@@ -167,8 +428,8 @@ export async function flushablePipe(source, sink, state) {
             if (state.streamEnded) {
                 return;
             }
-            // Read from source - don't count as pending op since we're just waiting for data
-            // The important ops are writes to the sink (server)
+            // Read from the source. Don't count this as a pending operation because
+            // reads wait for data. The important operations are writes to the sink.
             const readResult = await Promise.race([
                 reader.read(),
                 writer.closed.then(() => {
@@ -194,6 +455,11 @@ export async function flushablePipe(source, sink, state) {
             state.pendingOps++;
             try {
                 await writer.write(readResult.value);
+                state.acceptedFrames++;
+                const ready = state.frameWaiters.filter((waiter) => waiter.target <= state.acceptedFrames);
+                state.frameWaiters = state.frameWaiters.filter((waiter) => waiter.target > state.acceptedFrames);
+                for (const waiter of ready)
+                    waiter.resolve();
             }
             finally {
                 state.pendingOps--;
@@ -202,7 +468,21 @@ export async function flushablePipe(source, sink, state) {
     }
     catch (err) {
         state.streamEnded = true;
+        state.pipeError = err;
         cancelReason = err;
+        const frameWaiters = state.frameWaiters;
+        state.frameWaiters = [];
+        for (const waiter of frameWaiters)
+            waiter.reject(err);
+        // Against an early-ack sink, chunks can still be buffered or in flight
+        // when the pipe fails (pendingOps only counts un-acked writes). Deliver
+        // that accepted prefix before settling the failure: once the state
+        // rejects, the step may persist its failure and the invocation finish,
+        // and anything still client-side would be lost. The original pipe error
+        // stays primary, since a drain failure is already sticky on the sink.
+        if (state.drainBarrier) {
+            await state.drainBarrier().catch(() => { });
+        }
         if (!state.doneResolved) {
             state.doneResolved = true;
             state.reject(err);
@@ -217,11 +497,11 @@ export async function flushablePipe(source, sink, state) {
     finally {
         // Cancel the upstream reader so the source knows to stop generating data.
         // Uses cancelReason (set in the catch block) so the source receives context
-        // about why it was cancelled. On normal completion cancelReason is undefined,
+        // about why it was canceled. On normal completion cancelReason is undefined,
         // which is a harmless no-op on an already-done reader.
         reader.cancel(cancelReason).catch(() => { });
         reader.releaseLock();
         writer.releaseLock();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flushable-stream.js","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { type PromiseWithResolvers, withResolvers } from '@workflow/utils';\n\n/**\n * Polling interval (in ms) for lock release detection.\n *\n * The Web Streams API does not expose an event for \"lock released but stream\n * still open\"; we can only distinguish that state by periodically attempting\n * to acquire a reader/writer. For that reason we use polling instead of a\n * fully event-driven approach here.\n *\n * 10ms is chosen so the polling tick almost never sits on the critical path:\n * the V2 step-executor's `opsSettled` race waits for this state to resolve\n * after each step body returns, so a coarser interval (the previous 100ms)\n * adds visible per-step latency to streaming workflows. With a uniformly\n * distributed offset between step return and the next tick, the expected\n * wait is half the interval — so 10ms means ~5ms average wait per step\n * instead of ~50ms. The per-tick work is `writable.locked` plus a\n * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more\n * ticks during a stream's lifetime is not measurable in practice.\n */\nexport const LOCK_POLL_INTERVAL_MS = 10;\n\n/**\n * State tracker for flushable stream operations.\n * Resolves when either:\n * 1. Stream completes (close/error), OR\n * 2. Lock is released AND all pending operations are flushed\n *\n * Note: `doneResolved` and `streamEnded` are separate:\n * - `doneResolved`: The `done` promise has been resolved (step can complete)\n * - `streamEnded`: The underlying stream has actually closed/errored\n *\n * Once `doneResolved` is set to true, the `done` promise will not resolve\n * again. Re-acquiring locks after release is not supported as a way to\n * trigger additional completion signaling.\n */\nexport interface FlushableStreamState extends PromiseWithResolvers<void> {\n  /** Number of write operations currently in flight to the server */\n  pendingOps: number;\n  /** Whether the `done` promise has been resolved */\n  doneResolved: boolean;\n  /** Whether the underlying stream has actually closed/errored */\n  streamEnded: boolean;\n  /** Interval ID for writable lock polling (if active) */\n  writablePollingInterval?: ReturnType<typeof setInterval>;\n  /** Interval ID for readable lock polling (if active) */\n  readablePollingInterval?: ReturnType<typeof setInterval>;\n}\n\nexport function createFlushableState(): FlushableStreamState {\n  return {\n    ...withResolvers<void>(),\n    pendingOps: 0,\n    doneResolved: false,\n    streamEnded: false,\n  };\n}\n\n/**\n * Checks if a WritableStream is unlocked (user released lock) vs closed.\n * When a stream is closed, .locked is false but getWriter() throws.\n * We only want to resolve via polling when the stream is unlocked, not closed.\n * If closed, the pump will handle resolution via the stream ending naturally.\n */\nfunction isWritableUnlockedNotClosed(writable: WritableStream): boolean {\n  if (writable.locked) return false;\n\n  let writer: WritableStreamDefaultWriter | undefined;\n  try {\n    // Try to acquire writer - if successful, stream is unlocked (not closed)\n    writer = writable.getWriter();\n  } catch {\n    // getWriter() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    writer.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Checks if a ReadableStream is unlocked (user released lock) vs closed.\n */\nfunction isReadableUnlockedNotClosed(readable: ReadableStream): boolean {\n  if (readable.locked) return false;\n\n  let reader: ReadableStreamDefaultReader | undefined;\n  try {\n    // Try to acquire reader - if successful, stream is unlocked (not closed)\n    reader = readable.getReader();\n  } catch {\n    // getReader() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    reader.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Polls a WritableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollWritableLock(\n  writable: WritableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.writablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      state.resolve();\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n    }\n  }, LOCK_POLL_INTERVAL_MS);\n\n  state.writablePollingInterval = intervalId;\n}\n\n/**\n * Polls a ReadableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollReadableLock(\n  readable: ReadableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.readablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      state.resolve();\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n    }\n  }, LOCK_POLL_INTERVAL_MS);\n\n  state.readablePollingInterval = intervalId;\n}\n\n/**\n * Creates a flushable pipe from a ReadableStream to a WritableStream.\n * Unlike pipeTo(), this resolves when:\n * 1. The source stream completes (close/error), OR\n * 2. The user releases their lock on userStream AND all pending writes are flushed\n *\n * @param source - The readable stream to read from (e.g., transform's readable)\n * @param sink - The writable stream to write to (e.g., server writable)\n * @param state - The flushable state tracker\n * @returns Promise that resolves when stream ends (not when done promise resolves)\n */\nexport async function flushablePipe(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  const reader = source.getReader();\n  const writer = sink.getWriter();\n  let cancelReason: unknown;\n\n  try {\n    while (true) {\n      // Check if stream has ended\n      if (state.streamEnded) {\n        return;\n      }\n\n      // Read from source - don't count as pending op since we're just waiting for data\n      // The important ops are writes to the sink (server)\n      const readResult = await Promise.race([\n        reader.read(),\n        writer.closed.then(() => {\n          throw new WorkflowRuntimeError('Writable stream closed prematurely');\n        }),\n      ]);\n\n      // Check if stream has ended (e.g., due to error in another path) before processing\n      if (state.streamEnded) {\n        return;\n      }\n\n      if (readResult.done) {\n        // Source stream completed - close sink and resolve\n        state.streamEnded = true;\n        await writer.close();\n        // Resolve done promise if not already resolved\n        if (!state.doneResolved) {\n          state.doneResolved = true;\n          state.resolve();\n        }\n        return;\n      }\n\n      // Count write as a pending op - this is what we need to flush\n      state.pendingOps++;\n      try {\n        await writer.write(readResult.value);\n      } finally {\n        state.pendingOps--;\n      }\n    }\n  } catch (err) {\n    state.streamEnded = true;\n    cancelReason = err;\n    if (!state.doneResolved) {\n      state.doneResolved = true;\n      state.reject(err);\n    }\n    // Propagate error through flushablePipe's own promise as well.\n    // Callers that rely on the FlushableStreamState should use `state.promise`,\n    // while other callers may depend on this rejection. Some known callers\n    // explicitly ignore this rejection (`.catch(() => {})`) and rely solely\n    // on `state.reject(err)` for error handling.\n    throw err;\n  } finally {\n    // Cancel the upstream reader so the source knows to stop generating data.\n    // Uses cancelReason (set in the catch block) so the source receives context\n    // about why it was cancelled. On normal completion cancelReason is undefined,\n    // which is a harmless no-op on an already-done reader.\n    reader.cancel(cancelReason).catch(() => {});\n    reader.releaseLock();\n    writer.releaseLock();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flushable-stream.js","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { type PromiseWithResolvers, withResolvers } from '@workflow/utils';\nimport { envNumber } from '@workflow/world/env-config';\nimport { STREAM_DRAIN_SYMBOL } from './symbols.js';\n\n/**\n * A durability barrier a sink may expose under {@link STREAM_DRAIN_SYMBOL}:\n * resolves once every chunk the sink has accepted is durably written, rejects\n * if any server write failed. See `WorkflowServerWritableStream`.\n */\ntype DrainBarrier = () => Promise<void>;\n\n/**\n * Flow-control knob: upper bound on chunks read-but-not-yet-durably-written\n * while coalescing. Once this many chunks are outstanding the producer stops\n * reading until the consumer drains a batch, so a fast producer paired with a\n * slow server can't grow the in-memory queue without bound. Override:\n * `WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS`.\n *\n * This is deliberately distinct from the per-request batch caps below: this\n * bounds how much is *buffered*, those bound how much goes out in one\n * `writeMulti`. Raising this must never let a single request exceed a wire\n * limit, since batch sizing enforces that independently.\n */\nexport const MAX_INFLIGHT_CHUNKS = 1000;\n\nexport const getMaxInflightChunks = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS', MAX_INFLIGHT_CHUNKS, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Wire limit: maximum number of chunks in a single coalesced `writeMulti`.\n * The server enforces a per-multi-write chunk cap (1,000 today); a batch is\n * split at this bound so it can never be rejected wholesale, independently of\n * the backpressure knob above. Override: `WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH`.\n */\nexport const MAX_CHUNKS_PER_BATCH = 1000;\n\nexport const getMaxChunksPerBatch = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH', MAX_CHUNKS_PER_BATCH, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Wire limit: maximum cumulative bytes in a single coalesced `writeMulti`.\n * Chunk *count* alone is not enough: 1,000 small chunks are ~100KB but 1,000\n * file-sized chunks can be hundreds of MB, which platform request-body limits\n * reject long before the count cap matters. A batch is split once adding the\n * next chunk would exceed this (a single chunk larger than the cap still goes\n * out alone). Default 1 MiB. Override: `WORKFLOW_STREAM_MAX_BYTES_PER_BATCH`.\n */\nexport const MAX_BYTES_PER_BATCH = 1024 * 1024;\n\nexport const getMaxBytesPerBatch = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_BYTES_PER_BATCH', MAX_BYTES_PER_BATCH, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Buffer bound (bytes) for the server writable's group-commit buffer, the\n * byte-denominated counterpart of {@link MAX_INFLIGHT_CHUNKS}. `write()`\n * blocks once this much data is buffered-but-not-durable, so a fast producer\n * of large chunks can't grow client memory without bound. Default 8 MiB\n * (eight request-sized groups). Override: `WORKFLOW_STREAM_MAX_BUFFERED_BYTES`.\n */\nexport const MAX_BUFFERED_BYTES = 8 * 1024 * 1024;\n\nexport const getMaxBufferedBytes = (): number =>\n  envNumber('WORKFLOW_STREAM_MAX_BUFFERED_BYTES', MAX_BUFFERED_BYTES, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * Polling interval (in ms) for lock release detection.\n *\n * The Web Streams API does not expose an event for \"lock released but stream\n * still open\"; we can only distinguish that state by periodically attempting\n * to acquire a reader/writer. For that reason we use polling instead of a\n * fully event-driven approach here.\n *\n * 10ms is chosen so the polling tick almost never sits on the critical path:\n * the V2 step-executor's `opsSettled` race waits for this state to resolve\n * after each step body returns, so a coarser interval (the previous 100ms)\n * adds visible per-step latency to streaming workflows. With a uniformly\n * distributed offset between step return and the next tick, the expected\n * wait is half the interval, so 10ms means ~5ms average wait per step\n * instead of ~50ms. The per-tick work is `writable.locked` plus a\n * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more\n * ticks during a stream's lifetime is not measurable in practice.\n */\nexport const LOCK_POLL_INTERVAL_MS = 10;\n\n/** Effective lock-poll interval. Override: `WORKFLOW_LOCK_POLL_INTERVAL_MS`. */\nconst getLockPollIntervalMs = (): number =>\n  envNumber('WORKFLOW_LOCK_POLL_INTERVAL_MS', LOCK_POLL_INTERVAL_MS, {\n    integer: true,\n    min: 1,\n  });\n\n/**\n * State tracker for flushable stream operations.\n * Resolves when either:\n * 1. Stream completes (close/error), OR\n * 2. Lock is released AND all pending operations are flushed\n *\n * Note: `doneResolved` and `streamEnded` are separate:\n * - `doneResolved`: The `done` promise has been resolved (step can complete)\n * - `streamEnded`: The underlying stream has actually closed/errored\n *\n * Once `doneResolved` is set to true, the `done` promise will not resolve\n * again. Re-acquiring locks after release is not supported as a way to\n * trigger additional completion signaling.\n */\nexport interface FlushableStreamState extends PromiseWithResolvers<void> {\n  /** Number of write operations currently in flight to the server */\n  pendingOps: number;\n  /** Frames emitted by this pipe's producer. */\n  producedFrames: number;\n  /** Produced frames accepted by this pipe's sink. */\n  acceptedFrames: number;\n  /** Terminal pipe error, retained for snapshots registered after failure. */\n  pipeError?: unknown;\n  /**\n   * If the user-facing writable is unlocked, enqueue an ordered checkpoint and\n   * durably drain every write ahead of it. Returns false while a writer remains\n   * locked, so lock-held streams never block step completion.\n   */\n  settleReleasedWrites?: () => Promise<boolean>;\n  /** Whether release settlement waits for explicit step-end arming. */\n  deferReleaseSettlement?: boolean;\n  /** Whether step-end processing has armed released-writer settlement. */\n  releaseSettlementArmed?: boolean;\n  /** Whether the user-facing writable has begun a normal close. */\n  userWritableClosing?: boolean;\n  /** Step-end snapshot waiters blocked until their target reaches the sink. */\n  frameWaiters: Array<{\n    target: number;\n    resolve: () => void;\n    reject: (error: unknown) => void;\n  }>;\n  /** Whether the `done` promise has been resolved */\n  doneResolved: boolean;\n  /** Whether the underlying stream has actually closed/errored */\n  streamEnded: boolean;\n  /** Interval ID for writable lock polling (if active) */\n  writablePollingInterval?: ReturnType<typeof setInterval>;\n  /** Interval ID for readable lock polling (if active) */\n  readablePollingInterval?: ReturnType<typeof setInterval>;\n  /**\n   * Durability barrier of the pipe's sink, when it acks writes on buffer\n   * entry (see {@link STREAM_DRAIN_SYMBOL}). Lock-release completion awaits\n   * this before resolving so `pendingOps === 0` (fast, buffered acks) can't\n   * complete a step while data is still client-side.\n   */\n  drainBarrier?: DrainBarrier;\n}\n\nexport function createFlushableState(): FlushableStreamState {\n  const state: FlushableStreamState = {\n    ...withResolvers<void>(),\n    pendingOps: 0,\n    producedFrames: 0,\n    acceptedFrames: 0,\n    frameWaiters: [],\n    doneResolved: false,\n    streamEnded: false,\n  };\n\n  // The runtime awaits this promise after user code returns. Observe early\n  // stream failures now so they do not become unhandled rejections first.\n  state.promise.catch(() => {});\n\n  return state;\n}\n\n/**\n * Checks if a WritableStream is unlocked (user released lock) vs closed.\n * When a stream is closed, .locked is false but getWriter() throws.\n * We only want to resolve via polling when the stream is unlocked, not closed.\n * If closed, the pump will handle resolution via the stream ending naturally.\n */\nfunction isWritableUnlockedNotClosed(writable: WritableStream): boolean {\n  if (writable.locked) return false;\n\n  let writer: WritableStreamDefaultWriter | undefined;\n  try {\n    // Try to acquire writer - if successful, stream is unlocked (not closed)\n    writer = writable.getWriter();\n  } catch {\n    // getWriter() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    writer.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Checks if a ReadableStream is unlocked (user released lock) vs closed.\n */\nfunction isReadableUnlockedNotClosed(readable: ReadableStream): boolean {\n  if (readable.locked) return false;\n\n  let reader: ReadableStreamDefaultReader | undefined;\n  try {\n    // Try to acquire reader - if successful, stream is unlocked (not closed)\n    reader = readable.getReader();\n  } catch {\n    // getReader() throws if stream is closed/errored - let pump handle it\n    return false;\n  }\n\n  try {\n    reader.releaseLock();\n  } catch {\n    // If releaseLock() throws for any reason, conservatively treat the\n    // stream as closed/errored so callers don't assume it's safe to use.\n    // The pump will observe the failure via the stream's end state.\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Settle the flushable completion after the sink's durability barrier.\n *\n * Lock release means the producer is done *writing*; with a group-commit\n * sink, accepted chunks may still be client-buffered or in a request that is\n * in flight. Awaiting the barrier here keeps the completion's meaning\n * (\"everything written so far is durable\") identical to the pre-batching\n * behavior where each write() was individually durable.\n */\nfunction resolveAfterDrain(state: FlushableStreamState): void {\n  const barrier = state.drainBarrier;\n  if (!barrier) {\n    state.resolve();\n    return;\n  }\n  barrier().then(\n    () => state.resolve(),\n    (err) => state.reject(err)\n  );\n}\n\n/** Record a frame synchronously when its producer emits it into this pipe. */\nfunction markFlushableFrameProduced(state: FlushableStreamState): void {\n  state.producedFrames++;\n}\n\n/**\n * Capture a step-end producer watermark, wait until the pipe has handed every\n * frame through that watermark to its sink, then await the sink's durability\n * barrier. Unlike {@link FlushableStreamState.promise}, this never waits for a\n * user writer lock to be released.\n */\nexport async function drainFlushableSnapshot(\n  state: FlushableStreamState\n): Promise<void> {\n  const drainBeforeThrow = async (error: unknown): Promise<never> => {\n    // A later frame can fail after an earlier frame was early-acked by the\n    // group-commit sink. Keep the earlier accepted prefix durable before\n    // surfacing the producer error, matching flushablePipe's failure path.\n    await state.drainBarrier?.().catch(() => {});\n    throw error;\n  };\n\n  const target = state.producedFrames;\n  if (state.acceptedFrames < target) {\n    if (state.pipeError !== undefined) {\n      return drainBeforeThrow(state.pipeError);\n    }\n    try {\n      await new Promise<void>((resolve, reject) => {\n        state.frameWaiters.push({ target, resolve, reject });\n      });\n    } catch (error) {\n      return drainBeforeThrow(error);\n    }\n  }\n  if (state.pipeError !== undefined) {\n    return drainBeforeThrow(state.pipeError);\n  }\n  await state.drainBarrier?.();\n}\n\n/**\n * Mark byte-stream chunks at the producer side of a flushable pipe. Serialized\n * streams should instead use `getSerializeStream`'s synchronous output hook.\n */\n/**\n * Wrap the user-facing producer boundary of a flushable writable. A completed\n * write through this handle has a sequence number before step-end snapshots,\n * while the original writable remains the input to the serialization pipe.\n */\nexport function trackFlushableWritable<T>(\n  writable: WritableStream<T>,\n  state: FlushableStreamState,\n  WritableStreamConstructor: typeof WritableStream = WritableStream\n): WritableStream<T> {\n  const targetWriter = writable.getWriter();\n  const checkpoint = Symbol('workflow-stream-release-checkpoint');\n  let trackedController: WritableStreamDefaultController;\n  const tracked = new WritableStreamConstructor({\n    start(controller) {\n      trackedController = controller;\n    },\n    async write(chunk) {\n      if (chunk === checkpoint) return;\n      markFlushableFrameProduced(state);\n      await targetWriter.write(chunk);\n    },\n    async close() {\n      state.userWritableClosing = true;\n      try {\n        await targetWriter.close();\n      } finally {\n        targetWriter.releaseLock();\n      }\n    },\n    async abort(reason) {\n      try {\n        await targetWriter.abort(reason);\n      } finally {\n        targetWriter.releaseLock();\n      }\n    },\n  }) as WritableStream<T>;\n\n  // A downstream sink can fail after its early-acknowledged write has already\n  // resolved. Forward that terminal error into the public writable even while\n  // its producer is idle, so native pipeTo() rejects and cancels its source.\n  targetWriter.closed.catch((error) => {\n    trackedController.error(error);\n  });\n\n  let settlement: Promise<boolean> | undefined;\n  state.settleReleasedWrites = (): Promise<boolean> => {\n    state.releaseSettlementArmed = true;\n    if (settlement) return settlement;\n    if (tracked.locked) return Promise.resolve(false);\n    if (state.userWritableClosing) {\n      settlement = state.promise.then(() => true);\n      return settlement;\n    }\n\n    let checkpointWriter: WritableStreamDefaultWriter<T>;\n    try {\n      checkpointWriter = tracked.getWriter();\n    } catch {\n      // Closed/errored streams settle through the pipe's normal completion.\n      return Promise.resolve(false);\n    }\n\n    settlement = (async () => {\n      try {\n        // Native writable ordering puts this behind writes queued by the\n        // released writer, including write promises it did not await.\n        try {\n          await checkpointWriter.write(checkpoint as T);\n        } catch (checkpointError) {\n          // A close can move from requested to terminal between getWriter()\n          // and write(). Its normal pipe completion already drains the sink;\n          // an errored pipe rejects here with its actual failure instead.\n          try {\n            await state.promise;\n            return true;\n          } catch (pipeError) {\n            throw pipeError ?? checkpointError;\n          }\n        }\n        await drainFlushableSnapshot(state);\n        if (!state.doneResolved) {\n          state.doneResolved = true;\n          state.resolve();\n        }\n        return true;\n      } catch (error) {\n        if (!state.doneResolved) {\n          state.doneResolved = true;\n          state.reject(error);\n        }\n        throw error;\n      } finally {\n        checkpointWriter.releaseLock();\n      }\n    })();\n    return settlement;\n  };\n\n  return tracked;\n}\n\n/**\n * Polls a WritableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollWritableLock(\n  writable: WritableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.writablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      return;\n    }\n\n    if (state.settleReleasedWrites) {\n      if (\n        (!state.deferReleaseSettlement || state.releaseSettlementArmed) &&\n        !writable.locked\n      ) {\n        clearInterval(intervalId);\n        state.writablePollingInterval = undefined;\n        void state.settleReleasedWrites().catch(() => {\n          // Failure is surfaced through state.promise.\n        });\n      }\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      clearInterval(intervalId);\n      state.writablePollingInterval = undefined;\n      resolveAfterDrain(state);\n    }\n  }, getLockPollIntervalMs());\n\n  state.writablePollingInterval = intervalId;\n}\n\n/**\n * Polls a ReadableStream to check if the user has released their lock.\n * Resolves the done promise when lock is released and no pending ops remain.\n *\n * Note: Only resolves if stream is unlocked but NOT closed. If the user closes\n * the stream, the pump will handle resolution via the stream ending naturally.\n *\n * Protection: If polling is already active on this state, the existing interval\n * is used to avoid creating multiple simultaneous polling operations.\n */\nexport function pollReadableLock(\n  readable: ReadableStream,\n  state: FlushableStreamState\n): void {\n  // Prevent multiple simultaneous polling on the same state\n  if (state.readablePollingInterval !== undefined) {\n    return;\n  }\n\n  const intervalId = setInterval(() => {\n    // Stop polling if already resolved or stream ended\n    if (state.doneResolved || state.streamEnded) {\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      return;\n    }\n\n    // Check if lock is released (not closed) and no pending ops\n    if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {\n      state.doneResolved = true;\n      clearInterval(intervalId);\n      state.readablePollingInterval = undefined;\n      resolveAfterDrain(state);\n    }\n  }, getLockPollIntervalMs());\n\n  state.readablePollingInterval = intervalId;\n}\n\n/**\n * Creates a flushable pipe from a ReadableStream to a WritableStream.\n * Unlike pipeTo(), this resolves when:\n * 1. The source stream completes (close/error), OR\n * 2. The user releases their lock on userStream AND all pending writes are flushed\n *\n * @param source - The readable stream to read from (e.g., transform's readable)\n * @param sink - The writable stream to write to (e.g., server writable)\n * @param state - The flushable state tracker\n * @returns Promise that resolves when stream ends (not when done promise resolves)\n */\nexport function flushablePipe(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  // Batching lives in the sink (`WorkflowServerWritableStream` group-commits\n  // its buffer), so this pipe is a plain per-chunk pump regardless of path:\n  // its only responsibilities are lock-release completion and durability\n  // tracking. Group-commit sinks ack write() on buffer entry; adopt their\n  // durability barrier so the lock-release completion still means\n  // \"everything written is durable\" (see resolveAfterDrain).\n  const drain = (sink as { [STREAM_DRAIN_SYMBOL]?: DrainBarrier })[\n    STREAM_DRAIN_SYMBOL\n  ];\n  if (typeof drain === 'function') {\n    state.drainBarrier = drain;\n  }\n  return flushablePipePerChunk(source, sink, state);\n}\n\n/**\n * The pump behind {@link flushablePipe}: awaits each `writer.write()` before\n * reading the next chunk. Against a group-commit sink, write() acks on buffer\n * entry, so this loop feeds the sink as fast as the producer emits (bounded\n * by the sink's buffer bound) and batching happens inside the sink; against a\n * plain sink each write is individually durable, as before. The source-done\n * path closes the sink, which drains it, so completion always implies\n * durability.\n */\nasync function flushablePipePerChunk(\n  source: ReadableStream,\n  sink: WritableStream,\n  state: FlushableStreamState\n): Promise<void> {\n  const reader = source.getReader();\n  const writer = sink.getWriter();\n  let cancelReason: unknown;\n\n  try {\n    while (true) {\n      // Check if stream has ended\n      if (state.streamEnded) {\n        return;\n      }\n\n      // Read from the source. Don't count this as a pending operation because\n      // reads wait for data. The important operations are writes to the sink.\n      const readResult = await Promise.race([\n        reader.read(),\n        writer.closed.then(() => {\n          throw new WorkflowRuntimeError('Writable stream closed prematurely');\n        }),\n      ]);\n\n      // Check if stream has ended (e.g., due to error in another path) before processing\n      if (state.streamEnded) {\n        return;\n      }\n\n      if (readResult.done) {\n        // Source stream completed - close sink and resolve\n        state.streamEnded = true;\n        await writer.close();\n        // Resolve done promise if not already resolved\n        if (!state.doneResolved) {\n          state.doneResolved = true;\n          state.resolve();\n        }\n        return;\n      }\n\n      // Count write as a pending op - this is what we need to flush\n      state.pendingOps++;\n      try {\n        await writer.write(readResult.value);\n        state.acceptedFrames++;\n        const ready = state.frameWaiters.filter(\n          (waiter) => waiter.target <= state.acceptedFrames\n        );\n        state.frameWaiters = state.frameWaiters.filter(\n          (waiter) => waiter.target > state.acceptedFrames\n        );\n        for (const waiter of ready) waiter.resolve();\n      } finally {\n        state.pendingOps--;\n      }\n    }\n  } catch (err) {\n    state.streamEnded = true;\n    state.pipeError = err;\n    cancelReason = err;\n    const frameWaiters = state.frameWaiters;\n    state.frameWaiters = [];\n    for (const waiter of frameWaiters) waiter.reject(err);\n    // Against an early-ack sink, chunks can still be buffered or in flight\n    // when the pipe fails (pendingOps only counts un-acked writes). Deliver\n    // that accepted prefix before settling the failure: once the state\n    // rejects, the step may persist its failure and the invocation finish,\n    // and anything still client-side would be lost. The original pipe error\n    // stays primary, since a drain failure is already sticky on the sink.\n    if (state.drainBarrier) {\n      await state.drainBarrier().catch(() => {});\n    }\n    if (!state.doneResolved) {\n      state.doneResolved = true;\n      state.reject(err);\n    }\n    // Propagate error through flushablePipe's own promise as well.\n    // Callers that rely on the FlushableStreamState should use `state.promise`,\n    // while other callers may depend on this rejection. Some known callers\n    // explicitly ignore this rejection (`.catch(() => {})`) and rely solely\n    // on `state.reject(err)` for error handling.\n    throw err;\n  } finally {\n    // Cancel the upstream reader so the source knows to stop generating data.\n    // Uses cancelReason (set in the catch block) so the source receives context\n    // about why it was canceled. On normal completion cancelReason is undefined,\n    // which is a harmless no-op on an already-done reader.\n    reader.cancel(cancelReason).catch(() => {});\n    reader.releaseLock();\n    writer.releaseLock();\n  }\n}\n"]}

package/dist/global.d.ts

@@ -1,3 +1,4 @@
+import type { AttributeChange } from '@workflow/world';
 import type { Serializable } from './schemas.js';
 export interface StepInvocationQueueItem {
     type: 'step';
@@ -7,13 +8,37 @@ export interface StepInvocationQueueItem {
     closureVars?: Record<string, Serializable>;
     thisVal?: Serializable;
     hasCreatedEvent?: boolean;
+    /**
+     * Inline step ownership, derived from the step's LATEST `step_started`
+     * during replay: the queue message ID stamped by the invocation running
+     * the step inline, or undefined when the latest start was unstamped (a
+     * retry attempt driven by a queued step message, or an older runtime).
+     * Latest start wins: an unstamped bare start clears a previous stamp; an
+     * owner-recovery re-stamped start restores it.
+     */
+    ownerMessageId?: string;
+    /**
+     * `createdAt` (ms) of the step's latest observed `step_started`. Anchors
+     * the ownership lease: `leaseRemaining = lastStartedAt + lease − now`.
+     */
+    lastStartedAt?: number;
+    /**
+     * Whether a `step_retrying` was observed for this step. From that point
+     * the step is queue-owned (the delayed retry handoff or replay requeue),
+     * so inline ownership is permanently lapsed for this correlation ID.
+     */
+    sawRetrying?: boolean;
 }
 export interface HookInvocationQueueItem {
     type: 'hook';
     correlationId: string;
     token: string;
+    /** Earliest time the token can be reused after the run ends. */
+    tokenRetentionUntil?: Date;
     metadata?: Serializable;
     hasCreatedEvent?: boolean;
+    /** Whether the workflow is awaiting `hook.getConflict()` for this hook */
+    hasConflictAwaiter?: boolean;
     disposed?: boolean;
     isWebhook?: boolean;
     isSystem?: boolean;
@@ -26,7 +51,13 @@ export interface WaitInvocationQueueItem {
     resumeAt: Date;
     hasCreatedEvent?: boolean;
 }
-export type QueueItem = StepInvocationQueueItem | HookInvocationQueueItem | WaitInvocationQueueItem;
+export interface AttributeInvocationQueueItem {
+    type: 'attribute';
+    correlationId: string;
+    changes: AttributeChange[];
+    allowReservedAttributes?: true;
+}
+export type QueueItem = StepInvocationQueueItem | HookInvocationQueueItem | WaitInvocationQueueItem | AttributeInvocationQueueItem;
 /**
  * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do
  * not yet have corresponding entries in the event log. The workflow
@@ -34,14 +65,17 @@ export type QueueItem = StepInvocationQueueItem | HookInvocationQueueItem | Wait
  * onto the queue.
  */
 export declare class WorkflowSuspension extends Error {
+    items: QueueItem[];
+    /** @deprecated Use `items` instead. */
     steps: QueueItem[];
     globalThis: typeof globalThis;
     stepCount: number;
     hookCount: number;
     waitCount: number;
+    attributeCount: number;
     hookDisposedCount: number;
     abortCount: number;
-    constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis);
+    constructor(itemsInput: Map<string, QueueItem>, global: typeof globalThis);
     static is(value: unknown): value is WorkflowSuspension;
 }
 export declare function ENOTSUP(): never;

package/dist/global.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,IAAI,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,MAAM,SAAS,GACjB,uBAAuB,GACvB,uBAAuB,GACvB,uBAAuB,CAAC;AAE5B;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;gBAEP,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,UAAU;IA2EzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB;CAGvD;AAED,wBAAgB,OAAO,IAAI,KAAK,CAI/B"}
+{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,mBAAmB,CAAC,EAAE,IAAI,CAAC;IAC3B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,0EAA0E;IAC1E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,IAAI,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,WAAW,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,uBAAuB,CAAC,EAAE,IAAI,CAAC;CAChC;AAED,MAAM,MAAM,SAAS,GACjB,uBAAuB,GACvB,uBAAuB,GACvB,uBAAuB,GACvB,4BAA4B,CAAC;AAEjC;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,uCAAuC;IACvC,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;gBAEP,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,UAAU;IAwFzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB;CAGvD;AAED,wBAAgB,OAAO,IAAI,KAAK,CAI/B"}