@durable-streams/client 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -46,6 +46,11 @@ const STREAM_CURSOR_HEADER = `Stream-Cursor`;
 */
 const STREAM_UP_TO_DATE_HEADER = `Stream-Up-To-Date`;
 /**
+* Response/request header indicating stream is closed (EOF).
+* When present with value "true", the stream is permanently closed.
+*/
+const STREAM_CLOSED_HEADER = `Stream-Closed`;
+/**
 * Request header for writer coordination sequence.
 * Monotonic, lexicographic. If lower than last appended seq -> 409 Conflict.
 */
@@ -94,8 +99,17 @@ const LIVE_QUERY_PARAM = `live`;
 */
 const CURSOR_QUERY_PARAM = `cursor`;
 /**
-* Content types that support SSE mode.
-* SSE is only valid for text/* or application/json streams.
+* Response header indicating SSE data encoding (e.g., base64 for binary streams).
+*/
+const STREAM_SSE_DATA_ENCODING_HEADER = `stream-sse-data-encoding`;
+/**
+* SSE control event field for stream closed state.
+* Note: Different from HTTP header name (camelCase vs Header-Case).
+*/
+const SSE_CLOSED_FIELD = `streamClosed`;
+/**
+* Content types that are natively compatible with SSE (UTF-8 text).
+* Binary content types are also supported via automatic base64 encoding.
 */
 const SSE_COMPATIBLE_CONTENT_TYPES = [`text/`, `application/json`];
 /**
@@ -225,6 +239,23 @@ var MissingStreamUrlError = class extends Error {
 	}
 };
 /**
+* Error thrown when attempting to append to a closed stream.
+*/
+var StreamClosedError = class extends DurableStreamError {
+	code = `STREAM_CLOSED`;
+	status = 409;
+	streamClosed = true;
+	/**
+	* The final offset of the stream, if available from the response.
+	*/
+	finalOffset;
+	constructor(url, finalOffset) {
+		super(`Cannot append to closed stream`, `STREAM_CLOSED`, 409, url);
+		this.name = `StreamClosedError`;
+		this.finalOffset = finalOffset;
+	}
+};
+/**
 * Error thrown when signal option is invalid.
 */
 var InvalidSignalError = class extends Error {
@@ -504,7 +535,8 @@ async function* parseSSEStream(stream$1, signal) {
 							type: `control`,
 							streamNextOffset: control.streamNextOffset,
 							streamCursor: control.streamCursor,
-							upToDate: control.upToDate
+							upToDate: control.upToDate,
+							streamClosed: control.streamClosed
 						};
 					} catch (err) {
 						const preview = dataStr.length > 100 ? dataStr.slice(0, 100) + `...` : dataStr;
@@ -512,8 +544,10 @@ async function* parseSSEStream(stream$1, signal) {
 					}
 				}
 				currentEvent = { data: [] };
-			} else if (line.startsWith(`event:`)) currentEvent.type = line.slice(6).trim();
-			else if (line.startsWith(`data:`)) {
+			} else if (line.startsWith(`event:`)) {
+				const eventType = line.slice(6);
+				currentEvent.type = eventType.startsWith(` `) ? eventType.slice(1) : eventType;
+			} else if (line.startsWith(`data:`)) {
 				const content = line.slice(5);
 				currentEvent.data.push(content.startsWith(` `) ? content.slice(1) : content);
 			}
