@durable-streams/client 0.2.1 → 0.2.2

package/dist/index.cjs

@@ -579,6 +579,207 @@ async function* parseSSEStream(stream$1, signal) {
 	}
 }
 
+//#endregion
+//#region src/stream-response-state.ts
+/**
+* Abstract base class for stream response state.
+* All state transitions return new immutable state objects.
+*/
+var StreamResponseState = class {
+	shouldContinueLive(stopAfterUpToDate, liveMode) {
+		if (stopAfterUpToDate && this.upToDate) return false;
+		if (liveMode === false) return false;
+		if (this.streamClosed) return false;
+		return true;
+	}
+};
+/**
+* State for long-poll mode. shouldUseSse() returns false.
+*/
+var LongPollState = class LongPollState extends StreamResponseState {
+	offset;
+	cursor;
+	upToDate;
+	streamClosed;
+	constructor(fields) {
+		super();
+		this.offset = fields.offset;
+		this.cursor = fields.cursor;
+		this.upToDate = fields.upToDate;
+		this.streamClosed = fields.streamClosed;
+	}
+	shouldUseSse() {
+		return false;
+	}
+	withResponseMetadata(update) {
+		return new LongPollState({
+			offset: update.offset ?? this.offset,
+			cursor: update.cursor ?? this.cursor,
+			upToDate: update.upToDate,
+			streamClosed: this.streamClosed || update.streamClosed
+		});
+	}
+	withSSEControl(event) {
+		const streamClosed = this.streamClosed || (event.streamClosed ?? false);
+		return new LongPollState({
+			offset: event.streamNextOffset,
+			cursor: event.streamCursor || this.cursor,
+			upToDate: event.streamClosed ?? false ? true : event.upToDate ?? this.upToDate,
+			streamClosed
+		});
+	}
+	pause() {
+		return new PausedState(this);
+	}
+};
+/**
+* State for SSE mode. shouldUseSse() returns true.
+* Tracks SSE connection resilience (short connection detection).
+*/
+var SSEState = class SSEState extends StreamResponseState {
+	offset;
+	cursor;
+	upToDate;
+	streamClosed;
+	consecutiveShortConnections;
+	connectionStartTime;
+	constructor(fields) {
+		super();
+		this.offset = fields.offset;
+		this.cursor = fields.cursor;
+		this.upToDate = fields.upToDate;
+		this.streamClosed = fields.streamClosed;
+		this.consecutiveShortConnections = fields.consecutiveShortConnections ?? 0;
+		this.connectionStartTime = fields.connectionStartTime;
+	}
+	shouldUseSse() {
+		return true;
+	}
+	withResponseMetadata(update) {
+		return new SSEState({
+			offset: update.offset ?? this.offset,
+			cursor: update.cursor ?? this.cursor,
+			upToDate: update.upToDate,
+			streamClosed: this.streamClosed || update.streamClosed,
+			consecutiveShortConnections: this.consecutiveShortConnections,
+			connectionStartTime: this.connectionStartTime
+		});
+	}
+	withSSEControl(event) {
+		const streamClosed = this.streamClosed || (event.streamClosed ?? false);
+		return new SSEState({
+			offset: event.streamNextOffset,
+			cursor: event.streamCursor || this.cursor,
+			upToDate: event.streamClosed ?? false ? true : event.upToDate ?? this.upToDate,
+			streamClosed,
+			consecutiveShortConnections: this.consecutiveShortConnections,
+			connectionStartTime: this.connectionStartTime
+		});
+	}
+	startConnection(now) {
+		return new SSEState({
+			offset: this.offset,
+			cursor: this.cursor,
+			upToDate: this.upToDate,
+			streamClosed: this.streamClosed,
+			consecutiveShortConnections: this.consecutiveShortConnections,
+			connectionStartTime: now
+		});
+	}
+	handleConnectionEnd(now, wasAborted, config) {
+		if (this.connectionStartTime === void 0) return {
+			action: `healthy`,
+			state: this
+		};
+		const duration = now - this.connectionStartTime;
+		if (duration < config.minConnectionDuration && !wasAborted) {
+			const newCount = this.consecutiveShortConnections + 1;
+			if (newCount >= config.maxShortConnections) return {
+				action: `fallback`,
+				state: new LongPollState({
+					offset: this.offset,
+					cursor: this.cursor,
+					upToDate: this.upToDate,
+					streamClosed: this.streamClosed
+				})
+			};
+			return {
+				action: `reconnect`,
+				state: new SSEState({
+					offset: this.offset,
+					cursor: this.cursor,
+					upToDate: this.upToDate,
+					streamClosed: this.streamClosed,
+					consecutiveShortConnections: newCount,
+					connectionStartTime: this.connectionStartTime
+				}),
+				backoffAttempt: newCount
+			};
+		}
+		if (duration >= config.minConnectionDuration) return {
+			action: `healthy`,
+			state: new SSEState({
+				offset: this.offset,
+				cursor: this.cursor,
+				upToDate: this.upToDate,
+				streamClosed: this.streamClosed,
+				consecutiveShortConnections: 0,
+				connectionStartTime: this.connectionStartTime
+			})
+		};
+		return {
+			action: `healthy`,
+			state: this
+		};
+	}
+	pause() {
+		return new PausedState(this);
+	}
+};
+/**
+* Paused state wrapper. Delegates all sync field access to the inner state.
+* resume() returns the wrapped state unchanged (identity preserved).
+*/
+var PausedState = class PausedState extends StreamResponseState {
+	#inner;
+	constructor(inner) {
+		super();
+		this.#inner = inner;
+	}
+	get offset() {
+		return this.#inner.offset;
+	}
+	get cursor() {
+		return this.#inner.cursor;
+	}
+	get upToDate() {
+		return this.#inner.upToDate;
+	}
+	get streamClosed() {
+		return this.#inner.streamClosed;
+	}
+	shouldUseSse() {
+		return this.#inner.shouldUseSse();
+	}
+	withResponseMetadata(update) {
+		const newInner = this.#inner.withResponseMetadata(update);
+		return new PausedState(newInner);
+	}
+	withSSEControl(event) {
+		const newInner = this.#inner.withSSEControl(event);
+		return new PausedState(newInner);
+	}
+	pause() {
+		return this;
+	}
+	resume() {
+		return {
+			state: this.#inner,
+			justResumed: true
+		};
+	}
+};
+
 //#endregion
 //#region src/response.ts
 /**
@@ -598,10 +799,7 @@ var StreamResponseImpl = class {
 	#statusText;
 	#ok;
 	#isLoading;
-	#offset;
-	#cursor;
-	#upToDate;
-	#streamClosed;
+	#syncState;
 	#isJsonMode;
 	#abortController;
 	#fetchNext;
@@ -616,11 +814,7 @@ var StreamResponseImpl = class {
 	#unsubscribeFromVisibilityChanges;
 	#pausePromise;
 	#pauseResolve;
-	#justResumedFromPause = false;
 	#sseResilience;
-	#lastSSEConnectionStartTime;
-	#consecutiveShortSSEConnections = 0;
-	#sseFallbackToLongPoll = false;
 	#encoding;
 	#responseStream;
 	constructor(config) {
@@ -628,10 +822,13 @@ var StreamResponseImpl = class {
 		this.contentType = config.contentType;
 		this.live = config.live;
 		this.startOffset = config.startOffset;
-		this.#offset = config.initialOffset;
-		this.#cursor = config.initialCursor;
-		this.#upToDate = config.initialUpToDate;
-		this.#streamClosed = config.initialStreamClosed;
+		const syncFields = {
+			offset: config.initialOffset,
+			cursor: config.initialCursor,
+			upToDate: config.initialUpToDate,
+			streamClosed: config.initialStreamClosed
+		};
+		this.#syncState = config.startSSE ? new SSEState(syncFields) : new LongPollState(syncFields);
 		this.#headers = config.firstResponse.headers;
 		this.#status = config.firstResponse.status;
 		this.#statusText = config.firstResponse.statusText;
@@ -688,6 +885,7 @@ var StreamResponseImpl = class {
 	#pause() {
 		if (this.#state === `active`) {
 			this.#state = `pause-requested`;
+			this.#syncState = this.#syncState.pause();
 			this.#pausePromise = new Promise((resolve) => {
 				this.#pauseResolve = resolve;
 			});
@@ -701,8 +899,8 @@ var StreamResponseImpl = class {
 	#resume() {
 		if (this.#state === `paused` || this.#state === `pause-requested`) {
 			if (this.#abortController.signal.aborted) return;
+			if (this.#syncState instanceof PausedState) this.#syncState = this.#syncState.resume().state;
 			this.#state = `active`;
-			this.#justResumedFromPause = true;
 			this.#pauseResolve?.();
 			this.#pausePromise = void 0;
 			this.#pauseResolve = void 0;
@@ -724,16 +922,16 @@ var StreamResponseImpl = class {
 		return this.#isLoading;
 	}
 	get offset() {
-		return this.#offset;
+		return this.#syncState.offset;
 	}
 	get cursor() {
-		return this.#cursor;
+		return this.#syncState.cursor;
 	}
 	get upToDate() {
-		return this.#upToDate;
+		return this.#syncState.upToDate;
 	}
 	get streamClosed() {
-		return this.#streamClosed;
+		return this.#syncState.streamClosed;
 	}
 	#ensureJsonMode() {
 		if (!this.#isJsonMode) throw new DurableStreamError(`JSON methods are only valid for JSON-mode streams. Content-Type is "${this.contentType}" and json hint was not set.`, `BAD_REQUEST`);
@@ -759,159 +957,61 @@ var StreamResponseImpl = class {
 	* and whether we've received upToDate or streamClosed.
 	*/
 	#shouldContinueLive() {
