@workflow/core 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/serialization.js

@@ -1,161 +1,43 @@
-import { types } from 'node:util';
-import { WorkflowRuntimeError } from '@workflow/errors';
-import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';
-import { DevalueError, parse, stringify, unflatten } from 'devalue';
+import { RuntimeDecryptionError, SerializationError, WorkflowRuntimeError, } from '@workflow/errors';
+import { envNumber } from '@workflow/world';
+import { parse, stringify, unflatten } from 'devalue';
 import { monotonicFactory } from 'ulid';
-import { getSerializationClass } from './class-serialization.js';
-import { decrypt as aesGcmDecrypt, encrypt as aesGcmEncrypt, } from './encryption.js';
+import { decrypt as aesGcmDecrypt, encrypt as aesGcmEncrypt, importKey, } from './encryption.js';
 import { createFlushableState, flushablePipe, pollReadableLock, pollWritableLock, } from './flushable-stream.js';
-import { runtimeLogger } from './logger.js';
 import { getStepFunction } from './private.js';
-import { getWorld } from './runtime/world.js';
+// V2: use getWorldLazy in step-side code paths so Turbopack can statically
+// resolve the world bridge from the step bundle without dragging the full
+// host world module into the flow route.
+// See `packages/core/src/runtime/get-world-lazy.ts` and the
+// "Turbopack NFT Tracing Errors in V2 Combined Flow Route" section of
+// `docs/content/docs/changelog/eager-processing.mdx`.
+import { getWorldLazy } from './runtime/get-world-lazy.js';
+import * as clientModule from './serialization/client.js';
+import { compress, decompress, } from './serialization/compression.js';
+import { decrypt, encrypt, resolveEncryptionKey, } from './serialization/encryption.js';
+import { formatSerializationError, rethrowIfRuntimeError, } from './serialization/errors.js';
+import { decodeFormatPrefix, encodeWithFormatPrefix, isEncrypted, peekFormatPrefix, } from './serialization/format.js';
+import { getClassReducers, getClassRevivers, } from './serialization/reducers/class.js';
+import { getCommonReducers, getCommonRevivers as getCommonReviversFromModule, revive, } from './serialization/reducers/common.js';
+import { getStepFunctionReducer, getStepFunctionReviver, } from './serialization/reducers/step-function.js';
+import * as stepModule from './serialization/step.js';
+import { isFormatPrefix, SerializationFormat, } from './serialization/types.js';
+import * as workflowModule from './serialization/workflow.js';
 import { contextStorage } from './step/context-storage.js';
-import { BODY_INIT_SYMBOL, STABLE_ULID, STREAM_NAME_SYMBOL, STREAM_TYPE_SYMBOL, WEBHOOK_RESPONSE_WRITABLE, } from './symbols.js';
-// ============================================================================
-// Serialization Format Prefix System
-// ============================================================================
-//
-// All serialized payloads are prefixed with a 4-byte format identifier that
-// allows the client to determine how to decode the payload. This enables:
-//
-// 1. Self-describing payloads - The World layer is agnostic to serialization format
-// 2. Gradual migration - Old runs keep working, new runs can use new formats
-// 3. Composability - Encryption can wrap any format (e.g., "encr" wrapping "devl")
-// 4. Debugging - Raw data inspection immediately reveals the format
-//
-// Format: [4 bytes: format identifier][payload]
-//
-// The 4-character prefix convention matches other workflow IDs (wrun, step, wait, etc.)
-//
-// Current formats:
-// - "devl" - devalue stringify/parse with TextEncoder/TextDecoder (current default)
-// - "encr" - Encrypted payload (inner payload has its own format prefix)
-//
-// Future formats (reserved):
-// - "cbor" - CBOR binary serialization
-/**
- * Known serialization format identifiers.
- * Each format ID is exactly 4 ASCII characters, matching the convention
- * used for other workflow IDs (wrun, step, wait, etc.)
- */
-export const SerializationFormat = {
-    /** devalue stringify/parse with TextEncoder/TextDecoder */
-    DEVALUE_V1: 'devl',
-    /** Encrypted payload (inner payload has its own format prefix) */
-    ENCRYPTED: 'encr',
-};
-/** Length of the format prefix in bytes */
-const FORMAT_PREFIX_LENGTH = 4;
-/** TextEncoder instance for format prefix encoding */
-const formatEncoder = new TextEncoder();
-/** TextDecoder instance for format prefix decoding */
-const formatDecoder = new TextDecoder();
-/**
- * Encode a payload with a format prefix.
- *
- * @param format - The format identifier (must be exactly 4 ASCII characters)
- * @param payload - The serialized payload bytes
- * @returns A new Uint8Array with format prefix prepended
- */
-export function encodeWithFormatPrefix(format, payload) {
-    if (!(payload instanceof Uint8Array)) {
-        return payload;
-    }
-    const prefixBytes = formatEncoder.encode(format);
-    if (prefixBytes.length !== FORMAT_PREFIX_LENGTH) {
-        throw new Error(`Format identifier must be exactly ${FORMAT_PREFIX_LENGTH} ASCII characters, got "${format}" (${prefixBytes.length} bytes)`);
-    }
-    const result = new Uint8Array(FORMAT_PREFIX_LENGTH + payload.length);
-    result.set(prefixBytes, 0);
-    result.set(payload, FORMAT_PREFIX_LENGTH);
-    return result;
-}
-/**
- * Peek at the format prefix without consuming it.
- * Useful for checking if data is encrypted before deciding how to process it.
- *
- * @param data - The format-prefixed data
- * @returns The format identifier, or null if data is legacy/non-binary
- */
-export function peekFormatPrefix(data) {
-    if (!(data instanceof Uint8Array) || data.length < FORMAT_PREFIX_LENGTH) {
-        return null;
-    }
-    const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);
-    const format = formatDecoder.decode(prefixBytes);
-    const knownFormats = Object.values(SerializationFormat);
-    if (!knownFormats.includes(format)) {
-        return null;
-    }
-    return format;
-}
-/**
- * Check if data is encrypted (has 'encr' format prefix).
- *
- * @param data - The format-prefixed data
- * @returns true if data has the encrypted format prefix
- */
-export function isEncrypted(data) {
-    return peekFormatPrefix(data) === SerializationFormat.ENCRYPTED;
-}
-/**
- * Decode a format-prefixed payload.
- *
- * @param data - The format-prefixed data
- * @returns An object with the format identifier and payload
- * @throws Error if the data is too short or has an unknown format
- */
-export function decodeFormatPrefix(data) {
-    // Compat for legacy specVersion 1 runs that don't have a format prefix,
-    // and don't have a binary payload
-    if (!(data instanceof Uint8Array)) {
-        return {
-            format: SerializationFormat.DEVALUE_V1,
-            payload: new TextEncoder().encode(JSON.stringify(data)),
-        };
-    }
-    if (data.length < FORMAT_PREFIX_LENGTH) {
-        throw new Error(`Data too short to contain format prefix: expected at least ${FORMAT_PREFIX_LENGTH} bytes, got ${data.length}`);
-    }
-    const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);
-    const format = formatDecoder.decode(prefixBytes);
-    // Validate the format is known
-    const knownFormats = Object.values(SerializationFormat);
-    if (!knownFormats.includes(format)) {
-        throw new WorkflowRuntimeError(`Unknown serialization format: "${format}". Known formats: ${knownFormats.join(', ')}`);
-    }
-    const payload = data.subarray(FORMAT_PREFIX_LENGTH);
-    return { format: format, payload };
-}
+import { ABORT_HOOK_TOKEN, ABORT_LISTENER_ATTACHED, ABORT_READER_CANCEL, ABORT_STREAM_NAME, BODY_INIT_SYMBOL, STABLE_ULID, STREAM_FRAMING_SYMBOL, STREAM_NAME_SYMBOL, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL, STREAM_SERVER_RUN_ID_SYMBOL, STREAM_TYPE_SYMBOL, WEBHOOK_RESPONSE_WRITABLE, } from './symbols.js';
+import * as Attr from './telemetry/semantic-conventions.js';
+import { getActiveSpan, getSpanKind, recordElapsedSpan } from './telemetry.js';
+import { getAbortStreamId } from './util.js';
+import { WorkflowAbortSignal } from './workflow/abort-controller.js';
+// Re-export types and utilities from the modular serialization modules
+// so existing consumers of `@workflow/core/serialization` keep working.
+export { SerializationFormat, isFormatPrefix, encodeWithFormatPrefix, decodeFormatPrefix, peekFormatPrefix, isEncrypted, encrypt, decrypt, compress, decompress, };
 /**
  * Default ULID generator for contexts where VM's seeded `stableUlid` isn't available.
  * Used as a fallback when serializing streams outside the workflow VM context
  * (e.g., when starting a workflow or handling step return values).
  */
 const defaultUlid = monotonicFactory();
-/**
- * Format a serialization error with context about what failed.
- * Extracts path, value, and reason from devalue's DevalueError when available.
- * Logs the problematic value to the console for better debugging.
- */
-function formatSerializationError(context, error) {
-    // Use "returning" for return values, "passing" for arguments/inputs
-    const verb = context.includes('return value') ? 'returning' : 'passing';
-    // Build the error message with path info if available from DevalueError
-    let message = `Failed to serialize ${context}`;
-    if (error instanceof DevalueError && error.path) {
-        message += ` at path "${error.path}"`;
-    }
-    message += `. Ensure you're ${verb} serializable types (plain objects, arrays, primitives, Date, RegExp, Map, Set).`;
-    // Log the problematic value for debugging
-    if (error instanceof DevalueError && error.value !== undefined) {
-        runtimeLogger.error('Serialization failed', {
-            context,
-            problematicValue: error.value,
-        });
-    }
-    return message;
-}
 /**
  * Detect if a readable stream is a byte stream.
  *
@@ -179,10 +61,72 @@ export function getStreamType(stream) {
  * split across transport reads.
  */
 const FRAME_HEADER_SIZE = 4;
