@workflow/core 5.0.0-beta.50 → 5.0.0-beta.52

package/dist/flushable-stream.js

@@ -83,6 +83,9 @@ export function createFlushableState() {
     const state = {
         ...withResolvers(),
         pendingOps: 0,
+        producedFrames: 0,
+        acceptedFrames: 0,
+        frameWaiters: [],
         doneResolved: false,
         streamEnded: false,
     };
@@ -163,6 +166,150 @@ function resolveAfterDrain(state) {
     }
     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.
@@ -185,6 +332,17 @@ 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;
@@ -297,6 +455,11 @@ async function flushablePipePerChunk(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--;
@@ -305,7 +468,12 @@ async function flushablePipePerChunk(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
@@ -336,4 +504,4 @@ async function flushablePipePerChunk(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 { 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  /** 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 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      } 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, 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"]}
+//# 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/log-format.d.ts

@@ -11,6 +11,9 @@
  *     FatalError: …
  *         at … (trimmed stack, internals collapsed)
  *
+ * The stack body comes from the message when the caller embedded it there,
+ * and from the `errorStack` metadata field otherwise.
+ *
  * 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

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

@@ -1 +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"}
+{"version":3,"file":"log-format.d.ts","sourceRoot":"","sources":["../src/log-format.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC5C,MAAM,CAkBR"}

package/dist/log-format.js

@@ -13,6 +13,9 @@ import { formatStepName, formatWorkflowName, parseStepName, parseWorkflowName, }
  *     FatalError: …
  *         at … (trimmed stack, internals collapsed)
  *
+ * The stack body comes from the message when the caller embedded it there,
+ * and from the `errorStack` metadata field otherwise.
+ *
  * 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
@@ -25,8 +28,16 @@ import { formatStepName, formatWorkflowName, parseStepName, parseWorkflowName, }
  */
 export function composeLogLine(prefix, message, metadata) {
     const [framing, ...rest] = message.split('\n');
-    const body = rest.join('\n');
-    const fields = renderStructuredFields(framing ?? '', metadata);
+    const embeddedBody = rest.join('\n');
+    // Callers supply the stack one of two ways: embedded in the message (step
+    // executor / combined runtime render `${framing}\n${stack}`) or as an
+    // `errorStack` field next to a single-line framing (the run-failure log in
+    // runtime.ts). Promote the field when the message has no body of its own so
+    // the stack survives either way, and gets the same trimming either way.
+    const body = embeddedBody.trim()
+        ? embeddedBody
+        : (pickString(metadata ?? {}, 'errorStack') ?? '');
+    const fields = renderStructuredFields(framing ?? '', body, metadata);
     const trimmedBody = trimStackBody(body);
     const lines = [`${prefix} ${framing ?? ''}`];
     if (fields)
@@ -35,16 +46,21 @@ export function composeLogLine(prefix, message, metadata) {
         lines.push(trimmedBody);
     return lines.join('\n');
 }
-function renderStructuredFields(framing, metadata) {
+function renderStructuredFields(framing, body, metadata) {
     if (!metadata || Object.keys(metadata).length === 0)
         return null;
-    // Drop fields that the message already encodes. We render framings and
-    // stacks into the message string itself in step executor / combined runtime, so
-    // repeating them here would be pure noise.
+    // Drop fields the composed line already shows elsewhere. `errorStack` is
+    // always rendered as the body — embedded in the message by the step
+    // executor / combined runtime, or promoted out of the field by
+    // composeLogLine — so repeating it here would be pure noise. A message
+    // with neither (a WARN whose framing is a fixed sentence and whose
+    // `errorMessage` is the only place the underlying error's text appears)
+    // keeps `errorMessage` and renders it as its own row below.
     const redundant = new Set();
     redundant.add('errorStack');
-    if (typeof metadata.errorMessage === 'string' &&
-        framing.includes(metadata.errorMessage)) {
+    const errorMessage = pickString(metadata, 'errorMessage');
+    if (errorMessage &&
+        (framing.includes(errorMessage) || body.includes(errorMessage))) {
         redundant.add('errorMessage');
     }
     const wellKnown = new Set([
@@ -63,9 +79,16 @@ function renderStructuredFields(framing, metadata) {
     ]);
     const lines = [];
     // Header: error class + attribution badge.
+    //
+    // Without a badge the row is just the class name, which the stack header
+    // below (`Name: message`) already states — so it only earns its line when
+    // the stack doesn't open with that same name. A badge always earns its
+    // line: attribution is the one thing the stack cannot express, and the
+    // class stays attached to it as the thing being attributed.
     const errorName = pickString(metadata, 'errorName');
     const attribution = pickString(metadata, 'errorAttribution');
-    if (errorName || attribution) {
+    const nameEchoedByStack = errorName !== null && stackHeaderNames(body, errorName);
+    if (attribution || (errorName && !nameEchoedByStack)) {
         const badge = attribution
             ? attribution === 'sdk'
                 ? Ansi.magenta('sdk error')
@@ -107,6 +130,9 @@ function renderStructuredFields(framing, metadata) {
     if (errorCode && errorCode !== errorName) {
         lines.push(`  ${kvKey('code')} ${Ansi.dim(errorCode)}`);
     }
+    if (errorMessage && !redundant.has('errorMessage')) {
+        lines.push(`  ${kvKey('error')} ${formatPassthroughValue(errorMessage)}`);
+    }
     const hint = pickString(metadata, 'hint');
     if (hint) {
         lines.push(`  ${Ansi.hint(hint)}`);
@@ -209,6 +235,15 @@ function isFrameworkFrame(line) {
     }
     return false;
 }
+/**
+ * True when the stack body opens with `<errorName>:` (or the bare name), the
+ * shape V8 gives `Error#stack`. Used to avoid restating the class in a
+ * header row directly above it.
+ */
+function stackHeaderNames(body, errorName) {
+    const header = body.split('\n', 1)[0]?.trim() ?? '';
+    return header === errorName || header.startsWith(`${errorName}:`);
+}
 function pickString(metadata, key) {
     const v = metadata[key];
     return typeof v === 'string' && v.length > 0 ? v : null;
@@ -247,4 +282,4 @@ function formatPassthroughValue(v) {
         return String(v);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log-format.js","sourceRoot":"","sources":["../src/log-format.ts"],"names":[],"mappings":"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","sourcesContent":["import * as Ansi from '@workflow/errors/ansi';\nimport {\n  formatStepName,\n  formatWorkflowName,\n  parseStepName,\n  parseWorkflowName,\n} from '@workflow/utils';\n\n/**\n * Structured-log composition for `console.error` / `console.warn`. Emits\n * one string in three sections so the most useful information is at the\n * top, stack trace at the bottom:\n *\n *     [workflow-sdk] <framing line>\n *       user error · FatalError\n *       run    wrun_…\n *       step   step_… · add (./workflows/x)\n *       hint:  Move the call to a step function.\n *     FatalError: …\n *         at … (trimmed stack, internals collapsed)\n *\n * Without this composition, callers passing `${framing}\\n${stack}` as the\n * message and structured fields as the metadata object got `util.inspect`'s\n * default object dump appended *after* the stack, which buries the run ID\n * and attribution badge under 30+ lines of `node_modules/.pnpm/...` frames.\n *\n * The same metadata is also emitted as structured OTel span events from\n * the logger itself, so backends that want JSON-shaped data still get it.\n * web/web-shared do not consume stderr at all: they read CBOR/JSON event\n * payloads from the World event log.\n */\nexport function composeLogLine(\n  prefix: string,\n  message: string,\n  metadata: Record<string, unknown> | undefined\n): string {\n  const [framing, ...rest] = message.split('\\n');\n  const body = rest.join('\\n');\n  const fields = renderStructuredFields(framing ?? '', metadata);\n  const trimmedBody = trimStackBody(body);\n\n  const lines: string[] = [`${prefix} ${framing ?? ''}`];\n  if (fields) lines.push(fields);\n  if (trimmedBody) lines.push(trimmedBody);\n  return lines.join('\\n');\n}\n\nfunction renderStructuredFields(\n  framing: string,\n  metadata: Record<string, unknown> | undefined\n): string | null {\n  if (!metadata || Object.keys(metadata).length === 0) return null;\n\n  // Drop fields that the message already encodes. We render framings and\n  // stacks into the message string itself in step executor / combined runtime, so\n  // repeating them here would be pure noise.\n  const redundant = new Set<string>();\n  redundant.add('errorStack');\n  if (\n    typeof metadata.errorMessage === 'string' &&\n    framing.includes(metadata.errorMessage as string)\n  ) {\n    redundant.add('errorMessage');\n  }\n\n  const wellKnown = new Set([\n    'workflowRunId',\n    'workflowName',\n    'stepId',\n    'stepName',\n    'errorAttribution',\n    'errorCode',\n    'errorName',\n    'errorMessage',\n    'errorStack',\n    'hint',\n    'attempt',\n    'retryCount',\n  ]);\n\n  const lines: string[] = [];\n\n  // Header: error class + attribution badge.\n  const errorName = pickString(metadata, 'errorName');\n  const attribution = pickString(metadata, 'errorAttribution');\n  if (errorName || attribution) {\n    const badge = attribution\n      ? attribution === 'sdk'\n        ? Ansi.magenta('sdk error')\n        : Ansi.red('user error')\n      : '';\n    const cls = errorName ? Ansi.bold(errorName) : '';\n    const sep = badge && cls ? Ansi.dim(' · ') : '';\n    lines.push(`  ${badge}${sep}${cls}`);\n  }\n\n  // ID + parsed friendly-name rows.\n  const runId = pickString(metadata, 'workflowRunId');\n  const wfName = pickString(metadata, 'workflowName');\n  if (runId) {\n    lines.push(formatIdRow('run', runId, wfName, formatWorkflowName));\n  } else if (wfName) {\n    lines.push(formatIdRow('run', null, wfName, formatWorkflowName));\n  }\n\n  const stepId = pickString(metadata, 'stepId');\n  const stepName = pickString(metadata, 'stepName');\n  if (stepId || stepName) {\n    lines.push(formatIdRow('step', stepId, stepName, formatStepName));\n  }\n\n  if (metadata.attempt !== undefined || metadata.retryCount !== undefined) {\n    // `attempt` and `retryCount` read ambiguously next to each other (is\n    // \"3 retries\" the limit or what already happened?). Render the limit\n    // as \"max retries\" to make the boundary explicit, and keep `attempt`\n    // as the count of total invocations including the original.\n    const a = metadata.attempt;\n    const r = metadata.retryCount;\n    if (a !== undefined && r !== undefined) {\n      lines.push(\n        `  ${kvKey('retry')} ${a} ${Ansi.dim('attempts ·')} ${r} ${Ansi.dim('max retries')}`\n      );\n    } else if (a !== undefined) {\n      lines.push(`  ${kvKey('retry')} ${a} ${Ansi.dim('attempts')}`);\n    }\n  }\n\n  const errorCode = pickString(metadata, 'errorCode');\n  if (errorCode && errorCode !== errorName) {\n    lines.push(`  ${kvKey('code')} ${Ansi.dim(errorCode)}`);\n  }\n\n  const hint = pickString(metadata, 'hint');\n  if (hint) {\n    lines.push(`  ${Ansi.hint(hint)}`);\n  }\n\n  // Sorted pass-through for unknown fields.\n  const passThrough = Object.entries(metadata)\n    .filter(\n      ([k, v]) =>\n        !wellKnown.has(k) && !redundant.has(k) && v !== undefined && v !== null\n    )\n    .sort(([a], [b]) => a.localeCompare(b));\n  for (const [k, v] of passThrough) {\n    lines.push(`  ${kvKey(k)} ${formatPassthroughValue(v)}`);\n  }\n\n  return lines.length ? lines.join('\\n') : null;\n}\n\n/**\n * Strip the stack down to frames the user can act on. V8 stacks for our\n * runtime errors look like:\n *\n *     Name: message\n *         at userStep (./workflows/foo.ts:12:11)\n *         at <unknown> (../../packages/core/src/runtime/step-executor.ts:535:32)\n *         at <unknown> (.../node_modules/.pnpm/next@…/…/base-server.js:1454:9)\n *         at <unknown> (.../node_modules/.pnpm/@opentelemetry+api@…/…/api.js:5440)\n *         at … (15 more frames into Next.js / pnpm internals)\n *\n * Two-pass trim:\n *\n *   1. Drop framework-internal frames (`node_modules/.pnpm/`, `node:internal/`,\n *      Turbopack-bundled `node_modules__pnpm_*` / `_next_dist_*` chunks).\n *   2. Cap the surviving frames at `MAX_VISIBLE_FRAMES`: past that, even\n *      \"user-ish\" frames are usually deep async wrapping that doesn't help\n *      pinpoint the throw. The user can drop into the inspect CLI for the\n *      full stack on demand.\n *\n * Each suppressed run emits one summary line so people know how much was\n * trimmed.\n */\nconst MAX_VISIBLE_FRAMES = 6;\n\nfunction trimStackBody(body: string): string | null {\n  if (!body) return null;\n  const lines = body.split('\\n');\n  const out: string[] = [];\n  let droppedRun = 0;\n  let visibleFrameCount = 0;\n  let cappedFrames = 0;\n\n  const flushDropped = () => {\n    if (droppedRun > 0) {\n      out.push(\n        Ansi.dim(\n          `        … ${droppedRun} more ${droppedRun === 1 ? 'frame' : 'frames'} in framework internals`\n        )\n      );\n      droppedRun = 0;\n    }\n  };\n\n  for (const line of lines) {\n    const isFrame = line.trimStart().startsWith('at ');\n    if (isFrame && isFrameworkFrame(line)) {\n      droppedRun++;\n      continue;\n    }\n    if (isFrame && visibleFrameCount >= MAX_VISIBLE_FRAMES) {\n      cappedFrames++;\n      continue;\n    }\n    flushDropped();\n    out.push(line);\n    if (isFrame) visibleFrameCount++;\n  }\n  flushDropped();\n  if (cappedFrames > 0) {\n    out.push(\n      Ansi.dim(\n        `        … ${cappedFrames} more ${cappedFrames === 1 ? 'frame' : 'frames'} (run \\`pnpm wf inspect run <id>\\` for the full stack)`\n      )\n    );\n  }\n  return out.join('\\n');\n}\n\nfunction isFrameworkFrame(line: string): boolean {\n  // Only at-frames are candidates for stripping. Header lines (`Name: …`)\n  // and arbitrary trailing context (e.g. `code: 'USER_ERROR'`) pass through.\n  const trimmed = line.trimStart();\n  if (!trimmed.startsWith('at ')) return false;\n  // node:* internals (timers, async hooks, vm, etc.) never help users.\n  if (trimmed.includes('node:internal/')) return true;\n  // pnpm-rooted frameworks installed as node_modules dependencies.\n  if (trimmed.includes('node_modules/.pnpm/')) return true;\n  // Turbopack/Next bundle the same framework code into chunks like\n  // `node_modules__pnpm_<hash>._.js` and `<...>_next_dist_<hash>._.js`,\n  // and emits Next.js loader runtime as `0dx6_next_dist_<hash>._.js`.\n  // These are the frames that show up after Turbopack DCE, same intent\n  // as the raw `node_modules/.pnpm/` filter above.\n  if (trimmed.includes('node_modules__pnpm_')) return true;\n  if (trimmed.includes('_next_dist_')) return true;\n  // Plain node_modules (non-pnpm setups) for the same kinds of frameworks.\n  if (\n    trimmed.includes('node_modules/next/') ||\n    trimmed.includes('node_modules/@opentelemetry/') ||\n    trimmed.includes('node_modules/vitest/') ||\n    trimmed.includes('node_modules/@vitest/')\n  ) {\n    return true;\n  }\n  return false;\n}\n\nfunction pickString(\n  metadata: Record<string, unknown>,\n  key: string\n): string | null {\n  const v = metadata[key];\n  return typeof v === 'string' && v.length > 0 ? v : null;\n}\n\nfunction kvKey(key: string): string {\n  return Ansi.dim(key.padEnd(6));\n}\n\nfunction formatIdRow(\n  label: string,\n  id: string | null,\n  name: string | null,\n  formatName: (n: string) => string\n): string {\n  const idCell = id ? id : Ansi.dim('—');\n  const parsed = name\n    ? label === 'run'\n      ? parseWorkflowName(name)\n      : parseStepName(name)\n    : null;\n  const nameCell = parsed\n    ? `${Ansi.dim('·')} ${formatName(name as string)}`\n    : '';\n  return `  ${kvKey(label)} ${idCell}${nameCell ? ' ' + nameCell : ''}`;\n}\n\nfunction formatPassthroughValue(v: unknown): string {\n  if (typeof v === 'string') {\n    if (v.includes('\\n')) {\n      return v\n        .split('\\n')\n        .map((line, i) => (i === 0 ? line : `         ${line}`))\n        .join('\\n');\n    }\n    return v;\n  }\n  if (typeof v === 'number' || typeof v === 'boolean') return String(v);\n  try {\n    return JSON.stringify(v);\n  } catch {\n    return String(v);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log-format.js","sourceRoot":"","sources":["../src/log-format.ts"],"names":[],"mappings":"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","sourcesContent":["import * as Ansi from '@workflow/errors/ansi';\nimport {\n  formatStepName,\n  formatWorkflowName,\n  parseStepName,\n  parseWorkflowName,\n} from '@workflow/utils';\n\n/**\n * Structured-log composition for `console.error` / `console.warn`. Emits\n * one string in three sections so the most useful information is at the\n * top, stack trace at the bottom:\n *\n *     [workflow-sdk] <framing line>\n *       user error · FatalError\n *       run    wrun_…\n *       step   step_… · add (./workflows/x)\n *       hint:  Move the call to a step function.\n *     FatalError: …\n *         at … (trimmed stack, internals collapsed)\n *\n * The stack body comes from the message when the caller embedded it there,\n * and from the `errorStack` metadata field otherwise.\n *\n * Without this composition, callers passing `${framing}\\n${stack}` as the\n * message and structured fields as the metadata object got `util.inspect`'s\n * default object dump appended *after* the stack, which buries the run ID\n * and attribution badge under 30+ lines of `node_modules/.pnpm/...` frames.\n *\n * The same metadata is also emitted as structured OTel span events from\n * the logger itself, so backends that want JSON-shaped data still get it.\n * web/web-shared do not consume stderr at all: they read CBOR/JSON event\n * payloads from the World event log.\n */\nexport function composeLogLine(\n  prefix: string,\n  message: string,\n  metadata: Record<string, unknown> | undefined\n): string {\n  const [framing, ...rest] = message.split('\\n');\n  const embeddedBody = rest.join('\\n');\n  // Callers supply the stack one of two ways: embedded in the message (step\n  // executor / combined runtime render `${framing}\\n${stack}`) or as an\n  // `errorStack` field next to a single-line framing (the run-failure log in\n  // runtime.ts). Promote the field when the message has no body of its own so\n  // the stack survives either way, and gets the same trimming either way.\n  const body = embeddedBody.trim()\n    ? embeddedBody\n    : (pickString(metadata ?? {}, 'errorStack') ?? '');\n  const fields = renderStructuredFields(framing ?? '', body, metadata);\n  const trimmedBody = trimStackBody(body);\n\n  const lines: string[] = [`${prefix} ${framing ?? ''}`];\n  if (fields) lines.push(fields);\n  if (trimmedBody) lines.push(trimmedBody);\n  return lines.join('\\n');\n}\n\nfunction renderStructuredFields(\n  framing: string,\n  body: string,\n  metadata: Record<string, unknown> | undefined\n): string | null {\n  if (!metadata || Object.keys(metadata).length === 0) return null;\n\n  // Drop fields the composed line already shows elsewhere. `errorStack` is\n  // always rendered as the body — embedded in the message by the step\n  // executor / combined runtime, or promoted out of the field by\n  // composeLogLine — so repeating it here would be pure noise. A message\n  // with neither (a WARN whose framing is a fixed sentence and whose\n  // `errorMessage` is the only place the underlying error's text appears)\n  // keeps `errorMessage` and renders it as its own row below.\n  const redundant = new Set<string>();\n  redundant.add('errorStack');\n  const errorMessage = pickString(metadata, 'errorMessage');\n  if (\n    errorMessage &&\n    (framing.includes(errorMessage) || body.includes(errorMessage))\n  ) {\n    redundant.add('errorMessage');\n  }\n\n  const wellKnown = new Set([\n    'workflowRunId',\n    'workflowName',\n    'stepId',\n    'stepName',\n    'errorAttribution',\n    'errorCode',\n    'errorName',\n    'errorMessage',\n    'errorStack',\n    'hint',\n    'attempt',\n    'retryCount',\n  ]);\n\n  const lines: string[] = [];\n\n  // Header: error class + attribution badge.\n  //\n  // Without a badge the row is just the class name, which the stack header\n  // below (`Name: message`) already states — so it only earns its line when\n  // the stack doesn't open with that same name. A badge always earns its\n  // line: attribution is the one thing the stack cannot express, and the\n  // class stays attached to it as the thing being attributed.\n  const errorName = pickString(metadata, 'errorName');\n  const attribution = pickString(metadata, 'errorAttribution');\n  const nameEchoedByStack =\n    errorName !== null && stackHeaderNames(body, errorName);\n  if (attribution || (errorName && !nameEchoedByStack)) {\n    const badge = attribution\n      ? attribution === 'sdk'\n        ? Ansi.magenta('sdk error')\n        : Ansi.red('user error')\n      : '';\n    const cls = errorName ? Ansi.bold(errorName) : '';\n    const sep = badge && cls ? Ansi.dim(' · ') : '';\n    lines.push(`  ${badge}${sep}${cls}`);\n  }\n\n  // ID + parsed friendly-name rows.\n  const runId = pickString(metadata, 'workflowRunId');\n  const wfName = pickString(metadata, 'workflowName');\n  if (runId) {\n    lines.push(formatIdRow('run', runId, wfName, formatWorkflowName));\n  } else if (wfName) {\n    lines.push(formatIdRow('run', null, wfName, formatWorkflowName));\n  }\n\n  const stepId = pickString(metadata, 'stepId');\n  const stepName = pickString(metadata, 'stepName');\n  if (stepId || stepName) {\n    lines.push(formatIdRow('step', stepId, stepName, formatStepName));\n  }\n\n  if (metadata.attempt !== undefined || metadata.retryCount !== undefined) {\n    // `attempt` and `retryCount` read ambiguously next to each other (is\n    // \"3 retries\" the limit or what already happened?). Render the limit\n    // as \"max retries\" to make the boundary explicit, and keep `attempt`\n    // as the count of total invocations including the original.\n    const a = metadata.attempt;\n    const r = metadata.retryCount;\n    if (a !== undefined && r !== undefined) {\n      lines.push(\n        `  ${kvKey('retry')} ${a} ${Ansi.dim('attempts ·')} ${r} ${Ansi.dim('max retries')}`\n      );\n    } else if (a !== undefined) {\n      lines.push(`  ${kvKey('retry')} ${a} ${Ansi.dim('attempts')}`);\n    }\n  }\n\n  const errorCode = pickString(metadata, 'errorCode');\n  if (errorCode && errorCode !== errorName) {\n    lines.push(`  ${kvKey('code')} ${Ansi.dim(errorCode)}`);\n  }\n\n  if (errorMessage && !redundant.has('errorMessage')) {\n    lines.push(`  ${kvKey('error')} ${formatPassthroughValue(errorMessage)}`);\n  }\n\n  const hint = pickString(metadata, 'hint');\n  if (hint) {\n    lines.push(`  ${Ansi.hint(hint)}`);\n  }\n\n  // Sorted pass-through for unknown fields.\n  const passThrough = Object.entries(metadata)\n    .filter(\n      ([k, v]) =>\n        !wellKnown.has(k) && !redundant.has(k) && v !== undefined && v !== null\n    )\n    .sort(([a], [b]) => a.localeCompare(b));\n  for (const [k, v] of passThrough) {\n    lines.push(`  ${kvKey(k)} ${formatPassthroughValue(v)}`);\n  }\n\n  return lines.length ? lines.join('\\n') : null;\n}\n\n/**\n * Strip the stack down to frames the user can act on. V8 stacks for our\n * runtime errors look like:\n *\n *     Name: message\n *         at userStep (./workflows/foo.ts:12:11)\n *         at <unknown> (../../packages/core/src/runtime/step-executor.ts:535:32)\n *         at <unknown> (.../node_modules/.pnpm/next@…/…/base-server.js:1454:9)\n *         at <unknown> (.../node_modules/.pnpm/@opentelemetry+api@…/…/api.js:5440)\n *         at … (15 more frames into Next.js / pnpm internals)\n *\n * Two-pass trim:\n *\n *   1. Drop framework-internal frames (`node_modules/.pnpm/`, `node:internal/`,\n *      Turbopack-bundled `node_modules__pnpm_*` / `_next_dist_*` chunks).\n *   2. Cap the surviving frames at `MAX_VISIBLE_FRAMES`: past that, even\n *      \"user-ish\" frames are usually deep async wrapping that doesn't help\n *      pinpoint the throw. The user can drop into the inspect CLI for the\n *      full stack on demand.\n *\n * Each suppressed run emits one summary line so people know how much was\n * trimmed.\n */\nconst MAX_VISIBLE_FRAMES = 6;\n\nfunction trimStackBody(body: string): string | null {\n  if (!body) return null;\n  const lines = body.split('\\n');\n  const out: string[] = [];\n  let droppedRun = 0;\n  let visibleFrameCount = 0;\n  let cappedFrames = 0;\n\n  const flushDropped = () => {\n    if (droppedRun > 0) {\n      out.push(\n        Ansi.dim(\n          `        … ${droppedRun} more ${droppedRun === 1 ? 'frame' : 'frames'} in framework internals`\n        )\n      );\n      droppedRun = 0;\n    }\n  };\n\n  for (const line of lines) {\n    const isFrame = line.trimStart().startsWith('at ');\n    if (isFrame && isFrameworkFrame(line)) {\n      droppedRun++;\n      continue;\n    }\n    if (isFrame && visibleFrameCount >= MAX_VISIBLE_FRAMES) {\n      cappedFrames++;\n      continue;\n    }\n    flushDropped();\n    out.push(line);\n    if (isFrame) visibleFrameCount++;\n  }\n  flushDropped();\n  if (cappedFrames > 0) {\n    out.push(\n      Ansi.dim(\n        `        … ${cappedFrames} more ${cappedFrames === 1 ? 'frame' : 'frames'} (run \\`pnpm wf inspect run <id>\\` for the full stack)`\n      )\n    );\n  }\n  return out.join('\\n');\n}\n\nfunction isFrameworkFrame(line: string): boolean {\n  // Only at-frames are candidates for stripping. Header lines (`Name: …`)\n  // and arbitrary trailing context (e.g. `code: 'USER_ERROR'`) pass through.\n  const trimmed = line.trimStart();\n  if (!trimmed.startsWith('at ')) return false;\n  // node:* internals (timers, async hooks, vm, etc.) never help users.\n  if (trimmed.includes('node:internal/')) return true;\n  // pnpm-rooted frameworks installed as node_modules dependencies.\n  if (trimmed.includes('node_modules/.pnpm/')) return true;\n  // Turbopack/Next bundle the same framework code into chunks like\n  // `node_modules__pnpm_<hash>._.js` and `<...>_next_dist_<hash>._.js`,\n  // and emits Next.js loader runtime as `0dx6_next_dist_<hash>._.js`.\n  // These are the frames that show up after Turbopack DCE, same intent\n  // as the raw `node_modules/.pnpm/` filter above.\n  if (trimmed.includes('node_modules__pnpm_')) return true;\n  if (trimmed.includes('_next_dist_')) return true;\n  // Plain node_modules (non-pnpm setups) for the same kinds of frameworks.\n  if (\n    trimmed.includes('node_modules/next/') ||\n    trimmed.includes('node_modules/@opentelemetry/') ||\n    trimmed.includes('node_modules/vitest/') ||\n    trimmed.includes('node_modules/@vitest/')\n  ) {\n    return true;\n  }\n  return false;\n}\n\n/**\n * True when the stack body opens with `<errorName>:` (or the bare name), the\n * shape V8 gives `Error#stack`. Used to avoid restating the class in a\n * header row directly above it.\n */\nfunction stackHeaderNames(body: string, errorName: string): boolean {\n  const header = body.split('\\n', 1)[0]?.trim() ?? '';\n  return header === errorName || header.startsWith(`${errorName}:`);\n}\n\nfunction pickString(\n  metadata: Record<string, unknown>,\n  key: string\n): string | null {\n  const v = metadata[key];\n  return typeof v === 'string' && v.length > 0 ? v : null;\n}\n\nfunction kvKey(key: string): string {\n  return Ansi.dim(key.padEnd(6));\n}\n\nfunction formatIdRow(\n  label: string,\n  id: string | null,\n  name: string | null,\n  formatName: (n: string) => string\n): string {\n  const idCell = id ? id : Ansi.dim('—');\n  const parsed = name\n    ? label === 'run'\n      ? parseWorkflowName(name)\n      : parseStepName(name)\n    : null;\n  const nameCell = parsed\n    ? `${Ansi.dim('·')} ${formatName(name as string)}`\n    : '';\n  return `  ${kvKey(label)} ${idCell}${nameCell ? ' ' + nameCell : ''}`;\n}\n\nfunction formatPassthroughValue(v: unknown): string {\n  if (typeof v === 'string') {\n    if (v.includes('\\n')) {\n      return v\n        .split('\\n')\n        .map((line, i) => (i === 0 ? line : `         ${line}`))\n        .join('\\n');\n    }\n    return v;\n  }\n  if (typeof v === 'number' || typeof v === 'boolean') return String(v);\n  try {\n    return JSON.stringify(v);\n  } catch {\n    return String(v);\n  }\n}\n"]}