@durable-streams/client 0.2.0 → 0.2.2

package/src/response.ts

@@ -7,14 +7,17 @@
 
 import { asAsyncIterableReadableStream } from "./asyncIterableReadableStream"
 import {
+  STREAM_CLOSED_HEADER,
   STREAM_CURSOR_HEADER,
   STREAM_OFFSET_HEADER,
   STREAM_UP_TO_DATE_HEADER,
 } from "./constants"
 import { DurableStreamError } from "./error"
 import { parseSSEStream } from "./sse"
+import { LongPollState, PausedState, SSEState } from "./stream-response-state"
 import type { ReadableStreamAsyncIterable } from "./asyncIterableReadableStream"
 import type { SSEControlEvent, SSEEvent } from "./sse"
+import type { StreamResponseState } from "./stream-response-state"
 import type {
   ByteChunk,
   StreamResponse as IStreamResponse,
@@ -55,6 +58,8 @@ export interface StreamResponseConfig {
   initialCursor?: string
   /** Initial upToDate from first response headers */
   initialUpToDate: boolean
+  /** Initial streamClosed from first response headers */
+  initialStreamClosed: boolean
   /** The held first Response object */
   firstResponse: Response
   /** Abort controller for the session */
@@ -74,6 +79,8 @@ export interface StreamResponseConfig {
   ) => Promise<Response>
   /** SSE resilience options */
   sseResilience?: SSEResilienceOptions
+  /** Encoding for SSE data events */
+  encoding?: `base64`
 }
 
 /**
@@ -95,10 +102,8 @@ export class StreamResponseImpl<
   #ok: boolean
   #isLoading: boolean
 
-  // --- Evolving state ---
-  #offset: Offset
-  #cursor?: string
-  #upToDate: boolean
+  // --- Evolving state (immutable state machine) ---
+  #syncState: StreamResponseState
 
   // --- Internal state ---
   #isJsonMode: boolean
@@ -117,13 +122,12 @@ export class StreamResponseImpl<
   #unsubscribeFromVisibilityChanges?: () => void
   #pausePromise?: Promise<void>
   #pauseResolve?: () => void
-  #justResumedFromPause = false
 
-  // --- SSE Resilience State ---
+  // --- SSE Resilience Config ---
   #sseResilience: Required<SSEResilienceOptions>
-  #lastSSEConnectionStartTime?: number
-  #consecutiveShortSSEConnections = 0
-  #sseFallbackToLongPoll = false
+
+  // --- SSE Encoding State ---
+  #encoding?: `base64`
 
   // Core primitive: a ReadableStream of Response objects
   #responseStream: ReadableStream<Response>
@@ -133,9 +137,18 @@ export class StreamResponseImpl<
     this.contentType = config.contentType
     this.live = config.live
     this.startOffset = config.startOffset
-    this.#offset = config.initialOffset
-    this.#cursor = config.initialCursor
-    this.#upToDate = config.initialUpToDate
+
+    // Initialize immutable state machine — SSEState if SSE is available,
+    // LongPollState otherwise. The type encodes whether SSE has fallen back.
+    const syncFields = {
+      offset: config.initialOffset,
+      cursor: config.initialCursor,
+      upToDate: config.initialUpToDate,
+      streamClosed: config.initialStreamClosed,
+    }
+    this.#syncState = config.startSSE
+      ? new SSEState(syncFields)
+      : new LongPollState(syncFields)
 
     // Initialize response metadata from first response
     this.#headers = config.firstResponse.headers
@@ -162,6 +175,9 @@ export class StreamResponseImpl<
       logWarnings: config.sseResilience?.logWarnings ?? true,
     }
 
+    // Initialize SSE encoding
+    this.#encoding = config.encoding
+
     this.#closed = new Promise((resolve, reject) => {
       this.#closedResolve = resolve
       this.#closedReject = reject
@@ -233,6 +249,8 @@ export class StreamResponseImpl<
   #pause(): void {
     if (this.#state === `active`) {
       this.#state = `pause-requested`
+      // Wrap state in PausedState to preserve it across pause/resume
+      this.#syncState = this.#syncState.pause()
       // Create promise that pull() will await
       this.#pausePromise = new Promise((resolve) => {
         this.#pauseResolve = resolve
@@ -253,9 +271,13 @@ export class StreamResponseImpl<
         return
       }
 
+      // Unwrap PausedState to restore the inner state
+      if (this.#syncState instanceof PausedState) {
+        this.#syncState = this.#syncState.resume().state
+      }
+
       // Transition to active and resolve the pause promise
       this.#state = `active`
-      this.#justResumedFromPause = true // Flag for single-shot skip of live param
       this.#pauseResolve?.()
       this.#pausePromise = undefined
       this.#pauseResolve = undefined
@@ -284,18 +306,22 @@ export class StreamResponseImpl<
     return this.#isLoading
   }
 
-  // --- Evolving state getters ---
+  // --- Evolving state getters (delegated to state machine) ---
 
   get offset(): Offset {
-    return this.#offset
+    return this.#syncState.offset
   }
 
   get cursor(): string | undefined {
-    return this.#cursor
+    return this.#syncState.cursor
   }
 
   get upToDate(): boolean {
-    return this.#upToDate
+    return this.#syncState.upToDate
+  }
+
+  get streamClosed(): boolean {
+    return this.#syncState.streamClosed
   }
 
   // =================================
@@ -338,26 +364,27 @@ export class StreamResponseImpl<
 
   /**
    * Determine if we should continue with live updates based on live mode
-   * and whether we've received upToDate.
+   * and whether we've received upToDate or streamClosed.
    */
   #shouldContinueLive(): boolean {
-    // Stop if we've received upToDate and a consumption method wants to stop after upToDate
-    if (this.#stopAfterUpToDate && this.upToDate) return false
-    // Stop if live mode is explicitly disabled
-    if (this.live === false) return false
-    return true
+    return this.#syncState.shouldContinueLive(
+      this.#stopAfterUpToDate,
+      this.live
+    )
   }
 
   /**
    * Update state from response headers.
    */
   #updateStateFromResponse(response: Response): void {