+/**
+ * The mode-specific serializers (`./serialization/{client,step,workflow}.ts`)
+ * already throw a `SerializationError` whose `.cause` is the underlying
+ * devalue / serde failure. The outer dehydrate/hydrate wrappers want to
+ * re-frame that error with a more specific context label (e.g. "workflow
+ * arguments" instead of generic "workflow value"), so they unwrap the
+ * inner SerializationError and reformat with the original cause. Errors
+ * that aren't already SerializationError flow through unchanged.
+ *
+ * `RuntimeDecryptionError` is an exception: it must keep its identity (and
+ * `context`) so the run-failure classifier routes it to `RUNTIME_ERROR`,
+ * so this rethrows it unchanged before any unwrapping. Note this guard
+ * must run before the generic `WorkflowRuntimeError` unwrap below, since
+ * `RuntimeDecryptionError` extends `WorkflowRuntimeError` and carries a
+ * `cause` (the underlying DOMException) that would otherwise be unwrapped
+ * and reframed as a `SerializationError`.
+ */
+function unwrapSerializationCause(error) {
+    rethrowIfRuntimeError(error);
+    if (error instanceof SerializationError && error.cause !== undefined) {
+        return error.cause;
+    }
+    if (error instanceof WorkflowRuntimeError && error.cause !== undefined) {
+        return error.cause;
+    }
+    return error;
+}
+/**
+ * Emit compression telemetry onto the active span after a (de)serialize.
+ *
+ * The compression layer populates `stats` only when it actually ran (binary
+ * data on a spec >= 5 path); legacy / v1Compat paths leave it unrecorded, so
+ * this no-ops for them and avoids the `getActiveSpan` lookup. Attributes land
+ * on whatever span is active — typically the dedicated `step.dehydrate` /
+ * `step.hydrate` span, otherwise the enclosing run/start span.
+ */
+async function recordCompression(stats, operation) {
+    if (!stats.recorded)
+        return;
+    // Telemetry must never break the serialize/deserialize data path — a
+    // missing/failing tracer is purely an observability loss.
+    try {
+        const span = await getActiveSpan();
+        if (!span)
+            return;
+        const uncompressedBytes = stats.uncompressedBytes ?? 0;
+        const storedBytes = stats.storedBytes ?? 0;
+        span.setAttributes({
+            ...Attr.SerializationOperation(operation),
+            ...Attr.SerializationCompressed(stats.compressed ?? false),
+            ...Attr.SerializationCodec(stats.codec ?? 'none'),
+            ...Attr.SerializationUncompressedBytes(uncompressedBytes),
+            ...Attr.SerializationStoredBytes(storedBytes),
+            ...(stats.compressed && uncompressedBytes > 0
+                ? Attr.SerializationCompressionRatio(1 - storedBytes / uncompressedBytes)
+                : {}),
+        });
+    }
+    catch {
+        // ignore telemetry failures
+    }
+}
 export function getSerializeStream(reducers, cryptoKey) {
     const encoder = new TextEncoder();
-    // Resolve the key promise once on first use and cache the result.
-    // Note: if the cryptoKey promise rejects (e.g., network error fetching
+    // Resolve the key input once on first use and cache the result.
+    // Note: if resolving cryptoKey rejects (e.g., network error fetching
     // the derived key), the rejection won't surface until the first chunk
     // is processed — not at stream construction time.
     const keyState = { resolved: false, key: undefined };
@@ -190,7 +134,7 @@ export function getSerializeStream(reducers, cryptoKey) {
         async transform(chunk, controller) {
             try {
                 if (!keyState.resolved) {
-                    keyState.key = await cryptoKey;
+                    keyState.key = await resolveEncryptionKey(cryptoKey);
                     keyState.resolved = true;
                 }
                 const serialized = stringify(chunk, reducers);
@@ -210,7 +154,15 @@ export function getSerializeStream(reducers, cryptoKey) {
                 controller.enqueue(frame);
             }
             catch (error) {
-                controller.error(new WorkflowRuntimeError(formatSerializationError('stream chunk', error), { slug: 'serialization-failed', cause: error }));
+                // Encryption failures must keep their RuntimeDecryptionError
+                // identity (RUNTIME_ERROR) rather than be reframed as a
+                // SerializationError (USER_ERROR).
+                if (RuntimeDecryptionError.is(error)) {
+                    controller.error(error);
+                    return;
+                }
+                const { message, hint } = formatSerializationError('stream chunk', error);
+                controller.error(new SerializationError(message, { hint, cause: error }));
             }
         },
     });
@@ -219,7 +171,7 @@ export function getSerializeStream(reducers, cryptoKey) {
 export function getDeserializeStream(revivers, cryptoKey) {
     const decoder = new TextDecoder();
     let buffer = new Uint8Array(0);
-    // Resolve the key promise once on first use and cache the result.
+    // Resolve the key input once on first use and cache the result.
     const keyState = { resolved: false, key: undefined };
     function appendToBuffer(data) {
         const newBuffer = new Uint8Array(buffer.length + data.length);
@@ -228,9 +180,9 @@ export function getDeserializeStream(revivers, cryptoKey) {
         buffer = newBuffer;
     }
     async function processFrames(controller) {
-        // Resolve the key promise once on first use and cache the result
+        // Resolve the key input once on first use and cache the result
         if (!keyState.resolved) {
-            keyState.key = await cryptoKey;
+            keyState.key = await resolveEncryptionKey(cryptoKey);
             keyState.resolved = true;
         }
         // Try to extract complete length-prefixed frames
@@ -247,11 +199,30 @@ export function getDeserializeStream(revivers, cryptoKey) {
             // then fall through to the normal deserialization path.
             if (format === SerializationFormat.ENCRYPTED) {
                 if (!keyState.key) {
-                    controller.error(new WorkflowRuntimeError('Encrypted stream data encountered but no encryption key is available. ' +
-                        'Encryption is not configured or no key was provided for this run.'));
+                    controller.error(new RuntimeDecryptionError('Encrypted stream data encountered but no encryption key is available. ' +
+                        'Encryption is not configured or no key was provided for this run.', {
+                        context: {
+                            operation: 'decrypt',
+                            byteLength: payload.byteLength,
+                            formatPrefix: 'encr',
+                        },
+                    }));
                     return;
                 }
-                const decrypted = await aesGcmDecrypt(keyState.key, payload);
+                let decrypted;
+                try {
+                    decrypted = await aesGcmDecrypt(keyState.key, payload);
+                }
+                catch (error) {
+                    // The low-level AES layer only sees the stripped payload, so it
+                    // cannot record the outer envelope prefix. We peeked it here
+                    // (`encr`), so enrich the diagnostic context with the real format
+                    // prefix before propagating — mirroring serialization/encryption.ts.
+                    if (RuntimeDecryptionError.is(error) && error.context) {
+                        error.context.formatPrefix = format;
+                    }
+                    throw error;
+                }
                 ({ format, payload } = decodeFormatPrefix(decrypted));
             }
             if (format === SerializationFormat.DEVALUE_V1) {
@@ -299,19 +270,168 @@ export function getDeserializeStream(revivers, cryptoKey) {
     });
     return stream;
 }
+// ============================================================================
+// Byte-stream wire framing
+// ============================================================================
+//
+// Byte streams (`type: 'bytes'` ReadableStreams passed across boundaries)
+// are written to the underlying world's stream transport one user chunk at
+// a time. Without an in-band envelope, the reader sees a flat stream of
+// bytes — there is no way to tell where one user chunk ends and the next
+// begins, which makes mid-stream reconnect impossible (we don't know how
+// many server-side chunks have been consumed).
+//
+// To enable transparent reconnect, this PR introduces an opt-in wire
+// envelope that wraps each user chunk in a length-prefix:
+//
+//   [4-byte big-endian length][user payload bytes]
+//
+// The envelope is identical in shape to `getSerializeStream`'s framing,
+// but the payload here is *raw user bytes* — there is no inner
+// format-prefix, no devalue, no encryption. A framed byte stream stays
+// semantically a byte stream end-to-end; the framing is purely transport.
+//
+// The decision to use framing for a given stream is recorded in the
+// serialized stream ref (`framing: 'framed-v1'`), so both sides agree on
+// the wire format without runtime negotiation. Producers that target a
+// run whose deployment doesn't support framing (see `getRunCapabilities`
+// in capabilities.ts) emit raw bytes and a ref without the field — which
+// the reader treats as legacy raw bytes for backwards compatibility.
+/**
+ * Maximum allowed byte-stream frame payload size (100MB). Shared by the
+ * framer (rejects oversized user chunks at write time, where the error is
+ * actionable) and the unframer (rejects oversized length headers at read
+ * time, which usually indicate a non-framed wire being read as framed).
+ * Keeping both sides on one constant guarantees any chunk the framer
+ * accepts can always be decoded by the unframer.
+ */
+const MAX_FRAME_SIZE = 100_000_000;
+/**
+ * Wraps each chunk of a byte stream in a 4-byte big-endian length
+ * prefix. Used by the producer side of a framed byte-stream pipe.
+ *
+ * Empty chunks (length 0) are dropped — the resulting `[0x00 0x00 0x00 0x00]`
+ * frame would be ambiguous with the legacy "looks framed" detection in
+ * `getDeserializeStream`, and it carries no information.
+ *
+ * Load-bearing invariant: each user chunk becomes exactly one frame, and
+ * each frame is enqueued as exactly one transport chunk (the downstream
+ * writable performs one wire write per chunk, preserving boundaries). The
+ * server therefore stores one frame per chunk index, which is what allows
+ * a future reconnecting reader to resume a framed byte stream at
+ * `startIndex + consumedFrames` — the same arithmetic
+ * `createReconnectingFramedStream` relies on for object streams. Do not
+ * coalesce or split frames here without revisiting that resume logic.
+ */
+export function getByteFramingStream() {
+    return new TransformStream({
+        transform(chunk, controller) {
+            if (chunk.length === 0)
+                return;
+            if (chunk.length > MAX_FRAME_SIZE) {
+                controller.error(new WorkflowRuntimeError(`Byte-stream chunk of ${chunk.length} bytes exceeds the maximum ` +
+                    `framed chunk size (${MAX_FRAME_SIZE}). Split the data into ` +
+                    `smaller chunks before writing.`, { slug: 'serialization-failed' }));
+                return;
+            }
+            const frame = new Uint8Array(FRAME_HEADER_SIZE + chunk.length);
+            new DataView(frame.buffer).setUint32(0, chunk.length, false);
+            frame.set(chunk, FRAME_HEADER_SIZE);
+            controller.enqueue(frame);
+        },
+    });
+}
+/**
+ * Unwraps length-prefixed byte-stream frames back into the original user
+ * chunks. Used by the consumer side of a framed byte-stream pipe.
+ *
+ * Buffers across read boundaries — the transport may split a single
+ * frame across multiple reads (header in one chunk, payload in another)
+ * or coalesce multiple frames into a single read. The transform emits
+ * whole user chunks regardless of transport chunking.
+ *
+ * Errors the stream if the length header advertises a frame larger than
+ * `MAX_FRAME_SIZE` bytes, since that almost certainly indicates a
+ * misframed wire (e.g. a raw byte stream being fed through this transform
+ * by mistake) and we don't want to allocate an enormous buffer.
+ */
+export function getByteUnframingStream() {
+    let buffer = new Uint8Array(0);
+    function appendToBuffer(data) {
+        const next = new Uint8Array(buffer.length + data.length);
+        next.set(buffer, 0);
+        next.set(data, buffer.length);
+        buffer = next;
+    }
+    return new TransformStream({
+        transform(chunk, controller) {
+            if (chunk.length > 0)
+                appendToBuffer(chunk);
+            while (buffer.length >= FRAME_HEADER_SIZE) {
+                const frameLength = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength).getUint32(0, false);
+                if (frameLength > MAX_FRAME_SIZE) {
+                    controller.error(new WorkflowRuntimeError(`Byte-stream frame length ${frameLength} exceeds maximum (${MAX_FRAME_SIZE}). ` +
+                        `This usually means a non-framed byte stream is being read as framed.`, { slug: 'serialization-failed' }));
+                    return;
+                }
+                const total = FRAME_HEADER_SIZE + frameLength;
+                if (buffer.length < total)
+                    break;
+                controller.enqueue(buffer.slice(FRAME_HEADER_SIZE, total));
+                buffer = buffer.slice(total);
+            }
+        },
+        flush(controller) {
+            if (buffer.length > 0) {
+                controller.error(new WorkflowRuntimeError(`Byte-stream ended with ${buffer.length} bytes of incomplete frame data. ` +
+                    `The stream was truncated mid-frame.`, { slug: 'serialization-failed' }));
+            }
+        },
+    });
+}
+/**
+ * Emit the client-observed end-to-end time-to-first-chunk span for a live read:
+ * read dispatch (`startEpochMs`) → the first non-empty chunk reaching the
+ * reader, including the network hop. Fire-and-forget; no-op without OTEL.
+ */
+function recordReadTimeToFirstChunk(startEpochMs, runId, name, startIndex) {
+    void (async () => {
+        await recordElapsedSpan('workflow.stream.read', startEpochMs, {
+            kind: await getSpanKind('CLIENT'),
+            attributes: {
+                'workflow.run.id': runId,
+                'workflow.stream.name': name,
+                'workflow.stream.operation': 'read',
+                'workflow.stream.read.ttfc_ms': Date.now() - startEpochMs,
+                ...(typeof startIndex === 'number'
+                    ? { 'workflow.stream.start_index': startIndex }
+                    : {}),
+            },
+        });
+    })();
+}
 export class WorkflowServerReadableStream extends ReadableStream {
     #reader;
     constructor(runId, name, startIndex) {
         if (typeof name !== 'string' || name.length === 0) {
-            throw new Error(`"name" is required, got "${name}"`);
+            throw new WorkflowRuntimeError(`"name" is required, got "${name}"`);
         }
+        // Client-observed time-to-first-chunk state. `readStart` is stamped when the
+        // reader starts consuming (first pull → the read dispatch); the span is
+        // emitted once, when the first non-empty chunk reaches the reader. So its
+        // duration is the end-to-end TTFC including the network hop. No-op without
+        // an OpenTelemetry SDK registered.
+        let readStart;
+        let firstChunkReported = false;
         super({
             // @ts-expect-error Not sure why TypeScript is complaining about this
             type: 'bytes',
             pull: async (controller) => {
                 let reader = this.#reader;
                 if (!reader) {
-                    const world = await getWorld();
+                    if (readStart === undefined)
+                        readStart = Date.now();
+                    const world = await getWorldLazy();
                     const stream = await world.streams.get(runId, name, startIndex);
                     reader = this.#reader = stream.getReader();
                 }
@@ -325,6 +445,15 @@ export class WorkflowServerReadableStream extends ReadableStream {
                     controller.close();
                 }
                 else {
+                    // The server flushes a leading zero-length chunk (v3+) to commit
+                    // response headers before any data; skip empties so TTFC measures to
+                    // the first real chunk.
+                    if (!firstChunkReported &&
+                        result.value.byteLength > 0 &&
+                        readStart !== undefined) {
+                        firstChunkReported = true;
+                        recordReadTimeToFirstChunk(readStart, runId, name, startIndex);
+                    }
                     // Forward raw bytes; encryption/decryption is handled at the
                     // framing level by getSerializeStream/getDeserializeStream.
                     controller.enqueue(result.value);
@@ -339,20 +468,236 @@ export class WorkflowServerReadableStream extends ReadableStream {
         });
     }
 }
+/**
+ * Maximum consecutive reconnect attempts for a single framed stream session.
+ * The counter resets to zero whenever a reconnect makes forward progress (a
+ * frame is delivered), so this bounds *consecutive* failures, not the lifetime
+ * total — a long-lived serverless stream may legitimately reconnect far more
+ * than this many times as long as each reconnect keeps delivering data. We only
+ * give up after this many reconnects in a row produce nothing.
+ */
+export const FRAMED_STREAM_MAX_RECONNECTS = 50;
+/** Effective consecutive-reconnect cap. Override: `WORKFLOW_FRAMED_STREAM_MAX_RECONNECTS`. */
+const getFramedStreamMaxReconnects = () => envNumber('WORKFLOW_FRAMED_STREAM_MAX_RECONNECTS', FRAMED_STREAM_MAX_RECONNECTS, {
+    integer: true,
+    min: 1,
+});
+/**
+ * Absolute backstop on total reconnects for a single session, independent of
+ * progress. The consecutive cap above resets on forward progress, which is
+ * correct for a well-behaved backend that honors `startIndex`. But if a World's
+ * `streams.get` ever ignored `startIndex` and re-delivered earlier chunks,
+ * "progress" would be reported every reconnect and the consecutive cap would
+ * never trip — turning a bounded failure into an unbounded reconnect loop. This
+ * hard ceiling guarantees the loop always terminates. It is set high enough
+ * (hours of streaming at realistic per-session timeouts) to never interfere
+ * with legitimate long-lived streams.
+ */
+export const FRAMED_STREAM_MAX_TOTAL_RECONNECTS = 1000;
+/** Effective total-reconnect backstop. Override: `WORKFLOW_FRAMED_STREAM_MAX_TOTAL_RECONNECTS`. */
+const getFramedStreamMaxTotalReconnects = () => envNumber('WORKFLOW_FRAMED_STREAM_MAX_TOTAL_RECONNECTS', FRAMED_STREAM_MAX_TOTAL_RECONNECTS, { integer: true, min: 1 });
+/**
+ * Wraps the length-prefix-framed byte stream from `world.streams.get` with
+ * transparent auto-reconnect.
+ *
+ * Every fully-decoded outer frame corresponds to exactly one server-side
+ * chunk (the serialize transform enqueues one frame per workflow write, and
+ * the writable buffers one frame per chunk when multi-writing). The wrapper
+ * counts completed frames and, on upstream error, reopens the connection
+ * with `startIndex = resolvedStartIndex + consumedFrames`. Partial-frame
+ * bytes buffered before the cut are discarded — the server will resend the
+ * in-flight chunk in full from the new startIndex.
+ *
+ * A clean upstream close (EOF with no error) signals the stream is truly
+ * done; we close the wrapper and do not reconnect.
+ *
+ * Negative `startIndex` values (last-N semantics) skip the reconnect
+ * machinery because we cannot compute an absolute resume position without
+ * a tail-index lookup — the returned stream behaves as a single-shot read.
+ */
+export function createReconnectingFramedStream(runId, name, startIndex) {
+    const reconnectSupported = startIndex === undefined || startIndex >= 0;
+    let currentStartIndex = startIndex ?? 0;
+    let consumedFrames = 0;
+    let reconnectCount = 0;
+    let totalReconnectCount = 0;
+    let reader;
+    let buffer = new Uint8Array(0);
+    async function connect() {
+        const world = await getWorldLazy();
+        const effectiveStartIndex = reconnectSupported
+            ? currentStartIndex + consumedFrames
+            : startIndex;
+        const stream = await world.streams.get(runId, name, effectiveStartIndex);
+        reader = stream.getReader();
+    }
+    async function reconnect() {
+        if (reader) {
+            await reader.cancel().catch(() => { });
+            reader = undefined;
+        }
+        // Advance the resume position past the frames already delivered, then
+        // drop any partial-frame bytes — the reopened connection re-sends from a
+        // frame boundary at the new index.
+        currentStartIndex += consumedFrames;
+        consumedFrames = 0;
+        buffer = new Uint8Array(0);
+        // Retry the reopen itself against the reconnect budget. A transient
+        // failure of connect() — the server briefly unavailable during the
+        // reconnect window — is the exact blip this wrapper exists to survive, so
+        // count it against the budget and try again rather than treating it as
+        // fatal. Only budget exhaustion (a server that stays down) terminates the
+        // stream.
+        const maxReconnects = getFramedStreamMaxReconnects();
+        const maxTotalReconnects = getFramedStreamMaxTotalReconnects();
+        for (;;) {
+            reconnectCount++;
+            totalReconnectCount++;
+            if (reconnectCount > maxReconnects) {
+                throw new Error(`Stream "${name}" exceeded maximum reconnection attempts (${maxReconnects})`);
+            }
+            if (totalReconnectCount > maxTotalReconnects) {
+                throw new Error(`Stream "${name}" exceeded maximum total reconnection attempts (${maxTotalReconnects})`);
+            }
+            try {
+                await connect();
+                return;
+            }
+            catch {
+                // Reopen failed transiently; loop to retry, counting against the
+                // budget so a server that never recovers still terminates the stream.
+            }
+        }
+    }
+    return new ReadableStream({
+        pull: async (controller) => {
+            // Loop until we emit something, hit EOF, or fatally error. Reads that
+            // only extend the in-flight-frame buffer don't enqueue anything — we
+            // keep reading rather than returning empty-handed.
+            for (;;) {
+                if (!reader) {
+                    try {
+                        await connect();
+                    }
+                    catch (err) {
+                        controller.error(err);
+                        return;
+                    }
+                }
+                let result;
+                try {
+                    // biome-ignore lint/style/noNonNullAssertion: connect() guarantees reader
+                    result = await reader.read();
+                }
+                catch (err) {
+                    if (!reconnectSupported) {
+                        controller.error(err);
+                        return;
+                    }
+                    try {
+                        await reconnect();
+                    }
+                    catch (reconnectErr) {
+                        controller.error(reconnectErr);
+                        return;
+                    }
+                    continue;
+                }
+                if (result.done || !result.value) {
+                    // Clean EOF — stream is truly complete. Drop any partial-frame
+                    // bytes (there shouldn't be any; a well-formed stream ends on a
+                    // frame boundary).
+                    reader = undefined;
+                    controller.close();
+                    return;
+                }
+                // Append to buffer and emit all complete frames.
+                const incoming = result.value;
+                if (incoming.length > 0) {
+                    const combined = new Uint8Array(buffer.length + incoming.length);
+                    combined.set(buffer, 0);
+                    combined.set(incoming, buffer.length);
+                    buffer = combined;
+                }
+                let emitted = false;
+                while (buffer.length >= FRAME_HEADER_SIZE) {
+                    const frameLength = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength).getUint32(0, false);
+                    const total = FRAME_HEADER_SIZE + frameLength;
+                    if (buffer.length < total)
+                        break;
+                    // Forward the entire framed chunk (header + payload) to the
+                    // downstream deserializer, which already expects this layout.
+                    controller.enqueue(buffer.slice(0, total));
+                    buffer = buffer.slice(total);
+                    consumedFrames++;
+                    emitted = true;
+                }
+                if (emitted) {
+                    // Forward progress on the current connection — clear the
+                    // consecutive-failure budget so a long stream that reconnects
+                    // many times (but keeps delivering) is never falsely capped.
+                    reconnectCount = 0;
+                    return;
+                }
+                // Only partial bytes — read more.
+            }
+        },
+        cancel: async () => {
+            if (reader) {
+                await reader.cancel().catch((err) => {
+                    console.warn('Error closing ReadableStream reader:', err);
+                });
+                reader = undefined;
+            }
+        },
+    });
+}
 /**
  * Default flush interval in milliseconds for buffered stream writes.
  * Chunks are accumulated and flushed together to reduce network overhead.
  */
 const STREAM_FLUSH_INTERVAL_MS = 10;
+/**
+ * Effective default stream-flush interval (a `world.streamFlushIntervalMs`
+ * still takes precedence). Override: `WORKFLOW_STREAM_FLUSH_INTERVAL_MS`.
+ */
+const getStreamFlushIntervalMs = () => envNumber('WORKFLOW_STREAM_FLUSH_INTERVAL_MS', STREAM_FLUSH_INTERVAL_MS, {
+    integer: true,
+});
 export class WorkflowServerWritableStream extends WritableStream {
-    constructor(runId, name) {
+    /**
+     * @param runReadyBarrier Turbo mode only: a promise that resolves once the
+     * backgrounded `run_started` has landed. When the step body runs
+     * optimistically (before `run_started` is durable), the first chunk write to
+     * a brand-new stream would otherwise reach the World before the run exists
+     * and be rejected as run-not-found. Awaiting this once before the first
+     * flush/close orders the write after the run's creation. `undefined` outside
+     * turbo and on the await path, where the run was already durable.
+     */
+    constructor(runId, name, runReadyBarrier) {
         if (typeof runId !== 'string') {
-            throw new Error(`"runId" must be a string, got "${typeof runId}"`);
+            throw new WorkflowRuntimeError(`"runId" must be a string, got "${typeof runId}"`);
         }
         if (typeof name !== 'string' || name.length === 0) {
-            throw new Error(`"name" is required, got "${name}"`);
+            throw new WorkflowRuntimeError(`"name" is required, got "${name}"`);
         }
-        const worldPromise = getWorld();
+        const worldPromise = getWorldLazy();
+        // Hold the first server write until the run exists (turbo optimistic
+        // start). Awaited once, then cleared so later flushes pay nothing. The
+        // rejection is swallowed for ordering only: if `run_started` truly failed
+        // the run does not exist, so the write below surfaces the real error.
+        let pendingRunReady = runReadyBarrier;
+        const ensureRunReady = async () => {
+            if (pendingRunReady) {
+                try {
+                    await pendingRunReady;
+                }
+                catch {
+                    // intentional: ordering barrier only — see above.
+                }
+                pendingRunReady = undefined;
+            }
+        };
         // Buffering state for batched writes
         // Encryption/decryption is handled at the framing level by
         // getSerializeStream/getDeserializeStream, not here.
@@ -367,6 +712,9 @@ export class WorkflowServerWritableStream extends WritableStream {
             }
             if (buffer.length === 0)
                 return;
+            // Order the first server write after the run exists (turbo optimistic
+            // start); a no-op on every later flush and outside turbo.
+            await ensureRunReady();
             // Copy chunks to flush, but don't clear buffer until write succeeds
             // This prevents data loss if the write operation fails
             const chunksToFlush = buffer.slice();
@@ -374,7 +722,7 @@ export class WorkflowServerWritableStream extends WritableStream {
             // Cache the flush interval from the world on first use
             if (resolvedFlushIntervalMs === undefined) {
                 resolvedFlushIntervalMs =
-                    world.streamFlushIntervalMs ?? STREAM_FLUSH_INTERVAL_MS;
+                    world.streamFlushIntervalMs ?? getStreamFlushIntervalMs();
             }
             // Use writeMulti if available for batch writes
             if (typeof world.streams.writeMulti === 'function' &&
@@ -406,7 +754,7 @@ export class WorkflowServerWritableStream extends WritableStream {
                     for (const w of currentWaiters)
                         w.reject(err);
                 });
-            }, resolvedFlushIntervalMs ?? STREAM_FLUSH_INTERVAL_MS);
+            }, resolvedFlushIntervalMs ?? getStreamFlushIntervalMs());
         };
         super({
             async write(chunk) {
@@ -434,6 +782,9 @@ export class WorkflowServerWritableStream extends WritableStream {
                 }
                 // Flush any remaining buffered chunks
                 await flush();
+                // A close with an empty buffer skips flush()'s write (and its barrier),
+                // but can itself be the first write to a brand-new stream — gate it too.
+                await ensureRunReady();
                 const world = await worldPromise;
                 await world.streams.close(runId, name);
             },
@@ -457,115 +808,22 @@ export class WorkflowServerWritableStream extends WritableStream {
         });
     }
 }
-function revive(str) {
-    // devalue.stringify() always produces valid JSON: special values
-    // (undefined, NaN, Infinity, -0) are encoded as negative integer
-    // sentinels and the remaining structure is ordinary JSON. Parsing
-    // with JSON.parse yields the flattened form that unflatten() expects.
-    return JSON.parse(str);
-}
-function getCommonReducers(global = globalThis) {
-    const abToBase64 = (value, offset, length) => {
-        // Avoid returning falsy value for zero-length buffers
-        if (length === 0)
-            return '.';
-        // Create a proper copy to avoid ArrayBuffer detachment issues
-        // Buffer.from(ArrayBuffer, offset, length) creates a view, not a copy
-        const uint8 = new Uint8Array(value, offset, length);
-        return Buffer.from(uint8).toString('base64');
-    };
-    const viewToBase64 = (value) => abToBase64(value.buffer, value.byteOffset, value.byteLength);
+// ---- Composed reducers ----
+// Composes modular reducers (common, class, step-function) with
+// mode-specific Request/Response/Stream reducers below.
+/**
+ * Base reducers shared across all serialization boundaries.
+ * Composes: class + step-function + common reducers from the modular modules.
+ */
+function getAllBaseReducers(global = globalThis) {
+    // Class/Instance MUST come before Error so that custom Error subclasses
+    // with WORKFLOW_SERIALIZE take precedence (devalue uses first-match-wins).
     return {
-        ArrayBuffer: (value) => value instanceof global.ArrayBuffer &&
-            abToBase64(value, 0, value.byteLength),
-        BigInt: (value) => typeof value === 'bigint' && value.toString(),
-        BigInt64Array: (value) => value instanceof global.BigInt64Array && viewToBase64(value),
-        BigUint64Array: (value) => value instanceof global.BigUint64Array && viewToBase64(value),
-        // Class and Instance are intentionally placed before Error so that
-        // custom Error subclasses with WORKFLOW_SERIALIZE take precedence
-        // over the generic Error serialization (devalue uses first-match-wins).
-        Class: (value) => {
-            // Check if this is a class constructor with a classId property
-            // (set by the SWC plugin for classes with static step/workflow methods)
-            if (typeof value !== 'function')
-                return false;
-            const classId = value.classId;
-            if (typeof classId !== 'string')
-                return false;
-            return { classId };
-        },
-        Instance: (value) => {
-            // Check if this is an instance of a class with custom serialization
-            if (value === null || typeof value !== 'object')
-                return false;
-            const cls = value.constructor;
-            if (!cls || typeof cls !== 'function')
-                return false;
-            // Check if the class has a static WORKFLOW_SERIALIZE method
-            const serialize = cls[WORKFLOW_SERIALIZE];
-            if (typeof serialize !== 'function') {
-                return false;
-            }
-            // Get the classId from the static class property (set by SWC plugin)
-            const classId = cls.classId;
-            if (typeof classId !== 'string') {
-                throw new Error(`Class "${cls.name}" with ${String(WORKFLOW_SERIALIZE)} must have a static "classId" property.`);
-            }
-            // Serialize the instance using the custom serializer
-            const data = serialize.call(cls, value);
-            return { classId, data };
-        },
-        Date: (value) => {
-            if (!(value instanceof global.Date))
-                return false;
-            const valid = !Number.isNaN(value.getDate());
-            // Note: "." is to avoid returning a falsy value when the date is invalid
-            return valid ? value.toISOString() : '.';
-        },
-        // DOMException is a special case: in Node.js it passes isNativeError()
-        // and instanceof Error, but has a unique constructor signature
-        // (message, name) and a read-only numeric `code` property derived from
-        // `name`. It must be checked before the generic Error reducer.
-        DOMException: (value) => {
-            if (!types.isNativeError(value))
-                return false;
-            if (value.constructor?.name !== 'DOMException')
-                return false;
-            const reduced = {
-                message: value.message,
-                name: value.name,
-                stack: value.stack,
-            };
-            if ('cause' in value)
-                reduced.cause = value.cause;
-            return reduced;
-        },
-        Error: (value) => {
-            // Use types.isNativeError() instead of `instanceof global.Error`
-            // because errors may originate from a different VM context (e.g.
-            // FatalError from the host context passed into a VM-context workflow).
-            // `instanceof` checks fail across VM boundaries since each context
-            // has its own Error constructor, but isNativeError() uses V8's
-            // internal type tag which works across all contexts.
-            if (!types.isNativeError(value))
-                return false;
-            return {
-                name: value.name,
-                message: value.message,
-                stack: value.stack,
-            };
-        },
-        Float32Array: (value) => value instanceof global.Float32Array && viewToBase64(value),
-        Float64Array: (value) => value instanceof global.Float64Array && viewToBase64(value),
-        Headers: (value) => value instanceof global.Headers && Array.from(value),
-        Int8Array: (value) => value instanceof global.Int8Array && viewToBase64(value),
-        Int16Array: (value) => value instanceof global.Int16Array && viewToBase64(value),
-        Int32Array: (value) => value instanceof global.Int32Array && viewToBase64(value),
-        Map: (value) => value instanceof global.Map && Array.from(value),
-        RegExp: (value) => value instanceof global.RegExp && {
-            source: value.source,
-            flags: value.flags,
-        },
+        ...getClassReducers(),
+        ...getStepFunctionReducer(),
+        ...getCommonReducers(global),
+        // Request and Response reducers are mode-specific and added by
+        // getExternalReducers / getWorkflowReducers / getStepReducers below.
         Request: (value) => {
             if (!(value instanceof global.Request))
                 return false;
@@ -580,6 +838,20 @@ function getCommonReducers(global = globalThis) {
             if (responseWritable) {
                 data.responseWritable = responseWritable;
             }
+            // Forward the signal in two cases:
+            //   1. Already aborted — preserve aborted=true/reason so the hydrated
+            //      step sees the cancellation that happened before serialize.
+            //   2. Already tagged with workflow infrastructure — i.e. a signal
+            //      from a workflow-managed AbortController, which has stream/hook
+            //      backing for cross-boundary propagation.
+            // Plain non-aborted native signals are intentionally dropped (would
+            // mint stream infra for every Request, including the auto-generated
+            // signal on `new Request(url)`).
+            if (value.signal &&
+                (value.signal.aborted ||
+                    value.signal[ABORT_STREAM_NAME])) {
+                data.signal = value.signal;
+            }
             return data;
         },
         Response: (value) => {
@@ -595,94 +867,192 @@ function getCommonReducers(global = globalThis) {
                 redirected: value.redirected,
             };
         },
-        Set: (value) => value instanceof global.Set && Array.from(value),
-        StepFunction: (value) => {
-            if (typeof value !== 'function')
-                return false;
-            const stepId = value.stepId;
-            if (typeof stepId !== 'string')
-                return false;
-            // Check if the step function has closure variables
-            const closureVarsFn = value.__closureVarsFn;
-            if (closureVarsFn && typeof closureVarsFn === 'function') {
-                // Invoke the closure variables function and serialize along with stepId
-                const closureVars = closureVarsFn();
-                return { stepId, closureVars };
-            }
-            // No closure variables - return object with just stepId
-            return { stepId };
-        },
-        URL: (value) => value instanceof global.URL && value.href,
-        WorkflowFunction: (value) => {
-            // Only match function references with a workflowId property (set by
-            // the SWC compiler on workflow functions). Plain { workflowId } objects
-            // are NOT matched — this prevents infinite recursion since the reduced
-            // form { workflowId } is a plain object, not a function.
-            if (typeof value !== 'function')
-                return false;
-            const workflowId = value.workflowId;
-            if (typeof workflowId !== 'string')
-                return false;
-            return { workflowId };
-        },
-        URLSearchParams: (value) => {
-            if (!(value instanceof global.URLSearchParams))
-                return false;
-            // Avoid returning a falsy value when the URLSearchParams is empty
-            if (value.size === 0)
-                return '.';
-            return String(value);
-        },
-        Uint8Array: (value) => value instanceof global.Uint8Array && viewToBase64(value),
-        Uint8ClampedArray: (value) => value instanceof global.Uint8ClampedArray && viewToBase64(value),
-        Uint16Array: (value) => value instanceof global.Uint16Array && viewToBase64(value),
-        Uint32Array: (value) => value instanceof global.Uint32Array && viewToBase64(value),
     };
 }
+/**
+ * Shared logic for AbortController/AbortSignal reducers in external and step
+ * contexts. Assigns stream/hook names if not already present, optionally
+ * attaches an abort listener for real-time propagation, and returns the
+ * serialized representation.
+ */
+function reduceAbortWithListener(signal, holder, global, ops, runId, cryptoKey) {
+    let streamName = holder[ABORT_STREAM_NAME];
+    let hookToken = holder[ABORT_HOOK_TOKEN];
+    if (!streamName) {
+        const id = (global[STABLE_ULID] || defaultUlid)();
+        streamName = getAbortStreamId(id);
+        hookToken = `abrt_${id}`;
+        holder[ABORT_STREAM_NAME] = streamName;
+        holder[ABORT_HOOK_TOKEN] = hookToken;
+        if (holder.signal) {
+            holder.signal[ABORT_STREAM_NAME] = streamName;
+            holder.signal[ABORT_HOOK_TOKEN] = hookToken;
+        }
+    }
+    // Deduped via ABORT_LISTENER_ATTACHED marker — see attachAbortListenerOnce.
+    attachAbortListenerOnce(signal, streamName, runId, cryptoKey, ops);
+    return {
+        streamName,
+        hookToken: hookToken,
+        aborted: signal.aborted,
+        reason: signal.aborted ? signal.reason : undefined,
+    };
+}
+/**
+ * Shared logic for AbortController/AbortSignal reducers in workflow context.
+ * Reads existing stream/hook names from symbols (must already be set).
+ */
+function reduceAbortBySymbol(signal, holder) {
+    const streamName = holder[ABORT_STREAM_NAME] ?? holder.signal?.[ABORT_STREAM_NAME];
+    const hookToken = holder[ABORT_HOOK_TOKEN] ?? holder.signal?.[ABORT_HOOK_TOKEN];
+    if (!streamName) {
+        throw new Error('AbortController/AbortSignal stream name is not set');
+    }
+    return {
+        streamName,
+        hookToken: hookToken,
+        aborted: signal.aborted,
+        reason: signal.aborted ? signal.reason : undefined,
+    };
+}
+/**
+ * Attach a single abort listener to a signal, deduped across calls.
+ *
+ * Each serialization pass goes through the reducer, but a controller passed
+ * to N steps would otherwise accumulate N listeners — each writing the same
+ * stream packet and double-closing the stream on abort. The marker symbol
+ * ensures the stream-write side-effect runs at most once per (signal, runId).
+ */
+function attachAbortListenerOnce(signal, streamName, runId, cryptoKey, ops) {
+    if (signal.aborted)
+        return;
+    if (signal[ABORT_LISTENER_ATTACHED])
+        return;
+    signal[ABORT_LISTENER_ATTACHED] = true;
+    signal.addEventListener('abort', () => {
+        ops.push((async () => {
+            try {
+                // Dehydrate via the same machinery the reader uses (hydrateStepArguments)
+                // so the reason round-trips with full type fidelity (DOMException,
+                // Errors, custom classes, etc.) and respects the run's encryption key.
+                // A bare JSON.stringify here would write a packet the reader can't
+                // decode and the listener-side abort would propagate with no reason.
+                const key = await resolveEncryptionKey(cryptoKey);
+                const payload = await dehydrateStepArguments({ aborted: true, reason: signal.reason }, runId, key);
+                const writable = new WorkflowServerWritableStream(runId, streamName);
+                const writer = writable.getWriter();
+                await writer.write(payload);
+                await writer.close();
+            }
+            catch {
+                // Best-effort stream write
+            }
+        })());
+    }, { once: true });
+}
 /**
  * Reducers for serialization boundary from the client side, passing arguments
  * to the workflow handler.
  *
  * @param global
  * @param ops
+ * @param runId
+ * @param cryptoKey
+ * @param framedByteStreams - When `true`, byte streams (`type: 'bytes'`)
+ *   are wrapped in length-prefixed frames on the wire so the consumer
+ *   can reconnect on transient errors. Should match the target run's
+ *   capability — see `getRunCapabilities` in `capabilities.ts`. Defaults
+ *   to `false` for backwards compatibility with older runs.
  * @returns
  */
-export function getExternalReducers(global = globalThis, ops, runId, cryptoKey) {
+export function getExternalReducers(global = globalThis, ops, runId, cryptoKey, framedByteStreams = false, 
+// Turbo optimistic start: a nested `ReadableStream` found while serializing
+// is piped to its own server stream independently of the outer sink, so its
+// first chunk can race `run_started`. Thread the run-ready barrier into that
+// sink so the write orders after the run exists. Undefined outside turbo /
+// on the await path.
+runReadyBarrier) {
     return {
-        ...getCommonReducers(global),
+        ...getAllBaseReducers(global),
         ReadableStream: (value) => {
             if (!(value instanceof global.ReadableStream))
                 return false;
             // Stream must not be locked when passing across execution boundary
             if (value.locked) {
-                throw new Error('ReadableStream is locked');
+                throw new SerializationError('ReadableStream is locked and cannot be passed across a workflow boundary.', {
+                    hint: 'Pass the stream before calling .getReader() / .pipeThrough() / .pipeTo(), or tee it with .tee() and pass one of the branches.',
+                });
             }
             const streamId = (global[STABLE_ULID] || defaultUlid)();
             const name = `strm_${streamId}`;
             const type = getStreamType(value);
-            const writable = new WorkflowServerWritableStream(runId, name);
+            const writable = new WorkflowServerWritableStream(runId, name, runReadyBarrier);
             if (type === 'bytes') {
-                ops.push(value.pipeTo(writable));
+                if (framedByteStreams) {
+                    ops.push(value.pipeThrough(getByteFramingStream()).pipeTo(writable));
+                }
+                else {
+                    ops.push(value.pipeTo(writable));
+                }
             }
             else {
                 ops.push(value
-                    .pipeThrough(getSerializeStream(getExternalReducers(global, ops, runId, cryptoKey), cryptoKey))
+                    .pipeThrough(getSerializeStream(getExternalReducers(global, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier), cryptoKey))
                     .pipeTo(writable));
             }
             const s = { name };
             if (type)
                 s.type = type;
+            if (type === 'bytes' && framedByteStreams)
+                s.framing = 'framed-v1';
             return s;
         },
         WritableStream: (value) => {
             if (!(value instanceof global.WritableStream))
                 return false;
+            // Fast path: when the writable is already backed by a workflow
+            // server stream (e.g. it came from a step-context `getWritable()`
+            // or was hydrated from a workflow input by `getStepRevivers`),
+            // forward its underlying `(runId, name)` to the receiving run.
+            // The receiving run's step-side reviver opens a server writable
+            // against the original `(runId, name)` and resolves that run's
+            // encryption key directly, so writes land on the original stream
+            // for the full lifetime of the receiving run — no in-process
+            // bridge tied to the dehydrating step's lifetime.
+            const existingName = value[STREAM_NAME_SYMBOL];
+            const existingRunId = value[STREAM_SERVER_RUN_ID_SYMBOL];
+            if (typeof existingName === 'string' &&
+                typeof existingRunId === 'string') {
+                const descriptor = {
+                    name: existingName,
+                    runId: existingRunId,
+                };
+                const existingDeploymentId = value[STREAM_SERVER_DEPLOYMENT_ID_SYMBOL];
+                if (typeof existingDeploymentId === 'string') {
+                    descriptor.deploymentId = existingDeploymentId;
+                }
+                return descriptor;
+            }
             const streamId = (global[STABLE_ULID] || defaultUlid)();
             const name = `strm_${streamId}`;
             const readable = new WorkflowServerReadableStream(runId, name);
             ops.push(readable.pipeTo(value));
             return { name };
         },
+        AbortController: (value) => {
+            if (!global.AbortController ||
+                typeof global.AbortController !== 'function' ||
+                !(value instanceof global.AbortController))
+                return false;
+            return reduceAbortWithListener(value.signal, value, global, ops, runId, cryptoKey);
+        },
+        AbortSignal: (value) => {
+            if (!global.AbortSignal ||
+                typeof global.AbortSignal !== 'function' ||
+                !(value instanceof global.AbortSignal))
+                return false;
+            return reduceAbortWithListener(value, value, global, ops, runId, cryptoKey);
+        },
     };
 }
 /**
@@ -694,7 +1064,7 @@ export function getExternalReducers(global = globalThis, ops, runId, cryptoKey)
  */
 export function getWorkflowReducers(global = globalThis) {
     return {
-        ...getCommonReducers(global),
+        ...getAllBaseReducers(global),
         // Readable/Writable streams from within the workflow execution environment
         // are simply "handles" that can be passed around to other steps.
         ReadableStream: (value) => {
@@ -709,12 +1079,15 @@ export function getWorkflowReducers(global = globalThis) {
             }
             const name = value[STREAM_NAME_SYMBOL];
             if (!name) {
-                throw new Error('ReadableStream `name` is not set');
+                throw new WorkflowRuntimeError('ReadableStream `name` is not set');
             }
             const s = { name };
             const type = value[STREAM_TYPE_SYMBOL];
             if (type)
                 s.type = type;
+            const framing = value[STREAM_FRAMING_SYMBOL];
+            if (framing)
+                s.framing = framing;
             return s;
         },
         WritableStream: (value) => {
@@ -722,9 +1095,46 @@ export function getWorkflowReducers(global = globalThis) {
                 return false;
             const name = value[STREAM_NAME_SYMBOL];
             if (!name) {
-                throw new Error('WritableStream `name` is not set');
+                throw new WorkflowRuntimeError('WritableStream `name` is not set');
             }
-            return { name };
+            const s = { name };
+            // When the handle was forwarded from another run (parent → child
+            // via `start()`), preserve the foreign runId so the step-side
+            // reviver opens the writable against the original stream.
+            const foreignRunId = value[STREAM_SERVER_RUN_ID_SYMBOL];
+            if (typeof foreignRunId === 'string')
+                s.runId = foreignRunId;
+            const foreignDeploymentId = value[STREAM_SERVER_DEPLOYMENT_ID_SYMBOL];
+            if (typeof foreignDeploymentId === 'string') {
+                s.deploymentId = foreignDeploymentId;
+            }
+            return s;
+        },
+        // AbortController/AbortSignal in workflow context — just read symbols (handles).
+        // In the workflow VM, global.AbortController is a class but global.AbortSignal
+        // is a plain object (not a class), so instanceof checks won't work for signals.
+        // Detect instances by the presence of the ABORT_STREAM_NAME symbol instead.
+        AbortController: (value) => {
+            if (!value || !value.signal)
+                return false;
+            const holder = value;
+            const hasAbortSymbol = holder[ABORT_STREAM_NAME] ?? holder.signal?.[ABORT_STREAM_NAME];
+            const isNativeAbortController = global.AbortController &&
+                typeof global.AbortController === 'function' &&
+                value instanceof global.AbortController;
+            if (!hasAbortSymbol && !isNativeAbortController)
+                return false;
+            return reduceAbortBySymbol(value.signal, holder);
+        },
+        AbortSignal: (value) => {
+            const signal = value;
+            const hasAbortSymbol = signal?.[ABORT_STREAM_NAME];
+            const isNativeAbortSignal = global.AbortSignal &&
+                typeof global.AbortSignal === 'function' &&
+                value instanceof global.AbortSignal;
+            if (!hasAbortSymbol && !isNativeAbortSignal)
+                return false;
+            return reduceAbortBySymbol(value, value);
         },
     };
 }
@@ -737,44 +1147,66 @@ export function getWorkflowReducers(global = globalThis) {
  * @param runId
  * @returns
  */
-function getStepReducers(global = globalThis, ops, runId, cryptoKey) {
+function getStepReducers(global = globalThis, ops, runId, cryptoKey, framedByteStreams = false, 
+// Turbo optimistic start: a returned `ReadableStream` is piped to the server
+// after the body but within the same op flush, so its first chunk can race
+// `run_started`. Thread the run-ready barrier into the sink so that write
+// orders after the run exists. Undefined outside turbo / on the await path.
+runReadyBarrier) {
     return {
-        ...getCommonReducers(global),
+        ...getAllBaseReducers(global),
         ReadableStream: (value) => {
             if (!(value instanceof global.ReadableStream))
                 return false;
             // Stream must not be locked when passing across execution boundary
             if (value.locked) {
-                throw new Error('ReadableStream is locked');
+                throw new SerializationError('ReadableStream is locked and cannot be passed across a workflow boundary.', {
+                    hint: 'Pass the stream before calling .getReader() / .pipeThrough() / .pipeTo(), or tee it with .tee() and pass one of the branches.',
+                });
             }
             // Check if the stream already has the name symbol set, in which case
             // it's already being sunk to the server and we can just return the
             // name and type.
             let name = value[STREAM_NAME_SYMBOL];
             let type = value[STREAM_TYPE_SYMBOL];
+            // The framing symbol is set when a workflow VM revives a stream
+            // handle from a previous step (see `getWorkflowRevivers`). When
+            // present we must propagate the same framing choice on the way
+            // back out, since the bytes already on the server's stream are in
+            // that format — switching format mid-stream would corrupt them.
+            let framing = value[STREAM_FRAMING_SYMBOL];
             if (!name) {
                 const streamId = (global[STABLE_ULID] || defaultUlid)();
                 name = `strm_${streamId}`;
                 type = getStreamType(value);
-                const writable = new WorkflowServerWritableStream(runId, name);
+                framing = type === 'bytes' && framedByteStreams ? 'framed-v1' : framing;
+                const writable = new WorkflowServerWritableStream(runId, name, runReadyBarrier);
                 if (type === 'bytes') {
-                    ops.push(value.pipeTo(writable));
+                    if (framing === 'framed-v1') {
+                        ops.push(value.pipeThrough(getByteFramingStream()).pipeTo(writable));
+                    }
+                    else {
+                        ops.push(value.pipeTo(writable));
+                    }
                 }
                 else {
                     ops.push(value
-                        .pipeThrough(getSerializeStream(getStepReducers(global, ops, runId, cryptoKey), cryptoKey))
+                        .pipeThrough(getSerializeStream(getStepReducers(global, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier), cryptoKey))
                         .pipeTo(writable));
                 }
             }
             const s = { name };
             if (type)
                 s.type = type;
+            if (framing)
+                s.framing = framing;
             return s;
         },
         WritableStream: (value) => {
             if (!(value instanceof global.WritableStream))
                 return false;
             let name = value[STREAM_NAME_SYMBOL];
+            const foreignRunId = value[STREAM_SERVER_RUN_ID_SYMBOL];
             if (!name) {
                 const streamId = (global[STABLE_ULID] || defaultUlid)();
                 name = `strm_${streamId}`;
@@ -782,120 +1214,311 @@ function getStepReducers(global = globalThis, ops, runId, cryptoKey) {
                     .pipeThrough(getDeserializeStream(getStepRevivers(global, ops, runId, cryptoKey), cryptoKey))
                     .pipeTo(value));
             }
-            return { name };
+            const s = { name };
+            if (typeof foreignRunId === 'string')
+                s.runId = foreignRunId;
+            const foreignDeploymentId = value[STREAM_SERVER_DEPLOYMENT_ID_SYMBOL];
+            if (typeof foreignDeploymentId === 'string') {
+                s.deploymentId = foreignDeploymentId;
+            }
+            return s;
+        },
+        AbortController: (value) => {
+            if (!global.AbortController ||
+                typeof global.AbortController !== 'function' ||
+                !(value instanceof global.AbortController))
+                return false;
+            return reduceAbortWithListener(value.signal, value, global, ops, runId, cryptoKey);
+        },
+        AbortSignal: (value) => {
+            if (!global.AbortSignal ||
+                typeof global.AbortSignal !== 'function' ||
+                !(value instanceof global.AbortSignal))
+                return false;
+            return reduceAbortWithListener(value, value, global, ops, runId, cryptoKey);
         },
     };
 }
-export function getCommonRevivers(global = globalThis) {
-    function reviveArrayBuffer(value) {
-        // Handle sentinel value for zero-length buffers
-        const base64 = value === '.' ? '' : value;
-        const buffer = Buffer.from(base64, 'base64');
-        const arrayBuffer = new global.ArrayBuffer(buffer.length);
-        const uint8Array = new global.Uint8Array(arrayBuffer);
-        uint8Array.set(buffer);
-        return arrayBuffer;
+/**
+ * Cancel dangling abort-stream readers on any AbortController instances found
+ * in the hydrated step arguments. Called after the step function returns
+ * (success or failure) to prevent reader promises from keeping the serverless
+ * function alive indefinitely.
+ */
+export function cancelAbortReaders(...values) {
+    const visited = new WeakSet();
+    function cancelIfPresent(val) {
+        const cancel = val[ABORT_READER_CANCEL];
+        if (cancel && !cancel.signal.aborted) {
+            cancel.abort();
+        }
     }
-    return {
-        ArrayBuffer: reviveArrayBuffer,
-        BigInt: (value) => global.BigInt(value),
-        BigInt64Array: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.BigInt64Array(ab);
-        },
-        BigUint64Array: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.BigUint64Array(ab);
-        },
-        Date: (value) => new global.Date(value),
-        DOMException: (value) => {
-            const error = new global.DOMException(value.message, value.name);
-            if (value.stack !== undefined)
-                error.stack = value.stack;
-            // DOMException's constructor doesn't accept a cause option, so
-            // we set it manually when present in the serialized data.
-            if ('cause' in value)
-                error.cause = value.cause;
-            return error;
-        },
-        Error: (value) => {
-            const error = new global.Error(value.message);
-            error.name = value.name;
-            error.stack = value.stack;
-            return error;
-        },
-        Float32Array: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.Float32Array(ab);
-        },
-        Float64Array: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.Float64Array(ab);
-        },
-        Headers: (value) => new global.Headers(value),
-        Int8Array: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.Int8Array(ab);
-        },
-        Int16Array: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.Int16Array(ab);
-        },
-        Int32Array: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.Int32Array(ab);
-        },
-        Map: (value) => new global.Map(value),
-        RegExp: (value) => new global.RegExp(value.source, value.flags),
-        Class: (value) => {
-            const classId = value.classId;
-            // Pass the global object to support VM contexts where classes are registered
-            // on the VM's global rather than the host's globalThis
-            const cls = getSerializationClass(classId, global);
-            if (!cls) {
-                throw new Error(`Class "${classId}" not found. Make sure the class is registered with registerSerializationClass.`);
+    function walk(val) {
+        if (val == null || typeof val !== 'object')
+            return;
+        if (visited.has(val))
+            return;
+        visited.add(val);
+        if (val instanceof AbortController) {
+            cancelIfPresent(val);
+            cancelIfPresent(val.signal);
+            return;
+        }
+        if (val instanceof AbortSignal) {
+            cancelIfPresent(val);
+            return;
+        }
+        if (Array.isArray(val)) {
+            for (const item of val)
+                walk(item);
+            return;
+        }
+        if (val instanceof Map) {
+            for (const v of val.values())
+                walk(v);
+            return;
+        }
+        if (val instanceof Set) {
+            for (const v of val)
+                walk(v);
+            return;
+        }
+        // Request/Response expose `signal`/`body` as prototype getters, so
+        // Object.values() won't find them. Descend explicitly.
+        if (typeof Request !== 'undefined' && val instanceof Request) {
+            walk(val.signal);
+            return;
+        }
+        for (const v of Object.values(val))
+            walk(v);
+    }
+    for (const v of values)
+        walk(v);
+}
+/**
+ * Sets up a stream reader on the controller that listens for an abort packet.
+ * Returns the readerCancel controller so it can be stored on both the
+ * controller and signal for cleanup by cancelAbortReaders.
+ */
+function setupAbortStreamReader(controller, runId, streamName, ops) {
+    const readerCancel = new AbortController();
+    ops.push((async () => {
+        try {
+            const readable = new WorkflowServerReadableStream(runId, streamName);
+            const reader = readable.getReader();
+            const result = await Promise.race([
+                reader.read(),
+                new Promise((resolve) => {
+                    if (readerCancel.signal.aborted) {
+                        resolve({ value: undefined, done: true });
+                        return;
+                    }
+                    readerCancel.signal.addEventListener('abort', () => resolve({ value: undefined, done: true }), { once: true });
+                }),
+            ]);
+            if (result.value && !result.done) {
+                // An abort packet arrived: propagate it as fast as possible. Release
+                // the lock (synchronous) rather than cancelling here — on a
+                // service-backed World `reader.cancel()` can do a network round-trip,
+                // and awaiting it before `controller.abort()` would delay (or, if it
+                // hangs, drop) real-time abort delivery to the in-flight step.
+                try {
+                    reader.releaseLock();
+                }
+                catch {
+                    // Reader may already be released; ignore.
+                }
+                try {
+                    // Hydrate via the same machinery the writer used so the reason
+                    // round-trips with full type fidelity. Encryption key (if any)
+                    // comes from the step context — set up by the step handler before
+                    // this reader runs. Fallback to undefined for external-context
+                    // revives (the hydrate path is encryption-key-tolerant).
+                    const ctxForKey = contextStorage.getStore();
+                    const data = (await hydrateStepArguments(result.value, runId, ctxForKey?.encryptionKey));
+                    controller.abort(data?.reason);
+                }
+                catch {
+                    controller.abort();
+                }
             }
-            return cls;
-        },
-        Instance: (value) => {
-            const classId = value.classId;
-            const data = value.data;
-            // Look up the class by classId from the registry
-            // Pass the global object to support VM contexts where classes are registered
-            // on the VM's global rather than the host's globalThis
-            const cls = getSerializationClass(classId, global);
-            if (!cls) {
-                throw new Error(`Class "${classId}" not found. Make sure the class is registered with registerSerializationClass.`);
+            else {
+                // The step finished (or the reader was cancelled) without an abort.
+                // Cancel — not just release — so the underlying World stream is torn
+                // down: a polling World (e.g. world-local) otherwise leaks a tail
+                // reader (a 100ms filesystem poll plus emitter listeners) per step
+                // invocation for the life of the process, since a signal-bearing step
+                // opens one of these on every revival and usually never aborts. Fire
+                // and forget: a service-backed World's cancel may hit the network,
+                // and this path must not block the step's ops-settle window.
+                void reader.cancel().catch(() => { });
             }
-            // Get the deserializer from the class
-            const deserialize = cls[WORKFLOW_DESERIALIZE];
-            if (typeof deserialize !== 'function') {
-                throw new Error(`Class "${classId}" does not have a static ${String(WORKFLOW_DESERIALIZE)} method.`);
+        }
+        catch {
+            // Stream read failed — signal won't propagate in real-time,
+            // but hook-based propagation on next replay provides fallback
+        }
+    })());
+    return readerCancel;
+}
+/**
+ * Stores abort serialization symbols and the readerCancel controller
+ * on both the controller and its signal.
+ */
+function tagAbortPair(controller, value, readerCancel) {
+    const taggedController = controller;
+    const taggedSignal = controller.signal;
+    taggedController[ABORT_STREAM_NAME] = value.streamName;
+    taggedController[ABORT_HOOK_TOKEN] = value.hookToken;
+    taggedSignal[ABORT_STREAM_NAME] = value.streamName;
+    taggedSignal[ABORT_HOOK_TOKEN] = value.hookToken;
+    if (readerCancel) {
+        taggedController[ABORT_READER_CANCEL] = readerCancel;
+        taggedSignal[ABORT_READER_CANCEL] = readerCancel;
+    }
+}
+/**
+ * Propagate abort-internal symbols from one signal to another. Used by the
+ * Request reviver because `new Request(url, { signal })` copies the signal
+ * internally — the constructed `request.signal` is a fresh AbortSignal that
+ * doesn't carry symbols from the source.
+ */
+function copyAbortInternals(src, dest) {
+    const s = src;
+    const d = dest;
+    if (s[ABORT_STREAM_NAME] !== undefined) {
+        d[ABORT_STREAM_NAME] = s[ABORT_STREAM_NAME];
+    }
+    if (s[ABORT_HOOK_TOKEN] !== undefined) {
+        d[ABORT_HOOK_TOKEN] = s[ABORT_HOOK_TOKEN];
+    }
+    if (s[ABORT_READER_CANCEL] !== undefined) {
+        d[ABORT_READER_CANCEL] = s[ABORT_READER_CANCEL];
+    }
+}
+/**
+ * Creates an AbortController with stream-backed abort propagation.
+ * Used by step and external revivers where real abort signal behavior is needed.
+ *
+ * @param value - The serialized abort controller/signal data
+ * @param ops - The ops array for tracking async work
+ * @param runId - The workflow run ID (for stream reads)
+ * @returns A real AbortController with patched abort() method
+ */
+function reviveAbortController(value, ops, runId) {
+    const controller = new AbortController();
+    if (value.aborted) {
+        tagAbortPair(controller, value);
+        controller.abort(value.reason);
+    }
+    else if (value.streamName) {
+        const readerCancel = setupAbortStreamReader(controller, runId, value.streamName, ops);
+        tagAbortPair(controller, value, readerCancel);
+    }
+    else {
+        tagAbortPair(controller, value);
+    }
+    // Override abort() to also write stream + resume hook (for step-initiated abort)
+    const originalAbort = controller.abort.bind(controller);
+    controller.abort = (reason) => {
+        if (controller.signal.aborted)
+            return;
+        originalAbort(reason);
+        const ctx = contextStorage.getStore();
+        if (ctx) {
+            ctx.ops.push((async () => {
+                try {
+                    // Dehydrate the abort payload through the same machinery the hook
+                    // event uses so the `reason` round-trips with full type fidelity
+                    // (DOMException, custom errors, etc.) and respects the run's
+                    // encryption key — symmetric with what the suspension handler
+                    // writes for workflow-initiated aborts.
+                    const payload = await dehydrateStepArguments({ aborted: true, reason }, ctx.workflowMetadata.workflowRunId, ctx.encryptionKey);
+                    const writable = new WorkflowServerWritableStream(ctx.workflowMetadata.workflowRunId, value.streamName);
+                    const writer = writable.getWriter();
+                    await writer.write(payload);
+                    await writer.close();
+                }
+                catch {
+                    // Best-effort stream write
+                }
+            })());
+            if (value.hookToken) {
+                // The durable hook resume (which writes the `hook_received` event that
+                // records this abort in the workflow's event log) must be committed
+                // before the step completes. Otherwise the workflow continuation
+                // enqueued by `step_completed` can advance past the abort — dispatching
+                // a later step with a stale, non-aborted `signal` — before the event
+                // exists. Route it to `preCompletionOps` (awaited inline before
+                // completion) rather than `ops` (best-effort, background). The stream
+                // write above stays in `ops`: it must fire ASAP to reach an in-flight
+                // sibling step and is not the durable record.
+                // Swallow errors here so the promise can only ever enforce ordering
+                // when awaited (see the no-reject contract on
+                // StepContext.preCompletionOps); a failed resume retries on next replay.
+                const hookResume = (async () => {
+                    try {
+                        const { resumeHook: resumeHookFn } = await import('./runtime/resume-hook.js');
+                        await resumeHookFn(value.hookToken, {
+                            aborted: true,
+                            reason,
+                        });
+                    }
+                    catch {
+                        // Best-effort hook resume — retry on next replay
+                    }
+                })();
+                ctx.preCompletionOps.push(hookResume);
             }
-            // Deserialize the instance using the custom deserializer
-            return deserialize.call(cls, data);
-        },
-        Set: (value) => new global.Set(value),
-        URL: (value) => new global.URL(value),
-        URLSearchParams: (value) => new global.URLSearchParams(value === '.' ? '' : value),
-        Uint8Array: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.Uint8Array(ab);
-        },
-        Uint8ClampedArray: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.Uint8ClampedArray(ab);
-        },
-        Uint16Array: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.Uint16Array(ab);
-        },
-        Uint32Array: (value) => {
-            const ab = reviveArrayBuffer(value);
-            return new global.Uint32Array(ab);
-        },
+        }
+    };
+    return controller;
+}
+/**
+ * Revives just an AbortSignal without the patched abort() overhead.
+ * Used when only a signal (not a controller) was serialized.
+ */
+function reviveAbortSignal(value, ops, runId) {
+    const controller = new AbortController();
+    if (value.aborted) {
+        tagAbortPair(controller, value);
+        controller.abort(value.reason);
+    }
+    else if (value.streamName) {
+        const readerCancel = setupAbortStreamReader(controller, runId, value.streamName, ops);
+        tagAbortPair(controller, value, readerCancel);
+    }
+    else {
+        tagAbortPair(controller, value);
+    }
+    return controller.signal;
+}
+/**
+ * Base revivers shared across all serialization boundaries.
+ * Composes: class + common revivers from the modular modules.
+ *
+ * This is exported because serialization-format.ts and other files reference it.
+ */
+export function getCommonRevivers(global = globalThis) {
+    return {
+        ...getClassRevivers(global),
+        ...getCommonReviversFromModule(global),
     };
 }
+/**
+ * Resolve the encrypt-only key needed when a child writes into another run's
+ * stream. New descriptors include the owner's deployment ID; descriptors
+ * created by older SDK versions fall back to loading the owning run.
+ */
+async function getForwardedWritableEncryptionKey(runId, deploymentId) {
+    const world = await getWorldLazy();
+    if (!world.getEncryptionKeyForRun)
+        return undefined;
+    const rawKey = deploymentId
+        ? await world.getEncryptionKeyForRun(runId, { deploymentId })
+        : await world.getEncryptionKeyForRun(await world.runs.get(runId));
+    return rawKey ? await importKey(rawKey, ['encrypt']) : undefined;
+}
 /**
  * Revivers for deserialization boundary from the client side,
  * receiving the return value from the workflow handler.
@@ -909,18 +1532,31 @@ export function getExternalRevivers(global = globalThis, ops, runId, cryptoKey)
         ...getCommonRevivers(global),
         // StepFunction should not be returned from workflows to clients
         StepFunction: () => {
-            throw new Error('Step functions cannot be deserialized in client context. Step functions should not be returned from workflows.');
+            throw new SerializationError('Step functions cannot be deserialized in client context. Step functions should not be returned from workflows.', {
+                hint: 'A step function reference reached the client. Return a serializable value (e.g. the step result) instead of the step itself.',
+            });
         },
         WorkflowFunction: (value) => Object.assign(() => {
-            throw new Error('Workflow functions cannot be called directly. Use start() to invoke them.');
+            throw new SerializationError('Workflow functions cannot be called directly. Use start() to invoke them.', {
+                hint: 'Wrap the workflow with `start(workflowFn, { ... })` from `workflow` to begin a run instead of invoking it like a normal function.',
+            });
         }, { workflowId: value.workflowId }),
         Request: (value) => {
-            return new global.Request(value.url, {
+            const init = {
                 method: value.method,
                 headers: new global.Headers(value.headers),
                 body: value.body,
                 duplex: value.duplex,
-            });
+            };
+            if (value.signal)
+                init.signal = value.signal;
+            const request = new global.Request(value.url, init);
+            // The Request constructor creates an internal signal copy, so the
+            // abort-internal symbols set by reviveAbortSignal don't propagate.
+            // Re-tag the request's own signal so cancelAbortReaders can find it.
+            if (value.signal)
+                copyAbortInternals(value.signal, request.signal);
+            return request;
         },
         Response: (value) => {
             // Note: Response constructor only accepts status, statusText, and headers
@@ -940,13 +1576,24 @@ export function getExternalRevivers(global = globalThis, ops, runId, cryptoKey)
                 const response = new global.Response(bodyInit);
                 return response.body;
             }
-            const readable = new WorkflowServerReadableStream(runId, value.name, value.startIndex);
             if (value.type === 'bytes') {
-                // For byte streams, use flushable pipe with lock polling
+                // For byte streams, use flushable pipe with lock polling.
+                // If the producer wrote framed bytes (framing === 'framed-v1'),
+                // unwrap the length-prefix envelope before handing chunks to
+                // the user. Absent / 'raw' framing means legacy raw bytes —
+                // pipe through unchanged for backwards compatibility.
+                //
+                // No auto-reconnect here yet: raw byte streams have no wire
+                // framing to count consumed chunks with. Framed-v1 byte streams
+                // make frame counting possible, so extending the reconnecting
+                // reader to them is a separate follow-up.
+                const readable = new WorkflowServerReadableStream(runId, value.name, value.startIndex);
                 const state = createFlushableState();
                 ops.push(state.promise);
-                // Create an identity transform to give the user a readable
-                const { readable: userReadable, writable } = new global.TransformStream();
+                // Create an identity (or unframing) transform to give the user a readable
+                const { readable: userReadable, writable } = value.framing === 'framed-v1'
+                    ? getByteUnframingStream()
+                    : new global.TransformStream();
                 // Start the flushable pipe in the background
                 flushablePipe(readable, writable, state).catch(() => {
                     // Errors are handled via state.reject
@@ -956,6 +1603,10 @@ export function getExternalRevivers(global = globalThis, ops, runId, cryptoKey)
                 return userReadable;
             }
             else {
+                // Non-byte streams carry length-prefixed frames, so we can count
+                // completed frames and transparently reconnect when the server
+                // stream connection times out mid-run.
+                const readable = createReconnectingFramedStream(runId, value.name, value.startIndex);
                 const transform = getDeserializeStream(getExternalRevivers(global, ops, runId, cryptoKey), cryptoKey);
                 const state = createFlushableState();
                 ops.push(state.promise);
@@ -969,8 +1620,15 @@ export function getExternalRevivers(global = globalThis, ops, runId, cryptoKey)
             }
         },
         WritableStream: (value) => {
-            const serialize = getSerializeStream(getExternalReducers(global, ops, runId, cryptoKey), cryptoKey);
-            const serverWritable = new WorkflowServerWritableStream(runId, value.name);
+            // Same handling as `getStepRevivers.WritableStream` — see comments
+            // there for the cross-run case (writable carries `runId` from
+            // parent → child forwarding via `start()`).
+            const targetRunId = typeof value.runId === 'string' ? value.runId : runId;
+            const targetKey = targetRunId === runId
+                ? cryptoKey
+                : getForwardedWritableEncryptionKey(targetRunId, value.deploymentId);
+            const serialize = getSerializeStream(getExternalReducers(global, ops, targetRunId, targetKey), targetKey);
+            const serverWritable = new WorkflowServerWritableStream(targetRunId, value.name);
             // Create flushable state for this stream
             const state = createFlushableState();
             ops.push(state.promise);
@@ -980,8 +1638,24 @@ export function getExternalRevivers(global = globalThis, ops, runId, cryptoKey)
             });
             // Start polling to detect when user releases lock
             pollWritableLock(serialize.writable, state);
+            Object.defineProperty(serialize.writable, STREAM_NAME_SYMBOL, {
+                value: value.name,
+                writable: false,
+            });
+            Object.defineProperty(serialize.writable, STREAM_SERVER_RUN_ID_SYMBOL, {
+                value: targetRunId,
+                writable: false,
+            });
+            if (typeof value.deploymentId === 'string') {
+                Object.defineProperty(serialize.writable, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL, {
+                    value: value.deploymentId,
+                    writable: false,
+                });
+            }
             return serialize.writable;
         },
+        AbortController: (value) => reviveAbortController(value, ops, runId),
+        AbortSignal: (value) => reviveAbortSignal(value, ops, runId),
     };
 }
 /**
@@ -993,27 +1667,11 @@ export function getExternalRevivers(global = globalThis, ops, runId, cryptoKey)
  * @returns
  */
 export function getWorkflowRevivers(global = globalThis) {
-    // Get the useStep function from the VM's globalThis
-    // This is set up by the workflow runner in workflow.ts
-    // Use Symbol.for directly to access the symbol on the global object
-    const useStep = global[Symbol.for('WORKFLOW_USE_STEP')];
     return {
         ...getCommonRevivers(global),
-        // StepFunction reviver for workflow context - returns useStep wrapper
-        // This allows step functions passed as arguments to start() to be called directly
-        // from workflow code, just like step functions defined in the same file
-        StepFunction: (value) => {
-            const stepId = value.stepId;
-            const closureVars = value.closureVars;
-            if (!useStep) {
-                throw new Error('WORKFLOW_USE_STEP not found on global object. Step functions cannot be deserialized outside workflow context.');
-            }
-            if (closureVars) {
-                // For step functions with closure variables, create a wrapper that provides them
-                return useStep(stepId, () => closureVars);
-            }
-            return useStep(stepId);
-        },
+        // StepFunction reviver for workflow context - uses the modular reviver
+        // which calls WORKFLOW_USE_STEP from global to reconstruct step proxies
+        ...getStepFunctionReviver(global),
         Request: (value) => {
             Object.setPrototypeOf(value, global.Request.prototype);
             const responseWritable = value.responseWritable;
@@ -1021,7 +1679,9 @@ export function getWorkflowRevivers(global = globalThis) {
                 value[WEBHOOK_RESPONSE_WRITABLE] = responseWritable;
                 delete value.responseWritable;
                 value.respondWith = () => {
-                    throw new Error('`respondWith()` must be called from within a step function');
+                    throw new SerializationError('`respondWith()` must be called from within a step function.', {
+                        hint: 'Move the `respondWith(...)` call inside a `"use step"` function — it cannot be invoked from a workflow context.',
+                    });
                 };
             }
             return value;
@@ -1029,7 +1689,9 @@ export function getWorkflowRevivers(global = globalThis) {
         // Workflow function reviver for workflow context — returns a function-like
         // object with .workflowId that mimics what the SWC compiler produces,
         WorkflowFunction: (value) => Object.assign(() => {
-            throw new Error('Workflow functions cannot be called directly. Use start() to invoke them.');
+            throw new SerializationError('Workflow functions cannot be called directly. Use start() to invoke them.', {
+                hint: 'Wrap the workflow with `start(workflowFn, { ... })` from `workflow` to begin a run instead of invoking it like a normal function.',
+            });
         }, { workflowId: value.workflowId }),
         Response: (value) => {
             Object.setPrototypeOf(value, global.Response.prototype);
@@ -1056,15 +1718,64 @@ export function getWorkflowRevivers(global = globalThis) {
                     value: value.type,
                     writable: false,
                 },
+                // Carry the wire-framing decision through the workflow VM so
+                // that when the handle is later passed to a step (which reads
+                // the actual bytes from the server) we know whether to unframe.
+                // Defaults to undefined for streams whose serialized ref didn't
+                // carry the field — those are treated as legacy raw bytes.
+                [STREAM_FRAMING_SYMBOL]: {
+                    value: value.framing,
+                    writable: false,
+                },
             });
         },
         WritableStream: (value) => {
-            return Object.create(global.WritableStream.prototype, {
+            const descriptor = {
                 [STREAM_NAME_SYMBOL]: {
                     value: value.name,
                     writable: false,
                 },
-            });
+            };
+            // Preserve the foreign runId, if present, so that when the
+            // handle is later passed to a step the workflow reducer can
+            // forward it through to the step reviver.
+            if (typeof value.runId === 'string') {
+                descriptor[STREAM_SERVER_RUN_ID_SYMBOL] = {
+                    value: value.runId,
+                    writable: false,
+                };
+            }
+            if (typeof value.deploymentId === 'string') {
+                descriptor[STREAM_SERVER_DEPLOYMENT_ID_SYMBOL] = {
+                    value: value.deploymentId,
+                    writable: false,
+                };
+            }
+            return Object.create(global.WritableStream.prototype, descriptor);
+        },
+        // AbortController/AbortSignal revived inside the workflow VM. Use the
+        // real WorkflowAbortSignal class so addEventListener('abort', fn) actually
+        // fires when the signal aborts (the previous no-op stub silently dropped
+        // listener registrations — silent correctness bug for natural patterns
+        // like `signal.addEventListener('abort', fn)` after receiving a deserialized
+        // signal). The signal does not own a hook subscription here — abort state
+        // is delivered via the existing replay machinery on the source side.
+        AbortController: (value) => {
+            const signal = new WorkflowAbortSignal(value.streamName, value.hookToken);
+            if (value.aborted)
+                signal._setAborted(value.reason);
+            return {
+                [ABORT_STREAM_NAME]: value.streamName,
+                [ABORT_HOOK_TOKEN]: value.hookToken,
+                signal,
+                abort: () => { },
+            };
+        },
+        AbortSignal: (value) => {
+            const signal = new WorkflowAbortSignal(value.streamName, value.hookToken);
+            if (value.aborted)
+                signal._setAborted(value.reason);
+            return signal;
         },
     };
 }
@@ -1077,63 +1788,95 @@ export function getWorkflowRevivers(global = globalThis) {
  * @param runId
  * @returns
  */
-function getStepRevivers(global = globalThis, ops, runId, cryptoKey) {
+function getStepRevivers(global = globalThis, ops, runId, cryptoKey, deploymentId) {
     return {
         ...getCommonRevivers(global),
         // StepFunction reviver for step context - returns raw step function
-        // with closure variable support via AsyncLocalStorage
+        // with closure variable support via AsyncLocalStorage.
+        //
+        // Handles four independent flags from the serialized payload:
+        //   - `closureVars`: invoke the body inside an AsyncLocalStorage frame
+        //     so the SWC-emitted `WORKFLOW_STEP_CONTEXT_STORAGE` IIFE in the
+        //     hoisted body can pull the closure variables back out.
+        //   - `boundThis`:   a `this` value captured by
+        //     `useStep(...).bind(this)` in the workflow bundle (lexical-`this`
+        //     arrow steps). The wrapper invokes the body via
+        //     `stepFn.apply(boundThis, args)` so the body sees the same
+        //     `this` it would have had in the workflow bundle. Property
+        //     presence — not truthiness — is significant because
+        //     `bind(null)` and `bind(undefined)` are both legal and should
+        //     round-trip faithfully.
+        //   - `boundArgs`:   prefilled args from
+        //     `useStep(...).bind(thisArg, x, y)`. Prepended to the call args
+        //     so partial application survives serialization.
         StepFunction: (value) => {
             const stepId = value.stepId;
             const closureVars = value.closureVars;
+            const hasBoundThis = 'boundThis' in value;
+            const boundThis = hasBoundThis ? value.boundThis : undefined;
+            const boundArgs = Array.isArray(value.boundArgs) ? value.boundArgs : [];
             const stepFn = getStepFunction(stepId);
             if (!stepFn) {
-                throw new Error(`Step function "${stepId}" not found. Make sure the step function is registered.`);
+                throw new SerializationError(`Step function "${stepId}" not found. Make sure the step function is registered.`, {
+                    hint: 'Make sure the step file is included in your build (i.e. it is listed in the workflow manifest), and that the SWC plugin is configured for the file.',
+                });
+            }
+            // Fast path: nothing to wrap.
+            if (!closureVars && !hasBoundThis && boundArgs.length === 0) {
+                return stepFn;
             }
-            // If closure variables were serialized, return a wrapper function
-            // that sets up AsyncLocalStorage context when invoked
-            if (closureVars) {
-                const wrappedStepFn = ((...args) => {
-                    // Get the current context from AsyncLocalStorage
+            const wrappedStepFn = function (...args) {
+                const callThis = hasBoundThis ? boundThis : this;
+                const callArgs = boundArgs.length > 0 ? [...boundArgs, ...args] : args;
+                if (closureVars) {
                     const currentContext = contextStorage.getStore();
                     if (!currentContext) {
-                        throw new Error('Cannot call step function with closure variables outside step context');
+                        throw new WorkflowRuntimeError('Cannot call step function with closure variables outside step context');
                     }
-                    // Create a new context with the closure variables merged in
                     const newContext = {
                         ...currentContext,
                         closureVars,
                     };
-                    // Run the step function with the new context that includes closure vars
-                    return contextStorage.run(newContext, () => stepFn(...args));
-                });
-                // Copy properties from original step function
-                Object.defineProperty(wrappedStepFn, 'name', {
-                    value: stepFn.name,
-                });
-                Object.defineProperty(wrappedStepFn, 'stepId', {
-                    value: stepId,
-                    writable: false,
-                    enumerable: false,
-                    configurable: false,
-                });
-                if (stepFn.maxRetries !== undefined) {
-                    wrappedStepFn.maxRetries = stepFn.maxRetries;
+                    return contextStorage.run(newContext, () => stepFn.apply(callThis, callArgs));
                 }
-                return wrappedStepFn;
+                return stepFn.apply(callThis, callArgs);
+            };
+            // Copy properties from original step function
+            Object.defineProperty(wrappedStepFn, 'name', {
+                value: stepFn.name,
+            });
+            Object.defineProperty(wrappedStepFn, 'stepId', {
+                value: stepId,
+                writable: false,
+                enumerable: false,
+                configurable: false,
+            });
+            if (stepFn.maxRetries !== undefined) {
+                wrappedStepFn.maxRetries = stepFn.maxRetries;
             }
-            return stepFn;
+            return wrappedStepFn;
         },
         WorkflowFunction: (value) => Object.assign(() => {
-            throw new Error('Workflow functions cannot be called directly. Use start() to invoke them.');
+            throw new SerializationError('Workflow functions cannot be called directly. Use start() to invoke them.', {
+                hint: 'Wrap the workflow with `start(workflowFn, { ... })` from `workflow` to begin a run instead of invoking it like a normal function.',
+            });
         }, { workflowId: value.workflowId }),
         Request: (value) => {
             const responseWritable = value.responseWritable;
-            const request = new global.Request(value.url, {
+            const init = {
                 method: value.method,
                 headers: new global.Headers(value.headers),
                 body: value.body,
                 duplex: value.duplex,
-            });
+            };
+            if (value.signal)
+                init.signal = value.signal;
+            const request = new global.Request(value.url, init);
+            // The Request constructor creates an internal signal copy, so the
+            // abort-internal symbols set by reviveAbortSignal don't propagate.
+            // Re-tag the request's own signal so cancelAbortReaders can find it.
+            if (value.signal)
+                copyAbortInternals(value.signal, request.signal);
             if (responseWritable) {
                 request.respondWith = async (response) => {
                     const writer = responseWritable.getWriter();
@@ -1163,11 +1906,17 @@ function getStepRevivers(global = globalThis, ops, runId, cryptoKey) {
             }
             const readable = new WorkflowServerReadableStream(runId, value.name);
             if (value.type === 'bytes') {
-                // For byte streams, use flushable pipe with lock polling
+                // For byte streams, use flushable pipe with lock polling.
+                // If the producer wrote framed bytes (framing === 'framed-v1'),
+                // unwrap the length-prefix envelope before handing chunks to
+                // the user step. Absent / 'raw' framing means legacy raw bytes —
+                // pipe through unchanged for backwards compatibility.
                 const state = createFlushableState();
                 ops.push(state.promise);
-                // Create an identity transform to give the user a readable
-                const { readable: userReadable, writable } = new global.TransformStream();
+                // Create an identity (or unframing) transform to give the user a readable
+                const { readable: userReadable, writable } = value.framing === 'framed-v1'
+                    ? getByteUnframingStream()
+                    : new global.TransformStream();
                 // Start the flushable pipe in the background
                 flushablePipe(readable, writable, state).catch(() => {
                     // Errors are handled via state.reject
@@ -1177,7 +1926,7 @@ function getStepRevivers(global = globalThis, ops, runId, cryptoKey) {
                 return userReadable;
             }
             else {
-                const transform = getDeserializeStream(getStepRevivers(global, ops, runId, cryptoKey), cryptoKey);
+                const transform = getDeserializeStream(getStepRevivers(global, ops, runId, cryptoKey, deploymentId), cryptoKey);
                 const state = createFlushableState();
                 ops.push(state.promise);
                 // Start the flushable pipe in the background
@@ -1190,8 +1939,29 @@ function getStepRevivers(global = globalThis, ops, runId, cryptoKey) {
             }
         },
         WritableStream: (value) => {
-            const serialize = getSerializeStream(getStepReducers(global, ops, runId, cryptoKey), cryptoKey);
-            const serverWritable = new WorkflowServerWritableStream(runId, value.name);
+            // Same-run case: the writable belongs to the current run. Use the
+            // local cryptoKey and write to the local runId's server stream.
+            //
+            // Cross-run case (parent → child via `start()`): the descriptor
+            // carries the original `runId` and `name`. Open a server writable
+            // against the original `(runId, name)` and resolve THAT run's key
+            // for encryption. The resolution is async but doesn't need to
+            // block reviver return — `getSerializeStream` accepts the
+            // `Promise<CryptoKey | undefined>` directly and awaits it lazily
+            // on the first chunk written. The key is imported encrypt-only
+            // so the receiving run can never decrypt anything else on the
+            // owning run's stream — it can only contribute new writes.
+            const targetRunId = typeof value.runId === 'string' ? value.runId : runId;
+            const targetDeploymentId = typeof value.deploymentId === 'string'
+                ? value.deploymentId
+                : targetRunId === runId
+                    ? deploymentId
+                    : undefined;
+            const targetKey = targetRunId === runId
+                ? cryptoKey
+                : getForwardedWritableEncryptionKey(targetRunId, targetDeploymentId);
+            const serialize = getSerializeStream(getStepReducers(global, ops, targetRunId, targetKey), targetKey);
+            const serverWritable = new WorkflowServerWritableStream(targetRunId, value.name);
             // Create flushable state for this stream
             const state = createFlushableState();
             ops.push(state.promise);
@@ -1201,59 +1971,60 @@ function getStepRevivers(global = globalThis, ops, runId, cryptoKey) {
             });
             // Start polling to detect when user releases lock
             pollWritableLock(serialize.writable, state);
+            // Record the underlying `(runId, name)` so downstream reducers can
+            // recognize that this writable is already backed by a workflow
+            // server stream. When forwarded across `start()` again — e.g.
+            // the child passes this writable on to a grandchild — the
+            // external reducer needs both to emit the original `runId` in
+            // the descriptor.
+            Object.defineProperty(serialize.writable, STREAM_NAME_SYMBOL, {
+                value: value.name,
+                writable: false,
+            });
+            Object.defineProperty(serialize.writable, STREAM_SERVER_RUN_ID_SYMBOL, {
+                value: targetRunId,
+                writable: false,
+            });
+            if (targetDeploymentId) {
+                Object.defineProperty(serialize.writable, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL, {
+                    value: targetDeploymentId,
+                    writable: false,
+                });
+            }
             return serialize.writable;
         },
+        AbortController: (value) => reviveAbortController(value, ops, runId),
+        AbortSignal: (value) => reviveAbortSignal(value, ops, runId),
     };
 }
 // ============================================================================
 // Encryption Helpers
 // ============================================================================
+// These delegate to the modular `encrypt`/`decrypt` from `./serialization/encryption.js`
+// but are kept as named exports for backwards compatibility with existing consumers.
 /**
  * Encrypt data if the world supports encryption.
  * Returns original data if encryption is not available.
  *
- * @param data - Serialized data to encrypt
- * @param key - Encryption key (undefined to skip encryption)
- * @param context - Encryption context with runId
- * @returns Encrypted data if encryption available, original data otherwise
+ * @deprecated Use `encrypt` from `./serialization/encryption.js` instead.
  */
 export async function maybeEncrypt(data, key) {
-    if (!key)
-        return data;
-    const encrypted = await aesGcmEncrypt(key, data);
-    return encodeWithFormatPrefix(SerializationFormat.ENCRYPTED, encrypted);
+    return (await encrypt(data, key));
 }
 /**
  * Decrypt data if it has the 'encr' prefix.
  *
- * @param data - Data that may be encrypted
- * @param key - Encryption key (undefined if no key available)
- * @returns Decrypted data if encrypted, original data otherwise
- * @throws {WorkflowRuntimeError} If the data is encrypted but no key is
- *   available. Callers (e.g., `Run.pollReturnValue()`, `hydrateStepReturnValue`)
- *   should be aware this can surface as a rejected promise during key rotation
- *   or misconfiguration scenarios.
+ * @deprecated Use `decrypt` from `./serialization/encryption.js` instead.
  */
 export async function maybeDecrypt(data, key) {
-    // Legacy specVersion 1 runs stored event data as plain JSON arrays
-    // (not binary Uint8Array). Pass through as-is for backwards compat.
-    if (!(data instanceof Uint8Array)) {
-        return data;
-    }
-    if (isEncrypted(data)) {
-        if (!key) {
-            throw new WorkflowRuntimeError('Encrypted data encountered but no encryption key is available. ' +
-                'Encryption is not configured or no key was provided for this run.');
-        }
-        // Strip the 'encr' format prefix — the prefix is a core framing concern
-        const { payload } = decodeFormatPrefix(data);
-        return aesGcmDecrypt(key, payload);
-    }
-    return data;
+    return decrypt(data, key);
 }
 // ============================================================================
 // Dehydrate / Hydrate Functions
 // ============================================================================
+// These delegate to the modular mode modules (workflow, step, client) passing
+// mode-specific stream and Request/Response reducers/revivers as extra options.
+// The v1Compat path is handled inline before delegating to the modules.
 /**
  * Called from the `start()` function to serialize the workflow arguments
  * into a format that can be saved to the database and then hydrated from
@@ -1265,147 +2036,285 @@ export async function maybeDecrypt(data, key) {
  * @param ops - Promise array for stream operations
  * @param global - Global object for serialization context
  * @param v1Compat - Enable legacy v1 compatibility mode
+ * @param framedByteStreams - Whether the target run can decode wire-framed
+ *   byte streams. Should match the target deployment's capability — see
+ *   `getRunCapabilities` in `capabilities.ts`. Defaults to `false` for
+ *   backwards compatibility with older runs.
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export async function dehydrateWorkflowArguments(value, runId, key, ops = [], global = globalThis, v1Compat = false) {
+export async function dehydrateWorkflowArguments(value, runId, key, ops = [], global = globalThis, v1Compat = false, framedByteStreams = false, compression = false) {
+    if (v1Compat) {
+        const str = stringify(value, getExternalReducers(global, ops, runId, key, framedByteStreams));
+        return revive(str);
+    }
     try {
-        const str = stringify(value, getExternalReducers(global, ops, runId, key));
-        if (v1Compat) {
-            return revive(str);
-        }
-        const payload = new TextEncoder().encode(str);
-        const serialized = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
-        // Encrypt if world supports encryption
-        return maybeEncrypt(serialized, key);
+        const compressionStats = {};
+        const result = await clientModule.serialize(value, key, {
+            global,
+            extraReducers: getStreamAndRequestReducers(getExternalReducers(global, ops, runId, key, framedByteStreams)),
+            compression,
+            compressionStats,
+        });
+        await recordCompression(compressionStats, 'serialize');
+        return result;
     }
     catch (error) {
-        throw new WorkflowRuntimeError(formatSerializationError('workflow arguments', error), { slug: 'serialization-failed', cause: error });
+        const cause = unwrapSerializationCause(error);
+        const { message, hint } = formatSerializationError('workflow arguments', cause);
+        throw new SerializationError(message, { hint, cause });
     }
 }
 /**
  * Called from workflow execution environment to hydrate the workflow
  * arguments from the database at the start of workflow execution.
- *
- * @param value - Binary serialized data (Uint8Array) with format prefix
- * @param _runId - Workflow run ID (reserved for future decryption context; decryption is currently driven solely by the provided key)
- * @param key - Encryption key (undefined to skip decryption)
- * @param global - Global object for deserialization context
- * @param extraRevivers - Additional revivers for custom types
- * @returns The hydrated value
  */
 export async function hydrateWorkflowArguments(value, _runId, key, global = globalThis, extraRevivers = {}) {
-    // Decrypt if needed
-    const decrypted = await maybeDecrypt(value, key);
-    // Legacy specVersion 1 runs stored data as plain JSON arrays (not binary).
-    // These pass through maybeDecrypt unchanged and are deserialized directly
-    // via devalue's unflatten().
-    if (!(decrypted instanceof Uint8Array)) {
-        return unflatten(decrypted, {
-            ...getWorkflowRevivers(global),
+    const compressionStats = {};
+    const inflated = await decompress(await maybeDecrypt(value, key), compressionStats);
+    await recordCompression(compressionStats, 'deserialize');
+    return workflowModule.deserialize(inflated, {
+        global,
+        extraRevivers: {
+            ...getStreamAndRequestRevivers(getWorkflowRevivers(global)),
             ...extraRevivers,
+        },
+    });
+}
+/**
+ * Dehydrate workflow return value for storage.
+ */
+export async function dehydrateWorkflowReturnValue(value, _runId, key, global = globalThis, v1Compat = false, compression = false) {
+    if (v1Compat) {
+        const str = stringify(value, getWorkflowReducers(global));
+        return revive(str);
+    }
+    try {
+        const compressionStats = {};
+        const result = await stepModule.serialize(value, key, {
+            global,
+            extraReducers: getStreamAndRequestReducers(getWorkflowReducers(global)),
+            compression,
+            compressionStats,
         });
+        await recordCompression(compressionStats, 'serialize');
+        return result;
     }
-    const { format, payload } = decodeFormatPrefix(decrypted);
-    if (format === SerializationFormat.DEVALUE_V1) {
-        const str = new TextDecoder().decode(payload);
-        const obj = parse(str, {
-            ...getWorkflowRevivers(global),
+    catch (error) {
+        const cause = unwrapSerializationCause(error);
+        const { message, hint } = formatSerializationError('workflow return value', cause);
+        throw new SerializationError(message, { hint, cause });
+    }
+}
+/**
+ * Called from the client side to hydrate the workflow return value
+ * of a completed workflow run.
+ */
+export async function hydrateWorkflowReturnValue(value, runId, key, ops = [], global = globalThis, extraRevivers = {}) {
+    const compressionStats = {};
+    const result = await clientModule.deserialize(value, key, {
+        global,
+        extraRevivers: {
+            ...getStreamAndRequestRevivers(getExternalRevivers(global, ops, runId, key)),
             ...extraRevivers,
+        },
+        compressionStats,
+    });
+    await recordCompression(compressionStats, 'deserialize');
+    return result;
+}
+/**
+ * Called from the workflow handler when a step is being created.
+ * Dehydrates values from within the workflow execution environment.
+ */
+export async function dehydrateStepArguments(value, _runId, key, global = globalThis, v1Compat = false, compression = false) {
+    if (v1Compat) {
+        const str = stringify(value, getWorkflowReducers(global));
+        return revive(str);
+    }
+    try {
+        const compressionStats = {};
+        const result = await stepModule.serialize(value, key, {
+            global,
+            extraReducers: getStreamAndRequestReducers(getWorkflowReducers(global)),
+            compression,
+            compressionStats,
         });
-        return obj;
+        await recordCompression(compressionStats, 'serialize');
+        return result;
+    }
+    catch (error) {
+        const cause = unwrapSerializationCause(error);
+        const { message, hint } = formatSerializationError('step arguments', cause);
+        throw new SerializationError(message, { hint, cause });
     }
-    throw new Error(`Unsupported serialization format: ${format}`);
 }
 /**
- * Dehydrate workflow return value for storage.
+ * Called from the step handler to hydrate the arguments of a step
+ * from the database at the start of the step execution.
+ */
+export async function hydrateStepArguments(value, runId, key, ops = [], global = globalThis, extraRevivers = {}, deploymentId) {
+    const compressionStats = {};
+    const result = await stepModule.deserialize(value, key, {
+        global,
+        extraRevivers: {
+            ...getStreamAndRequestRevivers(getStepRevivers(global, ops, runId, key, deploymentId)),
+            ...extraRevivers,
+        },
+        compressionStats,
+    });
+    await recordCompression(compressionStats, 'deserialize');
+    return result;
+}
+/**
+ * Called from the step handler when a step has completed.
+ * Dehydrates values from within the step execution environment
+ * into a format that can be saved to the database.
  *
  * @param value - The value to serialize
  * @param runId - Run ID for encryption context
  * @param key - Encryption key (undefined to skip encryption)
+ * @param ops - Promise array for stream operations
  * @param global - Global object for serialization context
+ * @param v1Compat - Enable legacy v1 compatibility mode
+ * @param framedByteStreams - Whether the target run can decode wire-framed
+ *   byte streams. Should match the target deployment's capability — see
+ *   `getRunCapabilities` in `capabilities.ts`. Defaults to `false` for
+ *   backwards compatibility with older runs.
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export async function dehydrateWorkflowReturnValue(value, _runId, key, global = globalThis, v1Compat = false) {
+export async function dehydrateStepReturnValue(value, runId, key, ops = [], global = globalThis, v1Compat = false, framedByteStreams = false, compression = false, 
+// Turbo optimistic start: order the first chunk of a returned stream after
+// the backgrounded `run_started`. Threaded into the step reducers' stream
+// sink. Undefined outside turbo / on the await path.
+runReadyBarrier) {
+    if (v1Compat) {
+        const str = stringify(value, getStepReducers(global, ops, runId, key, framedByteStreams, runReadyBarrier));
+        return revive(str);
+    }
     try {
-        const str = stringify(value, getWorkflowReducers(global));
-        if (v1Compat) {
-            return revive(str);
-        }
+        const compressionStats = {};
+        const result = await stepModule.serialize(value, key, {
+            global,
+            extraReducers: getStreamAndRequestReducers(getStepReducers(global, ops, runId, key, framedByteStreams, runReadyBarrier)),
+            compression,
+            compressionStats,
+        });
+        await recordCompression(compressionStats, 'serialize');
+        return result;
+    }
+    catch (error) {
+        const cause = unwrapSerializationCause(error);
+        const { message, hint } = formatSerializationError('step return value', cause);
+        throw new SerializationError(message, { hint, cause });
+    }
+}
+/**
+ * Called from the step handler when a step throws. Dehydrates the thrown
+ * value from within the step execution environment into a format that can
+ * be saved to the database in a `step_failed` or `step_retrying` event.
+ *
+ * Any JavaScript value can be thrown (strings, numbers, objects, Errors,
+ * Error subclasses), so the same serialization pipeline used for step
+ * arguments and return values is applied here.
+ *
+ * @param value - The thrown value to serialize (can be any type)
+ * @param runId - Run ID for encryption context
+ * @param key - Encryption key (undefined to skip encryption)
+ * @param ops - Promise array for stream operations
+ * @param global - Global object for serialization context
+ * @returns The dehydrated value as binary data (Uint8Array) with format prefix
+ */
+export async function dehydrateStepError(value, runId, key, ops = [], global = globalThis, compression = false) {
+    try {
+        const str = stringify(value, getStepReducers(global, ops, runId, key));
         const payload = new TextEncoder().encode(str);
         const serialized = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
-        // Encrypt if world supports encryption
-        return maybeEncrypt(serialized, key);
+        // Compress before encrypting — encrypted bytes don't compress.
+        const compressionStats = {};
+        const compressed = await compress(serialized, compression, compressionStats);
+        const encrypted = (await maybeEncrypt(compressed, key));
+        await recordCompression(compressionStats, 'serialize');
+        return encrypted;
     }
     catch (error) {
-        throw new WorkflowRuntimeError(formatSerializationError('workflow return value', error), { slug: 'serialization-failed', cause: error });
+        const cause = unwrapSerializationCause(error);
+        const { message, hint } = formatSerializationError('step error', cause);
+        throw new SerializationError(message, { hint, cause });
     }
 }
 /**
- * Called from the client side (i.e. the execution environment where
- * the workflow run was initiated from) to hydrate the workflow
- * return value of a completed workflow run.
+ * Called from the workflow handler when replaying the event log of a
+ * `step_failed` or `step_retrying` event. Hydrates the thrown value from
+ * the database so the workflow can see the original thrown value.
  *
  * @param value - Binary serialized data (Uint8Array) with format prefix
  * @param runId - Run ID for decryption context
  * @param key - Encryption key (undefined to skip decryption)
- * @param ops - Promise array for stream operations
  * @param global - Global object for deserialization context
  * @param extraRevivers - Additional revivers for custom types
- * @returns The hydrated return value, ready to be consumed by the client
+ * @returns The hydrated thrown value, ready to reject the step promise
  */
-export async function hydrateWorkflowReturnValue(value, runId, key, ops = [], global = globalThis, extraRevivers = {}) {
-    // Decrypt if needed
-    const decrypted = await maybeDecrypt(value, key);
-    // Legacy specVersion 1 runs stored data as plain JSON arrays (not binary).
-    // These pass through maybeDecrypt unchanged and are deserialized directly
-    // via devalue's unflatten().
+export async function hydrateStepError(value, _runId, key, global = globalThis, extraRevivers = {}) {
+    const compressionStats = {};
+    const decrypted = await decompress(await maybeDecrypt(value, key), compressionStats);
+    await recordCompression(compressionStats, 'deserialize');
     if (!(decrypted instanceof Uint8Array)) {
+        // Treated as a devalue "flattened" array. In production this branch is
+        // exercised by legacy code paths that bypassed `dehydrateStepError`; the
+        // SDK version is pinned per workflow run via skew protection, so a
+        // current-version producer always emits a Uint8Array here. If a
+        // misshapen value reaches us, `unflatten` throws — that's intentional:
+        // the higher-level hydration helpers (`hydrateStepIO`,
+        // `hydrateResourceIO`) already wrap us in a try/catch that leaves the
+        // field un-hydrated for o11y display, and surfacing the throw to logs
+        // is more debuggable than silently masking the unsupported shape.
         return unflatten(decrypted, {
-            ...getExternalRevivers(global, ops, runId, key),
+            ...getWorkflowRevivers(global),
             ...extraRevivers,
         });
     }
     const { format, payload } = decodeFormatPrefix(decrypted);
     if (format === SerializationFormat.DEVALUE_V1) {
         const str = new TextDecoder().decode(payload);
-        const obj = parse(str, {
-            ...getExternalRevivers(global, ops, runId, key),
+        return parse(str, {
+            ...getWorkflowRevivers(global),
             ...extraRevivers,
         });
-        return obj;
     }
     throw new Error(`Unsupported serialization format: ${format}`);
 }
 /**
- * Called from the workflow handler when a step is being created.
- * Dehydrates values from within the workflow execution environment
- * into a format that can be saved to the database.
+ * Called from the workflow handler when the workflow itself throws.
+ * Dehydrates the thrown value from within the workflow execution environment
+ * into a format that can be saved to the database in a `run_failed` event.
  *
- * @param value - The value to serialize
+ * @param value - The thrown value to serialize (can be any type)
  * @param runId - Run ID for encryption context
  * @param key - Encryption key (undefined to skip encryption)
  * @param global - Global object for serialization context
- * @param v1Compat - Enable legacy v1 compatibility mode
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export async function dehydrateStepArguments(value, _runId, key, global = globalThis, v1Compat = false) {
+export async function dehydrateRunError(value, _runId, key, global = globalThis, compression = false) {
     try {
         const str = stringify(value, getWorkflowReducers(global));
-        if (v1Compat) {
-            return revive(str);
-        }
         const payload = new TextEncoder().encode(str);
         const serialized = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
-        // Encrypt if world supports encryption
-        return maybeEncrypt(serialized, key);
+        // Compress before encrypting — encrypted bytes don't compress.
+        const compressionStats = {};
+        const compressed = await compress(serialized, compression, compressionStats);
+        const encrypted = (await maybeEncrypt(compressed, key));
+        await recordCompression(compressionStats, 'serialize');
+        return encrypted;
     }
     catch (error) {
-        throw new WorkflowRuntimeError(formatSerializationError('step arguments', error), { slug: 'serialization-failed', cause: error });
+        const cause = unwrapSerializationCause(error);
+        const { message, hint } = formatSerializationError('run error', cause);
+        throw new SerializationError(message, { hint, cause });
     }
 }
 /**
- * Called from the step handler to hydrate the arguments of a step
- * from the database at the start of the step execution.
+ * Called from the client side (or observability tools) to hydrate the run
+ * error value of a failed workflow run.
  *
  * @param value - Binary serialized data (Uint8Array) with format prefix
  * @param runId - Run ID for decryption context
@@ -1413,59 +2322,33 @@ export async function dehydrateStepArguments(value, _runId, key, global = global
  * @param ops - Promise array for stream operations
  * @param global - Global object for deserialization context
  * @param extraRevivers - Additional revivers for custom types
- * @returns The hydrated value, ready to be consumed by the step user-code function
+ * @returns The hydrated thrown value, ready to be consumed by the client
  */
-export async function hydrateStepArguments(value, runId, key, ops = [], global = globalThis, extraRevivers = {}) {
-    // Decrypt if needed
-    const decrypted = await maybeDecrypt(value, key);
-    // Legacy specVersion 1 runs stored data as plain JSON arrays (not binary).
-    // These pass through maybeDecrypt unchanged and are deserialized directly
-    // via devalue's unflatten().
+export async function hydrateRunError(value, runId, key, ops = [], global = globalThis, extraRevivers = {}) {
+    const compressionStats = {};
+    const decrypted = await decompress(await maybeDecrypt(value, key), compressionStats);
+    await recordCompression(compressionStats, 'deserialize');
     if (!(decrypted instanceof Uint8Array)) {
+        // See the matching note in `hydrateStepError`: this branch is for
+        // devalue flattened arrays from legacy callers; current SDK versions
+        // always emit a Uint8Array, and a misshapen value here intentionally
+        // throws via `unflatten` so the surrounding try/catch in o11y helpers
+        // surfaces the issue rather than masking it.
         return unflatten(decrypted, {
-            ...getStepRevivers(global, ops, runId, key),
+            ...getExternalRevivers(global, ops, runId, key),
             ...extraRevivers,
         });
     }
     const { format, payload } = decodeFormatPrefix(decrypted);
     if (format === SerializationFormat.DEVALUE_V1) {
         const str = new TextDecoder().decode(payload);
-        const obj = parse(str, {
-            ...getStepRevivers(global, ops, runId, key),
+        return parse(str, {
+            ...getExternalRevivers(global, ops, runId, key),
             ...extraRevivers,
         });
-        return obj;
     }
     throw new Error(`Unsupported serialization format: ${format}`);
 }
-/**
- * Called from the step handler when a step has completed.
- * Dehydrates values from within the step execution environment
- * into a format that can be saved to the database.
- *
- * @param value - The value to serialize
- * @param runId - Run ID for encryption context
- * @param key - Encryption key (undefined to skip encryption)
- * @param ops - Promise array for stream operations
- * @param global - Global object for serialization context
- * @param v1Compat - Enable legacy v1 compatibility mode
- * @returns The dehydrated value as binary data (Uint8Array) with format prefix
- */
-export async function dehydrateStepReturnValue(value, runId, key, ops = [], global = globalThis, v1Compat = false) {
-    try {
-        const str = stringify(value, getStepReducers(global, ops, runId, key));
-        if (v1Compat) {
-            return revive(str);
-        }
-        const payload = new TextEncoder().encode(str);
-        const serialized = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
-        // Encrypt if world supports encryption
-        return maybeEncrypt(serialized, key);
-    }
-    catch (error) {
-        throw new WorkflowRuntimeError(formatSerializationError('step return value', error), { slug: 'serialization-failed', cause: error });
-    }
-}
 /**
  * Called from the workflow handler when replaying the event log of a `step_completed` event.
  * Hydrates the return value of a step from the database.
@@ -1475,28 +2358,56 @@ export async function dehydrateStepReturnValue(value, runId, key, ops = [], glob
  * @param key - Encryption key (undefined to skip decryption)
  * @param global - Global object for deserialization context
  * @param extraRevivers - Additional revivers for custom types
- * @returns The hydrated return value of a step, ready to be consumed by the workflow handler
+ * Called from the workflow handler when replaying the event log
+ * of a `step_completed` event.
  */
 export async function hydrateStepReturnValue(value, _runId, key, global = globalThis, extraRevivers = {}) {
-    // Decrypt if needed
-    const decrypted = await maybeDecrypt(value, key);
-    // Legacy specVersion 1 runs stored data as plain JSON arrays (not binary).
-    // These pass through maybeDecrypt unchanged and are deserialized directly
-    // via devalue's unflatten().
-    if (!(decrypted instanceof Uint8Array)) {
-        return unflatten(decrypted, {
-            ...getWorkflowRevivers(global),
+    const compressionStats = {};
+    const inflated = await decompress(await maybeDecrypt(value, key), compressionStats);
+    await recordCompression(compressionStats, 'deserialize');
+    return workflowModule.deserialize(inflated, {
+        global,
+        extraRevivers: {
+            ...getStreamAndRequestRevivers(getWorkflowRevivers(global)),
             ...extraRevivers,
-        });
+        },
+    });
+}
+// ---- Helpers to extract stream/Request/Response reducers and revivers ----
+// The mode-specific get*Reducers/get*Revivers functions return objects that
+// include both "common" entries (Date, Error, Map, etc.) and mode-specific
+// entries (ReadableStream, WritableStream, Request, Response, StepFunction).
+// The common entries are already composed by the codec. We only need to
+// pass through the mode-specific entries as extraReducers/extraRevivers.
+const STREAM_AND_REQUEST_KEYS = [
+    'ReadableStream',
+    'WritableStream',
+    'Request',
+    'Response',
+    'StepFunction',
+    // Wire AbortController/AbortSignal through the client serialization path so
+    // signals reachable via Request.signal (or as direct arguments) get their
+    // dedicated reducer. Without this, devalue falls back to its arbitrary-POJO
+    // path and fails for any signal the Request reducer forwards.
+    'AbortController',
+    'AbortSignal',
+];
+function getStreamAndRequestReducers(allReducers) {
+    const extra = {};
+    for (const key of STREAM_AND_REQUEST_KEYS) {
+        if (key in allReducers) {
+            extra[key] = allReducers[key];
+        }
     }
-    const { format, payload } = decodeFormatPrefix(decrypted);
-    if (format === SerializationFormat.DEVALUE_V1) {
-        const str = new TextDecoder().decode(payload);
-        return parse(str, {
-            ...getWorkflowRevivers(global),
-            ...extraRevivers,
-        });
+    return extra;
+}
+function getStreamAndRequestRevivers(allRevivers) {
+    const extra = {};
+    for (const key of STREAM_AND_REQUEST_KEYS) {
+        if (key in allRevivers) {
+            extra[key] = allRevivers[key];
+        }
     }
-    throw new Error(`Unsupported serialization format: ${format}`);
+    return extra;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serialization.js","sourceRoot":"","sources":["../src/serialization.ts"],"names":[],"mappings":"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","sourcesContent":["import { types } from 'node:util';\nimport { WorkflowRuntimeError } from '@workflow/errors';\nimport { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';\nimport { DevalueError, parse, stringify, unflatten } from 'devalue';\nimport { monotonicFactory } from 'ulid';\nimport { getSerializationClass } from './class-serialization.js';\nimport {\n  decrypt as aesGcmDecrypt,\n  encrypt as aesGcmEncrypt,\n  type CryptoKey,\n} from './encryption.js';\n\n/**\n * Encryption key parameter type. Accepts a resolved key, undefined (no encryption),\n * or a promise that resolves to either. This allows synchronous function signatures\n * (e.g., getReadable()) to thread the key through without awaiting it — the promise\n * is resolved lazily inside the first async transform() call.\n */\nexport type EncryptionKeyParam =\n  | CryptoKey\n  | undefined\n  | Promise<CryptoKey | undefined>;\n\nimport {\n  createFlushableState,\n  flushablePipe,\n  pollReadableLock,\n  pollWritableLock,\n} from './flushable-stream.js';\nimport { runtimeLogger } from './logger.js';\nimport { getStepFunction } from './private.js';\nimport { getWorld } from './runtime/world.js';\nimport { contextStorage } from './step/context-storage.js';\nimport {\n  BODY_INIT_SYMBOL,\n  STABLE_ULID,\n  STREAM_NAME_SYMBOL,\n  STREAM_TYPE_SYMBOL,\n  WEBHOOK_RESPONSE_WRITABLE,\n} from './symbols.js';\n\n// ============================================================================\n// Serialization Format Prefix System\n// ============================================================================\n//\n// All serialized payloads are prefixed with a 4-byte format identifier that\n// allows the client to determine how to decode the payload. This enables:\n//\n// 1. Self-describing payloads - The World layer is agnostic to serialization format\n// 2. Gradual migration - Old runs keep working, new runs can use new formats\n// 3. Composability - Encryption can wrap any format (e.g., \"encr\" wrapping \"devl\")\n// 4. Debugging - Raw data inspection immediately reveals the format\n//\n// Format: [4 bytes: format identifier][payload]\n//\n// The 4-character prefix convention matches other workflow IDs (wrun, step, wait, etc.)\n//\n// Current formats:\n// - \"devl\" - devalue stringify/parse with TextEncoder/TextDecoder (current default)\n// - \"encr\" - Encrypted payload (inner payload has its own format prefix)\n//\n// Future formats (reserved):\n// - \"cbor\" - CBOR binary serialization\n\n/**\n * Known serialization format identifiers.\n * Each format ID is exactly 4 ASCII characters, matching the convention\n * used for other workflow IDs (wrun, step, wait, etc.)\n */\nexport const SerializationFormat = {\n  /** devalue stringify/parse with TextEncoder/TextDecoder */\n  DEVALUE_V1: 'devl',\n  /** Encrypted payload (inner payload has its own format prefix) */\n  ENCRYPTED: 'encr',\n} as const;\n\nexport type SerializationFormatType =\n  (typeof SerializationFormat)[keyof typeof SerializationFormat];\n\n/** Length of the format prefix in bytes */\nconst FORMAT_PREFIX_LENGTH = 4;\n\n/** TextEncoder instance for format prefix encoding */\nconst formatEncoder = new TextEncoder();\n\n/** TextDecoder instance for format prefix decoding */\nconst formatDecoder = new TextDecoder();\n\n/**\n * Encode a payload with a format prefix.\n *\n * @param format - The format identifier (must be exactly 4 ASCII characters)\n * @param payload - The serialized payload bytes\n * @returns A new Uint8Array with format prefix prepended\n */\nexport function encodeWithFormatPrefix(\n  format: SerializationFormatType,\n  payload: Uint8Array | unknown\n): Uint8Array | unknown {\n  if (!(payload instanceof Uint8Array)) {\n    return payload;\n  }\n\n  const prefixBytes = formatEncoder.encode(format);\n  if (prefixBytes.length !== FORMAT_PREFIX_LENGTH) {\n    throw new Error(\n      `Format identifier must be exactly ${FORMAT_PREFIX_LENGTH} ASCII characters, got \"${format}\" (${prefixBytes.length} bytes)`\n    );\n  }\n\n  const result = new Uint8Array(FORMAT_PREFIX_LENGTH + payload.length);\n  result.set(prefixBytes, 0);\n  result.set(payload, FORMAT_PREFIX_LENGTH);\n  return result;\n}\n\n/**\n * Peek at the format prefix without consuming it.\n * Useful for checking if data is encrypted before deciding how to process it.\n *\n * @param data - The format-prefixed data\n * @returns The format identifier, or null if data is legacy/non-binary\n */\nexport function peekFormatPrefix(\n  data: Uint8Array | unknown\n): SerializationFormatType | null {\n  if (!(data instanceof Uint8Array) || data.length < FORMAT_PREFIX_LENGTH) {\n    return null;\n  }\n  const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);\n  const format = formatDecoder.decode(prefixBytes);\n  const knownFormats = Object.values(SerializationFormat) as string[];\n  if (!knownFormats.includes(format)) {\n    return null;\n  }\n  return format as SerializationFormatType;\n}\n\n/**\n * Check if data is encrypted (has 'encr' format prefix).\n *\n * @param data - The format-prefixed data\n * @returns true if data has the encrypted format prefix\n */\nexport function isEncrypted(data: Uint8Array | unknown): boolean {\n  return peekFormatPrefix(data) === SerializationFormat.ENCRYPTED;\n}\n\n/**\n * Decode a format-prefixed payload.\n *\n * @param data - The format-prefixed data\n * @returns An object with the format identifier and payload\n * @throws Error if the data is too short or has an unknown format\n */\nexport function decodeFormatPrefix(data: Uint8Array | unknown): {\n  format: SerializationFormatType;\n  payload: Uint8Array;\n} {\n  // Compat for legacy specVersion 1 runs that don't have a format prefix,\n  // and don't have a binary payload\n  if (!(data instanceof Uint8Array)) {\n    return {\n      format: SerializationFormat.DEVALUE_V1,\n      payload: new TextEncoder().encode(JSON.stringify(data)),\n    };\n  }\n\n  if (data.length < FORMAT_PREFIX_LENGTH) {\n    throw new Error(\n      `Data too short to contain format prefix: expected at least ${FORMAT_PREFIX_LENGTH} bytes, got ${data.length}`\n    );\n  }\n\n  const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);\n  const format = formatDecoder.decode(prefixBytes);\n\n  // Validate the format is known\n  const knownFormats = Object.values(SerializationFormat) as string[];\n  if (!knownFormats.includes(format)) {\n    throw new WorkflowRuntimeError(\n      `Unknown serialization format: \"${format}\". Known formats: ${knownFormats.join(', ')}`\n    );\n  }\n\n  const payload = data.subarray(FORMAT_PREFIX_LENGTH);\n  return { format: format as SerializationFormatType, payload };\n}\n\n/**\n * Default ULID generator for contexts where VM's seeded `stableUlid` isn't available.\n * Used as a fallback when serializing streams outside the workflow VM context\n * (e.g., when starting a workflow or handling step return values).\n */\nconst defaultUlid = monotonicFactory();\n\n/**\n * Format a serialization error with context about what failed.\n * Extracts path, value, and reason from devalue's DevalueError when available.\n * Logs the problematic value to the console for better debugging.\n */\nfunction formatSerializationError(context: string, error: unknown): string {\n  // Use \"returning\" for return values, \"passing\" for arguments/inputs\n  const verb = context.includes('return value') ? 'returning' : 'passing';\n\n  // Build the error message with path info if available from DevalueError\n  let message = `Failed to serialize ${context}`;\n  if (error instanceof DevalueError && error.path) {\n    message += ` at path \"${error.path}\"`;\n  }\n  message += `. Ensure you're ${verb} serializable types (plain objects, arrays, primitives, Date, RegExp, Map, Set).`;\n\n  // Log the problematic value for debugging\n  if (error instanceof DevalueError && error.value !== undefined) {\n    runtimeLogger.error('Serialization failed', {\n      context,\n      problematicValue: error.value,\n    });\n  }\n\n  return message;\n}\n\n/**\n * Detect if a readable stream is a byte stream.\n *\n * @param stream\n * @returns `\"bytes\"` if the stream is a byte stream, `undefined` otherwise\n */\nexport function getStreamType(stream: ReadableStream): 'bytes' | undefined {\n  try {\n    const reader = stream.getReader({ mode: 'byob' });\n    reader.releaseLock();\n    return 'bytes';\n  } catch {}\n}\n\n/**\n * Frame format for stream chunks:\n *   [4-byte big-endian length][format-prefixed payload]\n *\n * Each chunk is independently framed so the deserializer can find\n * chunk boundaries even when multiple chunks are concatenated or\n * split across transport reads.\n */\nconst FRAME_HEADER_SIZE = 4;\n\nexport function getSerializeStream(\n  reducers: Reducers,\n  cryptoKey: EncryptionKeyParam\n): TransformStream<any, Uint8Array> {\n  const encoder = new TextEncoder();\n  // Resolve the key promise once on first use and cache the result.\n  // Note: if the cryptoKey promise rejects (e.g., network error fetching\n  // the derived key), the rejection won't surface until the first chunk\n  // is processed — not at stream construction time.\n  const keyState = { resolved: false, key: undefined as CryptoKey | undefined };\n  const stream = new TransformStream<any, Uint8Array>({\n    async transform(chunk, controller) {\n      try {\n        if (!keyState.resolved) {\n          keyState.key = await cryptoKey;\n          keyState.resolved = true;\n        }\n        const serialized = stringify(chunk, reducers);\n        const payload = encoder.encode(serialized);\n        let prefixed = encodeWithFormatPrefix(\n          SerializationFormat.DEVALUE_V1,\n          payload\n        ) as Uint8Array;\n\n        // Encrypt the frame payload if a key is provided.\n        // The length header remains in the clear so the deserializer can\n        // find frame boundaries regardless of transport chunking.\n        if (keyState.key) {\n          const encrypted = await aesGcmEncrypt(keyState.key, prefixed);\n          prefixed = encodeWithFormatPrefix(\n            SerializationFormat.ENCRYPTED,\n            encrypted\n          ) as Uint8Array;\n        }\n\n        // Write length-prefixed frame: [4-byte length][prefixed data]\n        const frame = new Uint8Array(FRAME_HEADER_SIZE + prefixed.length);\n        new DataView(frame.buffer).setUint32(0, prefixed.length, false);\n        frame.set(prefixed, FRAME_HEADER_SIZE);\n        controller.enqueue(frame);\n      } catch (error) {\n        controller.error(\n          new WorkflowRuntimeError(\n            formatSerializationError('stream chunk', error),\n            { slug: 'serialization-failed', cause: error }\n          )\n        );\n      }\n    },\n  });\n  return stream;\n}\n\nexport function getDeserializeStream(\n  revivers: Revivers,\n  cryptoKey: EncryptionKeyParam\n): TransformStream<Uint8Array, any> {\n  const decoder = new TextDecoder();\n  let buffer = new Uint8Array(0);\n  // Resolve the key promise once on first use and cache the result.\n  const keyState = { resolved: false, key: undefined as CryptoKey | undefined };\n\n  function appendToBuffer(data: Uint8Array) {\n    const newBuffer = new Uint8Array(buffer.length + data.length);\n    newBuffer.set(buffer, 0);\n    newBuffer.set(data, buffer.length);\n    buffer = newBuffer;\n  }\n\n  async function processFrames(\n    controller: TransformStreamDefaultController<any>\n  ) {\n    // Resolve the key promise once on first use and cache the result\n    if (!keyState.resolved) {\n      keyState.key = await cryptoKey;\n      keyState.resolved = true;\n    }\n\n    // Try to extract complete length-prefixed frames\n    while (buffer.length >= FRAME_HEADER_SIZE) {\n      const frameLength = new DataView(\n        buffer.buffer,\n        buffer.byteOffset,\n        buffer.byteLength\n      ).getUint32(0, false);\n\n      if (buffer.length < FRAME_HEADER_SIZE + frameLength) {\n        break; // Incomplete frame, wait for more data\n      }\n\n      const frameData = buffer.slice(\n        FRAME_HEADER_SIZE,\n        FRAME_HEADER_SIZE + frameLength\n      );\n      buffer = buffer.slice(FRAME_HEADER_SIZE + frameLength);\n\n      let { format, payload } = decodeFormatPrefix(frameData);\n\n      // If the frame payload is encrypted, decrypt it first to reveal\n      // the inner format-prefixed data (e.g., 'devl' + serialized text),\n      // then fall through to the normal deserialization path.\n      if (format === SerializationFormat.ENCRYPTED) {\n        if (!keyState.key) {\n          controller.error(\n            new WorkflowRuntimeError(\n              'Encrypted stream data encountered but no encryption key is available. ' +\n                'Encryption is not configured or no key was provided for this run.'\n            )\n          );\n          return;\n        }\n        const decrypted = await aesGcmDecrypt(keyState.key, payload);\n        ({ format, payload } = decodeFormatPrefix(decrypted));\n      }\n\n      if (format === SerializationFormat.DEVALUE_V1) {\n        const text = decoder.decode(payload);\n        controller.enqueue(parse(text, revivers));\n      }\n    }\n  }\n\n  const stream = new TransformStream<Uint8Array, any>({\n    async transform(chunk, controller) {\n      // First, try to detect if this is length-prefixed framed data\n      // by checking if the first 4 bytes form a plausible length.\n      if (buffer.length === 0 && chunk.length >= FRAME_HEADER_SIZE) {\n        const possibleLength = new DataView(\n          chunk.buffer,\n          chunk.byteOffset,\n          chunk.byteLength\n        ).getUint32(0, false);\n        if (\n          possibleLength > 0 &&\n          possibleLength < 100_000_000 // sanity check: < 100MB\n        ) {\n          // Looks like framed data\n          appendToBuffer(chunk);\n          await processFrames(controller);\n          return;\n        }\n      } else if (buffer.length > 0) {\n        // Already in framed mode (have buffered data)\n        appendToBuffer(chunk);\n        await processFrames(controller);\n        return;\n      }\n\n      // Legacy format: newline-delimited devalue text (no framing)\n      const text = decoder.decode(chunk);\n      const lines = text.split('\\n');\n      for (const line of lines) {\n        if (line.length > 0) {\n          controller.enqueue(parse(line, revivers));\n        }\n      }\n    },\n    async flush(controller) {\n      // Process any remaining framed data\n      if (buffer.length > 0) {\n        await processFrames(controller);\n      }\n    },\n  });\n  return stream;\n}\n\nexport class WorkflowServerReadableStream extends ReadableStream<Uint8Array> {\n  #reader?: ReadableStreamDefaultReader<Uint8Array>;\n\n  constructor(runId: string, name: string, startIndex?: number) {\n    if (typeof name !== 'string' || name.length === 0) {\n      throw new Error(`\"name\" is required, got \"${name}\"`);\n    }\n    super({\n      // @ts-expect-error Not sure why TypeScript is complaining about this\n      type: 'bytes',\n\n      pull: async (controller) => {\n        let reader = this.#reader;\n        if (!reader) {\n          const world = await getWorld();\n          const stream = await world.streams.get(runId, name, startIndex);\n          reader = this.#reader = stream.getReader();\n        }\n        if (!reader) {\n          controller.error(new Error('Failed to get reader'));\n          return;\n        }\n\n        const result = await reader.read();\n        if (result.done) {\n          this.#reader = undefined;\n          controller.close();\n        } else {\n          // Forward raw bytes; encryption/decryption is handled at the\n          // framing level by getSerializeStream/getDeserializeStream.\n          controller.enqueue(result.value);\n        }\n      },\n      cancel: async (reason) => {\n        if (this.#reader) {\n          await this.#reader.cancel(reason).catch(() => {});\n          this.#reader = undefined;\n        }\n      },\n    });\n  }\n}\n\n/**\n * Default flush interval in milliseconds for buffered stream writes.\n * Chunks are accumulated and flushed together to reduce network overhead.\n */\nconst STREAM_FLUSH_INTERVAL_MS = 10;\n\nexport class WorkflowServerWritableStream extends WritableStream<Uint8Array> {\n  constructor(runId: string, name: string) {\n    if (typeof runId !== 'string') {\n      throw new Error(`\"runId\" must be a string, got \"${typeof runId}\"`);\n    }\n    if (typeof name !== 'string' || name.length === 0) {\n      throw new Error(`\"name\" is required, got \"${name}\"`);\n    }\n    const worldPromise = getWorld();\n\n    // Buffering state for batched writes\n    // Encryption/decryption is handled at the framing level by\n    // getSerializeStream/getDeserializeStream, not here.\n    let buffer: Uint8Array[] = [];\n    let flushTimer: ReturnType<typeof setTimeout> | null = null;\n    let flushPromise: Promise<void> | null = null;\n    let resolvedFlushIntervalMs: number | undefined;\n\n    const flush = async (): Promise<void> => {\n      if (flushTimer) {\n        clearTimeout(flushTimer);\n        flushTimer = null;\n      }\n\n      if (buffer.length === 0) return;\n\n      // Copy chunks to flush, but don't clear buffer until write succeeds\n      // This prevents data loss if the write operation fails\n      const chunksToFlush = buffer.slice();\n\n      const world = await worldPromise;\n      // Cache the flush interval from the world on first use\n      if (resolvedFlushIntervalMs === undefined) {\n        resolvedFlushIntervalMs =\n          world.streamFlushIntervalMs ?? STREAM_FLUSH_INTERVAL_MS;\n      }\n      // Use writeMulti if available for batch writes\n      if (\n        typeof world.streams.writeMulti === 'function' &&\n        chunksToFlush.length > 1\n      ) {\n        await world.streams.writeMulti(runId, name, chunksToFlush);\n      } else {\n        // Fall back to sequential writes\n        for (const chunk of chunksToFlush) {\n          await world.streams.write(runId, name, chunk);\n        }\n      }\n\n      // Only clear buffer after successful write to prevent data loss\n      buffer = [];\n    };\n\n    /** Resolvers/rejectors waiting for the current scheduled flush */\n    let flushWaiters: Array<{\n      resolve: () => void;\n      reject: (err: unknown) => void;\n    }> = [];\n\n    const scheduleFlush = (): void => {\n      if (flushTimer) return; // Already scheduled\n\n      flushTimer = setTimeout(() => {\n        flushTimer = null;\n        const currentWaiters = flushWaiters;\n        flushWaiters = [];\n        flushPromise = flush().then(\n          () => {\n            for (const w of currentWaiters) w.resolve();\n          },\n          (err) => {\n            for (const w of currentWaiters) w.reject(err);\n          }\n        );\n      }, resolvedFlushIntervalMs ?? STREAM_FLUSH_INTERVAL_MS);\n    };\n\n    super({\n      async write(chunk) {\n        // Wait for any in-progress flush to complete before adding to buffer\n        if (flushPromise) {\n          await flushPromise;\n          flushPromise = null;\n        }\n\n        buffer.push(chunk);\n        scheduleFlush();\n\n        // Wait for the scheduled flush to complete so that callers\n        // (like flushablePipe) know data has reached the server\n        // before decrementing pendingOps. Without this, pendingOps\n        // reaches 0 when the buffered write returns (instant), but\n        // the 10ms flush timer hasn't fired yet.\n        await new Promise<void>((resolve, reject) => {\n          flushWaiters.push({ resolve, reject });\n        });\n      },\n      async close() {\n        // Wait for any in-progress flush to complete\n        if (flushPromise) {\n          await flushPromise;\n          flushPromise = null;\n        }\n\n        // Flush any remaining buffered chunks\n        await flush();\n\n        const world = await worldPromise;\n        await world.streams.close(runId, name);\n      },\n      abort(reason) {\n        // Clean up timer to prevent leaks\n        if (flushTimer) {\n          clearTimeout(flushTimer);\n          flushTimer = null;\n        }\n        // Discard buffered chunks - they won't be written\n        buffer = [];\n        // Reject any pending flushWaiters so the write() promises settle\n        // and don't leak. Without this, write() hangs forever on an\n        // unsettled promise because the cleared timer will never fire.\n        const waiters = flushWaiters;\n        flushWaiters = [];\n        const abortError = reason ?? new Error('Stream aborted');\n        for (const w of waiters) w.reject(abortError);\n      },\n    });\n  }\n}\n\n// Types that need specialized handling when serialized/deserialized\n// ! If a type is added here, it MUST also be added to the `Serializable` type in `schemas.ts`\nexport interface SerializableSpecial {\n  ArrayBuffer: string; // base64 string\n  BigInt: string; // string representation of bigint\n  BigInt64Array: string; // base64 string\n  BigUint64Array: string; // base64 string\n  Date: string; // ISO string\n  DOMException: {\n    message: string;\n    name: string;\n    stack?: string;\n    cause?: unknown;\n  };\n  Float32Array: string; // base64 string\n  Float64Array: string; // base64 string\n  Error: Record<string, any>;\n  Headers: [string, string][];\n  Int8Array: string; // base64 string\n  Int16Array: string; // base64 string\n  Int32Array: string; // base64 string\n  Map: [any, any][];\n  ReadableStream:\n    | { name: string; type?: 'bytes'; startIndex?: number }\n    | { bodyInit: any };\n  RegExp: { source: string; flags: string };\n  Request: {\n    method: string;\n    url: string;\n    headers: Headers;\n    body: Request['body'];\n    duplex: Request['duplex'];\n\n    // This is specifically for the `RequestWithResponse` type which is used for webhooks\n    responseWritable?: WritableStream<Response>;\n  };\n  Response: {\n    type: Response['type'];\n    url: string;\n    status: number;\n    statusText: string;\n    headers: Headers;\n    body: Response['body'];\n    redirected: boolean;\n  };\n  Class: {\n    classId: string;\n  };\n  /**\n   * Custom serialized class instance.\n   * The class must have a `classId` property and be registered for deserialization.\n   */\n  Instance: {\n    classId: string; // Unique identifier for the class (used for lookup during deserialization)\n    data: unknown; // The serialized instance data\n  };\n  Set: any[];\n  StepFunction: {\n    stepId: string;\n    closureVars?: Record<string, any>;\n  };\n  URL: string;\n  WorkflowFunction: {\n    workflowId: string;\n  };\n  URLSearchParams: string;\n  Uint8Array: string; // base64 string\n  Uint8ClampedArray: string; // base64 string\n  Uint16Array: string; // base64 string\n  Uint32Array: string; // base64 string\n  WritableStream: { name: string };\n}\n\ntype Reducers = {\n  [K in keyof SerializableSpecial]: (\n    value: any\n  ) => SerializableSpecial[K] | false;\n};\n\ntype Revivers = {\n  [K in keyof SerializableSpecial]: (value: SerializableSpecial[K]) => any;\n};\n\nfunction revive(str: string) {\n  // devalue.stringify() always produces valid JSON: special values\n  // (undefined, NaN, Infinity, -0) are encoded as negative integer\n  // sentinels and the remaining structure is ordinary JSON. Parsing\n  // with JSON.parse yields the flattened form that unflatten() expects.\n  return JSON.parse(str);\n}\n\nfunction getCommonReducers(global: Record<string, any> = globalThis) {\n  const abToBase64 = (\n    value: ArrayBufferLike,\n    offset: number,\n    length: number\n  ) => {\n    // Avoid returning falsy value for zero-length buffers\n    if (length === 0) return '.';\n    // Create a proper copy to avoid ArrayBuffer detachment issues\n    // Buffer.from(ArrayBuffer, offset, length) creates a view, not a copy\n    const uint8 = new Uint8Array(value, offset, length);\n    return Buffer.from(uint8).toString('base64');\n  };\n  const viewToBase64 = (value: ArrayBufferView) =>\n    abToBase64(value.buffer, value.byteOffset, value.byteLength);\n\n  return {\n    ArrayBuffer: (value) =>\n      value instanceof global.ArrayBuffer &&\n      abToBase64(value, 0, value.byteLength),\n    BigInt: (value) => typeof value === 'bigint' && value.toString(),\n    BigInt64Array: (value) =>\n      value instanceof global.BigInt64Array && viewToBase64(value),\n    BigUint64Array: (value) =>\n      value instanceof global.BigUint64Array && viewToBase64(value),\n    // Class and Instance are intentionally placed before Error so that\n    // custom Error subclasses with WORKFLOW_SERIALIZE take precedence\n    // over the generic Error serialization (devalue uses first-match-wins).\n    Class: (value) => {\n      // Check if this is a class constructor with a classId property\n      // (set by the SWC plugin for classes with static step/workflow methods)\n      if (typeof value !== 'function') return false;\n      const classId = (value as any).classId;\n      if (typeof classId !== 'string') return false;\n      return { classId };\n    },\n    Instance: (value) => {\n      // Check if this is an instance of a class with custom serialization\n      if (value === null || typeof value !== 'object') return false;\n      const cls = value.constructor;\n      if (!cls || typeof cls !== 'function') return false;\n\n      // Check if the class has a static WORKFLOW_SERIALIZE method\n      const serialize = cls[WORKFLOW_SERIALIZE];\n      if (typeof serialize !== 'function') {\n        return false;\n      }\n\n      // Get the classId from the static class property (set by SWC plugin)\n      const classId = cls.classId;\n      if (typeof classId !== 'string') {\n        throw new Error(\n          `Class \"${cls.name}\" with ${String(WORKFLOW_SERIALIZE)} must have a static \"classId\" property.`\n        );\n      }\n\n      // Serialize the instance using the custom serializer\n      const data = serialize.call(cls, value);\n      return { classId, data };\n    },\n    Date: (value) => {\n      if (!(value instanceof global.Date)) return false;\n      const valid = !Number.isNaN(value.getDate());\n      // Note: \".\" is to avoid returning a falsy value when the date is invalid\n      return valid ? value.toISOString() : '.';\n    },\n    // DOMException is a special case: in Node.js it passes isNativeError()\n    // and instanceof Error, but has a unique constructor signature\n    // (message, name) and a read-only numeric `code` property derived from\n    // `name`. It must be checked before the generic Error reducer.\n    DOMException: (value) => {\n      if (!types.isNativeError(value)) return false;\n      if (value.constructor?.name !== 'DOMException') return false;\n      const reduced: SerializableSpecial['DOMException'] = {\n        message: value.message,\n        name: value.name,\n        stack: value.stack,\n      };\n      if ('cause' in value) reduced.cause = value.cause;\n      return reduced;\n    },\n    Error: (value) => {\n      // Use types.isNativeError() instead of `instanceof global.Error`\n      // because errors may originate from a different VM context (e.g.\n      // FatalError from the host context passed into a VM-context workflow).\n      // `instanceof` checks fail across VM boundaries since each context\n      // has its own Error constructor, but isNativeError() uses V8's\n      // internal type tag which works across all contexts.\n      if (!types.isNativeError(value)) return false;\n      return {\n        name: value.name,\n        message: value.message,\n        stack: value.stack,\n      };\n    },\n    Float32Array: (value) =>\n      value instanceof global.Float32Array && viewToBase64(value),\n    Float64Array: (value) =>\n      value instanceof global.Float64Array && viewToBase64(value),\n    Headers: (value) => value instanceof global.Headers && Array.from(value),\n    Int8Array: (value) =>\n      value instanceof global.Int8Array && viewToBase64(value),\n    Int16Array: (value) =>\n      value instanceof global.Int16Array && viewToBase64(value),\n    Int32Array: (value) =>\n      value instanceof global.Int32Array && viewToBase64(value),\n    Map: (value) => value instanceof global.Map && Array.from(value),\n    RegExp: (value) =>\n      value instanceof global.RegExp && {\n        source: value.source,\n        flags: value.flags,\n      },\n    Request: (value) => {\n      if (!(value instanceof global.Request)) return false;\n      const data: SerializableSpecial['Request'] = {\n        method: value.method,\n        url: value.url,\n        headers: value.headers,\n        body: value.body,\n        duplex: value.duplex,\n      };\n      const responseWritable = value[WEBHOOK_RESPONSE_WRITABLE];\n      if (responseWritable) {\n        data.responseWritable = responseWritable;\n      }\n      return data;\n    },\n    Response: (value) => {\n      if (!(value instanceof global.Response)) return false;\n      return {\n        type: value.type,\n        url: value.url,\n        status: value.status,\n        statusText: value.statusText,\n        headers: value.headers,\n        body: value.body,\n        redirected: value.redirected,\n      };\n    },\n    Set: (value) => value instanceof global.Set && Array.from(value),\n    StepFunction: (value) => {\n      if (typeof value !== 'function') return false;\n      const stepId = (value as any).stepId;\n      if (typeof stepId !== 'string') return false;\n\n      // Check if the step function has closure variables\n      const closureVarsFn = (value as any).__closureVarsFn;\n      if (closureVarsFn && typeof closureVarsFn === 'function') {\n        // Invoke the closure variables function and serialize along with stepId\n        const closureVars = closureVarsFn();\n        return { stepId, closureVars };\n      }\n\n      // No closure variables - return object with just stepId\n      return { stepId };\n    },\n    URL: (value) => value instanceof global.URL && value.href,\n    WorkflowFunction: (value) => {\n      // Only match function references with a workflowId property (set by\n      // the SWC compiler on workflow functions). Plain { workflowId } objects\n      // are NOT matched — this prevents infinite recursion since the reduced\n      // form { workflowId } is a plain object, not a function.\n      if (typeof value !== 'function') return false;\n      const workflowId = (value as any).workflowId;\n      if (typeof workflowId !== 'string') return false;\n      return { workflowId };\n    },\n    URLSearchParams: (value) => {\n      if (!(value instanceof global.URLSearchParams)) return false;\n\n      // Avoid returning a falsy value when the URLSearchParams is empty\n      if (value.size === 0) return '.';\n\n      return String(value);\n    },\n    Uint8Array: (value) =>\n      value instanceof global.Uint8Array && viewToBase64(value),\n    Uint8ClampedArray: (value) =>\n      value instanceof global.Uint8ClampedArray && viewToBase64(value),\n    Uint16Array: (value) =>\n      value instanceof global.Uint16Array && viewToBase64(value),\n    Uint32Array: (value) =>\n      value instanceof global.Uint32Array && viewToBase64(value),\n  } as const satisfies Partial<Reducers>;\n}\n\n/**\n * Reducers for serialization boundary from the client side, passing arguments\n * to the workflow handler.\n *\n * @param global\n * @param ops\n * @returns\n */\nexport function getExternalReducers(\n  global: Record<string, any> = globalThis,\n  ops: Promise<void>[],\n  runId: string,\n  cryptoKey: EncryptionKeyParam\n): Reducers {\n  return {\n    ...getCommonReducers(global),\n\n    ReadableStream: (value) => {\n      if (!(value instanceof global.ReadableStream)) return false;\n\n      // Stream must not be locked when passing across execution boundary\n      if (value.locked) {\n        throw new Error('ReadableStream is locked');\n      }\n\n      const streamId = ((global as any)[STABLE_ULID] || defaultUlid)();\n      const name = `strm_${streamId}`;\n      const type = getStreamType(value);\n\n      const writable = new WorkflowServerWritableStream(runId, name);\n      if (type === 'bytes') {\n        ops.push(value.pipeTo(writable));\n      } else {\n        ops.push(\n          value\n            .pipeThrough(\n              getSerializeStream(\n                getExternalReducers(global, ops, runId, cryptoKey),\n                cryptoKey\n              )\n            )\n            .pipeTo(writable)\n        );\n      }\n\n      const s: SerializableSpecial['ReadableStream'] = { name };\n      if (type) s.type = type;\n      return s;\n    },\n\n    WritableStream: (value) => {\n      if (!(value instanceof global.WritableStream)) return false;\n\n      const streamId = ((global as any)[STABLE_ULID] || defaultUlid)();\n      const name = `strm_${streamId}`;\n\n      const readable = new WorkflowServerReadableStream(runId, name);\n      ops.push(readable.pipeTo(value));\n\n      return { name };\n    },\n  };\n}\n\n/**\n * Reducers for serialization boundary from within the workflow execution\n * environment, passing return value to the client side and into step arguments.\n *\n * @param global\n * @returns\n */\nexport function getWorkflowReducers(\n  global: Record<string, any> = globalThis\n): Reducers {\n  return {\n    ...getCommonReducers(global),\n\n    // Readable/Writable streams from within the workflow execution environment\n    // are simply \"handles\" that can be passed around to other steps.\n    ReadableStream: (value) => {\n      if (!(value instanceof global.ReadableStream)) return false;\n\n      // Check if this is a fake stream storing BodyInit from Request/Response constructor\n      const bodyInit = value[BODY_INIT_SYMBOL];\n      if (bodyInit !== undefined) {\n        // This is a fake stream - serialize the BodyInit directly\n        // devalue will handle serializing strings, Uint8Array, etc.\n        return { bodyInit };\n      }\n\n      const name = value[STREAM_NAME_SYMBOL];\n      if (!name) {\n        throw new Error('ReadableStream `name` is not set');\n      }\n      const s: SerializableSpecial['ReadableStream'] = { name };\n      const type = value[STREAM_TYPE_SYMBOL];\n      if (type) s.type = type;\n      return s;\n    },\n    WritableStream: (value) => {\n      if (!(value instanceof global.WritableStream)) return false;\n      const name = value[STREAM_NAME_SYMBOL];\n      if (!name) {\n        throw new Error('WritableStream `name` is not set');\n      }\n      return { name };\n    },\n  };\n}\n\n/**\n * Reducers for serialization boundary from within the step execution\n * environment, passing return value to the workflow handler.\n *\n * @param global\n * @param ops\n * @param runId\n * @returns\n */\nfunction getStepReducers(\n  global: Record<string, any> = globalThis,\n  ops: Promise<void>[],\n  runId: string,\n  cryptoKey: EncryptionKeyParam\n): Reducers {\n  return {\n    ...getCommonReducers(global),\n\n    ReadableStream: (value) => {\n      if (!(value instanceof global.ReadableStream)) return false;\n\n      // Stream must not be locked when passing across execution boundary\n      if (value.locked) {\n        throw new Error('ReadableStream is locked');\n      }\n\n      // Check if the stream already has the name symbol set, in which case\n      // it's already being sunk to the server and we can just return the\n      // name and type.\n      let name = value[STREAM_NAME_SYMBOL];\n      let type = value[STREAM_TYPE_SYMBOL];\n\n      if (!name) {\n        const streamId = ((global as any)[STABLE_ULID] || defaultUlid)();\n        name = `strm_${streamId}`;\n        type = getStreamType(value);\n\n        const writable = new WorkflowServerWritableStream(runId, name);\n        if (type === 'bytes') {\n          ops.push(value.pipeTo(writable));\n        } else {\n          ops.push(\n            value\n              .pipeThrough(\n                getSerializeStream(\n                  getStepReducers(global, ops, runId, cryptoKey),\n                  cryptoKey\n                )\n              )\n              .pipeTo(writable)\n          );\n        }\n      }\n\n      const s: SerializableSpecial['ReadableStream'] = { name };\n      if (type) s.type = type;\n      return s;\n    },\n\n    WritableStream: (value) => {\n      if (!(value instanceof global.WritableStream)) return false;\n\n      let name = value[STREAM_NAME_SYMBOL];\n      if (!name) {\n        const streamId = ((global as any)[STABLE_ULID] || defaultUlid)();\n        name = `strm_${streamId}`;\n        ops.push(\n          new WorkflowServerReadableStream(runId, name)\n            .pipeThrough(\n              getDeserializeStream(\n                getStepRevivers(global, ops, runId, cryptoKey),\n                cryptoKey\n              )\n            )\n            .pipeTo(value)\n        );\n      }\n\n      return { name };\n    },\n  };\n}\n\nexport function getCommonRevivers(global: Record<string, any> = globalThis) {\n  function reviveArrayBuffer(value: string) {\n    // Handle sentinel value for zero-length buffers\n    const base64 = value === '.' ? '' : value;\n    const buffer = Buffer.from(base64, 'base64');\n    const arrayBuffer = new global.ArrayBuffer(buffer.length);\n    const uint8Array = new global.Uint8Array(arrayBuffer);\n    uint8Array.set(buffer);\n    return arrayBuffer;\n  }\n  return {\n    ArrayBuffer: reviveArrayBuffer,\n    BigInt: (value: string) => global.BigInt(value),\n    BigInt64Array: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.BigInt64Array(ab);\n    },\n    BigUint64Array: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.BigUint64Array(ab);\n    },\n    Date: (value) => new global.Date(value),\n    DOMException: (value) => {\n      const error = new global.DOMException(value.message, value.name);\n      if (value.stack !== undefined) error.stack = value.stack;\n      // DOMException's constructor doesn't accept a cause option, so\n      // we set it manually when present in the serialized data.\n      if ('cause' in value) error.cause = value.cause;\n      return error;\n    },\n    Error: (value) => {\n      const error = new global.Error(value.message);\n      error.name = value.name;\n      error.stack = value.stack;\n      return error;\n    },\n    Float32Array: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.Float32Array(ab);\n    },\n    Float64Array: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.Float64Array(ab);\n    },\n    Headers: (value) => new global.Headers(value),\n    Int8Array: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.Int8Array(ab);\n    },\n    Int16Array: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.Int16Array(ab);\n    },\n    Int32Array: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.Int32Array(ab);\n    },\n    Map: (value) => new global.Map(value),\n    RegExp: (value) => new global.RegExp(value.source, value.flags),\n    Class: (value) => {\n      const classId = value.classId;\n      // Pass the global object to support VM contexts where classes are registered\n      // on the VM's global rather than the host's globalThis\n      const cls = getSerializationClass(classId, global);\n      if (!cls) {\n        throw new Error(\n          `Class \"${classId}\" not found. Make sure the class is registered with registerSerializationClass.`\n        );\n      }\n      return cls;\n    },\n    Instance: (value) => {\n      const classId = value.classId;\n      const data = value.data;\n\n      // Look up the class by classId from the registry\n      // Pass the global object to support VM contexts where classes are registered\n      // on the VM's global rather than the host's globalThis\n      const cls = getSerializationClass(classId, global);\n\n      if (!cls) {\n        throw new Error(\n          `Class \"${classId}\" not found. Make sure the class is registered with registerSerializationClass.`\n        );\n      }\n\n      // Get the deserializer from the class\n      const deserialize = (cls as any)[WORKFLOW_DESERIALIZE];\n      if (typeof deserialize !== 'function') {\n        throw new Error(\n          `Class \"${classId}\" does not have a static ${String(WORKFLOW_DESERIALIZE)} method.`\n        );\n      }\n\n      // Deserialize the instance using the custom deserializer\n      return deserialize.call(cls, data);\n    },\n    Set: (value) => new global.Set(value),\n    URL: (value) => new global.URL(value),\n    URLSearchParams: (value) =>\n      new global.URLSearchParams(value === '.' ? '' : value),\n    Uint8Array: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.Uint8Array(ab);\n    },\n    Uint8ClampedArray: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.Uint8ClampedArray(ab);\n    },\n    Uint16Array: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.Uint16Array(ab);\n    },\n    Uint32Array: (value: string) => {\n      const ab = reviveArrayBuffer(value);\n      return new global.Uint32Array(ab);\n    },\n  } as const satisfies Partial<Revivers>;\n}\n\n/**\n * Revivers for deserialization boundary from the client side,\n * receiving the return value from the workflow handler.\n *\n * @param global\n * @param ops\n * @param runId\n */\nexport function getExternalRevivers(\n  global: Record<string, any> = globalThis,\n  ops: Promise<void>[],\n  runId: string,\n  cryptoKey: EncryptionKeyParam\n): Revivers {\n  return {\n    ...getCommonRevivers(global),\n\n    // StepFunction should not be returned from workflows to clients\n    StepFunction: () => {\n      throw new Error(\n        'Step functions cannot be deserialized in client context. Step functions should not be returned from workflows.'\n      );\n    },\n\n    WorkflowFunction: (value) =>\n      Object.assign(\n        () => {\n          throw new Error(\n            'Workflow functions cannot be called directly. Use start() to invoke them.'\n          );\n        },\n        { workflowId: value.workflowId }\n      ),\n\n    Request: (value) => {\n      return new global.Request(value.url, {\n        method: value.method,\n        headers: new global.Headers(value.headers),\n        body: value.body,\n        duplex: value.duplex,\n      });\n    },\n    Response: (value) => {\n      // Note: Response constructor only accepts status, statusText, and headers\n      // The type, url, and redirected properties are read-only and set by the constructor\n      return new global.Response(value.body, {\n        status: value.status,\n        statusText: value.statusText,\n        headers: new global.Headers(value.headers),\n      });\n    },\n    ReadableStream: (value) => {\n      // If this has bodyInit, it came from a Response constructor\n      // Convert it to a REAL stream now that we're outside the workflow\n      if ('bodyInit' in value) {\n        const bodyInit = value.bodyInit;\n        // Use the native Response constructor to properly convert BodyInit to ReadableStream\n        const response = new global.Response(bodyInit);\n        return response.body;\n      }\n\n      const readable = new WorkflowServerReadableStream(\n        runId,\n        value.name,\n        value.startIndex\n      );\n      if (value.type === 'bytes') {\n        // For byte streams, use flushable pipe with lock polling\n        const state = createFlushableState();\n        ops.push(state.promise);\n\n        // Create an identity transform to give the user a readable\n        const { readable: userReadable, writable } =\n          new global.TransformStream();\n\n        // Start the flushable pipe in the background\n        flushablePipe(readable, writable, state).catch(() => {\n          // Errors are handled via state.reject\n        });\n\n        // Start polling to detect when user releases lock\n        pollReadableLock(userReadable, state);\n\n        return userReadable;\n      } else {\n        const transform = getDeserializeStream(\n          getExternalRevivers(global, ops, runId, cryptoKey),\n          cryptoKey\n        );\n        const state = createFlushableState();\n        ops.push(state.promise);\n\n        // Start the flushable pipe in the background\n        flushablePipe(readable, transform.writable, state).catch(() => {\n          // Errors are handled via state.reject\n        });\n\n        // Start polling to detect when user releases lock\n        pollReadableLock(transform.readable, state);\n\n        return transform.readable;\n      }\n    },\n    WritableStream: (value) => {\n      const serialize = getSerializeStream(\n        getExternalReducers(global, ops, runId, cryptoKey),\n        cryptoKey\n      );\n      const serverWritable = new WorkflowServerWritableStream(\n        runId,\n        value.name\n      );\n\n      // Create flushable state for this stream\n      const state = createFlushableState();\n      ops.push(state.promise);\n\n      // Start the flushable pipe in the background\n      flushablePipe(serialize.readable, serverWritable, state).catch(() => {\n        // Errors are handled via state.reject\n      });\n\n      // Start polling to detect when user releases lock\n      pollWritableLock(serialize.writable, state);\n\n      return serialize.writable;\n    },\n  };\n}\n\n/**\n * Revivers for deserialization boundary from within the workflow execution\n * environment, receiving arguments from the client side, and return values\n * from the steps.\n *\n * @param global\n * @returns\n */\nexport function getWorkflowRevivers(\n  global: Record<string, any> = globalThis\n): Revivers {\n  // Get the useStep function from the VM's globalThis\n  // This is set up by the workflow runner in workflow.ts\n  // Use Symbol.for directly to access the symbol on the global object\n  const useStep = (global as any)[Symbol.for('WORKFLOW_USE_STEP')] as\n    | ((\n        stepId: string,\n        closureVarsFn?: () => Record<string, unknown>\n      ) => (...args: unknown[]) => Promise<unknown>)\n    | undefined;\n\n  return {\n    ...getCommonRevivers(global),\n    // StepFunction reviver for workflow context - returns useStep wrapper\n    // This allows step functions passed as arguments to start() to be called directly\n    // from workflow code, just like step functions defined in the same file\n    StepFunction: (value) => {\n      const stepId = value.stepId;\n      const closureVars = value.closureVars;\n\n      if (!useStep) {\n        throw new Error(\n          'WORKFLOW_USE_STEP not found on global object. Step functions cannot be deserialized outside workflow context.'\n        );\n      }\n\n      if (closureVars) {\n        // For step functions with closure variables, create a wrapper that provides them\n        return useStep(stepId, () => closureVars);\n      }\n      return useStep(stepId);\n    },\n    Request: (value) => {\n      Object.setPrototypeOf(value, global.Request.prototype);\n      const responseWritable = value.responseWritable;\n      if (responseWritable) {\n        (value as any)[WEBHOOK_RESPONSE_WRITABLE] = responseWritable;\n        delete value.responseWritable;\n        (value as any).respondWith = () => {\n          throw new Error(\n            '`respondWith()` must be called from within a step function'\n          );\n        };\n      }\n      return value;\n    },\n    // Workflow function reviver for workflow context — returns a function-like\n    // object with .workflowId that mimics what the SWC compiler produces,\n    WorkflowFunction: (value) =>\n      Object.assign(\n        () => {\n          throw new Error(\n            'Workflow functions cannot be called directly. Use start() to invoke them.'\n          );\n        },\n        { workflowId: value.workflowId }\n      ),\n    Response: (value) => {\n      Object.setPrototypeOf(value, global.Response.prototype);\n      return value;\n    },\n    ReadableStream: (value) => {\n      // Check if this is a BodyInit that should be wrapped in a fake stream\n      if ('bodyInit' in value) {\n        // Recreate the fake stream with the BodyInit\n        return Object.create(global.ReadableStream.prototype, {\n          [BODY_INIT_SYMBOL]: {\n            value: value.bodyInit,\n            writable: false,\n          },\n        });\n      }\n\n      // Regular stream handling\n      return Object.create(global.ReadableStream.prototype, {\n        [STREAM_NAME_SYMBOL]: {\n          value: value.name,\n          writable: false,\n        },\n        [STREAM_TYPE_SYMBOL]: {\n          value: value.type,\n          writable: false,\n        },\n      });\n    },\n    WritableStream: (value) => {\n      return Object.create(global.WritableStream.prototype, {\n        [STREAM_NAME_SYMBOL]: {\n          value: value.name,\n          writable: false,\n        },\n      });\n    },\n  };\n}\n\n/**\n * Revivers for deserialization boundary from within the step execution\n * environment, receiving arguments from the workflow handler.\n *\n * @param global\n * @param ops\n * @param runId\n * @returns\n */\nfunction getStepRevivers(\n  global: Record<string, any> = globalThis,\n  ops: Promise<void>[],\n  runId: string,\n  cryptoKey: EncryptionKeyParam\n): Revivers {\n  return {\n    ...getCommonRevivers(global),\n\n    // StepFunction reviver for step context - returns raw step function\n    // with closure variable support via AsyncLocalStorage\n    StepFunction: (value) => {\n      const stepId = value.stepId;\n      const closureVars = value.closureVars;\n\n      const stepFn = getStepFunction(stepId);\n      if (!stepFn) {\n        throw new Error(\n          `Step function \"${stepId}\" not found. Make sure the step function is registered.`\n        );\n      }\n\n      // If closure variables were serialized, return a wrapper function\n      // that sets up AsyncLocalStorage context when invoked\n      if (closureVars) {\n        const wrappedStepFn = ((...args: any[]) => {\n          // Get the current context from AsyncLocalStorage\n          const currentContext = contextStorage.getStore();\n\n          if (!currentContext) {\n            throw new Error(\n              'Cannot call step function with closure variables outside step context'\n            );\n          }\n\n          // Create a new context with the closure variables merged in\n          const newContext = {\n            ...currentContext,\n            closureVars,\n          };\n\n          // Run the step function with the new context that includes closure vars\n          return contextStorage.run(newContext, () => stepFn(...args));\n        }) as any;\n\n        // Copy properties from original step function\n        Object.defineProperty(wrappedStepFn, 'name', {\n          value: stepFn.name,\n        });\n        Object.defineProperty(wrappedStepFn, 'stepId', {\n          value: stepId,\n          writable: false,\n          enumerable: false,\n          configurable: false,\n        });\n        if (stepFn.maxRetries !== undefined) {\n          wrappedStepFn.maxRetries = stepFn.maxRetries;\n        }\n\n        return wrappedStepFn;\n      }\n\n      return stepFn;\n    },\n\n    WorkflowFunction: (value) =>\n      Object.assign(\n        () => {\n          throw new Error(\n            'Workflow functions cannot be called directly. Use start() to invoke them.'\n          );\n        },\n        { workflowId: value.workflowId }\n      ),\n\n    Request: (value) => {\n      const responseWritable = value.responseWritable;\n      const request = new global.Request(value.url, {\n        method: value.method,\n        headers: new global.Headers(value.headers),\n        body: value.body,\n        duplex: value.duplex,\n      });\n      if (responseWritable) {\n        request.respondWith = async (response: Response) => {\n          const writer = responseWritable.getWriter();\n          await writer.write(response);\n          await writer.close();\n        };\n      }\n      return request;\n    },\n    Response: (value) => {\n      // Note: Response constructor only accepts status, statusText, and headers\n      // The type, url, and redirected properties are read-only and set by the constructor\n      return new global.Response(value.body, {\n        status: value.status,\n        statusText: value.statusText,\n        headers: new global.Headers(value.headers),\n      });\n    },\n    ReadableStream: (value) => {\n      // If this has bodyInit, it came from a Response constructor\n      // Convert it to a REAL stream now that we're in the step environment\n      if ('bodyInit' in value) {\n        const bodyInit = value.bodyInit;\n        // Use the native Response constructor to properly convert BodyInit to ReadableStream\n        const response = new global.Response(bodyInit);\n        return response.body;\n      }\n\n      const readable = new WorkflowServerReadableStream(runId, value.name);\n      if (value.type === 'bytes') {\n        // For byte streams, use flushable pipe with lock polling\n        const state = createFlushableState();\n        ops.push(state.promise);\n\n        // Create an identity transform to give the user a readable\n        const { readable: userReadable, writable } =\n          new global.TransformStream();\n\n        // Start the flushable pipe in the background\n        flushablePipe(readable, writable, state).catch(() => {\n          // Errors are handled via state.reject\n        });\n\n        // Start polling to detect when user releases lock\n        pollReadableLock(userReadable, state);\n\n        return userReadable;\n      } else {\n        const transform = getDeserializeStream(\n          getStepRevivers(global, ops, runId, cryptoKey),\n          cryptoKey\n        );\n        const state = createFlushableState();\n        ops.push(state.promise);\n\n        // Start the flushable pipe in the background\n        flushablePipe(readable, transform.writable, state).catch(() => {\n          // Errors are handled via state.reject\n        });\n\n        // Start polling to detect when user releases lock\n        pollReadableLock(transform.readable, state);\n\n        return transform.readable;\n      }\n    },\n    WritableStream: (value) => {\n      const serialize = getSerializeStream(\n        getStepReducers(global, ops, runId, cryptoKey),\n        cryptoKey\n      );\n      const serverWritable = new WorkflowServerWritableStream(\n        runId,\n        value.name\n      );\n\n      // Create flushable state for this stream\n      const state = createFlushableState();\n      ops.push(state.promise);\n\n      // Start the flushable pipe in the background\n      flushablePipe(serialize.readable, serverWritable, state).catch(() => {\n        // Errors are handled via state.reject\n      });\n\n      // Start polling to detect when user releases lock\n      pollWritableLock(serialize.writable, state);\n\n      return serialize.writable;\n    },\n  };\n}\n\n// ============================================================================\n// Encryption Helpers\n// ============================================================================\n\n/**\n * Encrypt data if the world supports encryption.\n * Returns original data if encryption is not available.\n *\n * @param data - Serialized data to encrypt\n * @param key - Encryption key (undefined to skip encryption)\n * @param context - Encryption context with runId\n * @returns Encrypted data if encryption available, original data otherwise\n */\nexport async function maybeEncrypt(\n  data: Uint8Array,\n  key: CryptoKey | undefined\n): Promise<Uint8Array> {\n  if (!key) return data;\n  const encrypted = await aesGcmEncrypt(key, data);\n  return encodeWithFormatPrefix(\n    SerializationFormat.ENCRYPTED,\n    encrypted\n  ) as Uint8Array;\n}\n\n/**\n * Decrypt data if it has the 'encr' prefix.\n *\n * @param data - Data that may be encrypted\n * @param key - Encryption key (undefined if no key available)\n * @returns Decrypted data if encrypted, original data otherwise\n * @throws {WorkflowRuntimeError} If the data is encrypted but no key is\n *   available. Callers (e.g., `Run.pollReturnValue()`, `hydrateStepReturnValue`)\n *   should be aware this can surface as a rejected promise during key rotation\n *   or misconfiguration scenarios.\n */\nexport async function maybeDecrypt(\n  data: Uint8Array | unknown,\n  key: CryptoKey | undefined\n): Promise<Uint8Array | unknown> {\n  // Legacy specVersion 1 runs stored event data as plain JSON arrays\n  // (not binary Uint8Array). Pass through as-is for backwards compat.\n  if (!(data instanceof Uint8Array)) {\n    return data;\n  }\n\n  if (isEncrypted(data)) {\n    if (!key) {\n      throw new WorkflowRuntimeError(\n        'Encrypted data encountered but no encryption key is available. ' +\n          'Encryption is not configured or no key was provided for this run.'\n      );\n    }\n    // Strip the 'encr' format prefix — the prefix is a core framing concern\n    const { payload } = decodeFormatPrefix(data);\n    return aesGcmDecrypt(key, payload);\n  }\n\n  return data;\n}\n\n// ============================================================================\n// Dehydrate / Hydrate Functions\n// ============================================================================\n\n/**\n * Called from the `start()` function to serialize the workflow arguments\n * into a format that can be saved to the database and then hydrated from\n * within the workflow execution environment.\n *\n * @param value - The value to serialize\n * @param runId - The workflow run ID (required for encryption context)\n * @param key - Encryption key (undefined to skip encryption)\n * @param ops - Promise array for stream operations\n * @param global - Global object for serialization context\n * @param v1Compat - Enable legacy v1 compatibility mode\n * @returns The dehydrated value as binary data (Uint8Array) with format prefix\n */\nexport async function dehydrateWorkflowArguments(\n  value: unknown,\n  runId: string,\n  key: CryptoKey | undefined,\n  ops: Promise<void>[] = [],\n  global: Record<string, any> = globalThis,\n  v1Compat = false\n): Promise<Uint8Array | unknown> {\n  try {\n    const str = stringify(value, getExternalReducers(global, ops, runId, key));\n    if (v1Compat) {\n      return revive(str);\n    }\n    const payload = new TextEncoder().encode(str);\n    const serialized = encodeWithFormatPrefix(\n      SerializationFormat.DEVALUE_V1,\n      payload\n    ) as Uint8Array;\n\n    // Encrypt if world supports encryption\n    return maybeEncrypt(serialized, key);\n  } catch (error) {\n    throw new WorkflowRuntimeError(\n      formatSerializationError('workflow arguments', error),\n      { slug: 'serialization-failed', cause: error }\n    );\n  }\n}\n\n/**\n * Called from workflow execution environment to hydrate the workflow\n * arguments from the database at the start of workflow execution.\n *\n * @param value - Binary serialized data (Uint8Array) with format prefix\n * @param _runId - Workflow run ID (reserved for future decryption context; decryption is currently driven solely by the provided key)\n * @param key - Encryption key (undefined to skip decryption)\n * @param global - Global object for deserialization context\n * @param extraRevivers - Additional revivers for custom types\n * @returns The hydrated value\n */\nexport async function hydrateWorkflowArguments(\n  value: Uint8Array | unknown,\n  _runId: string,\n  key: CryptoKey | undefined,\n  global: Record<string, any> = globalThis,\n  extraRevivers: Record<string, (value: any) => any> = {}\n) {\n  // Decrypt if needed\n  const decrypted = await maybeDecrypt(value, key);\n\n  // Legacy specVersion 1 runs stored data as plain JSON arrays (not binary).\n  // These pass through maybeDecrypt unchanged and are deserialized directly\n  // via devalue's unflatten().\n  if (!(decrypted instanceof Uint8Array)) {\n    return unflatten(decrypted as any[], {\n      ...getWorkflowRevivers(global),\n      ...extraRevivers,\n    });\n  }\n\n  const { format, payload } = decodeFormatPrefix(decrypted);\n\n  if (format === SerializationFormat.DEVALUE_V1) {\n    const str = new TextDecoder().decode(payload);\n    const obj = parse(str, {\n      ...getWorkflowRevivers(global),\n      ...extraRevivers,\n    });\n    return obj;\n  }\n\n  throw new Error(`Unsupported serialization format: ${format}`);\n}\n\n/**\n * Dehydrate workflow return value for storage.\n *\n * @param value - The value to serialize\n * @param runId - Run ID for encryption context\n * @param key - Encryption key (undefined to skip encryption)\n * @param global - Global object for serialization context\n * @returns The dehydrated value as binary data (Uint8Array) with format prefix\n */\nexport async function dehydrateWorkflowReturnValue(\n  value: unknown,\n  _runId: string,\n  key: CryptoKey | undefined,\n  global: Record<string, any> = globalThis,\n  v1Compat = false\n): Promise<Uint8Array | unknown> {\n  try {\n    const str = stringify(value, getWorkflowReducers(global));\n    if (v1Compat) {\n      return revive(str);\n    }\n    const payload = new TextEncoder().encode(str);\n    const serialized = encodeWithFormatPrefix(\n      SerializationFormat.DEVALUE_V1,\n      payload\n    ) as Uint8Array;\n\n    // Encrypt if world supports encryption\n    return maybeEncrypt(serialized, key);\n  } catch (error) {\n    throw new WorkflowRuntimeError(\n      formatSerializationError('workflow return value', error),\n      { slug: 'serialization-failed', cause: error }\n    );\n  }\n}\n\n/**\n * Called from the client side (i.e. the execution environment where\n * the workflow run was initiated from) to hydrate the workflow\n * return value of a completed workflow run.\n *\n * @param value - Binary serialized data (Uint8Array) with format prefix\n * @param runId - Run ID for decryption context\n * @param key - Encryption key (undefined to skip decryption)\n * @param ops - Promise array for stream operations\n * @param global - Global object for deserialization context\n * @param extraRevivers - Additional revivers for custom types\n * @returns The hydrated return value, ready to be consumed by the client\n */\nexport async function hydrateWorkflowReturnValue(\n  value: Uint8Array | unknown,\n  runId: string,\n  key: CryptoKey | undefined,\n  ops: Promise<void>[] = [],\n  global: Record<string, any> = globalThis,\n  extraRevivers: Record<string, (value: any) => any> = {}\n) {\n  // Decrypt if needed\n  const decrypted = await maybeDecrypt(value, key);\n\n  // Legacy specVersion 1 runs stored data as plain JSON arrays (not binary).\n  // These pass through maybeDecrypt unchanged and are deserialized directly\n  // via devalue's unflatten().\n  if (!(decrypted instanceof Uint8Array)) {\n    return unflatten(decrypted as any[], {\n      ...getExternalRevivers(global, ops, runId, key),\n      ...extraRevivers,\n    });\n  }\n\n  const { format, payload } = decodeFormatPrefix(decrypted);\n\n  if (format === SerializationFormat.DEVALUE_V1) {\n    const str = new TextDecoder().decode(payload);\n    const obj = parse(str, {\n      ...getExternalRevivers(global, ops, runId, key),\n      ...extraRevivers,\n    });\n    return obj;\n  }\n\n  throw new Error(`Unsupported serialization format: ${format}`);\n}\n\n/**\n * Called from the workflow handler when a step is being created.\n * Dehydrates values from within the workflow execution environment\n * into a format that can be saved to the database.\n *\n * @param value - The value to serialize\n * @param runId - Run ID for encryption context\n * @param key - Encryption key (undefined to skip encryption)\n * @param global - Global object for serialization context\n * @param v1Compat - Enable legacy v1 compatibility mode\n * @returns The dehydrated value as binary data (Uint8Array) with format prefix\n */\nexport async function dehydrateStepArguments(\n  value: unknown,\n  _runId: string,\n  key: CryptoKey | undefined,\n  global: Record<string, any> = globalThis,\n  v1Compat = false\n): Promise<Uint8Array | unknown> {\n  try {\n    const str = stringify(value, getWorkflowReducers(global));\n    if (v1Compat) {\n      return revive(str);\n    }\n    const payload = new TextEncoder().encode(str);\n    const serialized = encodeWithFormatPrefix(\n      SerializationFormat.DEVALUE_V1,\n      payload\n    ) as Uint8Array;\n\n    // Encrypt if world supports encryption\n    return maybeEncrypt(serialized, key);\n  } catch (error) {\n    throw new WorkflowRuntimeError(\n      formatSerializationError('step arguments', error),\n      { slug: 'serialization-failed', cause: error }\n    );\n  }\n}\n\n/**\n * Called from the step handler to hydrate the arguments of a step\n * from the database at the start of the step execution.\n *\n * @param value - Binary serialized data (Uint8Array) with format prefix\n * @param runId - Run ID for decryption context\n * @param key - Encryption key (undefined to skip decryption)\n * @param ops - Promise array for stream operations\n * @param global - Global object for deserialization context\n * @param extraRevivers - Additional revivers for custom types\n * @returns The hydrated value, ready to be consumed by the step user-code function\n */\nexport async function hydrateStepArguments(\n  value: Uint8Array | unknown,\n  runId: string,\n  key: CryptoKey | undefined,\n  ops: Promise<any>[] = [],\n  global: Record<string, any> = globalThis,\n  extraRevivers: Record<string, (value: any) => any> = {}\n) {\n  // Decrypt if needed\n  const decrypted = await maybeDecrypt(value, key);\n\n  // Legacy specVersion 1 runs stored data as plain JSON arrays (not binary).\n  // These pass through maybeDecrypt unchanged and are deserialized directly\n  // via devalue's unflatten().\n  if (!(decrypted instanceof Uint8Array)) {\n    return unflatten(decrypted as any[], {\n      ...getStepRevivers(global, ops, runId, key),\n      ...extraRevivers,\n    });\n  }\n\n  const { format, payload } = decodeFormatPrefix(decrypted);\n\n  if (format === SerializationFormat.DEVALUE_V1) {\n    const str = new TextDecoder().decode(payload);\n    const obj = parse(str, {\n      ...getStepRevivers(global, ops, runId, key),\n      ...extraRevivers,\n    });\n    return obj;\n  }\n\n  throw new Error(`Unsupported serialization format: ${format}`);\n}\n\n/**\n * Called from the step handler when a step has completed.\n * Dehydrates values from within the step execution environment\n * into a format that can be saved to the database.\n *\n * @param value - The value to serialize\n * @param runId - Run ID for encryption context\n * @param key - Encryption key (undefined to skip encryption)\n * @param ops - Promise array for stream operations\n * @param global - Global object for serialization context\n * @param v1Compat - Enable legacy v1 compatibility mode\n * @returns The dehydrated value as binary data (Uint8Array) with format prefix\n */\nexport async function dehydrateStepReturnValue(\n  value: unknown,\n  runId: string,\n  key: CryptoKey | undefined,\n  ops: Promise<any>[] = [],\n  global: Record<string, any> = globalThis,\n  v1Compat = false\n): Promise<Uint8Array | unknown> {\n  try {\n    const str = stringify(value, getStepReducers(global, ops, runId, key));\n    if (v1Compat) {\n      return revive(str);\n    }\n    const payload = new TextEncoder().encode(str);\n    const serialized = encodeWithFormatPrefix(\n      SerializationFormat.DEVALUE_V1,\n      payload\n    ) as Uint8Array;\n\n    // Encrypt if world supports encryption\n    return maybeEncrypt(serialized, key);\n  } catch (error) {\n    throw new WorkflowRuntimeError(\n      formatSerializationError('step return value', error),\n      { slug: 'serialization-failed', cause: error }\n    );\n  }\n}\n\n/**\n * Called from the workflow handler when replaying the event log of a `step_completed` event.\n * Hydrates the return value of a step from the database.\n *\n * @param value - Binary serialized data (Uint8Array) with format prefix\n * @param runId - Run ID for decryption context\n * @param key - Encryption key (undefined to skip decryption)\n * @param global - Global object for deserialization context\n * @param extraRevivers - Additional revivers for custom types\n * @returns The hydrated return value of a step, ready to be consumed by the workflow handler\n */\nexport async function hydrateStepReturnValue(\n  value: Uint8Array | unknown,\n  _runId: string,\n  key: CryptoKey | undefined,\n  global: Record<string, any> = globalThis,\n  extraRevivers: Record<string, (value: any) => any> = {}\n) {\n  // Decrypt if needed\n  const decrypted = await maybeDecrypt(value, key);\n\n  // Legacy specVersion 1 runs stored data as plain JSON arrays (not binary).\n  // These pass through maybeDecrypt unchanged and are deserialized directly\n  // via devalue's unflatten().\n  if (!(decrypted instanceof Uint8Array)) {\n    return unflatten(decrypted as any[], {\n      ...getWorkflowRevivers(global),\n      ...extraRevivers,\n    });\n  }\n\n  const { format, payload } = decodeFormatPrefix(decrypted);\n\n  if (format === SerializationFormat.DEVALUE_V1) {\n    const str = new TextDecoder().decode(payload);\n    return parse(str, {\n      ...getWorkflowRevivers(global),\n      ...extraRevivers,\n    });\n  }\n\n  throw new Error(`Unsupported serialization format: ${format}`);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serialization.js","sourceRoot":"","sources":["../src/serialization.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  RuntimeDecryptionError,\n  SerializationError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport { envNumber } from '@workflow/world';\nimport { parse, stringify, unflatten } from 'devalue';\nimport { monotonicFactory } from 'ulid';\nimport {\n  decrypt as aesGcmDecrypt,\n  encrypt as aesGcmEncrypt,\n  type CryptoKey,\n  importKey,\n} from './encryption.js';\nimport {\n  createFlushableState,\n  flushablePipe,\n  pollReadableLock,\n  pollWritableLock,\n} from './flushable-stream.js';\nimport { getStepFunction } from './private.js';\n// V2: use getWorldLazy in step-side code paths so Turbopack can statically\n// resolve the world bridge from the step bundle without dragging the full\n// host world module into the flow route.\n// See `packages/core/src/runtime/get-world-lazy.ts` and the\n// \"Turbopack NFT Tracing Errors in V2 Combined Flow Route\" section of\n// `docs/content/docs/changelog/eager-processing.mdx`.\nimport { getWorldLazy } from './runtime/get-world-lazy.js';\nimport * as clientModule from './serialization/client.js';\nimport {\n  type CompressionStats,\n  compress,\n  decompress,\n} from './serialization/compression.js';\nimport {\n  decrypt,\n  type EncryptionKeyParam,\n  encrypt,\n  resolveEncryptionKey,\n} from './serialization/encryption.js';\nimport {\n  formatSerializationError,\n  rethrowIfRuntimeError,\n} from './serialization/errors.js';\nimport {\n  decodeFormatPrefix,\n  encodeWithFormatPrefix,\n  isEncrypted,\n  peekFormatPrefix,\n} from './serialization/format.js';\nimport {\n  getClassReducers,\n  getClassRevivers,\n} from './serialization/reducers/class.js';\nimport {\n  getCommonReducers,\n  getCommonRevivers as getCommonReviversFromModule,\n  revive,\n} from './serialization/reducers/common.js';\nimport {\n  getStepFunctionReducer,\n  getStepFunctionReviver,\n} from './serialization/reducers/step-function.js';\nimport * as stepModule from './serialization/step.js';\nimport {\n  type FormatPrefix,\n  isFormatPrefix,\n  SerializationFormat,\n} from './serialization/types.js';\nimport * as workflowModule from './serialization/workflow.js';\nimport { contextStorage } from './step/context-storage.js';\nimport {\n  ABORT_HOOK_TOKEN,\n  ABORT_LISTENER_ATTACHED,\n  ABORT_READER_CANCEL,\n  ABORT_STREAM_NAME,\n  BODY_INIT_SYMBOL,\n  STABLE_ULID,\n  STREAM_FRAMING_SYMBOL,\n  STREAM_NAME_SYMBOL,\n  STREAM_SERVER_DEPLOYMENT_ID_SYMBOL,\n  STREAM_SERVER_RUN_ID_SYMBOL,\n  STREAM_TYPE_SYMBOL,\n  WEBHOOK_RESPONSE_WRITABLE,\n} from './symbols.js';\nimport * as Attr from './telemetry/semantic-conventions.js';\nimport { getActiveSpan, getSpanKind, recordElapsedSpan } from './telemetry.js';\nimport { getAbortStreamId } from './util.js';\nimport { WorkflowAbortSignal } from './workflow/abort-controller.js';\n\n// Re-export types and utilities from the modular serialization modules\n// so existing consumers of `@workflow/core/serialization` keep working.\nexport {\n  SerializationFormat,\n  type FormatPrefix,\n  isFormatPrefix,\n  encodeWithFormatPrefix,\n  decodeFormatPrefix,\n  peekFormatPrefix,\n  isEncrypted,\n  encrypt,\n  decrypt,\n  compress,\n  decompress,\n  type EncryptionKeyParam,\n};\n\n// Re-export the legacy SerializationFormatType for backwards compatibility.\n// New code should use FormatPrefix from './serialization/types.js'.\nexport type SerializationFormatType =\n  (typeof SerializationFormat)[keyof typeof SerializationFormat];\n\n/**\n * Default ULID generator for contexts where VM's seeded `stableUlid` isn't available.\n * Used as a fallback when serializing streams outside the workflow VM context\n * (e.g., when starting a workflow or handling step return values).\n */\nconst defaultUlid = monotonicFactory();\n\n/**\n * Detect if a readable stream is a byte stream.\n *\n * @param stream\n * @returns `\"bytes\"` if the stream is a byte stream, `undefined` otherwise\n */\nexport function getStreamType(stream: ReadableStream): 'bytes' | undefined {\n  try {\n    const reader = stream.getReader({ mode: 'byob' });\n    reader.releaseLock();\n    return 'bytes';\n  } catch {}\n}\n\n/**\n * Frame format for stream chunks:\n *   [4-byte big-endian length][format-prefixed payload]\n *\n * Each chunk is independently framed so the deserializer can find\n * chunk boundaries even when multiple chunks are concatenated or\n * split across transport reads.\n */\nconst FRAME_HEADER_SIZE = 4;\n\n/**\n * The mode-specific serializers (`./serialization/{client,step,workflow}.ts`)\n * already throw a `SerializationError` whose `.cause` is the underlying\n * devalue / serde failure. The outer dehydrate/hydrate wrappers want to\n * re-frame that error with a more specific context label (e.g. \"workflow\n * arguments\" instead of generic \"workflow value\"), so they unwrap the\n * inner SerializationError and reformat with the original cause. Errors\n * that aren't already SerializationError flow through unchanged.\n *\n * `RuntimeDecryptionError` is an exception: it must keep its identity (and\n * `context`) so the run-failure classifier routes it to `RUNTIME_ERROR`,\n * so this rethrows it unchanged before any unwrapping. Note this guard\n * must run before the generic `WorkflowRuntimeError` unwrap below, since\n * `RuntimeDecryptionError` extends `WorkflowRuntimeError` and carries a\n * `cause` (the underlying DOMException) that would otherwise be unwrapped\n * and reframed as a `SerializationError`.\n */\nfunction unwrapSerializationCause(error: unknown): unknown {\n  rethrowIfRuntimeError(error);\n  if (error instanceof SerializationError && error.cause !== undefined) {\n    return error.cause;\n  }\n  if (error instanceof WorkflowRuntimeError && error.cause !== undefined) {\n    return error.cause;\n  }\n  return error;\n}\n\n/**\n * Emit compression telemetry onto the active span after a (de)serialize.\n *\n * The compression layer populates `stats` only when it actually ran (binary\n * data on a spec >= 5 path); legacy / v1Compat paths leave it unrecorded, so\n * this no-ops for them and avoids the `getActiveSpan` lookup. Attributes land\n * on whatever span is active — typically the dedicated `step.dehydrate` /\n * `step.hydrate` span, otherwise the enclosing run/start span.\n */\nasync function recordCompression(\n  stats: CompressionStats,\n  operation: 'serialize' | 'deserialize'\n): Promise<void> {\n  if (!stats.recorded) return;\n  // Telemetry must never break the serialize/deserialize data path — a\n  // missing/failing tracer is purely an observability loss.\n  try {\n    const span = await getActiveSpan();\n    if (!span) return;\n    const uncompressedBytes = stats.uncompressedBytes ?? 0;\n    const storedBytes = stats.storedBytes ?? 0;\n    span.setAttributes({\n      ...Attr.SerializationOperation(operation),\n      ...Attr.SerializationCompressed(stats.compressed ?? false),\n      ...Attr.SerializationCodec(stats.codec ?? 'none'),\n      ...Attr.SerializationUncompressedBytes(uncompressedBytes),\n      ...Attr.SerializationStoredBytes(storedBytes),\n      ...(stats.compressed && uncompressedBytes > 0\n        ? Attr.SerializationCompressionRatio(\n            1 - storedBytes / uncompressedBytes\n          )\n        : {}),\n    });\n  } catch {\n    // ignore telemetry failures\n  }\n}\n\nexport function getSerializeStream(\n  reducers: Partial<Reducers>,\n  cryptoKey: EncryptionKeyParam\n): TransformStream<any, Uint8Array> {\n  const encoder = new TextEncoder();\n  // Resolve the key input once on first use and cache the result.\n  // Note: if resolving cryptoKey rejects (e.g., network error fetching\n  // the derived key), the rejection won't surface until the first chunk\n  // is processed — not at stream construction time.\n  const keyState = { resolved: false, key: undefined as CryptoKey | undefined };\n  const stream = new TransformStream<any, Uint8Array>({\n    async transform(chunk, controller) {\n      try {\n        if (!keyState.resolved) {\n          keyState.key = await resolveEncryptionKey(cryptoKey);\n          keyState.resolved = true;\n        }\n        const serialized = stringify(chunk, reducers);\n        const payload = encoder.encode(serialized);\n        let prefixed = encodeWithFormatPrefix(\n          SerializationFormat.DEVALUE_V1,\n          payload\n        ) as Uint8Array;\n\n        // Encrypt the frame payload if a key is provided.\n        // The length header remains in the clear so the deserializer can\n        // find frame boundaries regardless of transport chunking.\n        if (keyState.key) {\n          const encrypted = await aesGcmEncrypt(keyState.key, prefixed);\n          prefixed = encodeWithFormatPrefix(\n            SerializationFormat.ENCRYPTED,\n            encrypted\n          ) as Uint8Array;\n        }\n\n        // Write length-prefixed frame: [4-byte length][prefixed data]\n        const frame = new Uint8Array(FRAME_HEADER_SIZE + prefixed.length);\n        new DataView(frame.buffer).setUint32(0, prefixed.length, false);\n        frame.set(prefixed, FRAME_HEADER_SIZE);\n        controller.enqueue(frame);\n      } catch (error) {\n        // Encryption failures must keep their RuntimeDecryptionError\n        // identity (RUNTIME_ERROR) rather than be reframed as a\n        // SerializationError (USER_ERROR).\n        if (RuntimeDecryptionError.is(error)) {\n          controller.error(error);\n          return;\n        }\n        const { message, hint } = formatSerializationError(\n          'stream chunk',\n          error\n        );\n        controller.error(\n          new SerializationError(message, { hint, cause: error })\n        );\n      }\n    },\n  });\n  return stream;\n}\n\nexport function getDeserializeStream(\n  revivers: Partial<Revivers>,\n  cryptoKey: EncryptionKeyParam\n): TransformStream<Uint8Array, any> {\n  const decoder = new TextDecoder();\n  let buffer = new Uint8Array(0);\n  // Resolve the key input once on first use and cache the result.\n  const keyState = { resolved: false, key: undefined as CryptoKey | undefined };\n\n  function appendToBuffer(data: Uint8Array) {\n    const newBuffer = new Uint8Array(buffer.length + data.length);\n    newBuffer.set(buffer, 0);\n    newBuffer.set(data, buffer.length);\n    buffer = newBuffer;\n  }\n\n  async function processFrames(\n    controller: TransformStreamDefaultController<any>\n  ) {\n    // Resolve the key input once on first use and cache the result\n    if (!keyState.resolved) {\n      keyState.key = await resolveEncryptionKey(cryptoKey);\n      keyState.resolved = true;\n    }\n\n    // Try to extract complete length-prefixed frames\n    while (buffer.length >= FRAME_HEADER_SIZE) {\n      const frameLength = new DataView(\n        buffer.buffer,\n        buffer.byteOffset,\n        buffer.byteLength\n      ).getUint32(0, false);\n\n      if (buffer.length < FRAME_HEADER_SIZE + frameLength) {\n        break; // Incomplete frame, wait for more data\n      }\n\n      const frameData = buffer.slice(\n        FRAME_HEADER_SIZE,\n        FRAME_HEADER_SIZE + frameLength\n      );\n      buffer = buffer.slice(FRAME_HEADER_SIZE + frameLength);\n\n      let { format, payload } = decodeFormatPrefix(frameData);\n\n      // If the frame payload is encrypted, decrypt it first to reveal\n      // the inner format-prefixed data (e.g., 'devl' + serialized text),\n      // then fall through to the normal deserialization path.\n      if (format === SerializationFormat.ENCRYPTED) {\n        if (!keyState.key) {\n          controller.error(\n            new RuntimeDecryptionError(\n              'Encrypted stream data encountered but no encryption key is available. ' +\n                'Encryption is not configured or no key was provided for this run.',\n              {\n                context: {\n                  operation: 'decrypt',\n                  byteLength: payload.byteLength,\n                  formatPrefix: 'encr',\n                },\n              }\n            )\n          );\n          return;\n        }\n        let decrypted: Uint8Array;\n        try {\n          decrypted = await aesGcmDecrypt(keyState.key, payload);\n        } catch (error) {\n          // The low-level AES layer only sees the stripped payload, so it\n          // cannot record the outer envelope prefix. We peeked it here\n          // (`encr`), so enrich the diagnostic context with the real format\n          // prefix before propagating — mirroring serialization/encryption.ts.\n          if (RuntimeDecryptionError.is(error) && error.context) {\n            error.context.formatPrefix = format;\n          }\n          throw error;\n        }\n        ({ format, payload } = decodeFormatPrefix(decrypted));\n      }\n\n      if (format === SerializationFormat.DEVALUE_V1) {\n        const text = decoder.decode(payload);\n        controller.enqueue(parse(text, revivers));\n      }\n    }\n  }\n\n  const stream = new TransformStream<Uint8Array, any>({\n    async transform(chunk, controller) {\n      // First, try to detect if this is length-prefixed framed data\n      // by checking if the first 4 bytes form a plausible length.\n      if (buffer.length === 0 && chunk.length >= FRAME_HEADER_SIZE) {\n        const possibleLength = new DataView(\n          chunk.buffer,\n          chunk.byteOffset,\n          chunk.byteLength\n        ).getUint32(0, false);\n        if (\n          possibleLength > 0 &&\n          possibleLength < 100_000_000 // sanity check: < 100MB\n        ) {\n          // Looks like framed data\n          appendToBuffer(chunk);\n          await processFrames(controller);\n          return;\n        }\n      } else if (buffer.length > 0) {\n        // Already in framed mode (have buffered data)\n        appendToBuffer(chunk);\n        await processFrames(controller);\n        return;\n      }\n\n      // Legacy format: newline-delimited devalue text (no framing)\n      const text = decoder.decode(chunk);\n      const lines = text.split('\\n');\n      for (const line of lines) {\n        if (line.length > 0) {\n          controller.enqueue(parse(line, revivers));\n        }\n      }\n    },\n    async flush(controller) {\n      // Process any remaining framed data\n      if (buffer.length > 0) {\n        await processFrames(controller);\n      }\n    },\n  });\n  return stream;\n}\n\n// ============================================================================\n// Byte-stream wire framing\n// ============================================================================\n//\n// Byte streams (`type: 'bytes'` ReadableStreams passed across boundaries)\n// are written to the underlying world's stream transport one user chunk at\n// a time. Without an in-band envelope, the reader sees a flat stream of\n// bytes — there is no way to tell where one user chunk ends and the next\n// begins, which makes mid-stream reconnect impossible (we don't know how\n// many server-side chunks have been consumed).\n//\n// To enable transparent reconnect, this PR introduces an opt-in wire\n// envelope that wraps each user chunk in a length-prefix:\n//\n//   [4-byte big-endian length][user payload bytes]\n//\n// The envelope is identical in shape to `getSerializeStream`'s framing,\n// but the payload here is *raw user bytes* — there is no inner\n// format-prefix, no devalue, no encryption. A framed byte stream stays\n// semantically a byte stream end-to-end; the framing is purely transport.\n//\n// The decision to use framing for a given stream is recorded in the\n// serialized stream ref (`framing: 'framed-v1'`), so both sides agree on\n// the wire format without runtime negotiation. Producers that target a\n// run whose deployment doesn't support framing (see `getRunCapabilities`\n// in capabilities.ts) emit raw bytes and a ref without the field — which\n// the reader treats as legacy raw bytes for backwards compatibility.\n\n/**\n * Maximum allowed byte-stream frame payload size (100MB). Shared by the\n * framer (rejects oversized user chunks at write time, where the error is\n * actionable) and the unframer (rejects oversized length headers at read\n * time, which usually indicate a non-framed wire being read as framed).\n * Keeping both sides on one constant guarantees any chunk the framer\n * accepts can always be decoded by the unframer.\n */\nconst MAX_FRAME_SIZE = 100_000_000;\n\n/**\n * Wraps each chunk of a byte stream in a 4-byte big-endian length\n * prefix. Used by the producer side of a framed byte-stream pipe.\n *\n * Empty chunks (length 0) are dropped — the resulting `[0x00 0x00 0x00 0x00]`\n * frame would be ambiguous with the legacy \"looks framed\" detection in\n * `getDeserializeStream`, and it carries no information.\n *\n * Load-bearing invariant: each user chunk becomes exactly one frame, and\n * each frame is enqueued as exactly one transport chunk (the downstream\n * writable performs one wire write per chunk, preserving boundaries). The\n * server therefore stores one frame per chunk index, which is what allows\n * a future reconnecting reader to resume a framed byte stream at\n * `startIndex + consumedFrames` — the same arithmetic\n * `createReconnectingFramedStream` relies on for object streams. Do not\n * coalesce or split frames here without revisiting that resume logic.\n */\nexport function getByteFramingStream(): TransformStream<\n  Uint8Array,\n  Uint8Array\n> {\n  return new TransformStream<Uint8Array, Uint8Array>({\n    transform(chunk, controller) {\n      if (chunk.length === 0) return;\n      if (chunk.length > MAX_FRAME_SIZE) {\n        controller.error(\n          new WorkflowRuntimeError(\n            `Byte-stream chunk of ${chunk.length} bytes exceeds the maximum ` +\n              `framed chunk size (${MAX_FRAME_SIZE}). Split the data into ` +\n              `smaller chunks before writing.`,\n            { slug: 'serialization-failed' }\n          )\n        );\n        return;\n      }\n      const frame = new Uint8Array(FRAME_HEADER_SIZE + chunk.length);\n      new DataView(frame.buffer).setUint32(0, chunk.length, false);\n      frame.set(chunk, FRAME_HEADER_SIZE);\n      controller.enqueue(frame);\n    },\n  });\n}\n\n/**\n * Unwraps length-prefixed byte-stream frames back into the original user\n * chunks. Used by the consumer side of a framed byte-stream pipe.\n *\n * Buffers across read boundaries — the transport may split a single\n * frame across multiple reads (header in one chunk, payload in another)\n * or coalesce multiple frames into a single read. The transform emits\n * whole user chunks regardless of transport chunking.\n *\n * Errors the stream if the length header advertises a frame larger than\n * `MAX_FRAME_SIZE` bytes, since that almost certainly indicates a\n * misframed wire (e.g. a raw byte stream being fed through this transform\n * by mistake) and we don't want to allocate an enormous buffer.\n */\nexport function getByteUnframingStream(): TransformStream<\n  Uint8Array,\n  Uint8Array\n> {\n  let buffer = new Uint8Array(0);\n\n  function appendToBuffer(data: Uint8Array) {\n    const next = new Uint8Array(buffer.length + data.length);\n    next.set(buffer, 0);\n    next.set(data, buffer.length);\n    buffer = next;\n  }\n\n  return new TransformStream<Uint8Array, Uint8Array>({\n    transform(chunk, controller) {\n      if (chunk.length > 0) appendToBuffer(chunk);\n\n      while (buffer.length >= FRAME_HEADER_SIZE) {\n        const frameLength = new DataView(\n          buffer.buffer,\n          buffer.byteOffset,\n          buffer.byteLength\n        ).getUint32(0, false);\n\n        if (frameLength > MAX_FRAME_SIZE) {\n          controller.error(\n            new WorkflowRuntimeError(\n              `Byte-stream frame length ${frameLength} exceeds maximum (${MAX_FRAME_SIZE}). ` +\n                `This usually means a non-framed byte stream is being read as framed.`,\n              { slug: 'serialization-failed' }\n            )\n          );\n          return;\n        }\n\n        const total = FRAME_HEADER_SIZE + frameLength;\n        if (buffer.length < total) break;\n\n        controller.enqueue(buffer.slice(FRAME_HEADER_SIZE, total));\n        buffer = buffer.slice(total);\n      }\n    },\n    flush(controller) {\n      if (buffer.length > 0) {\n        controller.error(\n          new WorkflowRuntimeError(\n            `Byte-stream ended with ${buffer.length} bytes of incomplete frame data. ` +\n              `The stream was truncated mid-frame.`,\n            { slug: 'serialization-failed' }\n          )\n        );\n      }\n    },\n  });\n}\n\n/**\n * Emit the client-observed end-to-end time-to-first-chunk span for a live read:\n * read dispatch (`startEpochMs`) → the first non-empty chunk reaching the\n * reader, including the network hop. Fire-and-forget; no-op without OTEL.\n */\nfunction recordReadTimeToFirstChunk(\n  startEpochMs: number,\n  runId: string,\n  name: string,\n  startIndex?: number\n): void {\n  void (async () => {\n    await recordElapsedSpan('workflow.stream.read', startEpochMs, {\n      kind: await getSpanKind('CLIENT'),\n      attributes: {\n        'workflow.run.id': runId,\n        'workflow.stream.name': name,\n        'workflow.stream.operation': 'read',\n        'workflow.stream.read.ttfc_ms': Date.now() - startEpochMs,\n        ...(typeof startIndex === 'number'\n          ? { 'workflow.stream.start_index': startIndex }\n          : {}),\n      },\n    });\n  })();\n}\n\nexport class WorkflowServerReadableStream extends ReadableStream<Uint8Array> {\n  #reader?: ReadableStreamDefaultReader<Uint8Array>;\n\n  constructor(runId: string, name: string, startIndex?: number) {\n    if (typeof name !== 'string' || name.length === 0) {\n      throw new WorkflowRuntimeError(`\"name\" is required, got \"${name}\"`);\n    }\n    // Client-observed time-to-first-chunk state. `readStart` is stamped when the\n    // reader starts consuming (first pull → the read dispatch); the span is\n    // emitted once, when the first non-empty chunk reaches the reader. So its\n    // duration is the end-to-end TTFC including the network hop. No-op without\n    // an OpenTelemetry SDK registered.\n    let readStart: number | undefined;\n    let firstChunkReported = false;\n    super({\n      // @ts-expect-error Not sure why TypeScript is complaining about this\n      type: 'bytes',\n\n      pull: async (controller) => {\n        let reader = this.#reader;\n        if (!reader) {\n          if (readStart === undefined) readStart = Date.now();\n          const world = await getWorldLazy();\n          const stream = await world.streams.get(runId, name, startIndex);\n          reader = this.#reader = stream.getReader();\n        }\n        if (!reader) {\n          controller.error(new Error('Failed to get reader'));\n          return;\n        }\n\n        const result = await reader.read();\n        if (result.done) {\n          this.#reader = undefined;\n          controller.close();\n        } else {\n          // The server flushes a leading zero-length chunk (v3+) to commit\n          // response headers before any data; skip empties so TTFC measures to\n          // the first real chunk.\n          if (\n            !firstChunkReported &&\n            result.value.byteLength > 0 &&\n            readStart !== undefined\n          ) {\n            firstChunkReported = true;\n            recordReadTimeToFirstChunk(readStart, runId, name, startIndex);\n          }\n          // Forward raw bytes; encryption/decryption is handled at the\n          // framing level by getSerializeStream/getDeserializeStream.\n          controller.enqueue(result.value);\n        }\n      },\n      cancel: async (reason) => {\n        if (this.#reader) {\n          await this.#reader.cancel(reason).catch(() => {});\n          this.#reader = undefined;\n        }\n      },\n    });\n  }\n}\n\n/**\n * Maximum consecutive reconnect attempts for a single framed stream session.\n * The counter resets to zero whenever a reconnect makes forward progress (a\n * frame is delivered), so this bounds *consecutive* failures, not the lifetime\n * total — a long-lived serverless stream may legitimately reconnect far more\n * than this many times as long as each reconnect keeps delivering data. We only\n * give up after this many reconnects in a row produce nothing.\n */\nexport const FRAMED_STREAM_MAX_RECONNECTS = 50;\n\n/** Effective consecutive-reconnect cap. Override: `WORKFLOW_FRAMED_STREAM_MAX_RECONNECTS`. */\nconst getFramedStreamMaxReconnects = (): number =>\n  envNumber(\n    'WORKFLOW_FRAMED_STREAM_MAX_RECONNECTS',\n    FRAMED_STREAM_MAX_RECONNECTS,\n    {\n      integer: true,\n      min: 1,\n    }\n  );\n\n/**\n * Absolute backstop on total reconnects for a single session, independent of\n * progress. The consecutive cap above resets on forward progress, which is\n * correct for a well-behaved backend that honors `startIndex`. But if a World's\n * `streams.get` ever ignored `startIndex` and re-delivered earlier chunks,\n * \"progress\" would be reported every reconnect and the consecutive cap would\n * never trip — turning a bounded failure into an unbounded reconnect loop. This\n * hard ceiling guarantees the loop always terminates. It is set high enough\n * (hours of streaming at realistic per-session timeouts) to never interfere\n * with legitimate long-lived streams.\n */\nexport const FRAMED_STREAM_MAX_TOTAL_RECONNECTS = 1000;\n\n/** Effective total-reconnect backstop. Override: `WORKFLOW_FRAMED_STREAM_MAX_TOTAL_RECONNECTS`. */\nconst getFramedStreamMaxTotalReconnects = (): number =>\n  envNumber(\n    'WORKFLOW_FRAMED_STREAM_MAX_TOTAL_RECONNECTS',\n    FRAMED_STREAM_MAX_TOTAL_RECONNECTS,\n    { integer: true, min: 1 }\n  );\n\n/**\n * Wraps the length-prefix-framed byte stream from `world.streams.get` with\n * transparent auto-reconnect.\n *\n * Every fully-decoded outer frame corresponds to exactly one server-side\n * chunk (the serialize transform enqueues one frame per workflow write, and\n * the writable buffers one frame per chunk when multi-writing). The wrapper\n * counts completed frames and, on upstream error, reopens the connection\n * with `startIndex = resolvedStartIndex + consumedFrames`. Partial-frame\n * bytes buffered before the cut are discarded — the server will resend the\n * in-flight chunk in full from the new startIndex.\n *\n * A clean upstream close (EOF with no error) signals the stream is truly\n * done; we close the wrapper and do not reconnect.\n *\n * Negative `startIndex` values (last-N semantics) skip the reconnect\n * machinery because we cannot compute an absolute resume position without\n * a tail-index lookup — the returned stream behaves as a single-shot read.\n */\nexport function createReconnectingFramedStream(\n  runId: string,\n  name: string,\n  startIndex?: number\n): ReadableStream<Uint8Array> {\n  const reconnectSupported = startIndex === undefined || startIndex >= 0;\n  let currentStartIndex = startIndex ?? 0;\n  let consumedFrames = 0;\n  let reconnectCount = 0;\n  let totalReconnectCount = 0;\n  let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;\n  let buffer = new Uint8Array(0);\n\n  async function connect(): Promise<void> {\n    const world = await getWorldLazy();\n    const effectiveStartIndex = reconnectSupported\n      ? currentStartIndex + consumedFrames\n      : startIndex;\n    const stream = await world.streams.get(runId, name, effectiveStartIndex);\n    reader = stream.getReader();\n  }\n\n  async function reconnect(): Promise<void> {\n    if (reader) {\n      await reader.cancel().catch(() => {});\n      reader = undefined;\n    }\n    // Advance the resume position past the frames already delivered, then\n    // drop any partial-frame bytes — the reopened connection re-sends from a\n    // frame boundary at the new index.\n    currentStartIndex += consumedFrames;\n    consumedFrames = 0;\n    buffer = new Uint8Array(0);\n\n    // Retry the reopen itself against the reconnect budget. A transient\n    // failure of connect() — the server briefly unavailable during the\n    // reconnect window — is the exact blip this wrapper exists to survive, so\n    // count it against the budget and try again rather than treating it as\n    // fatal. Only budget exhaustion (a server that stays down) terminates the\n    // stream.\n    const maxReconnects = getFramedStreamMaxReconnects();\n    const maxTotalReconnects = getFramedStreamMaxTotalReconnects();\n    for (;;) {\n      reconnectCount++;\n      totalReconnectCount++;\n      if (reconnectCount > maxReconnects) {\n        throw new Error(\n          `Stream \"${name}\" exceeded maximum reconnection attempts (${maxReconnects})`\n        );\n      }\n      if (totalReconnectCount > maxTotalReconnects) {\n        throw new Error(\n          `Stream \"${name}\" exceeded maximum total reconnection attempts (${maxTotalReconnects})`\n        );\n      }\n      try {\n        await connect();\n        return;\n      } catch {\n        // Reopen failed transiently; loop to retry, counting against the\n        // budget so a server that never recovers still terminates the stream.\n      }\n    }\n  }\n\n  return new ReadableStream<Uint8Array>({\n    pull: async (controller) => {\n      // Loop until we emit something, hit EOF, or fatally error. Reads that\n      // only extend the in-flight-frame buffer don't enqueue anything — we\n      // keep reading rather than returning empty-handed.\n      for (;;) {\n        if (!reader) {\n          try {\n            await connect();\n          } catch (err) {\n            controller.error(err);\n            return;\n          }\n        }\n\n        let result: { done: boolean; value?: Uint8Array };\n        try {\n          // biome-ignore lint/style/noNonNullAssertion: connect() guarantees reader\n          result = await reader!.read();\n        } catch (err) {\n          if (!reconnectSupported) {\n            controller.error(err);\n            return;\n          }\n          try {\n            await reconnect();\n          } catch (reconnectErr) {\n            controller.error(reconnectErr);\n            return;\n          }\n          continue;\n        }\n\n        if (result.done || !result.value) {\n          // Clean EOF — stream is truly complete. Drop any partial-frame\n          // bytes (there shouldn't be any; a well-formed stream ends on a\n          // frame boundary).\n          reader = undefined;\n          controller.close();\n          return;\n        }\n\n        // Append to buffer and emit all complete frames.\n        const incoming = result.value;\n        if (incoming.length > 0) {\n          const combined = new Uint8Array(buffer.length + incoming.length);\n          combined.set(buffer, 0);\n          combined.set(incoming, buffer.length);\n          buffer = combined;\n        }\n\n        let emitted = false;\n        while (buffer.length >= FRAME_HEADER_SIZE) {\n          const frameLength = new DataView(\n            buffer.buffer,\n            buffer.byteOffset,\n            buffer.byteLength\n          ).getUint32(0, false);\n          const total = FRAME_HEADER_SIZE + frameLength;\n          if (buffer.length < total) break;\n          // Forward the entire framed chunk (header + payload) to the\n          // downstream deserializer, which already expects this layout.\n          controller.enqueue(buffer.slice(0, total));\n          buffer = buffer.slice(total);\n          consumedFrames++;\n          emitted = true;\n        }\n\n        if (emitted) {\n          // Forward progress on the current connection — clear the\n          // consecutive-failure budget so a long stream that reconnects\n          // many times (but keeps delivering) is never falsely capped.\n          reconnectCount = 0;\n          return;\n        }\n        // Only partial bytes — read more.\n      }\n    },\n    cancel: async () => {\n      if (reader) {\n        await reader.cancel().catch((err) => {\n          console.warn('Error closing ReadableStream reader:', err);\n        });\n        reader = undefined;\n      }\n    },\n  });\n}\n\n/**\n * Default flush interval in milliseconds for buffered stream writes.\n * Chunks are accumulated and flushed together to reduce network overhead.\n */\nconst STREAM_FLUSH_INTERVAL_MS = 10;\n\n/**\n * Effective default stream-flush interval (a `world.streamFlushIntervalMs`\n * still takes precedence). Override: `WORKFLOW_STREAM_FLUSH_INTERVAL_MS`.\n */\nconst getStreamFlushIntervalMs = (): number =>\n  envNumber('WORKFLOW_STREAM_FLUSH_INTERVAL_MS', STREAM_FLUSH_INTERVAL_MS, {\n    integer: true,\n  });\n\nexport class WorkflowServerWritableStream extends WritableStream<Uint8Array> {\n  /**\n   * @param runReadyBarrier Turbo mode only: a promise that resolves once the\n   * backgrounded `run_started` has landed. When the step body runs\n   * optimistically (before `run_started` is durable), the first chunk write to\n   * a brand-new stream would otherwise reach the World before the run exists\n   * and be rejected as run-not-found. Awaiting this once before the first\n   * flush/close orders the write after the run's creation. `undefined` outside\n   * turbo and on the await path, where the run was already durable.\n   */\n  constructor(runId: string, name: string, runReadyBarrier?: Promise<unknown>) {\n    if (typeof runId !== 'string') {\n      throw new WorkflowRuntimeError(\n        `\"runId\" must be a string, got \"${typeof runId}\"`\n      );\n    }\n    if (typeof name !== 'string' || name.length === 0) {\n      throw new WorkflowRuntimeError(`\"name\" is required, got \"${name}\"`);\n    }\n    const worldPromise = getWorldLazy();\n\n    // Hold the first server write until the run exists (turbo optimistic\n    // start). Awaited once, then cleared so later flushes pay nothing. The\n    // rejection is swallowed for ordering only: if `run_started` truly failed\n    // the run does not exist, so the write below surfaces the real error.\n    let pendingRunReady: Promise<unknown> | undefined = runReadyBarrier;\n    const ensureRunReady = async (): Promise<void> => {\n      if (pendingRunReady) {\n        try {\n          await pendingRunReady;\n        } catch {\n          // intentional: ordering barrier only — see above.\n        }\n        pendingRunReady = undefined;\n      }\n    };\n\n    // Buffering state for batched writes\n    // Encryption/decryption is handled at the framing level by\n    // getSerializeStream/getDeserializeStream, not here.\n    let buffer: Uint8Array[] = [];\n    let flushTimer: ReturnType<typeof setTimeout> | null = null;\n    let flushPromise: Promise<void> | null = null;\n    let resolvedFlushIntervalMs: number | undefined;\n\n    const flush = async (): Promise<void> => {\n      if (flushTimer) {\n        clearTimeout(flushTimer);\n        flushTimer = null;\n      }\n\n      if (buffer.length === 0) return;\n\n      // Order the first server write after the run exists (turbo optimistic\n      // start); a no-op on every later flush and outside turbo.\n      await ensureRunReady();\n\n      // Copy chunks to flush, but don't clear buffer until write succeeds\n      // This prevents data loss if the write operation fails\n      const chunksToFlush = buffer.slice();\n\n      const world = await worldPromise;\n      // Cache the flush interval from the world on first use\n      if (resolvedFlushIntervalMs === undefined) {\n        resolvedFlushIntervalMs =\n          world.streamFlushIntervalMs ?? getStreamFlushIntervalMs();\n      }\n      // Use writeMulti if available for batch writes\n      if (\n        typeof world.streams.writeMulti === 'function' &&\n        chunksToFlush.length > 1\n      ) {\n        await world.streams.writeMulti(runId, name, chunksToFlush);\n      } else {\n        // Fall back to sequential writes\n        for (const chunk of chunksToFlush) {\n          await world.streams.write(runId, name, chunk);\n        }\n      }\n\n      // Only clear buffer after successful write to prevent data loss\n      buffer = [];\n    };\n\n    /** Resolvers/rejectors waiting for the current scheduled flush */\n    let flushWaiters: Array<{\n      resolve: () => void;\n      reject: (err: unknown) => void;\n    }> = [];\n\n    const scheduleFlush = (): void => {\n      if (flushTimer) return; // Already scheduled\n\n      flushTimer = setTimeout(() => {\n        flushTimer = null;\n        const currentWaiters = flushWaiters;\n        flushWaiters = [];\n        flushPromise = flush().then(\n          () => {\n            for (const w of currentWaiters) w.resolve();\n          },\n          (err) => {\n            for (const w of currentWaiters) w.reject(err);\n          }\n        );\n      }, resolvedFlushIntervalMs ?? getStreamFlushIntervalMs());\n    };\n\n    super({\n      async write(chunk) {\n        // Wait for any in-progress flush to complete before adding to buffer\n        if (flushPromise) {\n          await flushPromise;\n          flushPromise = null;\n        }\n\n        buffer.push(chunk);\n        scheduleFlush();\n\n        // Wait for the scheduled flush to complete so that callers\n        // (like flushablePipe) know data has reached the server\n        // before decrementing pendingOps. Without this, pendingOps\n        // reaches 0 when the buffered write returns (instant), but\n        // the 10ms flush timer hasn't fired yet.\n        await new Promise<void>((resolve, reject) => {\n          flushWaiters.push({ resolve, reject });\n        });\n      },\n      async close() {\n        // Wait for any in-progress flush to complete\n        if (flushPromise) {\n          await flushPromise;\n          flushPromise = null;\n        }\n\n        // Flush any remaining buffered chunks\n        await flush();\n\n        // A close with an empty buffer skips flush()'s write (and its barrier),\n        // but can itself be the first write to a brand-new stream — gate it too.\n        await ensureRunReady();\n\n        const world = await worldPromise;\n        await world.streams.close(runId, name);\n      },\n      abort(reason) {\n        // Clean up timer to prevent leaks\n        if (flushTimer) {\n          clearTimeout(flushTimer);\n          flushTimer = null;\n        }\n        // Discard buffered chunks - they won't be written\n        buffer = [];\n        // Reject any pending flushWaiters so the write() promises settle\n        // and don't leak. Without this, write() hangs forever on an\n        // unsettled promise because the cleared timer will never fire.\n        const waiters = flushWaiters;\n        flushWaiters = [];\n        const abortError = reason ?? new Error('Stream aborted');\n        for (const w of waiters) w.reject(abortError);\n      },\n    });\n  }\n}\n\n// Re-export types from the modular serialization modules.\nexport type {\n  ByteStreamFraming,\n  Reducers,\n  Revivers,\n  SerializableSpecial,\n} from './serialization/types.js';\n\n// Import types locally for use within this file.\nimport type {\n  ByteStreamFraming,\n  Reducers,\n  Revivers,\n  SerializableSpecial,\n} from './serialization/types.js';\n\n// ---- Composed reducers ----\n// Composes modular reducers (common, class, step-function) with\n// mode-specific Request/Response/Stream reducers below.\n\n/**\n * Base reducers shared across all serialization boundaries.\n * Composes: class + step-function + common reducers from the modular modules.\n */\nfunction getAllBaseReducers(\n  global: Record<string, any> = globalThis\n): Partial<Reducers> {\n  // Class/Instance MUST come before Error so that custom Error subclasses\n  // with WORKFLOW_SERIALIZE take precedence (devalue uses first-match-wins).\n  return {\n    ...getClassReducers(),\n    ...getStepFunctionReducer(),\n    ...getCommonReducers(global),\n    // Request and Response reducers are mode-specific and added by\n    // getExternalReducers / getWorkflowReducers / getStepReducers below.\n    Request: (value) => {\n      if (!(value instanceof global.Request)) return false;\n      const data: SerializableSpecial['Request'] = {\n        method: value.method,\n        url: value.url,\n        headers: value.headers,\n        body: value.body,\n        duplex: value.duplex,\n      };\n      const responseWritable = value[WEBHOOK_RESPONSE_WRITABLE];\n      if (responseWritable) {\n        data.responseWritable = responseWritable;\n      }\n      // Forward the signal in two cases:\n      //   1. Already aborted — preserve aborted=true/reason so the hydrated\n      //      step sees the cancellation that happened before serialize.\n      //   2. Already tagged with workflow infrastructure — i.e. a signal\n      //      from a workflow-managed AbortController, which has stream/hook\n      //      backing for cross-boundary propagation.\n      // Plain non-aborted native signals are intentionally dropped (would\n      // mint stream infra for every Request, including the auto-generated\n      // signal on `new Request(url)`).\n      if (\n        value.signal &&\n        (value.signal.aborted ||\n          (value.signal as AbortInternals)[ABORT_STREAM_NAME])\n      ) {\n        data.signal = value.signal;\n      }\n      return data;\n    },\n    Response: (value) => {\n      if (!(value instanceof global.Response)) return false;\n      return {\n        type: value.type,\n        url: value.url,\n        status: value.status,\n        statusText: value.statusText,\n        headers: value.headers,\n        body: value.body,\n        redirected: value.redirected,\n      };\n    },\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Shared abort reducer helpers\n// ---------------------------------------------------------------------------\n\ntype AbortSerializedData = {\n  streamName: string;\n  hookToken: string;\n  aborted: boolean;\n  reason: unknown;\n};\n\n/**\n * Symbol-keyed internal fields tagged onto AbortController/AbortSignal\n * instances (and `holder`s in reducer helpers). All optional — a plain\n * native instance has none of them set.\n */\ntype AbortInternals = {\n  [ABORT_STREAM_NAME]?: string;\n  [ABORT_HOOK_TOKEN]?: string;\n  [ABORT_READER_CANCEL]?: AbortController;\n};\n\ntype AbortSignalLike = AbortInternals & {\n  aborted: boolean;\n  reason?: unknown;\n  addEventListener?: Function;\n};\n\ntype AbortHolder = AbortInternals & { signal?: AbortInternals };\n\n/**\n * Shared logic for AbortController/AbortSignal reducers in external and step\n * contexts. Assigns stream/hook names if not already present, optionally\n * attaches an abort listener for real-time propagation, and returns the\n * serialized representation.\n */\nfunction reduceAbortWithListener(\n  signal: AbortSignalLike,\n  holder: AbortHolder,\n  global: Record<string, any>,\n  ops: Promise<void>[],\n  runId: string,\n  cryptoKey: EncryptionKeyParam\n): AbortSerializedData {\n  let streamName = holder[ABORT_STREAM_NAME];\n  let hookToken = holder[ABORT_HOOK_TOKEN];\n  if (!streamName) {\n    const id = ((global as any)[STABLE_ULID] || defaultUlid)();\n    streamName = getAbortStreamId(id);\n    hookToken = `abrt_${id}`;\n    holder[ABORT_STREAM_NAME] = streamName;\n    holder[ABORT_HOOK_TOKEN] = hookToken;\n    if (holder.signal) {\n      holder.signal[ABORT_STREAM_NAME] = streamName;\n      holder.signal[ABORT_HOOK_TOKEN] = hookToken;\n    }\n  }\n\n  // Deduped via ABORT_LISTENER_ATTACHED marker — see attachAbortListenerOnce.\n  attachAbortListenerOnce(\n    signal as AbortSignal,\n    streamName,\n    runId,\n    cryptoKey,\n    ops\n  );\n\n  return {\n    streamName,\n    hookToken: hookToken!,\n    aborted: signal.aborted,\n    reason: signal.aborted ? signal.reason : undefined,\n  };\n}\n\n/**\n * Shared logic for AbortController/AbortSignal reducers in workflow context.\n * Reads existing stream/hook names from symbols (must already be set).\n */\nfunction reduceAbortBySymbol(\n  signal: { aborted: boolean; reason?: unknown },\n  holder: AbortHolder\n): AbortSerializedData | false {\n  const streamName =\n    holder[ABORT_STREAM_NAME] ?? holder.signal?.[ABORT_STREAM_NAME];\n  const hookToken =\n    holder[ABORT_HOOK_TOKEN] ?? holder.signal?.[ABORT_HOOK_TOKEN];\n  if (!streamName) {\n    throw new Error('AbortController/AbortSignal stream name is not set');\n  }\n  return {\n    streamName,\n    hookToken: hookToken!,\n    aborted: signal.aborted,\n    reason: signal.aborted ? signal.reason : undefined,\n  };\n}\n\n/**\n * Attach a single abort listener to a signal, deduped across calls.\n *\n * Each serialization pass goes through the reducer, but a controller passed\n * to N steps would otherwise accumulate N listeners — each writing the same\n * stream packet and double-closing the stream on abort. The marker symbol\n * ensures the stream-write side-effect runs at most once per (signal, runId).\n */\nfunction attachAbortListenerOnce(\n  signal: AbortSignal,\n  streamName: string,\n  runId: string,\n  cryptoKey: EncryptionKeyParam,\n  ops: Promise<void>[]\n): void {\n  if (signal.aborted) return;\n  if ((signal as any)[ABORT_LISTENER_ATTACHED]) return;\n  (signal as any)[ABORT_LISTENER_ATTACHED] = true;\n\n  signal.addEventListener(\n    'abort',\n    () => {\n      ops.push(\n        (async () => {\n          try {\n            // Dehydrate via the same machinery the reader uses (hydrateStepArguments)\n            // so the reason round-trips with full type fidelity (DOMException,\n            // Errors, custom classes, etc.) and respects the run's encryption key.\n            // A bare JSON.stringify here would write a packet the reader can't\n            // decode and the listener-side abort would propagate with no reason.\n            const key = await resolveEncryptionKey(cryptoKey);\n            const payload = await dehydrateStepArguments(\n              { aborted: true, reason: signal.reason },\n              runId,\n              key\n            );\n            const writable = new WorkflowServerWritableStream(\n              runId,\n              streamName\n            );\n            const writer = writable.getWriter();\n            await writer.write(payload as Uint8Array);\n            await writer.close();\n          } catch {\n            // Best-effort stream write\n          }\n        })()\n      );\n    },\n    { once: true }\n  );\n}\n\n/**\n * Reducers for serialization boundary from the client side, passing arguments\n * to the workflow handler.\n *\n * @param global\n * @param ops\n * @param runId\n * @param cryptoKey\n * @param framedByteStreams - When `true`, byte streams (`type: 'bytes'`)\n *   are wrapped in length-prefixed frames on the wire so the consumer\n *   can reconnect on transient errors. Should match the target run's\n *   capability — see `getRunCapabilities` in `capabilities.ts`. Defaults\n *   to `false` for backwards compatibility with older runs.\n * @returns\n */\nexport function getExternalReducers(\n  global: Record<string, any> = globalThis,\n  ops: Promise<void>[],\n  runId: string,\n  cryptoKey: EncryptionKeyParam,\n  framedByteStreams = false,\n  // Turbo optimistic start: a nested `ReadableStream` found while serializing\n  // is piped to its own server stream independently of the outer sink, so its\n  // first chunk can race `run_started`. Thread the run-ready barrier into that\n  // sink so the write orders after the run exists. Undefined outside turbo /\n  // on the await path.\n  runReadyBarrier?: Promise<unknown>\n): Partial<Reducers> {\n  return {\n    ...getAllBaseReducers(global),\n\n    ReadableStream: (value) => {\n      if (!(value instanceof global.ReadableStream)) return false;\n\n      // Stream must not be locked when passing across execution boundary\n      if (value.locked) {\n        throw new SerializationError(\n          'ReadableStream is locked and cannot be passed across a workflow boundary.',\n          {\n            hint: 'Pass the stream before calling .getReader() / .pipeThrough() / .pipeTo(), or tee it with .tee() and pass one of the branches.',\n          }\n        );\n      }\n\n      const streamId = ((global as any)[STABLE_ULID] || defaultUlid)();\n      const name = `strm_${streamId}`;\n      const type = getStreamType(value);\n\n      const writable = new WorkflowServerWritableStream(\n        runId,\n        name,\n        runReadyBarrier\n      );\n      if (type === 'bytes') {\n        if (framedByteStreams) {\n          ops.push(value.pipeThrough(getByteFramingStream()).pipeTo(writable));\n        } else {\n          ops.push(value.pipeTo(writable));\n        }\n      } else {\n        ops.push(\n          value\n            .pipeThrough(\n              getSerializeStream(\n                getExternalReducers(\n                  global,\n                  ops,\n                  runId,\n                  cryptoKey,\n                  framedByteStreams,\n                  runReadyBarrier\n                ),\n                cryptoKey\n              )\n            )\n            .pipeTo(writable)\n        );\n      }\n\n      const s: SerializableSpecial['ReadableStream'] = { name };\n      if (type) s.type = type;\n      if (type === 'bytes' && framedByteStreams) s.framing = 'framed-v1';\n      return s;\n    },\n\n    WritableStream: (value) => {\n      if (!(value instanceof global.WritableStream)) return false;\n\n      // Fast path: when the writable is already backed by a workflow\n      // server stream (e.g. it came from a step-context `getWritable()`\n      // or was hydrated from a workflow input by `getStepRevivers`),\n      // forward its underlying `(runId, name)` to the receiving run.\n      // The receiving run's step-side reviver opens a server writable\n      // against the original `(runId, name)` and resolves that run's\n      // encryption key directly, so writes land on the original stream\n      // for the full lifetime of the receiving run — no in-process\n      // bridge tied to the dehydrating step's lifetime.\n      const existingName = (value as any)[STREAM_NAME_SYMBOL];\n      const existingRunId = (value as any)[STREAM_SERVER_RUN_ID_SYMBOL];\n      if (\n        typeof existingName === 'string' &&\n        typeof existingRunId === 'string'\n      ) {\n        const descriptor: SerializableSpecial['WritableStream'] = {\n          name: existingName,\n          runId: existingRunId,\n        };\n        const existingDeploymentId = (value as any)[\n          STREAM_SERVER_DEPLOYMENT_ID_SYMBOL\n        ];\n        if (typeof existingDeploymentId === 'string') {\n          descriptor.deploymentId = existingDeploymentId;\n        }\n        return descriptor;\n      }\n\n      const streamId = ((global as any)[STABLE_ULID] || defaultUlid)();\n      const name = `strm_${streamId}`;\n      const readable = new WorkflowServerReadableStream(runId, name);\n      ops.push(readable.pipeTo(value));\n\n      return { name };\n    },\n\n    AbortController: (value) => {\n      if (\n        !global.AbortController ||\n        typeof global.AbortController !== 'function' ||\n        !(value instanceof global.AbortController)\n      )\n        return false;\n      return reduceAbortWithListener(\n        value.signal,\n        value,\n        global,\n        ops,\n        runId,\n        cryptoKey\n      );\n    },\n\n    AbortSignal: (value) => {\n      if (\n        !global.AbortSignal ||\n        typeof global.AbortSignal !== 'function' ||\n        !(value instanceof global.AbortSignal)\n      )\n        return false;\n      return reduceAbortWithListener(\n        value,\n        value,\n        global,\n        ops,\n        runId,\n        cryptoKey\n      );\n    },\n  };\n}\n\n/**\n * Reducers for serialization boundary from within the workflow execution\n * environment, passing return value to the client side and into step arguments.\n *\n * @param global\n * @returns\n */\nexport function getWorkflowReducers(\n  global: Record<string, any> = globalThis\n): Partial<Reducers> {\n  return {\n    ...getAllBaseReducers(global),\n\n    // Readable/Writable streams from within the workflow execution environment\n    // are simply \"handles\" that can be passed around to other steps.\n    ReadableStream: (value) => {\n      if (!(value instanceof global.ReadableStream)) return false;\n\n      // Check if this is a fake stream storing BodyInit from Request/Response constructor\n      const bodyInit = value[BODY_INIT_SYMBOL];\n      if (bodyInit !== undefined) {\n        // This is a fake stream - serialize the BodyInit directly\n        // devalue will handle serializing strings, Uint8Array, etc.\n        return { bodyInit };\n      }\n\n      const name = value[STREAM_NAME_SYMBOL];\n      if (!name) {\n        throw new WorkflowRuntimeError('ReadableStream `name` is not set');\n      }\n      const s: SerializableSpecial['ReadableStream'] = { name };\n      const type = value[STREAM_TYPE_SYMBOL];\n      if (type) s.type = type;\n      const framing: ByteStreamFraming | undefined =\n        value[STREAM_FRAMING_SYMBOL];\n      if (framing) s.framing = framing;\n      return s;\n    },\n    WritableStream: (value) => {\n      if (!(value instanceof global.WritableStream)) return false;\n      const name = value[STREAM_NAME_SYMBOL];\n      if (!name) {\n        throw new WorkflowRuntimeError('WritableStream `name` is not set');\n      }\n      const s: SerializableSpecial['WritableStream'] = { name };\n      // When the handle was forwarded from another run (parent → child\n      // via `start()`), preserve the foreign runId so the step-side\n      // reviver opens the writable against the original stream.\n      const foreignRunId = value[STREAM_SERVER_RUN_ID_SYMBOL];\n      if (typeof foreignRunId === 'string') s.runId = foreignRunId;\n      const foreignDeploymentId = value[STREAM_SERVER_DEPLOYMENT_ID_SYMBOL];\n      if (typeof foreignDeploymentId === 'string') {\n        s.deploymentId = foreignDeploymentId;\n      }\n      return s;\n    },\n\n    // AbortController/AbortSignal in workflow context — just read symbols (handles).\n    // In the workflow VM, global.AbortController is a class but global.AbortSignal\n    // is a plain object (not a class), so instanceof checks won't work for signals.\n    // Detect instances by the presence of the ABORT_STREAM_NAME symbol instead.\n    AbortController: (value) => {\n      if (!value || !value.signal) return false;\n      const holder = value as AbortController & AbortHolder;\n      const hasAbortSymbol =\n        holder[ABORT_STREAM_NAME] ?? holder.signal?.[ABORT_STREAM_NAME];\n      const isNativeAbortController =\n        global.AbortController &&\n        typeof global.AbortController === 'function' &&\n        value instanceof global.AbortController;\n      if (!hasAbortSymbol && !isNativeAbortController) return false;\n      return reduceAbortBySymbol(value.signal, holder);\n    },\n    AbortSignal: (value) => {\n      const signal = value as (AbortSignal & AbortInternals) | undefined;\n      const hasAbortSymbol = signal?.[ABORT_STREAM_NAME];\n      const isNativeAbortSignal =\n        global.AbortSignal &&\n        typeof global.AbortSignal === 'function' &&\n        value instanceof global.AbortSignal;\n      if (!hasAbortSymbol && !isNativeAbortSignal) return false;\n      return reduceAbortBySymbol(value, value as AbortHolder);\n    },\n  };\n}\n\n/**\n * Reducers for serialization boundary from within the step execution\n * environment, passing return value to the workflow handler.\n *\n * @param global\n * @param ops\n * @param runId\n * @returns\n */\nfunction getStepReducers(\n  global: Record<string, any> = globalThis,\n  ops: Promise<void>[],\n  runId: string,\n  cryptoKey: EncryptionKeyParam,\n  framedByteStreams = false,\n  // Turbo optimistic start: a returned `ReadableStream` is piped to the server\n  // after the body but within the same op flush, so its first chunk can race\n  // `run_started`. Thread the run-ready barrier into the sink so that write\n  // orders after the run exists. Undefined outside turbo / on the await path.\n  runReadyBarrier?: Promise<unknown>\n): Partial<Reducers> {\n  return {\n    ...getAllBaseReducers(global),\n\n    ReadableStream: (value) => {\n      if (!(value instanceof global.ReadableStream)) return false;\n\n      // Stream must not be locked when passing across execution boundary\n      if (value.locked) {\n        throw new SerializationError(\n          'ReadableStream is locked and cannot be passed across a workflow boundary.',\n          {\n            hint: 'Pass the stream before calling .getReader() / .pipeThrough() / .pipeTo(), or tee it with .tee() and pass one of the branches.',\n          }\n        );\n      }\n\n      // Check if the stream already has the name symbol set, in which case\n      // it's already being sunk to the server and we can just return the\n      // name and type.\n      let name = value[STREAM_NAME_SYMBOL];\n      let type = value[STREAM_TYPE_SYMBOL];\n      // The framing symbol is set when a workflow VM revives a stream\n      // handle from a previous step (see `getWorkflowRevivers`). When\n      // present we must propagate the same framing choice on the way\n      // back out, since the bytes already on the server's stream are in\n      // that format — switching format mid-stream would corrupt them.\n      let framing: ByteStreamFraming | undefined = value[STREAM_FRAMING_SYMBOL];\n\n      if (!name) {\n        const streamId = ((global as any)[STABLE_ULID] || defaultUlid)();\n        name = `strm_${streamId}`;\n        type = getStreamType(value);\n        framing = type === 'bytes' && framedByteStreams ? 'framed-v1' : framing;\n\n        const writable = new WorkflowServerWritableStream(\n          runId,\n          name,\n          runReadyBarrier\n        );\n        if (type === 'bytes') {\n          if (framing === 'framed-v1') {\n            ops.push(\n              value.pipeThrough(getByteFramingStream()).pipeTo(writable)\n            );\n          } else {\n            ops.push(value.pipeTo(writable));\n          }\n        } else {\n          ops.push(\n            value\n              .pipeThrough(\n                getSerializeStream(\n                  getStepReducers(\n                    global,\n                    ops,\n                    runId,\n                    cryptoKey,\n                    framedByteStreams,\n                    runReadyBarrier\n                  ),\n                  cryptoKey\n                )\n              )\n              .pipeTo(writable)\n          );\n        }\n      }\n\n      const s: SerializableSpecial['ReadableStream'] = { name };\n      if (type) s.type = type;\n      if (framing) s.framing = framing;\n      return s;\n    },\n\n    WritableStream: (value) => {\n      if (!(value instanceof global.WritableStream)) return false;\n\n      let name = value[STREAM_NAME_SYMBOL];\n      const foreignRunId = (value as any)[STREAM_SERVER_RUN_ID_SYMBOL];\n      if (!name) {\n        const streamId = ((global as any)[STABLE_ULID] || defaultUlid)();\n        name = `strm_${streamId}`;\n        ops.push(\n          new WorkflowServerReadableStream(runId, name)\n            .pipeThrough(\n              getDeserializeStream(\n                getStepRevivers(global, ops, runId, cryptoKey),\n                cryptoKey\n              )\n            )\n            .pipeTo(value)\n        );\n      }\n\n      const s: SerializableSpecial['WritableStream'] = { name };\n      if (typeof foreignRunId === 'string') s.runId = foreignRunId;\n      const foreignDeploymentId = (value as any)[\n        STREAM_SERVER_DEPLOYMENT_ID_SYMBOL\n      ];\n      if (typeof foreignDeploymentId === 'string') {\n        s.deploymentId = foreignDeploymentId;\n      }\n      return s;\n    },\n\n    AbortController: (value) => {\n      if (\n        !global.AbortController ||\n        typeof global.AbortController !== 'function' ||\n        !(value instanceof global.AbortController)\n      )\n        return false;\n      return reduceAbortWithListener(\n        value.signal,\n        value,\n        global,\n        ops,\n        runId,\n        cryptoKey\n      );\n    },\n\n    AbortSignal: (value) => {\n      if (\n        !global.AbortSignal ||\n        typeof global.AbortSignal !== 'function' ||\n        !(value instanceof global.AbortSignal)\n      )\n        return false;\n      return reduceAbortWithListener(\n        value,\n        value,\n        global,\n        ops,\n        runId,\n        cryptoKey\n      );\n    },\n  };\n}\n\n/**\n * Cancel dangling abort-stream readers on any AbortController instances found\n * in the hydrated step arguments. Called after the step function returns\n * (success or failure) to prevent reader promises from keeping the serverless\n * function alive indefinitely.\n */\nexport function cancelAbortReaders(...values: unknown[]): void {\n  const visited = new WeakSet();\n  function cancelIfPresent(val: AbortInternals): void {\n    const cancel = val[ABORT_READER_CANCEL];\n    if (cancel && !cancel.signal.aborted) {\n      cancel.abort();\n    }\n  }\n  function walk(val: unknown): void {\n    if (val == null || typeof val !== 'object') return;\n    if (visited.has(val as object)) return;\n    visited.add(val as object);\n    if (val instanceof AbortController) {\n      cancelIfPresent(val as AbortController & AbortInternals);\n      cancelIfPresent(val.signal as AbortSignal & AbortInternals);\n      return;\n    }\n    if (val instanceof AbortSignal) {\n      cancelIfPresent(val as AbortSignal & AbortInternals);\n      return;\n    }\n    if (Array.isArray(val)) {\n      for (const item of val) walk(item);\n      return;\n    }\n    if (val instanceof Map) {\n      for (const v of val.values()) walk(v);\n      return;\n    }\n    if (val instanceof Set) {\n      for (const v of val) walk(v);\n      return;\n    }\n    // Request/Response expose `signal`/`body` as prototype getters, so\n    // Object.values() won't find them. Descend explicitly.\n    if (typeof Request !== 'undefined' && val instanceof Request) {\n      walk(val.signal);\n      return;\n    }\n    for (const v of Object.values(val as Record<string, unknown>)) walk(v);\n  }\n  for (const v of values) walk(v);\n}\n\n/**\n * Sets up a stream reader on the controller that listens for an abort packet.\n * Returns the readerCancel controller so it can be stored on both the\n * controller and signal for cleanup by cancelAbortReaders.\n */\nfunction setupAbortStreamReader(\n  controller: AbortController,\n  runId: string,\n  streamName: string,\n  ops: Promise<void>[]\n): AbortController {\n  const readerCancel = new AbortController();\n\n  ops.push(\n    (async () => {\n      try {\n        const readable = new WorkflowServerReadableStream(runId, streamName);\n        const reader = readable.getReader();\n        const result = await Promise.race([\n          reader.read(),\n          new Promise<{ value: undefined; done: true }>((resolve) => {\n            if (readerCancel.signal.aborted) {\n              resolve({ value: undefined, done: true });\n              return;\n            }\n            readerCancel.signal.addEventListener(\n              'abort',\n              () => resolve({ value: undefined, done: true }),\n              { once: true }\n            );\n          }),\n        ]);\n        if (result.value && !result.done) {\n          // An abort packet arrived: propagate it as fast as possible. Release\n          // the lock (synchronous) rather than cancelling here — on a\n          // service-backed World `reader.cancel()` can do a network round-trip,\n          // and awaiting it before `controller.abort()` would delay (or, if it\n          // hangs, drop) real-time abort delivery to the in-flight step.\n          try {\n            reader.releaseLock();\n          } catch {\n            // Reader may already be released; ignore.\n          }\n          try {\n            // Hydrate via the same machinery the writer used so the reason\n            // round-trips with full type fidelity. Encryption key (if any)\n            // comes from the step context — set up by the step handler before\n            // this reader runs. Fallback to undefined for external-context\n            // revives (the hydrate path is encryption-key-tolerant).\n            const ctxForKey = contextStorage.getStore();\n            const data = (await hydrateStepArguments(\n              result.value,\n              runId,\n              ctxForKey?.encryptionKey\n            )) as { reason?: unknown } | undefined;\n            controller.abort(data?.reason);\n          } catch {\n            controller.abort();\n          }\n        } else {\n          // The step finished (or the reader was cancelled) without an abort.\n          // Cancel — not just release — so the underlying World stream is torn\n          // down: a polling World (e.g. world-local) otherwise leaks a tail\n          // reader (a 100ms filesystem poll plus emitter listeners) per step\n          // invocation for the life of the process, since a signal-bearing step\n          // opens one of these on every revival and usually never aborts. Fire\n          // and forget: a service-backed World's cancel may hit the network,\n          // and this path must not block the step's ops-settle window.\n          void reader.cancel().catch(() => {});\n        }\n      } catch {\n        // Stream read failed — signal won't propagate in real-time,\n        // but hook-based propagation on next replay provides fallback\n      }\n    })()\n  );\n\n  return readerCancel;\n}\n\n/**\n * Stores abort serialization symbols and the readerCancel controller\n * on both the controller and its signal.\n */\nfunction tagAbortPair(\n  controller: AbortController,\n  value: { streamName: string; hookToken: string },\n  readerCancel?: AbortController\n): void {\n  const taggedController = controller as AbortController & AbortInternals;\n  const taggedSignal = controller.signal as AbortSignal & AbortInternals;\n  taggedController[ABORT_STREAM_NAME] = value.streamName;\n  taggedController[ABORT_HOOK_TOKEN] = value.hookToken;\n  taggedSignal[ABORT_STREAM_NAME] = value.streamName;\n  taggedSignal[ABORT_HOOK_TOKEN] = value.hookToken;\n  if (readerCancel) {\n    taggedController[ABORT_READER_CANCEL] = readerCancel;\n    taggedSignal[ABORT_READER_CANCEL] = readerCancel;\n  }\n}\n\n/**\n * Propagate abort-internal symbols from one signal to another. Used by the\n * Request reviver because `new Request(url, { signal })` copies the signal\n * internally — the constructed `request.signal` is a fresh AbortSignal that\n * doesn't carry symbols from the source.\n */\nfunction copyAbortInternals(src: AbortSignal, dest: AbortSignal): void {\n  const s = src as AbortSignal & AbortInternals;\n  const d = dest as AbortSignal & AbortInternals;\n  if (s[ABORT_STREAM_NAME] !== undefined) {\n    d[ABORT_STREAM_NAME] = s[ABORT_STREAM_NAME];\n  }\n  if (s[ABORT_HOOK_TOKEN] !== undefined) {\n    d[ABORT_HOOK_TOKEN] = s[ABORT_HOOK_TOKEN];\n  }\n  if (s[ABORT_READER_CANCEL] !== undefined) {\n    d[ABORT_READER_CANCEL] = s[ABORT_READER_CANCEL];\n  }\n}\n\n/**\n * Creates an AbortController with stream-backed abort propagation.\n * Used by step and external revivers where real abort signal behavior is needed.\n *\n * @param value - The serialized abort controller/signal data\n * @param ops - The ops array for tracking async work\n * @param runId - The workflow run ID (for stream reads)\n * @returns A real AbortController with patched abort() method\n */\nfunction reviveAbortController(\n  value: SerializableSpecial['AbortController'],\n  ops: Promise<void>[],\n  runId: string\n): AbortController {\n  const controller = new AbortController();\n\n  if (value.aborted) {\n    tagAbortPair(controller, value);\n    controller.abort(value.reason);\n  } else if (value.streamName) {\n    const readerCancel = setupAbortStreamReader(\n      controller,\n      runId,\n      value.streamName,\n      ops\n    );\n    tagAbortPair(controller, value, readerCancel);\n  } else {\n    tagAbortPair(controller, value);\n  }\n\n  // Override abort() to also write stream + resume hook (for step-initiated abort)\n  const originalAbort = controller.abort.bind(controller);\n  controller.abort = (reason?: unknown) => {\n    if (controller.signal.aborted) return;\n    originalAbort(reason);\n\n    const ctx = contextStorage.getStore();\n    if (ctx) {\n      ctx.ops.push(\n        (async () => {\n          try {\n            // Dehydrate the abort payload through the same machinery the hook\n            // event uses so the `reason` round-trips with full type fidelity\n            // (DOMException, custom errors, etc.) and respects the run's\n            // encryption key — symmetric with what the suspension handler\n            // writes for workflow-initiated aborts.\n            const payload = await dehydrateStepArguments(\n              { aborted: true, reason },\n              ctx.workflowMetadata.workflowRunId,\n              ctx.encryptionKey\n            );\n            const writable = new WorkflowServerWritableStream(\n              ctx.workflowMetadata.workflowRunId,\n              value.streamName\n            );\n            const writer = writable.getWriter();\n            await writer.write(payload as Uint8Array);\n            await writer.close();\n          } catch {\n            // Best-effort stream write\n          }\n        })()\n      );\n\n      if (value.hookToken) {\n        // The durable hook resume (which writes the `hook_received` event that\n        // records this abort in the workflow's event log) must be committed\n        // before the step completes. Otherwise the workflow continuation\n        // enqueued by `step_completed` can advance past the abort — dispatching\n        // a later step with a stale, non-aborted `signal` — before the event\n        // exists. Route it to `preCompletionOps` (awaited inline before\n        // completion) rather than `ops` (best-effort, background). The stream\n        // write above stays in `ops`: it must fire ASAP to reach an in-flight\n        // sibling step and is not the durable record.\n        // Swallow errors here so the promise can only ever enforce ordering\n        // when awaited (see the no-reject contract on\n        // StepContext.preCompletionOps); a failed resume retries on next replay.\n        const hookResume = (async () => {\n          try {\n            const { resumeHook: resumeHookFn } = await import(\n              './runtime/resume-hook.js'\n            );\n            await resumeHookFn(value.hookToken, {\n              aborted: true,\n              reason,\n            });\n          } catch {\n            // Best-effort hook resume — retry on next replay\n          }\n        })();\n        ctx.preCompletionOps.push(hookResume);\n      }\n    }\n  };\n\n  return controller;\n}\n\n/**\n * Revives just an AbortSignal without the patched abort() overhead.\n * Used when only a signal (not a controller) was serialized.\n */\nfunction reviveAbortSignal(\n  value: SerializableSpecial['AbortSignal'],\n  ops: Promise<void>[],\n  runId: string\n): AbortSignal {\n  const controller = new AbortController();\n\n  if (value.aborted) {\n    tagAbortPair(controller, value);\n    controller.abort(value.reason);\n  } else if (value.streamName) {\n    const readerCancel = setupAbortStreamReader(\n      controller,\n      runId,\n      value.streamName,\n      ops\n    );\n    tagAbortPair(controller, value, readerCancel);\n  } else {\n    tagAbortPair(controller, value);\n  }\n\n  return controller.signal;\n}\n\n/**\n * Base revivers shared across all serialization boundaries.\n * Composes: class + common revivers from the modular modules.\n *\n * This is exported because serialization-format.ts and other files reference it.\n */\nexport function getCommonRevivers(global: Record<string, any> = globalThis) {\n  return {\n    ...getClassRevivers(global),\n    ...getCommonReviversFromModule(global),\n  } as const satisfies Partial<Revivers>;\n}\n\n/**\n * Resolve the encrypt-only key needed when a child writes into another run's\n * stream. New descriptors include the owner's deployment ID; descriptors\n * created by older SDK versions fall back to loading the owning run.\n */\nasync function getForwardedWritableEncryptionKey(\n  runId: string,\n  deploymentId: string | undefined\n): Promise<CryptoKey | undefined> {\n  const world = await getWorldLazy();\n  if (!world.getEncryptionKeyForRun) return undefined;\n\n  const rawKey = deploymentId\n    ? await world.getEncryptionKeyForRun(runId, { deploymentId })\n    : await world.getEncryptionKeyForRun(await world.runs.get(runId));\n  return rawKey ? await importKey(rawKey, ['encrypt']) : undefined;\n}\n\n/**\n * Revivers for deserialization boundary from the client side,\n * receiving the return value from the workflow handler.\n *\n * @param global\n * @param ops\n * @param runId\n */\nexport function getExternalRevivers(\n  global: Record<string, any> = globalThis,\n  ops: Promise<void>[],\n  runId: string,\n  cryptoKey: EncryptionKeyParam\n): Partial<Revivers> {\n  return {\n    ...getCommonRevivers(global),\n\n    // StepFunction should not be returned from workflows to clients\n    StepFunction: () => {\n      throw new SerializationError(\n        'Step functions cannot be deserialized in client context. Step functions should not be returned from workflows.',\n        {\n          hint: 'A step function reference reached the client. Return a serializable value (e.g. the step result) instead of the step itself.',\n        }\n      );\n    },\n\n    WorkflowFunction: (value) =>\n      Object.assign(\n        () => {\n          throw new SerializationError(\n            'Workflow functions cannot be called directly. Use start() to invoke them.',\n            {\n              hint: 'Wrap the workflow with `start(workflowFn, { ... })` from `workflow` to begin a run instead of invoking it like a normal function.',\n            }\n          );\n        },\n        { workflowId: value.workflowId }\n      ),\n\n    Request: (value) => {\n      const init: RequestInit & { duplex?: string } = {\n        method: value.method,\n        headers: new global.Headers(value.headers),\n        body: value.body,\n        duplex: value.duplex,\n      };\n      if (value.signal) init.signal = value.signal;\n      const request = new global.Request(value.url, init);\n      // The Request constructor creates an internal signal copy, so the\n      // abort-internal symbols set by reviveAbortSignal don't propagate.\n      // Re-tag the request's own signal so cancelAbortReaders can find it.\n      if (value.signal) copyAbortInternals(value.signal, request.signal);\n      return request;\n    },\n    Response: (value) => {\n      // Note: Response constructor only accepts status, statusText, and headers\n      // The type, url, and redirected properties are read-only and set by the constructor\n      return new global.Response(value.body, {\n        status: value.status,\n        statusText: value.statusText,\n        headers: new global.Headers(value.headers),\n      });\n    },\n    ReadableStream: (value) => {\n      // If this has bodyInit, it came from a Response constructor\n      // Convert it to a REAL stream now that we're outside the workflow\n      if ('bodyInit' in value) {\n        const bodyInit = value.bodyInit;\n        // Use the native Response constructor to properly convert BodyInit to ReadableStream\n        const response = new global.Response(bodyInit);\n        return response.body;\n      }\n\n      if (value.type === 'bytes') {\n        // For byte streams, use flushable pipe with lock polling.\n        // If the producer wrote framed bytes (framing === 'framed-v1'),\n        // unwrap the length-prefix envelope before handing chunks to\n        // the user. Absent / 'raw' framing means legacy raw bytes —\n        // pipe through unchanged for backwards compatibility.\n        //\n        // No auto-reconnect here yet: raw byte streams have no wire\n        // framing to count consumed chunks with. Framed-v1 byte streams\n        // make frame counting possible, so extending the reconnecting\n        // reader to them is a separate follow-up.\n        const readable = new WorkflowServerReadableStream(\n          runId,\n          value.name,\n          value.startIndex\n        );\n        const state = createFlushableState();\n        ops.push(state.promise);\n\n        // Create an identity (or unframing) transform to give the user a readable\n        const { readable: userReadable, writable } =\n          value.framing === 'framed-v1'\n            ? getByteUnframingStream()\n            : new global.TransformStream();\n\n        // Start the flushable pipe in the background\n        flushablePipe(readable, writable, state).catch(() => {\n          // Errors are handled via state.reject\n        });\n\n        // Start polling to detect when user releases lock\n        pollReadableLock(userReadable, state);\n\n        return userReadable;\n      } else {\n        // Non-byte streams carry length-prefixed frames, so we can count\n        // completed frames and transparently reconnect when the server\n        // stream connection times out mid-run.\n        const readable = createReconnectingFramedStream(\n          runId,\n          value.name,\n          value.startIndex\n        );\n        const transform = getDeserializeStream(\n          getExternalRevivers(global, ops, runId, cryptoKey),\n          cryptoKey\n        );\n        const state = createFlushableState();\n        ops.push(state.promise);\n\n        // Start the flushable pipe in the background\n        flushablePipe(readable, transform.writable, state).catch(() => {\n          // Errors are handled via state.reject\n        });\n\n        // Start polling to detect when user releases lock\n        pollReadableLock(transform.readable, state);\n\n        return transform.readable;\n      }\n    },\n    WritableStream: (value) => {\n      // Same handling as `getStepRevivers.WritableStream` — see comments\n      // there for the cross-run case (writable carries `runId` from\n      // parent → child forwarding via `start()`).\n      const targetRunId = typeof value.runId === 'string' ? value.runId : runId;\n      const targetKey: EncryptionKeyParam =\n        targetRunId === runId\n          ? cryptoKey\n          : getForwardedWritableEncryptionKey(targetRunId, value.deploymentId);\n\n      const serialize = getSerializeStream(\n        getExternalReducers(global, ops, targetRunId, targetKey),\n        targetKey\n      );\n      const serverWritable = new WorkflowServerWritableStream(\n        targetRunId,\n        value.name\n      );\n\n      // Create flushable state for this stream\n      const state = createFlushableState();\n      ops.push(state.promise);\n\n      // Start the flushable pipe in the background\n      flushablePipe(serialize.readable, serverWritable, state).catch(() => {\n        // Errors are handled via state.reject\n      });\n\n      // Start polling to detect when user releases lock\n      pollWritableLock(serialize.writable, state);\n\n      Object.defineProperty(serialize.writable, STREAM_NAME_SYMBOL, {\n        value: value.name,\n        writable: false,\n      });\n      Object.defineProperty(serialize.writable, STREAM_SERVER_RUN_ID_SYMBOL, {\n        value: targetRunId,\n        writable: false,\n      });\n      if (typeof value.deploymentId === 'string') {\n        Object.defineProperty(\n          serialize.writable,\n          STREAM_SERVER_DEPLOYMENT_ID_SYMBOL,\n          {\n            value: value.deploymentId,\n            writable: false,\n          }\n        );\n      }\n\n      return serialize.writable;\n    },\n\n    AbortController: (value) => reviveAbortController(value, ops, runId),\n    AbortSignal: (value) => reviveAbortSignal(value, ops, runId),\n  };\n}\n\n/**\n * Revivers for deserialization boundary from within the workflow execution\n * environment, receiving arguments from the client side, and return values\n * from the steps.\n *\n * @param global\n * @returns\n */\nexport function getWorkflowRevivers(\n  global: Record<string, any> = globalThis\n): Partial<Revivers> {\n  return {\n    ...getCommonRevivers(global),\n    // StepFunction reviver for workflow context - uses the modular reviver\n    // which calls WORKFLOW_USE_STEP from global to reconstruct step proxies\n    ...getStepFunctionReviver(global),\n    Request: (value) => {\n      Object.setPrototypeOf(value, global.Request.prototype);\n      const responseWritable = value.responseWritable;\n      if (responseWritable) {\n        (value as any)[WEBHOOK_RESPONSE_WRITABLE] = responseWritable;\n        delete value.responseWritable;\n        (value as any).respondWith = () => {\n          throw new SerializationError(\n            '`respondWith()` must be called from within a step function.',\n            {\n              hint: 'Move the `respondWith(...)` call inside a `\"use step\"` function — it cannot be invoked from a workflow context.',\n            }\n          );\n        };\n      }\n      return value;\n    },\n    // Workflow function reviver for workflow context — returns a function-like\n    // object with .workflowId that mimics what the SWC compiler produces,\n    WorkflowFunction: (value) =>\n      Object.assign(\n        () => {\n          throw new SerializationError(\n            'Workflow functions cannot be called directly. Use start() to invoke them.',\n            {\n              hint: 'Wrap the workflow with `start(workflowFn, { ... })` from `workflow` to begin a run instead of invoking it like a normal function.',\n            }\n          );\n        },\n        { workflowId: value.workflowId }\n      ),\n    Response: (value) => {\n      Object.setPrototypeOf(value, global.Response.prototype);\n      return value;\n    },\n    ReadableStream: (value) => {\n      // Check if this is a BodyInit that should be wrapped in a fake stream\n      if ('bodyInit' in value) {\n        // Recreate the fake stream with the BodyInit\n        return Object.create(global.ReadableStream.prototype, {\n          [BODY_INIT_SYMBOL]: {\n            value: value.bodyInit,\n            writable: false,\n          },\n        });\n      }\n\n      // Regular stream handling\n      return Object.create(global.ReadableStream.prototype, {\n        [STREAM_NAME_SYMBOL]: {\n          value: value.name,\n          writable: false,\n        },\n        [STREAM_TYPE_SYMBOL]: {\n          value: value.type,\n          writable: false,\n        },\n        // Carry the wire-framing decision through the workflow VM so\n        // that when the handle is later passed to a step (which reads\n        // the actual bytes from the server) we know whether to unframe.\n        // Defaults to undefined for streams whose serialized ref didn't\n        // carry the field — those are treated as legacy raw bytes.\n        [STREAM_FRAMING_SYMBOL]: {\n          value: value.framing,\n          writable: false,\n        },\n      });\n    },\n    WritableStream: (value) => {\n      const descriptor: PropertyDescriptorMap = {\n        [STREAM_NAME_SYMBOL]: {\n          value: value.name,\n          writable: false,\n        },\n      };\n      // Preserve the foreign runId, if present, so that when the\n      // handle is later passed to a step the workflow reducer can\n      // forward it through to the step reviver.\n      if (typeof value.runId === 'string') {\n        descriptor[STREAM_SERVER_RUN_ID_SYMBOL] = {\n          value: value.runId,\n          writable: false,\n        };\n      }\n      if (typeof value.deploymentId === 'string') {\n        descriptor[STREAM_SERVER_DEPLOYMENT_ID_SYMBOL] = {\n          value: value.deploymentId,\n          writable: false,\n        };\n      }\n      return Object.create(global.WritableStream.prototype, descriptor);\n    },\n\n    // AbortController/AbortSignal revived inside the workflow VM. Use the\n    // real WorkflowAbortSignal class so addEventListener('abort', fn) actually\n    // fires when the signal aborts (the previous no-op stub silently dropped\n    // listener registrations — silent correctness bug for natural patterns\n    // like `signal.addEventListener('abort', fn)` after receiving a deserialized\n    // signal). The signal does not own a hook subscription here — abort state\n    // is delivered via the existing replay machinery on the source side.\n    AbortController: (value) => {\n      const signal = new WorkflowAbortSignal(value.streamName, value.hookToken);\n      if (value.aborted) signal._setAborted(value.reason);\n      return {\n        [ABORT_STREAM_NAME]: value.streamName,\n        [ABORT_HOOK_TOKEN]: value.hookToken,\n        signal,\n        abort: () => {},\n      };\n    },\n    AbortSignal: (value) => {\n      const signal = new WorkflowAbortSignal(value.streamName, value.hookToken);\n      if (value.aborted) signal._setAborted(value.reason);\n      return signal;\n    },\n  };\n}\n\n/**\n * Revivers for deserialization boundary from within the step execution\n * environment, receiving arguments from the workflow handler.\n *\n * @param global\n * @param ops\n * @param runId\n * @returns\n */\nfunction getStepRevivers(\n  global: Record<string, any> = globalThis,\n  ops: Promise<void>[],\n  runId: string,\n  cryptoKey: EncryptionKeyParam,\n  deploymentId?: string\n): Partial<Revivers> {\n  return {\n    ...getCommonRevivers(global),\n\n    // StepFunction reviver for step context - returns raw step function\n    // with closure variable support via AsyncLocalStorage.\n    //\n    // Handles four independent flags from the serialized payload:\n    //   - `closureVars`: invoke the body inside an AsyncLocalStorage frame\n    //     so the SWC-emitted `WORKFLOW_STEP_CONTEXT_STORAGE` IIFE in the\n    //     hoisted body can pull the closure variables back out.\n    //   - `boundThis`:   a `this` value captured by\n    //     `useStep(...).bind(this)` in the workflow bundle (lexical-`this`\n    //     arrow steps). The wrapper invokes the body via\n    //     `stepFn.apply(boundThis, args)` so the body sees the same\n    //     `this` it would have had in the workflow bundle. Property\n    //     presence — not truthiness — is significant because\n    //     `bind(null)` and `bind(undefined)` are both legal and should\n    //     round-trip faithfully.\n    //   - `boundArgs`:   prefilled args from\n    //     `useStep(...).bind(thisArg, x, y)`. Prepended to the call args\n    //     so partial application survives serialization.\n    StepFunction: (value) => {\n      const stepId = value.stepId;\n      const closureVars = value.closureVars;\n      const hasBoundThis = 'boundThis' in value;\n      const boundThis = hasBoundThis ? value.boundThis : undefined;\n      const boundArgs = Array.isArray(value.boundArgs) ? value.boundArgs : [];\n\n      const stepFn = getStepFunction(stepId);\n      if (!stepFn) {\n        throw new SerializationError(\n          `Step function \"${stepId}\" not found. Make sure the step function is registered.`,\n          {\n            hint: 'Make sure the step file is included in your build (i.e. it is listed in the workflow manifest), and that the SWC plugin is configured for the file.',\n          }\n        );\n      }\n\n      // Fast path: nothing to wrap.\n      if (!closureVars && !hasBoundThis && boundArgs.length === 0) {\n        return stepFn;\n      }\n\n      const wrappedStepFn = function (this: unknown, ...args: any[]) {\n        const callThis = hasBoundThis ? boundThis : this;\n        const callArgs = boundArgs.length > 0 ? [...boundArgs, ...args] : args;\n        if (closureVars) {\n          const currentContext = contextStorage.getStore();\n          if (!currentContext) {\n            throw new WorkflowRuntimeError(\n              'Cannot call step function with closure variables outside step context'\n            );\n          }\n          const newContext = {\n            ...currentContext,\n            closureVars,\n          };\n          return contextStorage.run(newContext, () =>\n            stepFn.apply(callThis, callArgs)\n          );\n        }\n        return stepFn.apply(callThis, callArgs);\n      } as any;\n\n      // Copy properties from original step function\n      Object.defineProperty(wrappedStepFn, 'name', {\n        value: stepFn.name,\n      });\n      Object.defineProperty(wrappedStepFn, 'stepId', {\n        value: stepId,\n        writable: false,\n        enumerable: false,\n        configurable: false,\n      });\n      if (stepFn.maxRetries !== undefined) {\n        wrappedStepFn.maxRetries = stepFn.maxRetries;\n      }\n\n      return wrappedStepFn;\n    },\n\n    WorkflowFunction: (value) =>\n      Object.assign(\n        () => {\n          throw new SerializationError(\n            'Workflow functions cannot be called directly. Use start() to invoke them.',\n            {\n              hint: 'Wrap the workflow with `start(workflowFn, { ... })` from `workflow` to begin a run instead of invoking it like a normal function.',\n            }\n          );\n        },\n        { workflowId: value.workflowId }\n      ),\n\n    Request: (value) => {\n      const responseWritable = value.responseWritable;\n      const init: RequestInit & { duplex?: string } = {\n        method: value.method,\n        headers: new global.Headers(value.headers),\n        body: value.body,\n        duplex: value.duplex,\n      };\n      if (value.signal) init.signal = value.signal;\n      const request = new global.Request(value.url, init);\n      // The Request constructor creates an internal signal copy, so the\n      // abort-internal symbols set by reviveAbortSignal don't propagate.\n      // Re-tag the request's own signal so cancelAbortReaders can find it.\n      if (value.signal) copyAbortInternals(value.signal, request.signal);\n      if (responseWritable) {\n        request.respondWith = async (response: Response) => {\n          const writer = responseWritable.getWriter();\n          await writer.write(response);\n          await writer.close();\n        };\n      }\n      return request;\n    },\n    Response: (value) => {\n      // Note: Response constructor only accepts status, statusText, and headers\n      // The type, url, and redirected properties are read-only and set by the constructor\n      return new global.Response(value.body, {\n        status: value.status,\n        statusText: value.statusText,\n        headers: new global.Headers(value.headers),\n      });\n    },\n    ReadableStream: (value) => {\n      // If this has bodyInit, it came from a Response constructor\n      // Convert it to a REAL stream now that we're in the step environment\n      if ('bodyInit' in value) {\n        const bodyInit = value.bodyInit;\n        // Use the native Response constructor to properly convert BodyInit to ReadableStream\n        const response = new global.Response(bodyInit);\n        return response.body;\n      }\n\n      const readable = new WorkflowServerReadableStream(runId, value.name);\n      if (value.type === 'bytes') {\n        // For byte streams, use flushable pipe with lock polling.\n        // If the producer wrote framed bytes (framing === 'framed-v1'),\n        // unwrap the length-prefix envelope before handing chunks to\n        // the user step. Absent / 'raw' framing means legacy raw bytes —\n        // pipe through unchanged for backwards compatibility.\n        const state = createFlushableState();\n        ops.push(state.promise);\n\n        // Create an identity (or unframing) transform to give the user a readable\n        const { readable: userReadable, writable } =\n          value.framing === 'framed-v1'\n            ? getByteUnframingStream()\n            : new global.TransformStream();\n\n        // Start the flushable pipe in the background\n        flushablePipe(readable, writable, state).catch(() => {\n          // Errors are handled via state.reject\n        });\n\n        // Start polling to detect when user releases lock\n        pollReadableLock(userReadable, state);\n\n        return userReadable;\n      } else {\n        const transform = getDeserializeStream(\n          getStepRevivers(global, ops, runId, cryptoKey, deploymentId),\n          cryptoKey\n        );\n        const state = createFlushableState();\n        ops.push(state.promise);\n\n        // Start the flushable pipe in the background\n        flushablePipe(readable, transform.writable, state).catch(() => {\n          // Errors are handled via state.reject\n        });\n\n        // Start polling to detect when user releases lock\n        pollReadableLock(transform.readable, state);\n\n        return transform.readable;\n      }\n    },\n    WritableStream: (value) => {\n      // Same-run case: the writable belongs to the current run. Use the\n      // local cryptoKey and write to the local runId's server stream.\n      //\n      // Cross-run case (parent → child via `start()`): the descriptor\n      // carries the original `runId` and `name`. Open a server writable\n      // against the original `(runId, name)` and resolve THAT run's key\n      // for encryption. The resolution is async but doesn't need to\n      // block reviver return — `getSerializeStream` accepts the\n      // `Promise<CryptoKey | undefined>` directly and awaits it lazily\n      // on the first chunk written. The key is imported encrypt-only\n      // so the receiving run can never decrypt anything else on the\n      // owning run's stream — it can only contribute new writes.\n      const targetRunId = typeof value.runId === 'string' ? value.runId : runId;\n      const targetDeploymentId =\n        typeof value.deploymentId === 'string'\n          ? value.deploymentId\n          : targetRunId === runId\n            ? deploymentId\n            : undefined;\n      const targetKey: EncryptionKeyParam =\n        targetRunId === runId\n          ? cryptoKey\n          : getForwardedWritableEncryptionKey(targetRunId, targetDeploymentId);\n\n      const serialize = getSerializeStream(\n        getStepReducers(global, ops, targetRunId, targetKey),\n        targetKey\n      );\n      const serverWritable = new WorkflowServerWritableStream(\n        targetRunId,\n        value.name\n      );\n\n      // Create flushable state for this stream\n      const state = createFlushableState();\n      ops.push(state.promise);\n\n      // Start the flushable pipe in the background\n      flushablePipe(serialize.readable, serverWritable, state).catch(() => {\n        // Errors are handled via state.reject\n      });\n\n      // Start polling to detect when user releases lock\n      pollWritableLock(serialize.writable, state);\n\n      // Record the underlying `(runId, name)` so downstream reducers can\n      // recognize that this writable is already backed by a workflow\n      // server stream. When forwarded across `start()` again — e.g.\n      // the child passes this writable on to a grandchild — the\n      // external reducer needs both to emit the original `runId` in\n      // the descriptor.\n      Object.defineProperty(serialize.writable, STREAM_NAME_SYMBOL, {\n        value: value.name,\n        writable: false,\n      });\n      Object.defineProperty(serialize.writable, STREAM_SERVER_RUN_ID_SYMBOL, {\n        value: targetRunId,\n        writable: false,\n      });\n      if (targetDeploymentId) {\n        Object.defineProperty(\n          serialize.writable,\n          STREAM_SERVER_DEPLOYMENT_ID_SYMBOL,\n          {\n            value: targetDeploymentId,\n            writable: false,\n          }\n        );\n      }\n\n      return serialize.writable;\n    },\n\n    AbortController: (value) => reviveAbortController(value, ops, runId),\n    AbortSignal: (value) => reviveAbortSignal(value, ops, runId),\n  };\n}\n\n// ============================================================================\n// Encryption Helpers\n// ============================================================================\n// These delegate to the modular `encrypt`/`decrypt` from `./serialization/encryption.js`\n// but are kept as named exports for backwards compatibility with existing consumers.\n\n/**\n * Encrypt data if the world supports encryption.\n * Returns original data if encryption is not available.\n *\n * @deprecated Use `encrypt` from `./serialization/encryption.js` instead.\n */\nexport async function maybeEncrypt(\n  data: Uint8Array,\n  key: CryptoKey | undefined\n): Promise<Uint8Array> {\n  return (await encrypt(data, key)) as Uint8Array;\n}\n\n/**\n * Decrypt data if it has the 'encr' prefix.\n *\n * @deprecated Use `decrypt` from `./serialization/encryption.js` instead.\n */\nexport async function maybeDecrypt(\n  data: Uint8Array | unknown,\n  key: CryptoKey | undefined\n): Promise<Uint8Array | unknown> {\n  return decrypt(data, key);\n}\n\n// ============================================================================\n// Dehydrate / Hydrate Functions\n// ============================================================================\n// These delegate to the modular mode modules (workflow, step, client) passing\n// mode-specific stream and Request/Response reducers/revivers as extra options.\n// The v1Compat path is handled inline before delegating to the modules.\n\n/**\n * Called from the `start()` function to serialize the workflow arguments\n * into a format that can be saved to the database and then hydrated from\n * within the workflow execution environment.\n *\n * @param value - The value to serialize\n * @param runId - The workflow run ID (required for encryption context)\n * @param key - Encryption key (undefined to skip encryption)\n * @param ops - Promise array for stream operations\n * @param global - Global object for serialization context\n * @param v1Compat - Enable legacy v1 compatibility mode\n * @param framedByteStreams - Whether the target run can decode wire-framed\n *   byte streams. Should match the target deployment's capability — see\n *   `getRunCapabilities` in `capabilities.ts`. Defaults to `false` for\n *   backwards compatibility with older runs.\n * @returns The dehydrated value as binary data (Uint8Array) with format prefix\n */\nexport async function dehydrateWorkflowArguments(\n  value: unknown,\n  runId: string,\n  key: CryptoKey | undefined,\n  ops: Promise<void>[] = [],\n  global: Record<string, any> = globalThis,\n  v1Compat = false,\n  framedByteStreams = false,\n  compression = false\n): Promise<Uint8Array | unknown> {\n  if (v1Compat) {\n    const str = stringify(\n      value,\n      getExternalReducers(global, ops, runId, key, framedByteStreams)\n    );\n    return revive(str);\n  }\n  try {\n    const compressionStats: CompressionStats = {};\n    const result = await clientModule.serialize(value, key, {\n      global,\n      extraReducers: getStreamAndRequestReducers(\n        getExternalReducers(global, ops, runId, key, framedByteStreams)\n      ),\n      compression,\n      compressionStats,\n    });\n    await recordCompression(compressionStats, 'serialize');\n    return result;\n  } catch (error) {\n    const cause = unwrapSerializationCause(error);\n    const { message, hint } = formatSerializationError(\n      'workflow arguments',\n      cause\n    );\n    throw new SerializationError(message, { hint, cause });\n  }\n}\n\n/**\n * Called from workflow execution environment to hydrate the workflow\n * arguments from the database at the start of workflow execution.\n */\nexport async function hydrateWorkflowArguments(\n  value: Uint8Array | unknown,\n  _runId: string,\n  key: CryptoKey | undefined,\n  global: Record<string, any> = globalThis,\n  extraRevivers: Record<string, (value: any) => any> = {}\n): Promise<any> {\n  const compressionStats: CompressionStats = {};\n  const inflated = await decompress(\n    await maybeDecrypt(value, key),\n    compressionStats\n  );\n  await recordCompression(compressionStats, 'deserialize');\n  return workflowModule.deserialize(inflated, {\n    global,\n    extraRevivers: {\n      ...getStreamAndRequestRevivers(getWorkflowRevivers(global)),\n      ...extraRevivers,\n    },\n  });\n}\n\n/**\n * Dehydrate workflow return value for storage.\n */\nexport async function dehydrateWorkflowReturnValue(\n  value: unknown,\n  _runId: string,\n  key: CryptoKey | undefined,\n  global: Record<string, any> = globalThis,\n  v1Compat = false,\n  compression = false\n): Promise<Uint8Array | unknown> {\n  if (v1Compat) {\n    const str = stringify(value, getWorkflowReducers(global));\n    return revive(str);\n  }\n  try {\n    const compressionStats: CompressionStats = {};\n    const result = await stepModule.serialize(value, key, {\n      global,\n      extraReducers: getStreamAndRequestReducers(getWorkflowReducers(global)),\n      compression,\n      compressionStats,\n    });\n    await recordCompression(compressionStats, 'serialize');\n    return result;\n  } catch (error) {\n    const cause = unwrapSerializationCause(error);\n    const { message, hint } = formatSerializationError(\n      'workflow return value',\n      cause\n    );\n    throw new SerializationError(message, { hint, cause });\n  }\n}\n\n/**\n * Called from the client side to hydrate the workflow return value\n * of a completed workflow run.\n */\nexport async function hydrateWorkflowReturnValue(\n  value: Uint8Array | unknown,\n  runId: string,\n  key: CryptoKey | undefined,\n  ops: Promise<void>[] = [],\n  global: Record<string, any> = globalThis,\n  extraRevivers: Record<string, (value: any) => any> = {}\n): Promise<any> {\n  const compressionStats: CompressionStats = {};\n  const result = await clientModule.deserialize(value, key, {\n    global,\n    extraRevivers: {\n      ...getStreamAndRequestRevivers(\n        getExternalRevivers(global, ops, runId, key)\n      ),\n      ...extraRevivers,\n    },\n    compressionStats,\n  });\n  await recordCompression(compressionStats, 'deserialize');\n  return result;\n}\n\n/**\n * Called from the workflow handler when a step is being created.\n * Dehydrates values from within the workflow execution environment.\n */\nexport async function dehydrateStepArguments(\n  value: unknown,\n  _runId: string,\n  key: CryptoKey | undefined,\n  global: Record<string, any> = globalThis,\n  v1Compat = false,\n  compression = false\n): Promise<Uint8Array | unknown> {\n  if (v1Compat) {\n    const str = stringify(value, getWorkflowReducers(global));\n    return revive(str);\n  }\n  try {\n    const compressionStats: CompressionStats = {};\n    const result = await stepModule.serialize(value, key, {\n      global,\n      extraReducers: getStreamAndRequestReducers(getWorkflowReducers(global)),\n      compression,\n      compressionStats,\n    });\n    await recordCompression(compressionStats, 'serialize');\n    return result;\n  } catch (error) {\n    const cause = unwrapSerializationCause(error);\n    const { message, hint } = formatSerializationError('step arguments', cause);\n    throw new SerializationError(message, { hint, cause });\n  }\n}\n\n/**\n * Called from the step handler to hydrate the arguments of a step\n * from the database at the start of the step execution.\n */\nexport async function hydrateStepArguments(\n  value: Uint8Array | unknown,\n  runId: string,\n  key: CryptoKey | undefined,\n  ops: Promise<any>[] = [],\n  global: Record<string, any> = globalThis,\n  extraRevivers: Record<string, (value: any) => any> = {},\n  deploymentId?: string\n): Promise<any> {\n  const compressionStats: CompressionStats = {};\n  const result = await stepModule.deserialize(value, key, {\n    global,\n    extraRevivers: {\n      ...getStreamAndRequestRevivers(\n        getStepRevivers(global, ops, runId, key, deploymentId)\n      ),\n      ...extraRevivers,\n    },\n    compressionStats,\n  });\n  await recordCompression(compressionStats, 'deserialize');\n  return result;\n}\n\n/**\n * Called from the step handler when a step has completed.\n * Dehydrates values from within the step execution environment\n * into a format that can be saved to the database.\n *\n * @param value - The value to serialize\n * @param runId - Run ID for encryption context\n * @param key - Encryption key (undefined to skip encryption)\n * @param ops - Promise array for stream operations\n * @param global - Global object for serialization context\n * @param v1Compat - Enable legacy v1 compatibility mode\n * @param framedByteStreams - Whether the target run can decode wire-framed\n *   byte streams. Should match the target deployment's capability — see\n *   `getRunCapabilities` in `capabilities.ts`. Defaults to `false` for\n *   backwards compatibility with older runs.\n * @returns The dehydrated value as binary data (Uint8Array) with format prefix\n */\nexport async function dehydrateStepReturnValue(\n  value: unknown,\n  runId: string,\n  key: CryptoKey | undefined,\n  ops: Promise<any>[] = [],\n  global: Record<string, any> = globalThis,\n  v1Compat = false,\n  framedByteStreams = false,\n  compression = false,\n  // Turbo optimistic start: order the first chunk of a returned stream after\n  // the backgrounded `run_started`. Threaded into the step reducers' stream\n  // sink. Undefined outside turbo / on the await path.\n  runReadyBarrier?: Promise<unknown>\n): Promise<Uint8Array | unknown> {\n  if (v1Compat) {\n    const str = stringify(\n      value,\n      getStepReducers(\n        global,\n        ops,\n        runId,\n        key,\n        framedByteStreams,\n        runReadyBarrier\n      )\n    );\n    return revive(str);\n  }\n  try {\n    const compressionStats: CompressionStats = {};\n    const result = await stepModule.serialize(value, key, {\n      global,\n      extraReducers: getStreamAndRequestReducers(\n        getStepReducers(\n          global,\n          ops,\n          runId,\n          key,\n          framedByteStreams,\n          runReadyBarrier\n        )\n      ),\n      compression,\n      compressionStats,\n    });\n    await recordCompression(compressionStats, 'serialize');\n    return result;\n  } catch (error) {\n    const cause = unwrapSerializationCause(error);\n    const { message, hint } = formatSerializationError(\n      'step return value',\n      cause\n    );\n    throw new SerializationError(message, { hint, cause });\n  }\n}\n\n/**\n * Called from the step handler when a step throws. Dehydrates the thrown\n * value from within the step execution environment into a format that can\n * be saved to the database in a `step_failed` or `step_retrying` event.\n *\n * Any JavaScript value can be thrown (strings, numbers, objects, Errors,\n * Error subclasses), so the same serialization pipeline used for step\n * arguments and return values is applied here.\n *\n * @param value - The thrown value to serialize (can be any type)\n * @param runId - Run ID for encryption context\n * @param key - Encryption key (undefined to skip encryption)\n * @param ops - Promise array for stream operations\n * @param global - Global object for serialization context\n * @returns The dehydrated value as binary data (Uint8Array) with format prefix\n */\nexport async function dehydrateStepError(\n  value: unknown,\n  runId: string,\n  key: CryptoKey | undefined,\n  ops: Promise<any>[] = [],\n  global: Record<string, any> = globalThis,\n  compression = false\n): Promise<Uint8Array> {\n  try {\n    const str = stringify(value, getStepReducers(global, ops, runId, key));\n    const payload = new TextEncoder().encode(str);\n    const serialized = encodeWithFormatPrefix(\n      SerializationFormat.DEVALUE_V1,\n      payload\n    ) as Uint8Array;\n    // Compress before encrypting — encrypted bytes don't compress.\n    const compressionStats: CompressionStats = {};\n    const compressed = await compress(\n      serialized,\n      compression,\n      compressionStats\n    );\n    const encrypted = (await maybeEncrypt(\n      compressed as Uint8Array,\n      key\n    )) as Uint8Array;\n    await recordCompression(compressionStats, 'serialize');\n    return encrypted;\n  } catch (error) {\n    const cause = unwrapSerializationCause(error);\n    const { message, hint } = formatSerializationError('step error', cause);\n    throw new SerializationError(message, { hint, cause });\n  }\n}\n\n/**\n * Called from the workflow handler when replaying the event log of a\n * `step_failed` or `step_retrying` event. Hydrates the thrown value from\n * the database so the workflow can see the original thrown value.\n *\n * @param value - Binary serialized data (Uint8Array) with format prefix\n * @param runId - Run ID for decryption context\n * @param key - Encryption key (undefined to skip decryption)\n * @param global - Global object for deserialization context\n * @param extraRevivers - Additional revivers for custom types\n * @returns The hydrated thrown value, ready to reject the step promise\n */\nexport async function hydrateStepError(\n  value: Uint8Array | unknown,\n  _runId: string,\n  key: CryptoKey | undefined,\n  global: Record<string, any> = globalThis,\n  extraRevivers: Record<string, (value: any) => any> = {}\n): Promise<unknown> {\n  const compressionStats: CompressionStats = {};\n  const decrypted = await decompress(\n    await maybeDecrypt(value, key),\n    compressionStats\n  );\n  await recordCompression(compressionStats, 'deserialize');\n\n  if (!(decrypted instanceof Uint8Array)) {\n    // Treated as a devalue \"flattened\" array. In production this branch is\n    // exercised by legacy code paths that bypassed `dehydrateStepError`; the\n    // SDK version is pinned per workflow run via skew protection, so a\n    // current-version producer always emits a Uint8Array here. If a\n    // misshapen value reaches us, `unflatten` throws — that's intentional:\n    // the higher-level hydration helpers (`hydrateStepIO`,\n    // `hydrateResourceIO`) already wrap us in a try/catch that leaves the\n    // field un-hydrated for o11y display, and surfacing the throw to logs\n    // is more debuggable than silently masking the unsupported shape.\n    return unflatten(decrypted as any[], {\n      ...getWorkflowRevivers(global),\n      ...extraRevivers,\n    });\n  }\n\n  const { format, payload } = decodeFormatPrefix(decrypted);\n\n  if (format === SerializationFormat.DEVALUE_V1) {\n    const str = new TextDecoder().decode(payload);\n    return parse(str, {\n      ...getWorkflowRevivers(global),\n      ...extraRevivers,\n    });\n  }\n\n  throw new Error(`Unsupported serialization format: ${format}`);\n}\n\n/**\n * Called from the workflow handler when the workflow itself throws.\n * Dehydrates the thrown value from within the workflow execution environment\n * into a format that can be saved to the database in a `run_failed` event.\n *\n * @param value - The thrown value to serialize (can be any type)\n * @param runId - Run ID for encryption context\n * @param key - Encryption key (undefined to skip encryption)\n * @param global - Global object for serialization context\n * @returns The dehydrated value as binary data (Uint8Array) with format prefix\n */\nexport async function dehydrateRunError(\n  value: unknown,\n  _runId: string,\n  key: CryptoKey | undefined,\n  global: Record<string, any> = globalThis,\n  compression = false\n): Promise<Uint8Array> {\n  try {\n    const str = stringify(value, getWorkflowReducers(global));\n    const payload = new TextEncoder().encode(str);\n    const serialized = encodeWithFormatPrefix(\n      SerializationFormat.DEVALUE_V1,\n      payload\n    ) as Uint8Array;\n    // Compress before encrypting — encrypted bytes don't compress.\n    const compressionStats: CompressionStats = {};\n    const compressed = await compress(\n      serialized,\n      compression,\n      compressionStats\n    );\n    const encrypted = (await maybeEncrypt(\n      compressed as Uint8Array,\n      key\n    )) as Uint8Array;\n    await recordCompression(compressionStats, 'serialize');\n    return encrypted;\n  } catch (error) {\n    const cause = unwrapSerializationCause(error);\n    const { message, hint } = formatSerializationError('run error', cause);\n    throw new SerializationError(message, { hint, cause });\n  }\n}\n\n/**\n * Called from the client side (or observability tools) to hydrate the run\n * error value of a failed workflow run.\n *\n * @param value - Binary serialized data (Uint8Array) with format prefix\n * @param runId - Run ID for decryption context\n * @param key - Encryption key (undefined to skip decryption)\n * @param ops - Promise array for stream operations\n * @param global - Global object for deserialization context\n * @param extraRevivers - Additional revivers for custom types\n * @returns The hydrated thrown value, ready to be consumed by the client\n */\nexport async function hydrateRunError(\n  value: Uint8Array | unknown,\n  runId: string,\n  key: CryptoKey | undefined,\n  ops: Promise<void>[] = [],\n  global: Record<string, any> = globalThis,\n  extraRevivers: Record<string, (value: any) => any> = {}\n): Promise<unknown> {\n  const compressionStats: CompressionStats = {};\n  const decrypted = await decompress(\n    await maybeDecrypt(value, key),\n    compressionStats\n  );\n  await recordCompression(compressionStats, 'deserialize');\n\n  if (!(decrypted instanceof Uint8Array)) {\n    // See the matching note in `hydrateStepError`: this branch is for\n    // devalue flattened arrays from legacy callers; current SDK versions\n    // always emit a Uint8Array, and a misshapen value here intentionally\n    // throws via `unflatten` so the surrounding try/catch in o11y helpers\n    // surfaces the issue rather than masking it.\n    return unflatten(decrypted as any[], {\n      ...getExternalRevivers(global, ops, runId, key),\n      ...extraRevivers,\n    });\n  }\n\n  const { format, payload } = decodeFormatPrefix(decrypted);\n\n  if (format === SerializationFormat.DEVALUE_V1) {\n    const str = new TextDecoder().decode(payload);\n    return parse(str, {\n      ...getExternalRevivers(global, ops, runId, key),\n      ...extraRevivers,\n    });\n  }\n\n  throw new Error(`Unsupported serialization format: ${format}`);\n}\n\n/**\n * Called from the workflow handler when replaying the event log of a `step_completed` event.\n * Hydrates the return value of a step from the database.\n *\n * @param value - Binary serialized data (Uint8Array) with format prefix\n * @param runId - Run ID for decryption context\n * @param key - Encryption key (undefined to skip decryption)\n * @param global - Global object for deserialization context\n * @param extraRevivers - Additional revivers for custom types\n * Called from the workflow handler when replaying the event log\n * of a `step_completed` event.\n */\nexport async function hydrateStepReturnValue(\n  value: Uint8Array | unknown,\n  _runId: string,\n  key: CryptoKey | undefined,\n  global: Record<string, any> = globalThis,\n  extraRevivers: Record<string, (value: any) => any> = {}\n): Promise<any> {\n  const compressionStats: CompressionStats = {};\n  const inflated = await decompress(\n    await maybeDecrypt(value, key),\n    compressionStats\n  );\n  await recordCompression(compressionStats, 'deserialize');\n  return workflowModule.deserialize(inflated, {\n    global,\n    extraRevivers: {\n      ...getStreamAndRequestRevivers(getWorkflowRevivers(global)),\n      ...extraRevivers,\n    },\n  });\n}\n\n// ---- Helpers to extract stream/Request/Response reducers and revivers ----\n// The mode-specific get*Reducers/get*Revivers functions return objects that\n// include both \"common\" entries (Date, Error, Map, etc.) and mode-specific\n// entries (ReadableStream, WritableStream, Request, Response, StepFunction).\n// The common entries are already composed by the codec. We only need to\n// pass through the mode-specific entries as extraReducers/extraRevivers.\n\nconst STREAM_AND_REQUEST_KEYS = [\n  'ReadableStream',\n  'WritableStream',\n  'Request',\n  'Response',\n  'StepFunction',\n  // Wire AbortController/AbortSignal through the client serialization path so\n  // signals reachable via Request.signal (or as direct arguments) get their\n  // dedicated reducer. Without this, devalue falls back to its arbitrary-POJO\n  // path and fails for any signal the Request reducer forwards.\n  'AbortController',\n  'AbortSignal',\n] as const;\n\nfunction getStreamAndRequestReducers(\n  allReducers: Record<string, any>\n): Record<string, (value: any) => any> {\n  const extra: Record<string, (value: any) => any> = {};\n  for (const key of STREAM_AND_REQUEST_KEYS) {\n    if (key in allReducers) {\n      extra[key] = allReducers[key];\n    }\n  }\n  return extra;\n}\n\nfunction getStreamAndRequestRevivers(\n  allRevivers: Record<string, any>\n): Record<string, (value: any) => any> {\n  const extra: Record<string, (value: any) => any> = {};\n  for (const key of STREAM_AND_REQUEST_KEYS) {\n    if (key in allRevivers) {\n      extra[key] = allRevivers[key];\n    }\n  }\n  return extra;\n}\n"]}