@workflow/core 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/flushable-stream.js

@@ -1,4 +1,60 @@
+import { WorkflowRuntimeError } from '@workflow/errors';
 import { withResolvers } from '@workflow/utils';
+import { envNumber } from '@workflow/world';
+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 — 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.
  *
@@ -7,24 +63,33 @@ import { withResolvers } from '@workflow/utils';
  * to acquire a reader/writer. For that reason we use polling instead of a
  * fully event-driven approach here.
  *
- * 100ms is a compromise between:
- * - Latency: how quickly we notice that the user has released their lock, and
- * - Cost/CPU usage: how often timers fire, especially with many concurrent
- *   streams or in serverless environments where billed time matters.
- *
- * This value should only be changed with care, as decreasing it will
- * increase polling frequency (and thus potential cost), while increasing it
- * will add worst-case delay before the `done` promise resolves after a lock
- * is released.
+ * 10ms is chosen so the polling tick almost never sits on the critical path:
+ * the V2 step-executor's `opsSettled` race waits for this state to resolve
+ * 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
+ * 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 = 100;
+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,
         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.
@@ -81,6 +146,23 @@ 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));
+}
 /**
  * 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.
@@ -106,11 +188,11 @@ export function pollWritableLock(writable, state) {
         // 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;
 }
 /**
@@ -138,11 +220,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;
 }
 /**
@@ -156,7 +238,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;
@@ -171,7 +275,7 @@ export async function flushablePipe(source, sink, state) {
             const readResult = await Promise.race([
                 reader.read(),
                 writer.closed.then(() => {
-                    throw new Error('Writable stream closed prematurely');
+                    throw new WorkflowRuntimeError('Writable stream closed prematurely');
                 }),
             ]);
             // Check if stream has ended (e.g., due to error in another path) before processing
@@ -202,6 +306,15 @@ export async function flushablePipe(source, sink, state) {
     catch (err) {
         state.streamEnded = true;
         cancelReason = 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 — 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);
@@ -223,4 +336,4 @@ export async function flushablePipe(source, sink, state) {
         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 { 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 * 100ms is a compromise between:\n * - Latency: how quickly we notice that the user has released their lock, and\n * - Cost/CPU usage: how often timers fire, especially with many concurrent\n *   streams or in serverless environments where billed time matters.\n *\n * This value should only be changed with care, as decreasing it will\n * increase polling frequency (and thus potential cost), while increasing it\n * will add worst-case delay before the `done` promise resolves after a lock\n * is released.\n */\nexport const LOCK_POLL_INTERVAL_MS = 100;\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 Error('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';\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 — 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  /** 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    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/**\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      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 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    // 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 — 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 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"]}

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,15 +8,42 @@ 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;
+    abortRequested?: boolean;
+    abortReason?: unknown;
 }
 export interface WaitInvocationQueueItem {
     type: 'wait';
@@ -23,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
@@ -36,7 +70,9 @@ export declare class WorkflowSuspension extends Error {
     stepCount: number;
     hookCount: number;
     waitCount: number;
+    attributeCount: number;
     hookDisposedCount: number;
+    abortCount: number;
     constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis);
     static is(value: unknown): value is WorkflowSuspension;
 }

package/dist/global.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AACA,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;CACrB;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;gBAEd,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,UAAU;IAwEzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB;CAGvD;AAED,wBAAgB,OAAO,IAAI,KAAK,CAE/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,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;IAuFzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB;CAGvD;AAED,wBAAgB,OAAO,IAAI,KAAK,CAI/B"}

package/dist/global.js

@@ -1,3 +1,4 @@
+import { WorkflowRuntimeError } from '@workflow/errors';
 import { pluralize } from '@workflow/utils';
 /**
  * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do
@@ -11,7 +12,9 @@ export class WorkflowSuspension extends Error {
     stepCount;
     hookCount;
     waitCount;
+    attributeCount;
     hookDisposedCount;
+    abortCount;
     constructor(stepsInput, global) {
         // Convert Map to array for iteration and storage
         const steps = [...stepsInput.values()];
@@ -19,18 +22,24 @@ export class WorkflowSuspension extends Error {
         let stepCount = 0;
         let hookCount = 0;
         let waitCount = 0;
+        let attributeCount = 0;
         let hookDisposedCount = 0;
+        let abortCount = 0;
         for (const item of steps) {
             if (item.type === 'step')
                 stepCount++;
             else if (item.type === 'hook') {
                 if (item.disposed)
                     hookDisposedCount++;
+                else if (item.abortRequested)
+                    abortCount++;
                 else
                     hookCount++;
             }
             else if (item.type === 'wait')
                 waitCount++;
+            else if (item.type === 'attribute')
+                attributeCount++;
         }
         // Build description parts
         const parts = [];
@@ -43,16 +52,20 @@ export class WorkflowSuspension extends Error {
         if (waitCount > 0) {
             parts.push(`${waitCount} ${pluralize('wait', 'waits', waitCount)}`);
         }
+        if (attributeCount > 0) {
+            parts.push(`${attributeCount} ${pluralize('attribute write', 'attribute writes', attributeCount)}`);
+        }
         if (hookDisposedCount > 0) {
             parts.push(`${hookDisposedCount} hook ${pluralize('disposal', 'disposals', hookDisposedCount)}`);
         }
         // Determine verb (has/have) and action (run/created/received)
-        const totalCount = stepCount + hookCount + waitCount + hookDisposedCount;
+        const totalCount = stepCount + hookCount + waitCount + attributeCount + hookDisposedCount;
         const hasOrHave = pluralize('has', 'have', totalCount);
         // Pick action verb: use "processed" when mixed types are present
         const typeCount = (stepCount > 0 ? 1 : 0) +
             (hookCount > 0 ? 1 : 0) +
             (waitCount > 0 ? 1 : 0) +
+            (attributeCount > 0 ? 1 : 0) +
             (hookDisposedCount > 0 ? 1 : 0);
         let action;
         if (typeCount > 1) {
@@ -67,6 +80,9 @@ export class WorkflowSuspension extends Error {
         else if (waitCount > 0) {
             action = 'created';
         }
+        else if (attributeCount > 0) {
+            action = 'written';
+        }
         else if (hookDisposedCount > 0) {
             action = 'processed';
         }
@@ -83,13 +99,15 @@ export class WorkflowSuspension extends Error {
         this.stepCount = stepCount;
         this.hookCount = hookCount;
         this.waitCount = waitCount;
+        this.attributeCount = attributeCount;
         this.hookDisposedCount = hookDisposedCount;
+        this.abortCount = abortCount;
     }
     static is(value) {
         return value instanceof WorkflowSuspension;
     }
 }
 export function ENOTSUP() {
-    throw new Error('Not supported in workflow functions');
+    throw new WorkflowRuntimeError('This API is not available inside a workflow function. Workflow functions run in a deterministic VM; move the call to a step function for full Node.js access.');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global.js","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"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","sourcesContent":["import { pluralize } from '@workflow/utils';\nimport type { Serializable } from './schemas.js';\n\nexport interface StepInvocationQueueItem {\n  type: 'step';\n  correlationId: string;\n  stepName: string;\n  args: Serializable[];\n  closureVars?: Record<string, Serializable>;\n  thisVal?: Serializable;\n  hasCreatedEvent?: boolean;\n}\n\nexport interface HookInvocationQueueItem {\n  type: 'hook';\n  correlationId: string;\n  token: string;\n  metadata?: Serializable;\n  hasCreatedEvent?: boolean;\n  disposed?: boolean;\n  isWebhook?: boolean;\n}\n\nexport interface WaitInvocationQueueItem {\n  type: 'wait';\n  correlationId: string;\n  resumeAt: Date;\n  hasCreatedEvent?: boolean;\n}\n\nexport type QueueItem =\n  | StepInvocationQueueItem\n  | HookInvocationQueueItem\n  | WaitInvocationQueueItem;\n\n/**\n * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do\n * not yet have corresponding entries in the event log. The workflow\n * dispatcher will catch this error and push the operations\n * onto the queue.\n */\nexport class WorkflowSuspension extends Error {\n  steps: QueueItem[];\n  globalThis: typeof globalThis;\n  stepCount: number;\n  hookCount: number;\n  waitCount: number;\n  hookDisposedCount: number;\n\n  constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis) {\n    // Convert Map to array for iteration and storage\n    const steps = [...stepsInput.values()];\n\n    // Single-pass counting for efficiency\n    let stepCount = 0;\n    let hookCount = 0;\n    let waitCount = 0;\n    let hookDisposedCount = 0;\n    for (const item of steps) {\n      if (item.type === 'step') stepCount++;\n      else if (item.type === 'hook') {\n        if (item.disposed) hookDisposedCount++;\n        else hookCount++;\n      } else if (item.type === 'wait') waitCount++;\n    }\n\n    // Build description parts\n    const parts: string[] = [];\n    if (stepCount > 0) {\n      parts.push(`${stepCount} ${pluralize('step', 'steps', stepCount)}`);\n    }\n    if (hookCount > 0) {\n      parts.push(`${hookCount} ${pluralize('hook', 'hooks', hookCount)}`);\n    }\n    if (waitCount > 0) {\n      parts.push(`${waitCount} ${pluralize('wait', 'waits', waitCount)}`);\n    }\n    if (hookDisposedCount > 0) {\n      parts.push(\n        `${hookDisposedCount} hook ${pluralize('disposal', 'disposals', hookDisposedCount)}`\n      );\n    }\n\n    // Determine verb (has/have) and action (run/created/received)\n    const totalCount = stepCount + hookCount + waitCount + hookDisposedCount;\n    const hasOrHave = pluralize('has', 'have', totalCount);\n    // Pick action verb: use \"processed\" when mixed types are present\n    const typeCount =\n      (stepCount > 0 ? 1 : 0) +\n      (hookCount > 0 ? 1 : 0) +\n      (waitCount > 0 ? 1 : 0) +\n      (hookDisposedCount > 0 ? 1 : 0);\n    let action: string;\n    if (typeCount > 1) {\n      action = 'processed';\n    } else if (stepCount > 0) {\n      action = 'run';\n    } else if (hookCount > 0) {\n      action = 'created';\n    } else if (waitCount > 0) {\n      action = 'created';\n    } else if (hookDisposedCount > 0) {\n      action = 'processed';\n    } else {\n      action = 'received';\n    }\n\n    const description =\n      parts.length > 0\n        ? `${parts.join(' and ')} ${hasOrHave} not been ${action} yet`\n        : '0 steps have not been run yet'; // Default case for empty array\n    super(description);\n    this.name = 'WorkflowSuspension';\n    this.steps = steps;\n    this.globalThis = global;\n    this.stepCount = stepCount;\n    this.hookCount = hookCount;\n    this.waitCount = waitCount;\n    this.hookDisposedCount = hookDisposedCount;\n  }\n\n  static is(value: unknown): value is WorkflowSuspension {\n    return value instanceof WorkflowSuspension;\n  }\n}\n\nexport function ENOTSUP(): never {\n  throw new Error('Not supported in workflow functions');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global.js","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { pluralize } from '@workflow/utils';\nimport type { AttributeChange } from '@workflow/world';\nimport type { Serializable } from './schemas.js';\n\nexport interface StepInvocationQueueItem {\n  type: 'step';\n  correlationId: string;\n  stepName: string;\n  args: Serializable[];\n  closureVars?: Record<string, Serializable>;\n  thisVal?: Serializable;\n  hasCreatedEvent?: boolean;\n  /**\n   * Inline step ownership, derived from the step's LATEST `step_started`\n   * during replay: the queue message ID stamped by the invocation running\n   * the step inline, or undefined when the latest start was unstamped (a\n   * retry attempt driven by a queued step message, or an older runtime).\n   * Latest start wins — an unstamped bare start clears a previous stamp; an\n   * owner-recovery re-stamped start restores it.\n   */\n  ownerMessageId?: string;\n  /**\n   * `createdAt` (ms) of the step's latest observed `step_started`. Anchors\n   * the ownership lease: `leaseRemaining = lastStartedAt + lease − now`.\n   */\n  lastStartedAt?: number;\n  /**\n   * Whether a `step_retrying` was observed for this step. From that point\n   * the step is queue-owned (the delayed retry handoff or replay requeue),\n   * so inline ownership is permanently lapsed for this correlation ID.\n   */\n  sawRetrying?: boolean;\n}\n\nexport interface HookInvocationQueueItem {\n  type: 'hook';\n  correlationId: string;\n  token: string;\n  /** Earliest time the token can be reused after the run ends. */\n  tokenRetentionUntil?: Date;\n  metadata?: Serializable;\n  hasCreatedEvent?: boolean;\n  /** Whether the workflow is awaiting `hook.getConflict()` for this hook */\n  hasConflictAwaiter?: boolean;\n  disposed?: boolean;\n  isWebhook?: boolean;\n  isSystem?: boolean;\n  abortRequested?: boolean;\n  abortReason?: unknown;\n}\n\nexport interface WaitInvocationQueueItem {\n  type: 'wait';\n  correlationId: string;\n  resumeAt: Date;\n  hasCreatedEvent?: boolean;\n}\n\nexport interface AttributeInvocationQueueItem {\n  type: 'attribute';\n  correlationId: string;\n  changes: AttributeChange[];\n  allowReservedAttributes?: true;\n}\n\nexport type QueueItem =\n  | StepInvocationQueueItem\n  | HookInvocationQueueItem\n  | WaitInvocationQueueItem\n  | AttributeInvocationQueueItem;\n\n/**\n * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do\n * not yet have corresponding entries in the event log. The workflow\n * dispatcher will catch this error and push the operations\n * onto the queue.\n */\nexport class WorkflowSuspension extends Error {\n  steps: QueueItem[];\n  globalThis: typeof globalThis;\n  stepCount: number;\n  hookCount: number;\n  waitCount: number;\n  attributeCount: number;\n  hookDisposedCount: number;\n  abortCount: number;\n\n  constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis) {\n    // Convert Map to array for iteration and storage\n    const steps = [...stepsInput.values()];\n\n    // Single-pass counting for efficiency\n    let stepCount = 0;\n    let hookCount = 0;\n    let waitCount = 0;\n    let attributeCount = 0;\n    let hookDisposedCount = 0;\n    let abortCount = 0;\n    for (const item of steps) {\n      if (item.type === 'step') stepCount++;\n      else if (item.type === 'hook') {\n        if (item.disposed) hookDisposedCount++;\n        else if (item.abortRequested) abortCount++;\n        else hookCount++;\n      } else if (item.type === 'wait') waitCount++;\n      else if (item.type === 'attribute') attributeCount++;\n    }\n\n    // Build description parts\n    const parts: string[] = [];\n    if (stepCount > 0) {\n      parts.push(`${stepCount} ${pluralize('step', 'steps', stepCount)}`);\n    }\n    if (hookCount > 0) {\n      parts.push(`${hookCount} ${pluralize('hook', 'hooks', hookCount)}`);\n    }\n    if (waitCount > 0) {\n      parts.push(`${waitCount} ${pluralize('wait', 'waits', waitCount)}`);\n    }\n    if (attributeCount > 0) {\n      parts.push(\n        `${attributeCount} ${pluralize('attribute write', 'attribute writes', attributeCount)}`\n      );\n    }\n    if (hookDisposedCount > 0) {\n      parts.push(\n        `${hookDisposedCount} hook ${pluralize('disposal', 'disposals', hookDisposedCount)}`\n      );\n    }\n\n    // Determine verb (has/have) and action (run/created/received)\n    const totalCount =\n      stepCount + hookCount + waitCount + attributeCount + hookDisposedCount;\n    const hasOrHave = pluralize('has', 'have', totalCount);\n    // Pick action verb: use \"processed\" when mixed types are present\n    const typeCount =\n      (stepCount > 0 ? 1 : 0) +\n      (hookCount > 0 ? 1 : 0) +\n      (waitCount > 0 ? 1 : 0) +\n      (attributeCount > 0 ? 1 : 0) +\n      (hookDisposedCount > 0 ? 1 : 0);\n    let action: string;\n    if (typeCount > 1) {\n      action = 'processed';\n    } else if (stepCount > 0) {\n      action = 'run';\n    } else if (hookCount > 0) {\n      action = 'created';\n    } else if (waitCount > 0) {\n      action = 'created';\n    } else if (attributeCount > 0) {\n      action = 'written';\n    } else if (hookDisposedCount > 0) {\n      action = 'processed';\n    } else {\n      action = 'received';\n    }\n\n    const description =\n      parts.length > 0\n        ? `${parts.join(' and ')} ${hasOrHave} not been ${action} yet`\n        : '0 steps have not been run yet'; // Default case for empty array\n    super(description);\n    this.name = 'WorkflowSuspension';\n    this.steps = steps;\n    this.globalThis = global;\n    this.stepCount = stepCount;\n    this.hookCount = hookCount;\n    this.waitCount = waitCount;\n    this.attributeCount = attributeCount;\n    this.hookDisposedCount = hookDisposedCount;\n    this.abortCount = abortCount;\n  }\n\n  static is(value: unknown): value is WorkflowSuspension {\n    return value instanceof WorkflowSuspension;\n  }\n}\n\nexport function ENOTSUP(): never {\n  throw new WorkflowRuntimeError(\n    'This API is not available inside a workflow function. Workflow functions run in a deterministic VM; move the call to a step function for full Node.js access.'\n  );\n}\n"]}

package/dist/index.d.ts

@@ -12,6 +12,7 @@
 export { FatalError, RetryableError, type RetryableErrorOptions, } from '@workflow/errors';
 export { createHook, createWebhook, type Hook, type HookOptions, type RequestWithResponse, type Webhook, type WebhookOptions, } from './create-hook.js';
 export { defineHook, type TypedHook } from './define-hook.js';
+export { type SetAttributesOptions, setAttributes, } from './set-attributes.js';
 export { sleep } from './sleep.js';
 export { getStepMetadata, type StepMetadata, } from './step/get-step-metadata.js';
 export { getWorkflowMetadata, type WorkflowMetadata, } from './step/get-workflow-metadata.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,UAAU,EACV,aAAa,EACb,KAAK,IAAI,EACT,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,OAAO,EACZ,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EACL,eAAe,EACf,KAAK,YAAY,GAClB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,WAAW,EACX,KAAK,6BAA6B,GACnC,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,UAAU,EACV,aAAa,EACb,KAAK,IAAI,EACT,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,OAAO,EACZ,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EACL,KAAK,oBAAoB,EACzB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EACL,eAAe,EACf,KAAK,YAAY,GAClB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,WAAW,EACX,KAAK,6BAA6B,GACnC,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -12,8 +12,9 @@
 export { FatalError, RetryableError, } from '@workflow/errors';
 export { createHook, createWebhook, } from './create-hook.js';
 export { defineHook } from './define-hook.js';
+export { setAttributes, } from './set-attributes.js';
 export { sleep } from './sleep.js';
 export { getStepMetadata, } from './step/get-step-metadata.js';
 export { getWorkflowMetadata, } from './step/get-workflow-metadata.js';
 export { getWritable, } from './step/writable-stream.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7R0FVRztBQUVILE9BQU8sRUFDTCxVQUFVLEVBQ1YsY0FBYyxHQUVmLE1BQU0sa0JBQWtCLENBQUM7QUFDMUIsT0FBTyxFQUNMLFVBQVUsRUFDVixhQUFhLEdBTWQsTUFBTSxrQkFBa0IsQ0FBQztBQUMxQixPQUFPLEVBQUUsVUFBVSxFQUFrQixNQUFNLGtCQUFrQixDQUFDO0FBQzlELE9BQU8sRUFFTCxhQUFhLEdBQ2QsTUFBTSxxQkFBcUIsQ0FBQztBQUM3QixPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQ25DLE9BQU8sRUFDTCxlQUFlLEdBRWhCLE1BQU0sNkJBQTZCLENBQUM7QUFDckMsT0FBTyxFQUNMLG1CQUFtQixHQUVwQixNQUFNLGlDQUFpQyxDQUFDO0FBQ3pDLE9BQU8sRUFDTCxXQUFXLEdBRVosTUFBTSwyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogSnVzdCB0aGUgY29yZSB1dGlsaXRpZXMgdGhhdCBhcmUgbWVhbnQgdG8gYmUgaW1wb3J0ZWQgYnkgdXNlclxuICogc3RlcHMvd29ya2Zsb3dzLiBUaGlzIGFsbG93cyB0aGUgYnVuZGxlciB0byB0cmVlLXNoYWtlIGFuZCBsaW1pdCB3aGF0IGdvZXNcbiAqIGludG8gdGhlIGZpbmFsIHVzZXIgYnVuZGxlcy4gTG9naWMgZm9yIHJ1bm5pbmcvaGFuZGxpbmcgc3RlcHMvd29ya2Zsb3dzXG4gKiBzaG91bGQgbGl2ZSBpbiBydW50aW1lLiBFdmVudHVhbGx5IHRoZXNlIG1pZ2h0IGJlIHNlcGFyYXRlIHBhY2thZ2VzXG4gKiBgd29ya2Zsb3dgIGFuZCBgd29ya2Zsb3cvcnVudGltZWA/XG4gKlxuICogRXZlcnl0aGluZyBoZXJlIHdpbGwgZ2V0IHJlLWV4cG9ydGVkIHVuZGVyIHRoZSAnd29ya2Zsb3cnIHRvcCBsZXZlbCBwYWNrYWdlLlxuICogVGhpcyBzaG91bGQgYmUgYSBtaW5pbWFsIHNldCBvZiBBUElzIHNvICoqZG8gbm90IGFueXRoaW5nIGhlcmUqKiB1bmxlc3MgaXQnc1xuICogbmVlZGVkIGZvciB1c2VybGFuZCB3b3JrZmxvdyBjb2RlLlxuICovXG5cbmV4cG9ydCB7XG4gIEZhdGFsRXJyb3IsXG4gIFJldHJ5YWJsZUVycm9yLFxuICB0eXBlIFJldHJ5YWJsZUVycm9yT3B0aW9ucyxcbn0gZnJvbSAnQHdvcmtmbG93L2Vycm9ycyc7XG5leHBvcnQge1xuICBjcmVhdGVIb29rLFxuICBjcmVhdGVXZWJob29rLFxuICB0eXBlIEhvb2ssXG4gIHR5cGUgSG9va09wdGlvbnMsXG4gIHR5cGUgUmVxdWVzdFdpdGhSZXNwb25zZSxcbiAgdHlwZSBXZWJob29rLFxuICB0eXBlIFdlYmhvb2tPcHRpb25zLFxufSBmcm9tICcuL2NyZWF0ZS1ob29rLmpzJztcbmV4cG9ydCB7IGRlZmluZUhvb2ssIHR5cGUgVHlwZWRIb29rIH0gZnJvbSAnLi9kZWZpbmUtaG9vay5qcyc7XG5leHBvcnQge1xuICB0eXBlIFNldEF0dHJpYnV0ZXNPcHRpb25zLFxuICBzZXRBdHRyaWJ1dGVzLFxufSBmcm9tICcuL3NldC1hdHRyaWJ1dGVzLmpzJztcbmV4cG9ydCB7IHNsZWVwIH0gZnJvbSAnLi9zbGVlcC5qcyc7XG5leHBvcnQge1xuICBnZXRTdGVwTWV0YWRhdGEsXG4gIHR5cGUgU3RlcE1ldGFkYXRhLFxufSBmcm9tICcuL3N0ZXAvZ2V0LXN0ZXAtbWV0YWRhdGEuanMnO1xuZXhwb3J0IHtcbiAgZ2V0V29ya2Zsb3dNZXRhZGF0YSxcbiAgdHlwZSBXb3JrZmxvd01ldGFkYXRhLFxufSBmcm9tICcuL3N0ZXAvZ2V0LXdvcmtmbG93LW1ldGFkYXRhLmpzJztcbmV4cG9ydCB7XG4gIGdldFdyaXRhYmxlLFxuICB0eXBlIFdvcmtmbG93V3JpdGFibGVTdHJlYW1PcHRpb25zLFxufSBmcm9tICcuL3N0ZXAvd3JpdGFibGUtc3RyZWFtLmpzJztcbiJdfQ==

package/dist/log-format.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Structured-log composition for `console.error` / `console.warn`. Emits
+ * one string in three sections so the most useful information is at the
+ * top, stack trace at the bottom:
+ *
+ *     [workflow-sdk] <framing line>
+ *       user error · FatalError
+ *       run    wrun_…
+ *       step   step_… · add (./workflows/x)
+ *       hint:  Move the call to a step function.
+ *     FatalError: …
+ *         at … (trimmed stack — internals collapsed)
+ *
+ * Without this composition, callers passing `${framing}\n${stack}` as the
+ * message and structured fields as the metadata object got `util.inspect`'s
+ * default object dump appended *after* the stack, which buries the run ID
+ * and attribution badge under 30+ lines of `node_modules/.pnpm/...` frames.
+ *
+ * The same metadata is also emitted as structured OTel span events from
+ * the logger itself, so backends that want JSON-shaped data still get it.
+ * web/web-shared do not consume stderr at all — they read CBOR/JSON event
+ * payloads from the World event log.
+ */
+export declare function composeLogLine(prefix: string, message: string, metadata: Record<string, unknown> | undefined): string;
+//# sourceMappingURL=log-format.d.ts.map

package/dist/log-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-format.d.ts","sourceRoot":"","sources":["../src/log-format.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC5C,MAAM,CAUR"}