-    // Update stream-specific state
-    const offset = response.headers.get(STREAM_OFFSET_HEADER)
-    if (offset) this.#offset = offset
-    const cursor = response.headers.get(STREAM_CURSOR_HEADER)
-    if (cursor) this.#cursor = cursor
-    this.#upToDate = response.headers.has(STREAM_UP_TO_DATE_HEADER)
+    // Immutable state transition
+    this.#syncState = this.#syncState.withResponseMetadata({
+      offset: response.headers.get(STREAM_OFFSET_HEADER) || undefined,
+      cursor: response.headers.get(STREAM_CURSOR_HEADER) || undefined,
+      upToDate: response.headers.has(STREAM_UP_TO_DATE_HEADER),
+      streamClosed:
+        response.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`,
+    })
 
     // Update response metadata to reflect latest server response
     this.#headers = response.headers
@@ -366,125 +393,28 @@ export class StreamResponseImpl<
     this.#ok = response.ok
   }
 
-  /**
-   * Extract stream metadata from Response headers.
-   * Used by subscriber APIs to get the correct offset/cursor/upToDate for each
-   * specific Response, rather than reading from `this` which may be stale due to
-   * ReadableStream prefetching or timing issues.
-   */
-  #getMetadataFromResponse(response: Response): {
-    offset: Offset
-    cursor: string | undefined
-    upToDate: boolean
-  } {
-    const offset = response.headers.get(STREAM_OFFSET_HEADER)
-    const cursor = response.headers.get(STREAM_CURSOR_HEADER)
-    const upToDate = response.headers.has(STREAM_UP_TO_DATE_HEADER)
-    return {
-      offset: offset ?? this.offset, // Fall back to instance state if no header
-      cursor: cursor ?? this.cursor,
-      upToDate,
-    }
-  }
-
-  /**
-   * Create a synthetic Response from SSE data with proper headers.
-   * Includes offset/cursor/upToDate in headers so subscribers can read them.
-   */
-  #createSSESyntheticResponse(
-    data: string,
-    offset: Offset,
-    cursor: string | undefined,
-    upToDate: boolean
-  ): Response {
-    const headers: Record<string, string> = {
-      "content-type": this.contentType ?? `application/json`,
-      [STREAM_OFFSET_HEADER]: String(offset),
-    }
-    if (cursor) {
-      headers[STREAM_CURSOR_HEADER] = cursor
-    }
-    if (upToDate) {
-      headers[STREAM_UP_TO_DATE_HEADER] = `true`
-    }
-    return new Response(data, { status: 200, headers })
-  }
-
   /**
    * Update instance state from an SSE control event.
    */
   #updateStateFromSSEControl(controlEvent: SSEControlEvent): void {
-    this.#offset = controlEvent.streamNextOffset
-    if (controlEvent.streamCursor) {
-      this.#cursor = controlEvent.streamCursor
-    }
-    if (controlEvent.upToDate !== undefined) {
-      this.#upToDate = controlEvent.upToDate
-    }
+    this.#syncState = this.#syncState.withSSEControl(controlEvent)
   }
 
   /**
    * Mark the start of an SSE connection for duration tracking.
+   * If the state is not SSEState (e.g., auto-detected SSE from content-type),
+   * transitions to SSEState first.
    */
   #markSSEConnectionStart(): void {
-    this.#lastSSEConnectionStartTime = Date.now()
-  }
-
-  /**
-   * Handle SSE connection end - check duration and manage fallback state.
-   * Returns a delay to wait before reconnecting, or null if should not reconnect.
-   */
-  async #handleSSEConnectionEnd(): Promise<number | null> {
-    if (this.#lastSSEConnectionStartTime === undefined) {
-      return 0 // No tracking, allow immediate reconnect
-    }
-
-    const connectionDuration = Date.now() - this.#lastSSEConnectionStartTime
-    const wasAborted = this.#abortController.signal.aborted
-
-    if (
-      connectionDuration < this.#sseResilience.minConnectionDuration &&
-      !wasAborted
-    ) {
-      // Connection was too short - likely proxy buffering or misconfiguration
-      this.#consecutiveShortSSEConnections++
-
-      if (
-        this.#consecutiveShortSSEConnections >=
-        this.#sseResilience.maxShortConnections
-      ) {
-        // Too many short connections - fall back to long polling
-        this.#sseFallbackToLongPoll = true
-
-        if (this.#sseResilience.logWarnings) {
-          console.warn(
-            `[Durable Streams] SSE connections are closing immediately (possibly due to proxy buffering or misconfiguration). ` +
-              `Falling back to long polling. ` +
-              `Your proxy must support streaming SSE responses (not buffer the complete response). ` +
-              `Configuration: Nginx add 'X-Accel-Buffering: no', Caddy add 'flush_interval -1' to reverse_proxy.`
-          )
-        }
-        return null // Signal to not reconnect SSE
-      } else {
-        // Add exponential backoff with full jitter to prevent tight infinite loop
-        // Formula: random(0, min(cap, base * 2^attempt))
-        const maxDelay = Math.min(
-          this.#sseResilience.backoffMaxDelay,
-          this.#sseResilience.backoffBaseDelay *
-            Math.pow(2, this.#consecutiveShortSSEConnections)
-        )
-        const delayMs = Math.floor(Math.random() * maxDelay)
-        await new Promise((resolve) => setTimeout(resolve, delayMs))
-        return delayMs
-      }
-    } else if (
-      connectionDuration >= this.#sseResilience.minConnectionDuration
-    ) {
-      // Connection was healthy - reset counter
-      this.#consecutiveShortSSEConnections = 0
+    if (!(this.#syncState instanceof SSEState)) {
+      this.#syncState = new SSEState({
+        offset: this.#syncState.offset,
+        cursor: this.#syncState.cursor,
+        upToDate: this.#syncState.upToDate,
+        streamClosed: this.#syncState.streamClosed,
+      })
     }
-
-    return 0 // Allow immediate reconnect
+    this.#syncState = (this.#syncState as SSEState).startConnection(Date.now())
   }
 
   /**
@@ -496,8 +426,8 @@ export class StreamResponseImpl<
     void,
     undefined
   > | null> {
-    // Check if we should fall back to long-poll due to repeated short connections
-    if (this.#sseFallbackToLongPoll) {
+    // Check if we should fall back to long-poll (state type encodes this)
+    if (!this.#syncState.shouldUseSse()) {
       return null // Will cause fallback to long-poll
     }
 
@@ -505,12 +435,37 @@ export class StreamResponseImpl<
       return null
     }
 
-    // Handle short connection detection and backoff
-    const delayOrNull = await this.#handleSSEConnectionEnd()
-    if (delayOrNull === null) {
+    // Pure state transition: check connection duration, manage counters
+    const result = (this.#syncState as SSEState).handleConnectionEnd(
+      Date.now(),
+      this.#abortController.signal.aborted,
+      this.#sseResilience
+    )
+    this.#syncState = result.state
+
+    if (result.action === `fallback`) {
+      if (this.#sseResilience.logWarnings) {
+        console.warn(
+          `[Durable Streams] SSE connections are closing immediately (possibly due to proxy buffering or misconfiguration). ` +
+            `Falling back to long polling. ` +
+            `Your proxy must support streaming SSE responses (not buffer the complete response). ` +
+            `Configuration: Nginx add 'X-Accel-Buffering: no', Caddy add 'flush_interval -1' to reverse_proxy.`
+        )
+      }
       return null // Fallback to long-poll was triggered
     }
 
+    if (result.action === `reconnect`) {
+      // Host applies jitter/delay — state machine only returns backoffAttempt
+      const maxDelay = Math.min(
+        this.#sseResilience.backoffMaxDelay,
+        this.#sseResilience.backoffBaseDelay *
+          Math.pow(2, result.backoffAttempt)
+      )
+      const delayMs = Math.floor(Math.random() * maxDelay)
+      await new Promise((resolve) => setTimeout(resolve, delayMs))
+    }
+
     // Track new connection start
     this.#markSSEConnectionStart()
 
@@ -578,8 +533,24 @@ export class StreamResponseImpl<
       return this.#processSSEDataEvent(event.data, sseEventIterator)
     }
 
-    // Control event without preceding data - update state and continue
+    // Control event without preceding data - update state
     this.#updateStateFromSSEControl(event)
+
+    // If upToDate is signaled, yield an empty response so subscribers receive the signal
+    // This is important for empty streams and for subscribers waiting for catch-up completion
+    if (event.upToDate) {
+      const response = createSSESyntheticResponse(
+        ``,
+        event.streamNextOffset,
+        event.streamCursor,
+        true,
+        event.streamClosed ?? false,
+        this.contentType,
+        this.#encoding
+      )
+      return { type: `response`, response }
+    }
+
     return { type: `continue` }
   }
 
@@ -587,6 +558,9 @@ export class StreamResponseImpl<
    * Process an SSE data event by waiting for its corresponding control event.
    * In SSE protocol, control events come AFTER data events.
    * Multiple data events may arrive before a single control event - we buffer them.
+   *
+   * For base64 mode, each data event is independently base64 encoded, so we
+   * collect them as an array and decode each separately.
    */
   async #processSSEDataEvent(
     pendingData: string,
@@ -600,7 +574,8 @@ export class StreamResponseImpl<
     | { type: `error`; error: Error }
   > {
     // Buffer to accumulate data from multiple consecutive data events
-    let bufferedData = pendingData
+    // For base64 mode, we collect as array since each event is independently encoded
+    const bufferedDataParts: Array<string> = [pendingData]
 
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     while (true) {
@@ -609,11 +584,15 @@ export class StreamResponseImpl<
 
       if (controlDone) {
         // Stream ended without control event - yield buffered data with current state
-        const response = this.#createSSESyntheticResponse(
-          bufferedData,
+        const response = createSSESyntheticResponseFromParts(
+          bufferedDataParts,
           this.offset,
           this.cursor,
-          this.upToDate
+          this.upToDate,
+          this.streamClosed,
+          this.contentType,
+          this.#encoding,
+          this.#isJsonMode
         )
 
         // Try to reconnect
@@ -636,18 +615,22 @@ export class StreamResponseImpl<
       if (controlEvent.type === `control`) {
         // Update state and create response with correct metadata
         this.#updateStateFromSSEControl(controlEvent)
-        const response = this.#createSSESyntheticResponse(
-          bufferedData,
+        const response = createSSESyntheticResponseFromParts(
+          bufferedDataParts,
           controlEvent.streamNextOffset,
           controlEvent.streamCursor,
-          controlEvent.upToDate ?? false
+          controlEvent.upToDate ?? false,
+          controlEvent.streamClosed ?? false,
+          this.contentType,
+          this.#encoding,
+          this.#isJsonMode
         )
         return { type: `response`, response }
       }
 
       // Got another data event before control - buffer it
       // Server sends multiple data events followed by one control event
-      bufferedData += controlEvent.data
+      bufferedDataParts.push(controlEvent.data)
     }
   }
 
@@ -762,8 +745,10 @@ export class StreamResponseImpl<
 
           // Long-poll mode: continue with live updates if needed
           if (this.#shouldContinueLive()) {
-            // If paused or pause-requested, await the pause promise
-            // This blocks pull() until resume() is called, avoiding deadlock
+            // Determine if we're resuming from pause — local variable replaces
+            // the old #justResumedFromPause one-shot field. If we enter the pause
+            // branch and wake up without abort, we just resumed.
+            let resumingFromPause = false
             if (this.#state === `pause-requested` || this.#state === `paused`) {
               this.#state = `paused`
               if (this.#pausePromise) {
@@ -775,6 +760,7 @@ export class StreamResponseImpl<
                 controller.close()
                 return
               }
+              resumingFromPause = true
             }
 
             if (this.#abortController.signal.aborted) {
@@ -783,10 +769,6 @@ export class StreamResponseImpl<
               return
             }
 
-            // Consume the single-shot resume flag (only first fetch after resume skips live param)
-            const resumingFromPause = this.#justResumedFromPause
-            this.#justResumedFromPause = false
-
             // Create a new AbortController for this request (so we can abort on pause)
             this.#requestAbortController = new AbortController()
 
@@ -1034,34 +1016,40 @@ export class StreamResponseImpl<
           return
         }
 
-        // Get next response
-        const { done, value: response } = await reader.read()
-        if (done) {
-          this.#markClosed()
-          controller.close()
-          return
-        }
+        // Keep reading until we can enqueue at least one item.
+        // This avoids stalling when a response contains an empty JSON array.
+        let result = await reader.read()
+        while (!result.done) {
+          const response = result.value
 
-        // Parse JSON and flatten arrays (handle empty responses gracefully)
-        const text = await response.text()
-        const content = text.trim() || `[]` // Default to empty array if no content or whitespace
-        let parsed: TJson | Array<TJson>
-        try {
-          parsed = JSON.parse(content) as TJson | Array<TJson>
-        } catch (err) {
-          const preview =
-            content.length > 100 ? content.slice(0, 100) + `...` : content
-          throw new DurableStreamError(
-            `Failed to parse JSON response: ${err instanceof Error ? err.message : String(err)}. Data: ${preview}`,
-            `PARSE_ERROR`
-          )
-        }
-        pendingItems = Array.isArray(parsed) ? parsed : [parsed]
+          // Parse JSON and flatten arrays (handle empty responses gracefully)
+          const text = await response.text()
+          const content = text.trim() || `[]` // Default to empty array if no content or whitespace
+          let parsed: TJson | Array<TJson>
+          try {
+            parsed = JSON.parse(content) as TJson | Array<TJson>
+          } catch (err) {
+            const preview =
+              content.length > 100 ? content.slice(0, 100) + `...` : content
+            throw new DurableStreamError(
+              `Failed to parse JSON response: ${err instanceof Error ? err.message : String(err)}. Data: ${preview}`,
+              `PARSE_ERROR`
+            )
+          }
+          pendingItems = Array.isArray(parsed) ? parsed : [parsed]
 
-        // Enqueue first item
-        if (pendingItems.length > 0) {
-          controller.enqueue(pendingItems.shift())
+          if (pendingItems.length > 0) {
+            controller.enqueue(pendingItems.shift())
+            return
+          }
+
+          // Empty JSON batch; read the next response.
+          result = await reader.read()
         }
+
+        this.#markClosed()
+        controller.close()
+        return
       },
 
       cancel: () => {
@@ -1114,8 +1102,13 @@ export class StreamResponseImpl<
 
           // Get metadata from Response headers (not from `this` which may be stale)
           const response = result.value
-          const { offset, cursor, upToDate } =
-            this.#getMetadataFromResponse(response)
+          const { offset, cursor, upToDate, streamClosed } =
+            getMetadataFromResponse(
+              response,
+              this.offset,
+              this.cursor,
+              this.streamClosed
+            )
 
           // Get response text first (handles empty responses gracefully)
           const text = await response.text()
@@ -1139,6 +1132,7 @@ export class StreamResponseImpl<
             offset,
             cursor,
             upToDate,
+            streamClosed,
           })
 
           result = await reader.read()
@@ -1181,8 +1175,13 @@ export class StreamResponseImpl<
 
           // Get metadata from Response headers (not from `this` which may be stale)
           const response = result.value
-          const { offset, cursor, upToDate } =
-            this.#getMetadataFromResponse(response)
+          const { offset, cursor, upToDate, streamClosed } =
+            getMetadataFromResponse(
+              response,
+              this.offset,
+              this.cursor,
+              this.streamClosed
+            )
 
           const buffer = await response.arrayBuffer()
 
@@ -1192,6 +1191,7 @@ export class StreamResponseImpl<
             offset,
             cursor,
             upToDate,
+            streamClosed,
           })
 
           result = await reader.read()
@@ -1234,8 +1234,13 @@ export class StreamResponseImpl<
 
           // Get metadata from Response headers (not from `this` which may be stale)
           const response = result.value
-          const { offset, cursor, upToDate } =
-            this.#getMetadataFromResponse(response)
+          const { offset, cursor, upToDate, streamClosed } =
+            getMetadataFromResponse(
+              response,
+              this.offset,
+              this.cursor,
+              this.streamClosed
+            )
 
           const text = await response.text()
 
@@ -1245,6 +1250,7 @@ export class StreamResponseImpl<
             offset,
             cursor,
             upToDate,
+            streamClosed,
           })
 
           result = await reader.read()
@@ -1286,3 +1292,185 @@ export class StreamResponseImpl<
     return this.#closed
   }
 }
+
+// =================================
+// Pure helper functions
+// =================================
+
+/**
+ * Extract stream metadata from Response headers.
+ * Falls back to the provided defaults when headers are absent.
+ */
+function getMetadataFromResponse(
+  response: Response,
+  fallbackOffset: Offset,
+  fallbackCursor: string | undefined,
+  fallbackStreamClosed: boolean
+): {
+  offset: Offset
+  cursor: string | undefined
+  upToDate: boolean
+  streamClosed: boolean
+} {
+  const offset = response.headers.get(STREAM_OFFSET_HEADER)
+  const cursor = response.headers.get(STREAM_CURSOR_HEADER)
+  const upToDate = response.headers.has(STREAM_UP_TO_DATE_HEADER)
+  const streamClosed =
+    response.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`
+  return {
+    offset: offset ?? fallbackOffset,
+    cursor: cursor ?? fallbackCursor,
+    upToDate,
+    streamClosed: streamClosed || fallbackStreamClosed,
+  }
+}
+
+/**
+ * Decode base64 string to Uint8Array.
+ * Per protocol: concatenate data lines, remove \n and \r, then decode.
+ */
+function decodeBase64(base64Str: string): Uint8Array {
+  // Remove all newlines and carriage returns per protocol
+  const cleaned = base64Str.replace(/[\n\r]/g, ``)
+
+  // Empty string is valid
+  if (cleaned.length === 0) {
+    return new Uint8Array(0)
+  }
+
+  // Validate length is multiple of 4
+  if (cleaned.length % 4 !== 0) {
+    throw new DurableStreamError(
+      `Invalid base64 data: length ${cleaned.length} is not a multiple of 4`,
+      `PARSE_ERROR`
+    )
+  }
+
+  try {
+    // Prefer Buffer (native C++ in Node) over atob (requires JS charCodeAt loop)
+    if (typeof Buffer !== `undefined`) {
+      return new Uint8Array(Buffer.from(cleaned, `base64`))
+    } else {
+      const binaryStr = atob(cleaned)
+      const bytes = new Uint8Array(binaryStr.length)
+      for (let i = 0; i < binaryStr.length; i++) {
+        bytes[i] = binaryStr.charCodeAt(i)
+      }
+      return bytes
+    }
+  } catch (err) {
+    throw new DurableStreamError(
+      `Failed to decode base64 data: ${err instanceof Error ? err.message : String(err)}`,
+      `PARSE_ERROR`
+    )
+  }
+}
+
+/**
+ * Create a synthetic Response from SSE data with proper headers.
+ * Includes offset/cursor/upToDate/streamClosed in headers so subscribers can read them.
+ */
+function createSSESyntheticResponse(
+  data: string,
+  offset: Offset,
+  cursor: string | undefined,
+  upToDate: boolean,
+  streamClosed: boolean,
+  contentType: string | undefined,
+  encoding: `base64` | undefined
+): Response {
+  return createSSESyntheticResponseFromParts(
+    [data],
+    offset,
+    cursor,
+    upToDate,
+    streamClosed,
+    contentType,
+    encoding
+  )
+}
+
+/**
+ * Create a synthetic Response from multiple SSE data parts.
+ * For base64 mode, each part is independently encoded, so we decode each
+ * separately and concatenate the binary results.
+ * For text mode, parts are simply concatenated as strings.
+ */
+function createSSESyntheticResponseFromParts(
+  dataParts: Array<string>,
+  offset: Offset,
+  cursor: string | undefined,
+  upToDate: boolean,
+  streamClosed: boolean,
+  contentType: string | undefined,
+  encoding: `base64` | undefined,
+  isJsonMode?: boolean
+): Response {
+  const headers: Record<string, string> = {
+    "content-type": contentType ?? `application/json`,
+    [STREAM_OFFSET_HEADER]: String(offset),
+  }
+  if (cursor) {
+    headers[STREAM_CURSOR_HEADER] = cursor
+  }
+  if (upToDate) {
+    headers[STREAM_UP_TO_DATE_HEADER] = `true`
+  }
+  if (streamClosed) {
+    headers[STREAM_CLOSED_HEADER] = `true`
+  }
+
+  // Decode base64 if encoding is used
+  let body: BodyInit
+  if (encoding === `base64`) {
+    // Each data part is independently base64 encoded, decode each separately
+    const decodedParts = dataParts
+      .filter((part) => part.length > 0)
+      .map((part) => decodeBase64(part))
+
+    if (decodedParts.length === 0) {
+      // No data - return empty body
+      body = new ArrayBuffer(0)
+    } else if (decodedParts.length === 1) {
+      // Single part - use directly
+      const decoded = decodedParts[0]!
+      body = decoded.buffer.slice(
+        decoded.byteOffset,
+        decoded.byteOffset + decoded.byteLength
+      ) as ArrayBuffer
+    } else {
+      // Multiple parts - concatenate binary data
+      const totalLength = decodedParts.reduce(
+        (sum, part) => sum + part.length,
+        0
+      )
+      const combined = new Uint8Array(totalLength)
+      let offset = 0
+      for (const part of decodedParts) {
+        combined.set(part, offset)
+        offset += part.length
+      }
+      body = combined.buffer
+    }
+  } else if (isJsonMode) {
+    const mergedParts: Array<string> = []
+    for (const part of dataParts) {
+      const trimmed = part.trim()
+      if (trimmed.length === 0) continue
+
+      if (trimmed.startsWith(`[`) && trimmed.endsWith(`]`)) {
+        const inner = trimmed.slice(1, -1).trim()
+        if (inner.length > 0) {
+          mergedParts.push(inner)
+        }
+      } else {
+        mergedParts.push(trimmed)
+      }
+    }
+    body = `[${mergedParts.join(`,`)}]`
+  } else {
+    body = dataParts.join(``)
+  }
+
+  return new Response(body, { status: 200, headers })
+}