@prisma/composer-prisma-cloud 0.1.0-dev.4 → 0.1.0-dev.5

package/dist/streams/index.mjs

@@ -465,7 +465,7 @@ function storageService(opts) {
 }
 storageService({ bucket: "storage" });
 //#endregion
-//#region ../../1-prisma-cloud/2-shared-modules/streams/dist/streams-service-Mz48Yi0V.mjs
+//#region ../../1-prisma-cloud/2-shared-modules/streams/dist/streams-service-Br5Tj3AY.mjs
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -864,7 +864,7 @@ var FetchError = class FetchError extends Error {
 		let text = void 0;
 		let json = void 0;
 		const contentType = response.headers.get(`content-type`);
-		if (!response.bodyUsed) if (contentType && contentType.includes(`application/json`)) try {
+		if (!response.bodyUsed && response.body !== null) if (contentType && contentType.includes(`application/json`)) try {
 			json = await response.json();
 		} catch {
 			text = await response.text();
@@ -913,7 +913,7 @@ var DurableStreamError = class DurableStreamError extends Error {
 		const status = response.status;
 		let details;
 		const contentType = response.headers.get(`content-type`);
-		if (!response.bodyUsed) if (contentType && contentType.includes(`application/json`)) try {
+		if (!response.bodyUsed && response.body !== null) if (contentType && contentType.includes(`application/json`)) try {
 			details = await response.json();
 		} catch {
 			details = await response.text();
@@ -1282,6 +1282,204 @@ async function* parseSSEStream(stream$1, signal) {
 	}
 }
 /**
+* 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
+		};
+	}
+};
+/**
 * Constant used as abort reason when pausing the stream due to visibility change.
 */
 const PAUSE_STREAM = `PAUSE_STREAM`;
@@ -1298,10 +1496,7 @@ var StreamResponseImpl = class {
 	#statusText;
 	#ok;
 	#isLoading;
-	#offset;
-	#cursor;
-	#upToDate;
-	#streamClosed;
+	#syncState;
 	#isJsonMode;
 	#abortController;
 	#fetchNext;
@@ -1316,11 +1511,7 @@ var StreamResponseImpl = class {
 	#unsubscribeFromVisibilityChanges;
 	#pausePromise;
 	#pauseResolve;
-	#justResumedFromPause = false;
 	#sseResilience;
-	#lastSSEConnectionStartTime;
-	#consecutiveShortSSEConnections = 0;
-	#sseFallbackToLongPoll = false;
 	#encoding;
 	#responseStream;
 	constructor(config) {
@@ -1328,10 +1519,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;
@@ -1388,6 +1582,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;
 			});
@@ -1401,8 +1596,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;
@@ -1424,16 +1619,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`);
@@ -1459,160 +1654,68 @@ 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);
-		if (response.headers.get(STREAM_CLOSED_HEADER)?.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 /* @__PURE__ */ 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 = /* @__PURE__ */ 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);
+	}
+	#updateEncodingFromSSEResponse(response) {
+		this.#encoding = response.headers.get(STREAM_SSE_DATA_ENCODING_HEADER) === `base64` ? `base64` : void 0;
 	}
 	/**
 	* 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;
-		if (await this.#handleSSEConnectionEnd() === 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);
+		this.#updateEncodingFromSSEResponse(newSSEResponse);
 		if (newSSEResponse.body) return parseSSEStream(newSSEResponse.body, this.#requestAbortController.signal);
 		return null;
 	}
@@ -1645,7 +1748,7 @@ var StreamResponseImpl = class {
 		this.#updateStateFromSSEControl(event);
 		if (event.upToDate) return {
 			type: `response`,
-			response: this.#createSSESyntheticResponse(``, event.streamNextOffset, event.streamCursor, true, event.streamClosed ?? false)
+			response: createSSESyntheticResponse(``, event.streamNextOffset, event.streamCursor, true, event.streamClosed ?? false, this.contentType, this.#encoding)
 		};
 		return { type: `continue` };
 	}
@@ -1662,7 +1765,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 {
 					return {
 						type: `response`,
@@ -1680,7 +1783,7 @@ var StreamResponseImpl = class {
 				this.#updateStateFromSSEControl(controlEvent);
 				return {
 					type: `response`,
-					response: this.#createSSESyntheticResponseFromParts(bufferedDataParts, controlEvent.streamNextOffset, controlEvent.streamCursor, controlEvent.upToDate ?? false, controlEvent.streamClosed ?? false)
+					response: createSSESyntheticResponseFromParts(bufferedDataParts, controlEvent.streamNextOffset, controlEvent.streamCursor, controlEvent.upToDate ?? false, controlEvent.streamClosed ?? false, this.contentType, this.#encoding, this.#isJsonMode)
 				};
 			}
 			bufferedDataParts.push(controlEvent.data);
@@ -1703,6 +1806,7 @@ var StreamResponseImpl = class {
 						firstResponseYielded = true;
 						if ((firstResponse.headers.get(`content-type`)?.includes(`text/event-stream`) ?? false) && firstResponse.body) {
 							this.#markSSEConnectionStart();
+							this.#updateEncodingFromSSEResponse(firstResponse);
 							this.#requestAbortController = new AbortController();
 							sseEventIterator = parseSSEStream(firstResponse.body, this.#requestAbortController.signal);
 						} else {
@@ -1715,6 +1819,22 @@ var StreamResponseImpl = class {
 							return;
 						}
 					}
+					if (!sseEventIterator && this.upToDate && this.#startSSE && this.#shouldContinueLive()) {
+						if (this.#state === `pause-requested` || this.#state === `paused`) {
+							this.#state = `paused`;
+							if (this.#pausePromise) await this.#pausePromise;
+							if (this.#abortController.signal.aborted) {
+								this.#markClosed();
+								controller.close();
+								return;
+							}
+						}
+						this.#markSSEConnectionStart();
+						this.#requestAbortController = new AbortController();
+						const sseResponse = await this.#startSSE(this.offset, this.cursor, this.#requestAbortController.signal);
+						this.#updateEncodingFromSSEResponse(sseResponse);
+						if (sseResponse.body) sseEventIterator = parseSSEStream(sseResponse.body, this.#requestAbortController.signal);
+					}
 					if (sseEventIterator) {
 						if (this.#state === `pause-requested` || this.#state === `paused`) {
 							this.#state = `paused`;
@@ -1754,6 +1874,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;
@@ -1762,16 +1883,15 @@ 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);
+						const response = await this.#fetchNext(this.offset, this.cursor, this.#requestAbortController.signal, this.upToDate, resumingFromPause);
 						this.#updateStateFromResponse(response);
 						controller.enqueue(response);
 						return;
@@ -1934,22 +2054,25 @@ var StreamResponseImpl = class {
 					controller.enqueue(pendingItems.shift());
 					return;
 				}
-				const { done, value: response } = await reader.read();
-				if (done) {
-					this.#markClosed();
-					controller.close();
-					return;
-				}
-				const content = (await response.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 content = (await result.value.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();
 			},
 			cancel: () => {
 				reader.releaseLock();
@@ -1981,7 +2104,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 content = (await response.text()).trim() || `[]`;
 					let parsed;
 					try {
@@ -2025,7 +2148,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),
@@ -2062,7 +2185,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);
 					await subscriber({
 						text: await response.text(),
 						offset,
@@ -2098,6 +2221,97 @@ var StreamResponseImpl = class {
 	}
 };
 /**
+* 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 /* @__PURE__ */ 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 = /* @__PURE__ */ 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
+	});
+}
+/**
 * Resolve headers from HeadersRecord (supports async functions).
 * Unified implementation used by both stream() and DurableStream.
 */
@@ -2264,7 +2478,6 @@ async function streamInternal(options) {
 	const startOffset = options.offset ?? `-1`;
 	fetchUrl.searchParams.set(OFFSET_QUERY_PARAM, startOffset);
 	const live = options.live ?? true;
-	if (live === `long-poll` || live === `sse`) fetchUrl.searchParams.set(LIVE_QUERY_PARAM, live);
 	const params = await resolveParams(options.params);
 	for (const [key, value] of Object.entries(params)) fetchUrl.searchParams.set(key, value);
 	const headers = await resolveHeaders(options.headers);
@@ -2289,12 +2502,11 @@ async function streamInternal(options) {
 	const initialStreamClosed = firstResponse.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`;
 	const isJsonMode = options.json === true || (contentType?.includes(`application/json`) ?? false);
 	const encoding = firstResponse.headers.get(STREAM_SSE_DATA_ENCODING_HEADER) === `base64` ? `base64` : void 0;
-	const fetchNext = async (offset, cursor, signal, resumingFromPause) => {
+	const fetchNext = async (offset, cursor, signal, upToDate, resumingFromPause) => {
 		const nextUrl = new URL(url);
 		nextUrl.searchParams.set(OFFSET_QUERY_PARAM, offset);
-		if (!resumingFromPause) {
-			if (live === `sse`) nextUrl.searchParams.set(LIVE_QUERY_PARAM, `sse`);
-			else if (live === true || live === `long-poll`) nextUrl.searchParams.set(LIVE_QUERY_PARAM, `long-poll`);
+		if (upToDate && !resumingFromPause) {
+			if (live === true || live === `long-poll`) nextUrl.searchParams.set(LIVE_QUERY_PARAM, `long-poll`);
 		}
 		if (cursor) nextUrl.searchParams.set(`cursor`, cursor);
 		const nextParams = await resolveParams(options.params);
@@ -2418,6 +2630,7 @@ var IdempotentProducer = class {
 	#maxBatchBytes;
 	#lingerMs;
 	#fetchClient;
+	#headers;
 	#signal;
 	#onError;
 	#pendingBatch = [];
@@ -2425,9 +2638,11 @@ var IdempotentProducer = class {
 	#lingerTimeout = null;
 	#queue;
 	#maxInFlight;
+	#deferredEnqueues = /* @__PURE__ */ new Set();
 	#closed = false;
 	#closeResult = null;
 	#pendingFinalMessage;
+	#lastSuccessfulOffset;
 	#epochClaimed;
 	#seqState = /* @__PURE__ */ new Map();
 	/**
@@ -2453,6 +2668,7 @@ var IdempotentProducer = class {
 		this.#maxBatchBytes = maxBatchBytes;
 		this.#lingerMs = lingerMs;
 		this.#signal = opts?.signal;
+		this.#headers = opts?.headers;
 		this.#onError = opts?.onError;
 		this.#fetchClient = opts?.fetch ?? ((...args) => fetch(...args));
 		this.#maxInFlight = maxInFlight;
@@ -2514,7 +2730,10 @@ var IdempotentProducer = class {
 			this.#lingerTimeout = null;
 		}
 		if (this.#pendingBatch.length > 0) this.#enqueuePendingBatch();
-		await this.#queue.drained();
+		do {
+			await this.#queue.drained();
+			await Promise.all(this.#deferredEnqueues);
+		} while (this.#deferredEnqueues.size > 0 || this.inFlightCount > 0);
 	}
 	/**
 	* Stop the producer without closing the underlying stream.
@@ -2578,13 +2797,13 @@ var IdempotentProducer = class {
 			else body = bodyBytes;
 		}
 		const seqForThisRequest = this.#nextSeq;
-		const headers = {
+		const headers = await this.#buildHeaders({
 			"content-type": contentType,
 			[PRODUCER_ID_HEADER]: this.#producerId,
 			[PRODUCER_EPOCH_HEADER]: this.#epoch.toString(),
 			[PRODUCER_SEQ_HEADER]: seqForThisRequest.toString(),
 			[STREAM_CLOSED_HEADER]: `true`
-		};
+		});
 		const response = await this.#fetchClient(this.#stream.url, {
 			method: `POST`,
 			headers,
@@ -2593,11 +2812,15 @@ var IdempotentProducer = class {
 		});
 		if (response.status === 204) {
 			this.#nextSeq = seqForThisRequest + 1;
-			return { finalOffset: response.headers.get(STREAM_OFFSET_HEADER) ?? `` };
+			const finalOffset = response.headers.get(STREAM_OFFSET_HEADER) ?? ``;
+			this.#recordSuccessfulOffset(finalOffset);
+			return { finalOffset };
 		}
 		if (response.status === 200) {
 			this.#nextSeq = seqForThisRequest + 1;
-			return { finalOffset: response.headers.get(STREAM_OFFSET_HEADER) ?? `` };
+			const finalOffset = response.headers.get(STREAM_OFFSET_HEADER) ?? ``;
+			this.#recordSuccessfulOffset(finalOffset);
+			return { finalOffset };
 		}
 		if (response.status === 403) {
 			const currentEpochStr = response.headers.get(PRODUCER_EPOCH_HEADER);
@@ -2645,7 +2868,14 @@ var IdempotentProducer = class {
 	* Number of batches currently in flight.
 	*/
 	get inFlightCount() {
-		return this.#queue.length();
+		return this.#queue.length() + this.#queue.running();
+	}
+	/**
+	* The greatest non-empty stream offset returned by a successful producer
+	* append or close request.
+	*/
+	get lastSuccessfulOffset() {
+		return this.#lastSuccessfulOffset;
 	}
 	/**
 	* Enqueue the current pending batch for processing.
@@ -2653,17 +2883,22 @@ var IdempotentProducer = class {
 	#enqueuePendingBatch() {
 		if (this.#pendingBatch.length === 0) return;
 		const batch = this.#pendingBatch;
-		const seq = this.#nextSeq;
 		this.#pendingBatch = [];
 		this.#batchBytes = 0;
+		if (this.#autoClaim && !this.#epochClaimed && this.inFlightCount > 0) {
+			const deferred = this.#queue.drained().then(() => {
+				this.#pushBatch(batch);
+			}).finally(() => {
+				this.#deferredEnqueues.delete(deferred);
+			});
+			this.#deferredEnqueues.add(deferred);
+			deferred.catch(() => {});
+		} else this.#pushBatch(batch);
+	}
+	#pushBatch(batch) {
+		const seq = this.#nextSeq;
 		this.#nextSeq++;
-		if (this.#autoClaim && !this.#epochClaimed && this.#queue.length() > 0) this.#queue.drained().then(() => {
-			this.#queue.push({
-				batch,
-				seq
-			}).catch(() => {});
-		});
-		else this.#queue.push({
+		this.#queue.push({
 			batch,
 			seq
 		}).catch(() => {});
@@ -2675,7 +2910,8 @@ var IdempotentProducer = class {
 		const { batch, seq } = task;
 		const epoch = this.#epoch;
 		try {
-			await this.#doSendBatch(batch, seq, epoch);
+			const result = await this.#doSendBatch(batch, seq, epoch);
+			this.#recordSuccessfulOffset(result.offset);
 			if (!this.#epochClaimed) this.#epochClaimed = true;
 			this.#signalSeqComplete(epoch, seq, void 0);
 		} catch (error) {
@@ -2684,6 +2920,9 @@ var IdempotentProducer = class {
 			throw error;
 		}
 	}
+	#recordSuccessfulOffset(offset) {
+		if (offset && (!this.#lastSuccessfulOffset || offset > this.#lastSuccessfulOffset)) this.#lastSuccessfulOffset = offset;
+	}
 	/**
 	* Signal that a sequence has completed (success or failure).
 	*/
@@ -2758,12 +2997,12 @@ var IdempotentProducer = class {
 			batchedBody = concatenated;
 		}
 		const url = this.#stream.url;
-		const headers = {
+		const headers = await this.#buildHeaders({
 			"content-type": contentType,
 			[PRODUCER_ID_HEADER]: this.#producerId,
 			[PRODUCER_EPOCH_HEADER]: epoch.toString(),
 			[PRODUCER_SEQ_HEADER]: seq.toString()
-		};
+		});
 		const response = await this.#fetchClient(url, {
 			method: `POST`,
 			headers,
@@ -2804,6 +3043,15 @@ var IdempotentProducer = class {
 		if (response.status === 400) throw await DurableStreamError.fromResponse(response, url);
 		throw await FetchError.fromResponse(response, url);
 	}
+	async #buildHeaders(protocolHeaders) {
+		const streamHeaders = await this.#stream.resolveHeaders();
+		const producerHeaders = await resolveHeaders(this.#headers);
+		return {
+			...streamHeaders,
+			...producerHeaders,
+			...protocolHeaders
+		};
+	}
 	/**
 	* Clear pending batch and report error.
 	*/
@@ -2847,7 +3095,7 @@ function isPromiseLike(value) {
 *   contentType: "application/json"
 * });
 *
-* // Write data
+* // Single write
 * await stream.append(JSON.stringify({ message: "hello" }));
 *
 * // Read with the new API
@@ -2870,6 +3118,7 @@ var DurableStream = class DurableStream {
 	contentType;
 	#options;
 	#fetchClient;
+	#baseFetchClient;
 	#onError;
 	#batchingEnabled;
 	#queue;
@@ -2890,7 +3139,9 @@ var DurableStream = class DurableStream {
 		if (opts.contentType) this.contentType = opts.contentType;
 		this.#batchingEnabled = opts.batching !== false;
 		if (this.#batchingEnabled) this.#queue = import_queue.default.promise(this.#batchWorker.bind(this), 1);
-		const fetchWithBackoffClient = createFetchWithBackoff(opts.fetch ?? ((...args) => fetch(...args)), { ...opts.backoffOptions ?? BackoffDefaults });
+		this.#baseFetchClient = opts.fetch ?? ((...args) => fetch(...args));
+		const backOffOpts = { ...opts.backoffOptions ?? BackoffDefaults };
+		const fetchWithBackoffClient = createFetchWithBackoff(this.#baseFetchClient, backOffOpts);
 		this.#fetchClient = createFetchWithConsumedBody(fetchWithBackoffClient);
 	}
 	/**
@@ -2945,12 +3196,15 @@ var DurableStream = class DurableStream {
 	*/
 	async head(opts) {
 		const { requestHeaders, fetchUrl } = await this.#buildRequest();
-		const response = await this.#fetchClient(fetchUrl.toString(), {
+		const response = await this.#baseFetchClient(fetchUrl.toString(), {
 			method: `HEAD`,
 			headers: requestHeaders,
 			signal: opts?.signal ?? this.#options.signal
 		});
-		if (!response.ok) await handleErrorResponse(response, this.url);
+		if (!response.ok) {
+			if (response.status === 404) return { exists: false };
+			await handleErrorResponse(response, this.url);
+		}
 		const contentType = response.headers.get(`content-type`) ?? void 0;
 		const offset = response.headers.get(STREAM_OFFSET_HEADER) ?? void 0;
 		const etag = response.headers.get(`etag`) ?? void 0;
@@ -3048,9 +3302,14 @@ var DurableStream = class DurableStream {
 	/**
 	* Append a single payload to the stream.
 	*
-	* When batching is enabled (default), multiple append() calls made while
-	* a POST is in-flight will be batched together into a single request.
-	* This significantly improves throughput for high-frequency writes.
+	* Batching: when batching is enabled (default), append() calls that overlap
+	* in time (e.g. fired without awaiting each one) are coalesced into a
+	* single POST while a prior POST is in flight. If every call is awaited
+	* before the next is issued, no batching happens — each call becomes its
+	* own roundtrip. For tight loops driving an async iterable (e.g. LLM
+	* token streams), prefer `appendStream()` / `writable()` which pipe the
+	* source over a single POST, or fire `append()` calls without awaiting
+	* each one and await the last promise (and `close()`) at the end.
 	*
 	* - `body` must be string or Uint8Array.
 	* - For JSON streams, pass pre-serialized JSON strings.
@@ -3060,7 +3319,7 @@ var DurableStream = class DurableStream {
 	*
 	* @example
 	* ```typescript
-	* // JSON stream - pass pre-serialized JSON
+	* // JSON stream - pass pre-serialized JSON (single write)
 	* await stream.append(JSON.stringify({ message: "hello" }));
 	*
 	* // Byte stream
@@ -3069,6 +3328,14 @@ var DurableStream = class DurableStream {
 	*
 	* // Promise value - awaited before buffering
 	* await stream.append(fetchData());
+	*
+	* // High-frequency writes from an async iterable - fire-and-track-last
+	* let last: Promise<void> = Promise.resolve();
+	* for await (const chunk of source) {
+	*   last = stream.append(JSON.stringify(chunk));
+	* }
+	* await last;
+	* await stream.close();
 	* ```
 	*/
 	async append(body, opts) {
@@ -3275,6 +3542,7 @@ var DurableStream = class DurableStream {
 		let writeError = null;
 		const producer = new IdempotentProducer(this, producerId, {
 			autoClaim: true,
+			headers: opts?.headers,
 			lingerMs: opts?.lingerMs,
 			maxBatchBytes: opts?.maxBatchBytes,
 			onError: (error) => {
@@ -3357,6 +3625,14 @@ var DurableStream = class DurableStream {
 		});
 	}
 	/**
+	* Resolve the stream's configured headers.
+	* Used by IdempotentProducer to merge auth headers into its requests.
+	* @internal
+	*/
+	async resolveHeaders() {
+		return resolveHeaders(this.#options.headers);
+	}
+	/**
 	* Build request headers and URL.
 	*/
 	async #buildRequest() {