-		if (this.#stopAfterUpToDate && this.upToDate) return false;
-		if (this.live === false) return false;
-		if (this.#streamClosed) return false;
-		return true;
+		return this.#syncState.shouldContinueLive(this.#stopAfterUpToDate, this.live);
 	}
 	/**
 	* Update state from response headers.
 	*/
 	#updateStateFromResponse(response) {
-		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);
-		const streamClosedHeader = response.headers.get(STREAM_CLOSED_HEADER);
-		if (streamClosedHeader?.toLowerCase() === `true`) this.#streamClosed = true;
+		this.#syncState = this.#syncState.withResponseMetadata({
+			offset: response.headers.get(STREAM_OFFSET_HEADER) || void 0,
+			cursor: response.headers.get(STREAM_CURSOR_HEADER) || void 0,
+			upToDate: response.headers.has(STREAM_UP_TO_DATE_HEADER),
+			streamClosed: response.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`
+		});
 		this.#headers = response.headers;
 		this.#status = response.status;
 		this.#statusText = response.statusText;
 		this.#ok = response.ok;
 	}
 	/**
-	* Extract stream metadata from Response headers.
-	* Used by subscriber APIs to get the correct offset/cursor/upToDate/streamClosed for each
-	* specific Response, rather than reading from `this` which may be stale due to
-	* ReadableStream prefetching or timing issues.
-	*/
-	#getMetadataFromResponse(response) {
-		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 ?? this.offset,
-			cursor: cursor ?? this.cursor,
-			upToDate,
-			streamClosed: streamClosed || this.streamClosed
-		};
-	}
-	/**
-	* Decode base64 string to Uint8Array.
-	* Per protocol: concatenate data lines, remove \n and \r, then decode.
-	*/
-	#decodeBase64(base64Str) {
-		const cleaned = base64Str.replace(/[\n\r]/g, ``);
-		if (cleaned.length === 0) return new Uint8Array(0);
-		if (cleaned.length % 4 !== 0) throw new DurableStreamError(`Invalid base64 data: length ${cleaned.length} is not a multiple of 4`, `PARSE_ERROR`);
-		try {
-			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.
-	*/
-	#createSSESyntheticResponse(data, offset, cursor, upToDate, streamClosed) {
-		return this.#createSSESyntheticResponseFromParts([data], offset, cursor, upToDate, streamClosed);
-	}
-	/**
-	* 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.
-	*/
-	#createSSESyntheticResponseFromParts(dataParts, offset, cursor, upToDate, streamClosed) {
-		const headers = {
-			"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`;
-		if (streamClosed) headers[STREAM_CLOSED_HEADER] = `true`;
-		let body;
-		if (this.#encoding === `base64`) {
-			const decodedParts = dataParts.filter((part) => part.length > 0).map((part) => this.#decodeBase64(part));
-			if (decodedParts.length === 0) body = new ArrayBuffer(0);
-			else if (decodedParts.length === 1) {
-				const decoded = decodedParts[0];
-				body = decoded.buffer.slice(decoded.byteOffset, decoded.byteOffset + decoded.byteLength);
-			} else {
-				const totalLength = decodedParts.reduce((sum, part) => sum + part.length, 0);
-				const combined = new Uint8Array(totalLength);
-				let offset$1 = 0;
-				for (const part of decodedParts) {
-					combined.set(part, offset$1);
-					offset$1 += part.length;
-				}
-				body = combined.buffer;
-			}
-		} else body = dataParts.join(``);
-		return new Response(body, {
-			status: 200,
-			headers
-		});
-	}
-	/**
 	* Update instance state from an SSE control event.
 	*/
 	#updateStateFromSSEControl(controlEvent) {