@@ -532,7 +566,8 @@ async function* parseSSEStream(stream$1, signal) {
 					type: `control`,
 					streamNextOffset: control.streamNextOffset,
 					streamCursor: control.streamCursor,
-					upToDate: control.upToDate
+					upToDate: control.upToDate,
+					streamClosed: control.streamClosed
 				};
 			} catch (err) {
 				const preview = dataStr.length > 100 ? dataStr.slice(0, 100) + `...` : dataStr;
@@ -566,6 +601,7 @@ var StreamResponseImpl = class {
 	#offset;
 	#cursor;
 	#upToDate;
+	#streamClosed;
 	#isJsonMode;
 	#abortController;
 	#fetchNext;
@@ -585,6 +621,7 @@ var StreamResponseImpl = class {
 	#lastSSEConnectionStartTime;
 	#consecutiveShortSSEConnections = 0;
 	#sseFallbackToLongPoll = false;
+	#encoding;
 	#responseStream;
 	constructor(config) {
 		this.url = config.url;
@@ -594,6 +631,7 @@ var StreamResponseImpl = class {
 		this.#offset = config.initialOffset;
 		this.#cursor = config.initialCursor;
 		this.#upToDate = config.initialUpToDate;
+		this.#streamClosed = config.initialStreamClosed;
 		this.#headers = config.firstResponse.headers;
 		this.#status = config.firstResponse.status;
 		this.#statusText = config.firstResponse.statusText;
@@ -610,6 +648,7 @@ var StreamResponseImpl = class {
 			backoffMaxDelay: config.sseResilience?.backoffMaxDelay ?? 5e3,
 			logWarnings: config.sseResilience?.logWarnings ?? true
 		};
+		this.#encoding = config.encoding;
 		this.#closed = new Promise((resolve, reject) => {
 			this.#closedResolve = resolve;
 			this.#closedReject = reject;
@@ -693,6 +732,9 @@ var StreamResponseImpl = class {
 	get upToDate() {
 		return this.#upToDate;
 	}
+	get streamClosed() {
+		return this.#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`);
 	}
@@ -714,11 +756,12 @@ var StreamResponseImpl = class {
 	}
 	/**
 	* 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() {
 		if (this.#stopAfterUpToDate && this.upToDate) return false;
 		if (this.live === false) return false;
+		if (this.#streamClosed) return false;
 		return true;
 	}
 	/**
@@ -730,6 +773,8 @@ var StreamResponseImpl = class {
 		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.#headers = response.headers;
 		this.#status = response.status;
 		this.#statusText = response.statusText;
@@ -737,7 +782,7 @@ var StreamResponseImpl = class {
 	}
 	/**
 	* Extract stream metadata from Response headers.
-	* Used by subscriber APIs to get the correct offset/cursor/upToDate for each
+	* 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.
 	*/
@@ -745,24 +790,74 @@ var StreamResponseImpl = class {
 		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
+			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 in headers so subscribers can read them.
+	* 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.
 	*/
-	#createSSESyntheticResponse(data, offset, cursor, upToDate) {
+	#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`;
-		return new Response(data, {
+		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
 		});
@@ -774,6 +869,10 @@ var StreamResponseImpl = class {
 		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;
+		}
 	}
 	/**
 	* Mark the start of an SSE connection for duration tracking.
@@ -846,19 +945,29 @@ 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);
+			return {
+				type: `response`,
+				response
+			};
+		}
 		return { type: `continue` };
 	}
 	/**
 	* 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, sseEventIterator) {
-		let bufferedData = pendingData;
+		const bufferedDataParts = [pendingData];
 		while (true) {
 			const { done: controlDone, value: controlEvent } = await sseEventIterator.next();
 			if (controlDone) {
-				const response = this.#createSSESyntheticResponse(bufferedData, this.offset, this.cursor, this.upToDate);
+				const response = this.#createSSESyntheticResponseFromParts(bufferedDataParts, this.offset, this.cursor, this.upToDate, this.streamClosed);
 				try {
 					const newIterator = await this.#trySSEReconnect();
 					return {
@@ -875,13 +984,13 @@ var StreamResponseImpl = class {
 			}
 			if (controlEvent.type === `control`) {
 				this.#updateStateFromSSEControl(controlEvent);
-				const response = this.#createSSESyntheticResponse(bufferedData, controlEvent.streamNextOffset, controlEvent.streamCursor, controlEvent.upToDate ?? false);
+				const response = this.#createSSESyntheticResponseFromParts(bufferedDataParts, controlEvent.streamNextOffset, controlEvent.streamCursor, controlEvent.upToDate ?? false, controlEvent.streamClosed ?? false);
 				return {
 					type: `response`,
 					response
 				};
 			}
-			bufferedData += controlEvent.data;
+			bufferedDataParts.push(controlEvent.data);
 		}
 	}
 	/**
@@ -1184,7 +1293,7 @@ var StreamResponseImpl = class {
 				while (!result.done) {
 					if (abortController.signal.aborted) break;
 					const response = result.value;
-					const { offset, cursor, upToDate } = this.#getMetadataFromResponse(response);
+					const { offset, cursor, upToDate, streamClosed } = this.#getMetadataFromResponse(response);
 					const text = await response.text();
 					const content = text.trim() || `[]`;
 					let parsed;
@@ -1199,7 +1308,8 @@ var StreamResponseImpl = class {
 						items,
 						offset,
 						cursor,
-						upToDate
+						upToDate,
+						streamClosed
 					});
 					result = await reader.read();
 				}
@@ -1229,13 +1339,14 @@ var StreamResponseImpl = class {
 				while (!result.done) {
 					if (abortController.signal.aborted) break;
 					const response = result.value;
-					const { offset, cursor, upToDate } = this.#getMetadataFromResponse(response);
+					const { offset, cursor, upToDate, streamClosed } = this.#getMetadataFromResponse(response);
 					const buffer = await response.arrayBuffer();
 					await subscriber({
 						data: new Uint8Array(buffer),
 						offset,
 						cursor,
-						upToDate
+						upToDate,
+						streamClosed
 					});
 					result = await reader.read();
 				}
@@ -1265,13 +1376,14 @@ var StreamResponseImpl = class {
 				while (!result.done) {
 					if (abortController.signal.aborted) break;
 					const response = result.value;
-					const { offset, cursor, upToDate } = this.#getMetadataFromResponse(response);
+					const { offset, cursor, upToDate, streamClosed } = this.#getMetadataFromResponse(response);
 					const text = await response.text();
 					await subscriber({
 						text,
 						offset,
 						cursor,
-						upToDate
+						upToDate,
+						streamClosed
 					});
 					result = await reader.read();
 				}
@@ -1322,6 +1434,11 @@ async function handleErrorResponse(response, url, context) {
 	const status = response.status;
 	if (status === 404) throw new DurableStreamError(`Stream not found: ${url}`, `NOT_FOUND`, 404);
 	if (status === 409) {
+		const streamClosedHeader = response.headers.get(STREAM_CLOSED_HEADER);
+		if (streamClosedHeader?.toLowerCase() === `true`) {
+			const finalOffset = response.headers.get(STREAM_OFFSET_HEADER) ?? void 0;
+			throw new StreamClosedError(url, finalOffset);
+		}
 		const message = context?.operation === `create` ? `Stream already exists: ${url}` : `Sequence conflict: seq is lower than last appended`;
 		const code = context?.operation === `create` ? `CONFLICT_EXISTS` : `CONFLICT_SEQ`;
 		throw new DurableStreamError(message, code, 409);
@@ -1508,7 +1625,10 @@ async function streamInternal(options) {
 	const initialOffset = firstResponse.headers.get(STREAM_OFFSET_HEADER) ?? startOffset;
 	const initialCursor = firstResponse.headers.get(STREAM_CURSOR_HEADER) ?? void 0;
 	const initialUpToDate = firstResponse.headers.has(STREAM_UP_TO_DATE_HEADER);
+	const initialStreamClosed = firstResponse.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`;
 	const isJsonMode = options.json === true || (contentType?.includes(`application/json`) ?? false);
+	const sseDataEncoding = firstResponse.headers.get(STREAM_SSE_DATA_ENCODING_HEADER);
+	const encoding = sseDataEncoding === `base64` ? `base64` : void 0;
 	const fetchNext = async (offset, cursor, signal, resumingFromPause) => {
 		const nextUrl = new URL(url);
 		nextUrl.searchParams.set(OFFSET_QUERY_PARAM, offset);
@@ -1553,11 +1673,13 @@ async function streamInternal(options) {
 		initialOffset,
 		initialCursor,
 		initialUpToDate,
+		initialStreamClosed,
 		firstResponse,
 		abortController,
 		fetchNext,
 		startSSE,
-		sseResilience: options.sseResilience
+		sseResilience: options.sseResilience,
+		encoding
 	});
 }
 
@@ -1648,6 +1770,8 @@ var IdempotentProducer = class {
 	#queue;
 	#maxInFlight;
 	#closed = false;
+	#closeResult = null;
+	#pendingFinalMessage;
 	#epochClaimed;
 	#seqState = new Map();
 	/**
@@ -1737,11 +1861,17 @@ var IdempotentProducer = class {
 		await this.#queue.drained();
 	}
 	/**
-	* Flush pending messages and close the producer.
+	* Stop the producer without closing the underlying stream.
+	*
+	* Use this when you want to:
+	* - Hand off writing to another producer
+	* - Keep the stream open for future writes
+	* - Stop this producer but not signal EOF to readers
 	*
-	* After calling close(), further append() calls will throw.
+	* Flushes any pending messages before detaching.
+	* After calling detach(), further append() calls will throw.
 	*/
-	async close() {
+	async detach() {
 		if (this.#closed) return;
 		this.#closed = true;
 		try {
@@ -1749,6 +1879,89 @@ var IdempotentProducer = class {
 		} catch {}
 	}
 	/**
+	* Flush pending messages and close the underlying stream (EOF).
+	*
+	* This is the typical way to end a producer session. It:
+	* 1. Flushes all pending messages
+	* 2. Optionally appends a final message
+	* 3. Closes the stream (no further appends permitted)
+	*
+	* **Idempotent**: Unlike `DurableStream.close({ body })`, this method is
+	* idempotent even with a final message because it uses producer headers
+	* for deduplication. Safe to retry on network failures.
+	*
+	* @param finalMessage - Optional final message to append atomically with close
+	* @returns CloseResult with the final offset
+	*/
+	async close(finalMessage) {
+		if (this.#closed) {
+			if (this.#closeResult) return this.#closeResult;
+			await this.flush();
+			const result$1 = await this.#doClose(this.#pendingFinalMessage);
+			this.#closeResult = result$1;
+			return result$1;
+		}
+		this.#closed = true;
+		this.#pendingFinalMessage = finalMessage;
+		await this.flush();
+		const result = await this.#doClose(finalMessage);
+		this.#closeResult = result;
+		return result;
+	}
+	/**
+	* Actually close the stream with optional final message.
+	* Uses producer headers for idempotency.
+	*/
+	async #doClose(finalMessage) {
+		const contentType = this.#stream.contentType ?? `application/octet-stream`;
+		const isJson = normalizeContentType$1(contentType) === `application/json`;
+		let body;
+		if (finalMessage !== void 0) {
+			const bodyBytes = typeof finalMessage === `string` ? new TextEncoder().encode(finalMessage) : finalMessage;
+			if (isJson) {
+				const jsonStr = new TextDecoder().decode(bodyBytes);
+				body = `[${jsonStr}]`;
+			} else body = bodyBytes;
+		}
+		const seqForThisRequest = this.#nextSeq;
+		const headers = {
+			"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,
+			body,
+			signal: this.#signal
+		});
+		if (response.status === 204) {
+			this.#nextSeq = seqForThisRequest + 1;
+			const finalOffset = response.headers.get(STREAM_OFFSET_HEADER) ?? ``;
+			return { finalOffset };
+		}
+		if (response.status === 200) {
+			this.#nextSeq = seqForThisRequest + 1;
+			const finalOffset = response.headers.get(STREAM_OFFSET_HEADER) ?? ``;
+			return { finalOffset };
+		}
+		if (response.status === 403) {
+			const currentEpochStr = response.headers.get(PRODUCER_EPOCH_HEADER);
+			const currentEpoch = currentEpochStr ? parseInt(currentEpochStr, 10) : this.#epoch;
+			if (this.#autoClaim) {
+				const newEpoch = currentEpoch + 1;
+				this.#epoch = newEpoch;
+				this.#nextSeq = 0;
+				return this.#doClose(finalMessage);
+			}
+			throw new StaleEpochError(currentEpoch);
+		}
+		const error = await FetchError.fromResponse(response, this.#stream.url);
+		throw error;
+	}
+	/**
 	* Increment epoch and reset sequence.
 	*
 	* Call this when restarting the producer to establish a new session.
@@ -2054,7 +2267,8 @@ var DurableStream = class DurableStream {
 			contentType: opts.contentType,
 			ttlSeconds: opts.ttlSeconds,
 			expiresAt: opts.expiresAt,
-			body: opts.body
+			body: opts.body,
+			closed: opts.closed
 		});
 		return stream$1;
 	}
@@ -2107,13 +2321,15 @@ var DurableStream = class DurableStream {
 		const offset = response.headers.get(STREAM_OFFSET_HEADER) ?? void 0;
 		const etag = response.headers.get(`etag`) ?? void 0;
 		const cacheControl = response.headers.get(`cache-control`) ?? void 0;
+		const streamClosed = response.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`;
 		if (contentType) this.contentType = contentType;
 		return {
 			exists: true,
 			contentType,
 			offset,
 			etag,
-			cacheControl
+			cacheControl,
+			streamClosed
 		};
 	}
 	/**
@@ -2125,6 +2341,7 @@ var DurableStream = class DurableStream {
 		if (contentType) requestHeaders[`content-type`] = contentType;
 		if (opts?.ttlSeconds !== void 0) requestHeaders[STREAM_TTL_HEADER] = String(opts.ttlSeconds);
 		if (opts?.expiresAt) requestHeaders[STREAM_EXPIRES_AT_HEADER] = opts.expiresAt;
+		if (opts?.closed) requestHeaders[STREAM_CLOSED_HEADER] = `true`;
 		const body = encodeBody(opts?.body);
 		const response = await this.#fetchClient(fetchUrl.toString(), {
 			method: `PUT`,
@@ -2151,6 +2368,57 @@ var DurableStream = class DurableStream {
 		if (!response.ok) await handleErrorResponse(response, this.url);
 	}
 	/**
+	* Close the stream, optionally with a final message.
+	*
+	* After closing:
+	* - No further appends are permitted (server returns 409)
+	* - Readers can observe the closed state and treat it as EOF
+	* - The stream's data remains fully readable
+	*
+	* Closing is:
+	* - **Durable**: The closed state is persisted
+	* - **Monotonic**: Once closed, a stream cannot be reopened
+	*
+	* **Idempotency:**
+	* - `close()` without body: Idempotent — safe to call multiple times
+	* - `close({ body })` with body: NOT idempotent — throws `StreamClosedError`
+	*   if stream is already closed (use `IdempotentProducer.close()` for
+	*   idempotent close-with-body semantics)
+	*
+	* @returns CloseResult with the final offset
+	* @throws StreamClosedError if called with body on an already-closed stream
+	*/
+	async close(opts) {
+		const { requestHeaders, fetchUrl } = await this.#buildRequest();
+		const contentType = opts?.contentType ?? this.#options.contentType ?? this.contentType;
+		if (contentType) requestHeaders[`content-type`] = contentType;
+		requestHeaders[STREAM_CLOSED_HEADER] = `true`;
+		let body;
+		if (opts?.body !== void 0) {
+			const isJson = normalizeContentType(contentType) === `application/json`;
+			if (isJson) {
+				const bodyStr = typeof opts.body === `string` ? opts.body : new TextDecoder().decode(opts.body);
+				body = `[${bodyStr}]`;
+			} else body = typeof opts.body === `string` ? opts.body : opts.body;
+		}
+		const response = await this.#fetchClient(fetchUrl.toString(), {
+			method: `POST`,
+			headers: requestHeaders,
+			body,
+			signal: opts?.signal ?? this.#options.signal
+		});
+		if (response.status === 409) {
+			const isClosed = response.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`;
+			if (isClosed) {
+				const finalOffset$1 = response.headers.get(STREAM_OFFSET_HEADER) ?? void 0;
+				throw new StreamClosedError(this.url, finalOffset$1);
+			}
+		}
+		if (!response.ok) await handleErrorResponse(response, this.url);
+		const finalOffset = response.headers.get(STREAM_OFFSET_HEADER) ?? ``;
+		return { finalOffset };
+	}
+	/**
 	* Append a single payload to the stream.
 	*
 	* When batching is enabled (default), multiple append() calls made while
@@ -2190,8 +2458,12 @@ var DurableStream = class DurableStream {
 		if (contentType) requestHeaders[`content-type`] = contentType;
 		if (opts?.seq) requestHeaders[STREAM_SEQ_HEADER] = opts.seq;
 		const isJson = normalizeContentType(contentType) === `application/json`;
-		const bodyStr = typeof body === `string` ? body : new TextDecoder().decode(body);
-		const encodedBody = isJson ? `[${bodyStr}]` : bodyStr;
+		let encodedBody;
+		if (isJson) {
+			const bodyStr = typeof body === `string` ? body : new TextDecoder().decode(body);
+			encodedBody = `[${bodyStr}]`;
+		} else if (typeof body === `string`) encodedBody = body;
+		else encodedBody = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
 		const response = await this.#fetchClient(fetchUrl.toString(), {
 			method: `POST`,
 			headers: requestHeaders,
@@ -2261,8 +2533,31 @@ var DurableStream = class DurableStream {
 			const jsonStrings = batch.map((m) => typeof m.data === `string` ? m.data : new TextDecoder().decode(m.data));
 			batchedBody = `[${jsonStrings.join(`,`)}]`;
 		} else {
-			const strings = batch.map((m) => typeof m.data === `string` ? m.data : new TextDecoder().decode(m.data));
-			batchedBody = strings.join(``);
+			const hasUint8Array = batch.some((m) => m.data instanceof Uint8Array);
+			const hasString = batch.some((m) => typeof m.data === `string`);
+			if (hasUint8Array && !hasString) {
+				const chunks = batch.map((m) => m.data);
+				const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+				const combined = new Uint8Array(totalLength);
+				let offset = 0;
+				for (const chunk of chunks) {
+					combined.set(chunk, offset);
+					offset += chunk.length;
+				}
+				batchedBody = combined;
+			} else if (hasString && !hasUint8Array) batchedBody = batch.map((m) => m.data).join(``);
+			else {
+				const encoder = new TextEncoder();
+				const chunks = batch.map((m) => typeof m.data === `string` ? encoder.encode(m.data) : m.data);
+				const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+				const combined = new Uint8Array(totalLength);
+				let offset = 0;
+				for (const chunk of chunks) {
+					combined.set(chunk, offset);
+					offset += chunk.length;
+				}
+				batchedBody = combined;
+			}
 		}
 		const signals = [];
 		if (this.#options.signal) signals.push(this.#options.signal);
@@ -2370,12 +2665,11 @@ var DurableStream = class DurableStream {
 				producer.append(chunk);
 			},
 			async close() {
-				await producer.flush();
 				await producer.close();
 				if (writeError) throw writeError;
 			},
 			abort(_reason) {
-				producer.close().catch((err) => {
+				producer.detach().catch((err) => {
 					opts?.onError?.(err);
 				});
 			}
@@ -2417,10 +2711,6 @@ var DurableStream = class DurableStream {
 	* ```
 	*/
 	async stream(options) {
-		if (options?.live === `sse` && this.contentType) {
-			const isSSECompatible = SSE_COMPATIBLE_CONTENT_TYPES.some((prefix) => this.contentType.startsWith(prefix));
-			if (!isSSECompatible) throw new DurableStreamError(`SSE is not supported for content-type: ${this.contentType}`, `SSE_NOT_SUPPORTED`, 400);
-		}
 		const mergedHeaders = {
 			...this.#options.headers,
 			...options?.headers
@@ -2522,7 +2812,9 @@ exports.PRODUCER_EXPECTED_SEQ_HEADER = PRODUCER_EXPECTED_SEQ_HEADER
 exports.PRODUCER_ID_HEADER = PRODUCER_ID_HEADER
 exports.PRODUCER_RECEIVED_SEQ_HEADER = PRODUCER_RECEIVED_SEQ_HEADER
 exports.PRODUCER_SEQ_HEADER = PRODUCER_SEQ_HEADER
+exports.SSE_CLOSED_FIELD = SSE_CLOSED_FIELD
 exports.SSE_COMPATIBLE_CONTENT_TYPES = SSE_COMPATIBLE_CONTENT_TYPES
+exports.STREAM_CLOSED_HEADER = STREAM_CLOSED_HEADER
 exports.STREAM_CURSOR_HEADER = STREAM_CURSOR_HEADER
 exports.STREAM_EXPIRES_AT_HEADER = STREAM_EXPIRES_AT_HEADER
 exports.STREAM_OFFSET_HEADER = STREAM_OFFSET_HEADER
@@ -2531,6 +2823,7 @@ exports.STREAM_TTL_HEADER = STREAM_TTL_HEADER
 exports.STREAM_UP_TO_DATE_HEADER = STREAM_UP_TO_DATE_HEADER
 exports.SequenceGapError = SequenceGapError
 exports.StaleEpochError = StaleEpochError
+exports.StreamClosedError = StreamClosedError
 exports._resetHttpWarningForTesting = _resetHttpWarningForTesting
 exports.asAsyncIterableReadableStream = asAsyncIterableReadableStream
 exports.createFetchWithBackoff = createFetchWithBackoff