-		this.#offset = controlEvent.streamNextOffset;
-		if (controlEvent.streamCursor) this.#cursor = controlEvent.streamCursor;
-		if (controlEvent.upToDate !== void 0) this.#upToDate = controlEvent.upToDate;
-		if (controlEvent.streamClosed) {
-			this.#streamClosed = true;
-			this.#upToDate = true;
-		}
+		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() {
-		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() {
-		if (this.#lastSSEConnectionStartTime === void 0) return 0;
-		const connectionDuration = Date.now() - this.#lastSSEConnectionStartTime;
-		const wasAborted = this.#abortController.signal.aborted;
-		if (connectionDuration < this.#sseResilience.minConnectionDuration && !wasAborted) {
-			this.#consecutiveShortSSEConnections++;
-			if (this.#consecutiveShortSSEConnections >= this.#sseResilience.maxShortConnections) {
-				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;
-			} else {
-				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) this.#consecutiveShortSSEConnections = 0;
-		return 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
+		});
+		this.#syncState = this.#syncState.startConnection(Date.now());
 	}
 	/**
 	* Try to reconnect SSE and return the new iterator, or null if reconnection
 	* is not possible or fails.
 	*/
 	async #trySSEReconnect() {
-		if (this.#sseFallbackToLongPoll) return null;
+		if (!this.#syncState.shouldUseSse()) return null;
 		if (!this.#shouldContinueLive() || !this.#startSSE) return null;
-		const delayOrNull = await this.#handleSSEConnectionEnd();
-		if (delayOrNull === null) return null;
+		const result = this.#syncState.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;
+		}
+		if (result.action === `reconnect`) {
+			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));
+		}
 		this.#markSSEConnectionStart();
 		this.#requestAbortController = new AbortController();
 		const newSSEResponse = await this.#startSSE(this.offset, this.cursor, this.#requestAbortController.signal);
@@ -946,7 +1046,7 @@ var StreamResponseImpl = class {
 		if (event.type === `data`) return this.#processSSEDataEvent(event.data, sseEventIterator);
 		this.#updateStateFromSSEControl(event);
 		if (event.upToDate) {
-			const response = this.#createSSESyntheticResponse(``, event.streamNextOffset, event.streamCursor, true, event.streamClosed ?? false);
+			const response = createSSESyntheticResponse(``, event.streamNextOffset, event.streamCursor, true, event.streamClosed ?? false, this.contentType, this.#encoding);
 			return {
 				type: `response`,
 				response
@@ -967,7 +1067,7 @@ var StreamResponseImpl = class {
 		while (true) {
 			const { done: controlDone, value: controlEvent } = await sseEventIterator.next();
 			if (controlDone) {
-				const response = this.#createSSESyntheticResponseFromParts(bufferedDataParts, this.offset, this.cursor, this.upToDate, this.streamClosed);
+				const response = createSSESyntheticResponseFromParts(bufferedDataParts, this.offset, this.cursor, this.upToDate, this.streamClosed, this.contentType, this.#encoding, this.#isJsonMode);
 				try {
 					const newIterator = await this.#trySSEReconnect();
 					return {
@@ -984,7 +1084,7 @@ var StreamResponseImpl = class {
 			}
 			if (controlEvent.type === `control`) {
 				this.#updateStateFromSSEControl(controlEvent);
-				const response = this.#createSSESyntheticResponseFromParts(bufferedDataParts, controlEvent.streamNextOffset, controlEvent.streamCursor, controlEvent.upToDate ?? false, controlEvent.streamClosed ?? false);
+				const response = createSSESyntheticResponseFromParts(bufferedDataParts, controlEvent.streamNextOffset, controlEvent.streamCursor, controlEvent.upToDate ?? false, controlEvent.streamClosed ?? false, this.contentType, this.#encoding, this.#isJsonMode);
 				return {
 					type: `response`,
 					response
@@ -1062,6 +1162,7 @@ var StreamResponseImpl = class {
 						}
 					}
 					if (this.#shouldContinueLive()) {
+						let resumingFromPause = false;
 						if (this.#state === `pause-requested` || this.#state === `paused`) {
 							this.#state = `paused`;
 							if (this.#pausePromise) await this.#pausePromise;
@@ -1070,14 +1171,13 @@ var StreamResponseImpl = class {
 								controller.close();
 								return;
 							}
+							resumingFromPause = true;
 						}
 						if (this.#abortController.signal.aborted) {
 							this.#markClosed();
 							controller.close();
 							return;
 						}
-						const resumingFromPause = this.#justResumedFromPause;
-						this.#justResumedFromPause = false;
 						this.#requestAbortController = new AbortController();
 						const response = await this.#fetchNext(this.offset, this.cursor, this.#requestAbortController.signal, resumingFromPause);
 						this.#updateStateFromResponse(response);
@@ -1243,23 +1343,28 @@ var StreamResponseImpl = class {
 					controller.enqueue(pendingItems.shift());
 					return;
 				}
-				const { done, value: response } = await reader.read();
-				if (done) {
-					this.#markClosed();
-					controller.close();
-					return;
-				}
-				const text = await response.text();
-				const content = text.trim() || `[]`;
-				let parsed;
-				try {
-					parsed = JSON.parse(content);
-				} 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`);
+				let result = await reader.read();
+				while (!result.done) {
+					const response = result.value;
+					const text = await response.text();
+					const content = text.trim() || `[]`;
+					let parsed;
+					try {
+						parsed = JSON.parse(content);
+					} 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];
+					if (pendingItems.length > 0) {
+						controller.enqueue(pendingItems.shift());
+						return;
+					}
+					result = await reader.read();
 				}
-				pendingItems = Array.isArray(parsed) ? parsed : [parsed];
-				if (pendingItems.length > 0) controller.enqueue(pendingItems.shift());
+				this.#markClosed();
+				controller.close();
+				return;
 			},
 			cancel: () => {
 				reader.releaseLock();
@@ -1293,7 +1398,7 @@ var StreamResponseImpl = class {
 				while (!result.done) {
 					if (abortController.signal.aborted) break;
 					const response = result.value;
-					const { offset, cursor, upToDate, streamClosed } = this.#getMetadataFromResponse(response);
+					const { offset, cursor, upToDate, streamClosed } = getMetadataFromResponse(response, this.offset, this.cursor, this.streamClosed);
 					const text = await response.text();
 					const content = text.trim() || `[]`;
 					let parsed;
@@ -1339,7 +1444,7 @@ var StreamResponseImpl = class {
 				while (!result.done) {
 					if (abortController.signal.aborted) break;
 					const response = result.value;
-					const { offset, cursor, upToDate, streamClosed } = this.#getMetadataFromResponse(response);
+					const { offset, cursor, upToDate, streamClosed } = getMetadataFromResponse(response, this.offset, this.cursor, this.streamClosed);
 					const buffer = await response.arrayBuffer();
 					await subscriber({
 						data: new Uint8Array(buffer),
@@ -1376,7 +1481,7 @@ var StreamResponseImpl = class {
 				while (!result.done) {
 					if (abortController.signal.aborted) break;
 					const response = result.value;
-					const { offset, cursor, upToDate, streamClosed } = this.#getMetadataFromResponse(response);
+					const { offset, cursor, upToDate, streamClosed } = getMetadataFromResponse(response, this.offset, this.cursor, this.streamClosed);
 					const text = await response.text();
 					await subscriber({
 						text,
@@ -1412,6 +1517,97 @@ var StreamResponseImpl = class {
 		return this.#closed;
 	}
 };
+/**
+* Extract stream metadata from Response headers.
+* Falls back to the provided defaults when headers are absent.
+*/
+function getMetadataFromResponse(response, fallbackOffset, fallbackCursor, fallbackStreamClosed) {
+	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) {
+	const cleaned = base64Str.replace(/[\n\r]/g, ``);
+	if (cleaned.length === 0) return new Uint8Array(0);
+	if (cleaned.length % 4 !== 0) throw new DurableStreamError(`Invalid base64 data: length ${cleaned.length} is not a multiple of 4`, `PARSE_ERROR`);
+	try {
+		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, offset, cursor, upToDate, streamClosed, contentType, encoding) {
+	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, offset, cursor, upToDate, streamClosed, contentType, encoding, isJsonMode) {
+	const headers = {
+		"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`;
+	let body;
+	if (encoding === `base64`) {
+		const decodedParts = dataParts.filter((part) => part.length > 0).map((part) => decodeBase64(part));
+		if (decodedParts.length === 0) body = new ArrayBuffer(0);
+		else if (decodedParts.length === 1) {
+			const decoded = decodedParts[0];
+			body = decoded.buffer.slice(decoded.byteOffset, decoded.byteOffset + decoded.byteLength);
+		} else {
+			const totalLength = decodedParts.reduce((sum, part) => sum + part.length, 0);
+			const combined = new Uint8Array(totalLength);
+			let offset$1 = 0;
+			for (const part of decodedParts) {
+				combined.set(part, offset$1);
+				offset$1 += part.length;
+			}
+			body = combined.buffer;
+		}
+	} else if (isJsonMode) {
+		const mergedParts = [];
+		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
+	});
+}
 
 //#endregion
 //#region src/utils.ts