@durable-streams/server 0.1.7 → 0.2.1

package/dist/index.cjs

@@ -132,7 +132,8 @@ var StreamStore = class {
 			const contentTypeMatches = (normalizeContentType(options.contentType) || `application/octet-stream`) === (normalizeContentType(existing.contentType) || `application/octet-stream`);
 			const ttlMatches = options.ttlSeconds === existing.ttlSeconds;
 			const expiresMatches = options.expiresAt === existing.expiresAt;
-			if (contentTypeMatches && ttlMatches && expiresMatches) return existing;
+			const closedMatches = (options.closed ?? false) === (existing.closed ?? false);
+			if (contentTypeMatches && ttlMatches && expiresMatches && closedMatches) return existing;
 			else throw new Error(`Stream already exists with different configuration: ${path}`);
 		}
 		const stream = {
@@ -142,7 +143,8 @@ var StreamStore = class {
 			currentOffset: `0000000000000000_0000000000000000`,
 			ttlSeconds: options.ttlSeconds,
 			expiresAt: options.expiresAt,
-			createdAt: Date.now()
+			createdAt: Date.now(),
+			closed: options.closed ?? false
 		};
 		if (options.initialData && options.initialData.length > 0) this.appendToStream(stream, options.initialData, true);
 		this.streams.set(path, stream);
@@ -279,6 +281,20 @@ var StreamStore = class {
 	append(path, data, options = {}) {
 		const stream = this.getIfNotExpired(path);
 		if (!stream) throw new Error(`Stream not found: ${path}`);
+		if (stream.closed) {
+			if (options.producerId && stream.closedBy && stream.closedBy.producerId === options.producerId && stream.closedBy.epoch === options.producerEpoch && stream.closedBy.seq === options.producerSeq) return {
+				message: null,
+				streamClosed: true,
+				producerResult: {
+					status: `duplicate`,
+					lastSeq: options.producerSeq
+				}
+			};
+			return {
+				message: null,
+				streamClosed: true
+			};
+		}
 		if (options.contentType && stream.contentType) {
 			const providedType = normalizeContentType(options.contentType);
 			const streamType = normalizeContentType(stream.contentType);
@@ -298,10 +314,20 @@ var StreamStore = class {
 		const message = this.appendToStream(stream, data);
 		if (producerResult) this.commitProducerState(stream, producerResult);
 		if (options.seq !== void 0) stream.lastSeq = options.seq;
+		if (options.close) {
+			stream.closed = true;
+			if (options.producerId !== void 0) stream.closedBy = {
+				producerId: options.producerId,
+				epoch: options.producerEpoch,
+				seq: options.producerSeq
+			};
+			this.notifyLongPollsClosed(path);
+		}
 		this.notifyLongPolls(path);
-		if (producerResult) return {
+		if (producerResult || options.close) return {
 			message,
-			producerResult
+			producerResult,
+			streamClosed: options.close
 		};
 		return message;
 	}
@@ -325,6 +351,69 @@ var StreamStore = class {
 		}
 	}
 	/**
+	* Close a stream without appending data.
+	* @returns The final offset, or null if stream doesn't exist
+	*/
+	closeStream(path) {
+		const stream = this.getIfNotExpired(path);
+		if (!stream) return null;
+		const alreadyClosed = stream.closed ?? false;
+		stream.closed = true;
+		this.notifyLongPollsClosed(path);
+		return {
+			finalOffset: stream.currentOffset,
+			alreadyClosed
+		};
+	}
+	/**
+	* Close a stream with producer headers for idempotent close-only operations.
+	* Participates in producer sequencing for deduplication.
+	* @returns The final offset and producer result, or null if stream doesn't exist
+	*/
+	async closeStreamWithProducer(path, options) {
+		const releaseLock = await this.acquireProducerLock(path, options.producerId);
+		try {
+			const stream = this.getIfNotExpired(path);
+			if (!stream) return null;
+			if (stream.closed) {
+				if (stream.closedBy && stream.closedBy.producerId === options.producerId && stream.closedBy.epoch === options.producerEpoch && stream.closedBy.seq === options.producerSeq) return {
+					finalOffset: stream.currentOffset,
+					alreadyClosed: true,
+					producerResult: {
+						status: `duplicate`,
+						lastSeq: options.producerSeq
+					}
+				};
+				return {
+					finalOffset: stream.currentOffset,
+					alreadyClosed: true,
+					producerResult: { status: `stream_closed` }
+				};
+			}
+			const producerResult = this.validateProducer(stream, options.producerId, options.producerEpoch, options.producerSeq);
+			if (producerResult.status !== `accepted`) return {
+				finalOffset: stream.currentOffset,
+				alreadyClosed: stream.closed ?? false,
+				producerResult
+			};
+			this.commitProducerState(stream, producerResult);
+			stream.closed = true;
+			stream.closedBy = {
+				producerId: options.producerId,
+				epoch: options.producerEpoch,
+				seq: options.producerSeq
+			};
+			this.notifyLongPollsClosed(path);
+			return {
+				finalOffset: stream.currentOffset,
+				alreadyClosed: false,
+				producerResult
+			};
+		} finally {
+			releaseLock();
+		}
+	}
+	/**
 	* Get the current epoch for a producer on a stream.
 	* Returns undefined if the producer doesn't exist or stream not found.
 	*/
@@ -384,12 +473,20 @@ var StreamStore = class {
 			messages,
 			timedOut: false
 		};
+		if (stream.closed && offset === stream.currentOffset) return {
+			messages: [],
+			timedOut: false,
+			streamClosed: true
+		};
 		return new Promise((resolve) => {
 			const timeoutId = setTimeout(() => {
 				this.removePendingLongPoll(pending);
+				const currentStream = this.getIfNotExpired(path);
+				const streamClosed = currentStream?.closed ?? false;
 				resolve({
 					messages: [],
-					timedOut: true
+					timedOut: true,
+					streamClosed
 				});
 			}, timeoutMs);
 			const pending = {
@@ -398,9 +495,12 @@ var StreamStore = class {
 				resolve: (msgs) => {
 					clearTimeout(timeoutId);
 					this.removePendingLongPoll(pending);
+					const currentStream = this.getIfNotExpired(path);
+					const streamClosed = currentStream?.closed && msgs.length === 0 ? true : void 0;
 					resolve({
 						messages: msgs,
-						timedOut: false
+						timedOut: false,
+						streamClosed
 					});
 				},
 				timeoutId
@@ -473,6 +573,14 @@ var StreamStore = class {
 			if (messages.length > 0) pending.resolve(messages);
 		}
 	}
+	/**
+	* Notify pending long-polls that a stream has been closed.
+	* They should wake up immediately and return Stream-Closed: true.
+	*/
+	notifyLongPollsClosed(path) {
+		const toNotify = this.pendingLongPolls.filter((p) => p.path === path);
+		for (const pending of toNotify) pending.resolve([]);
+	}
 	cancelLongPollsForStream(path) {
 		const toCancel = this.pendingLongPolls.filter((p) => p.path === path);
 		for (const pending of toCancel) {
@@ -794,7 +902,9 @@ var FileBackedStreamStore = class {
 			ttlSeconds: meta.ttlSeconds,
 			expiresAt: meta.expiresAt,
 			createdAt: meta.createdAt,
-			producers
+			producers,
+			closed: meta.closed,
+			closedBy: meta.closedBy
 		};
 	}
 	/**
@@ -933,7 +1043,8 @@ var FileBackedStreamStore = class {
 			const contentTypeMatches = normalizeMimeType(options.contentType) === normalizeMimeType(existing.contentType);
 			const ttlMatches = options.ttlSeconds === existing.ttlSeconds;
 			const expiresMatches = options.expiresAt === existing.expiresAt;
-			if (contentTypeMatches && ttlMatches && expiresMatches) return this.streamMetaToStream(existing);
+			const closedMatches = (options.closed ?? false) === (existing.closed ?? false);
+			if (contentTypeMatches && ttlMatches && expiresMatches && closedMatches) return this.streamMetaToStream(existing);
 			else throw new Error(`Stream already exists with different configuration: ${streamPath}`);
 		}
 		const key = `stream:${streamPath}`;
@@ -947,7 +1058,8 @@ var FileBackedStreamStore = class {
 			createdAt: Date.now(),
 			segmentCount: 1,
 			totalBytes: 0,
-			directoryName: generateUniqueDirectoryName(streamPath)
+			directoryName: generateUniqueDirectoryName(streamPath),
+			closed: false
 		};
 		const streamDir = node_path.join(this.dataDir, `streams`, streamMeta.directoryName);
 		try {
@@ -959,15 +1071,17 @@ var FileBackedStreamStore = class {
 			throw err;
 		}
 		this.db.putSync(key, streamMeta);
-		if (options.initialData && options.initialData.length > 0) {
-			await this.append(streamPath, options.initialData, {
-				contentType: options.contentType,
-				isInitialCreate: true
-			});
-			const updated = this.db.get(key);
-			return this.streamMetaToStream(updated);
+		if (options.initialData && options.initialData.length > 0) await this.append(streamPath, options.initialData, {
+			contentType: options.contentType,
+			isInitialCreate: true
+		});
+		if (options.closed) {
+			const updatedMeta = this.db.get(key);
+			updatedMeta.closed = true;
+			this.db.putSync(key, updatedMeta);
 		}
-		return this.streamMetaToStream(streamMeta);
+		const updated = this.db.get(key);
+		return this.streamMetaToStream(updated);
 	}
 	get(streamPath) {
 		const meta = this.getMetaIfNotExpired(streamPath);
@@ -994,6 +1108,20 @@ var FileBackedStreamStore = class {
 	async append(streamPath, data, options = {}) {
 		const streamMeta = this.getMetaIfNotExpired(streamPath);
 		if (!streamMeta) throw new Error(`Stream not found: ${streamPath}`);
+		if (streamMeta.closed) {
+			if (options.producerId && streamMeta.closedBy && streamMeta.closedBy.producerId === options.producerId && streamMeta.closedBy.epoch === options.producerEpoch && streamMeta.closedBy.seq === options.producerSeq) return {
+				message: null,
+				streamClosed: true,
+				producerResult: {
+					status: `duplicate`,
+					lastSeq: options.producerSeq
+				}
+			};
+			return {
+				message: null,
+				streamClosed: true
+			};
+		}
 		if (options.contentType && streamMeta.contentType) {
 			const providedType = normalizeContentType(options.contentType);
 			const streamType = normalizeContentType(streamMeta.contentType);
@@ -1044,19 +1172,29 @@ var FileBackedStreamStore = class {
 		await this.fileHandlePool.fsyncFile(segmentPath);
 		const updatedProducers = { ...streamMeta.producers };
 		if (producerResult && producerResult.status === `accepted`) updatedProducers[producerResult.producerId] = producerResult.proposedState;
+		let closedBy = void 0;
+		if (options.close && options.producerId) closedBy = {
+			producerId: options.producerId,
+			epoch: options.producerEpoch,
+			seq: options.producerSeq
+		};
 		const updatedMeta = {
 			...streamMeta,
 			currentOffset: newOffset,
 			lastSeq: options.seq ?? streamMeta.lastSeq,
 			totalBytes: streamMeta.totalBytes + processedData.length + 5,
-			producers: updatedProducers
+			producers: updatedProducers,
+			closed: options.close ? true : streamMeta.closed,
+			closedBy: closedBy ?? streamMeta.closedBy
 		};
 		const key = `stream:${streamPath}`;
 		this.db.putSync(key, updatedMeta);
 		this.notifyLongPolls(streamPath);
-		if (producerResult) return {
+		if (options.close) this.notifyLongPollsClosed(streamPath);
+		if (producerResult || options.close) return {
 			message,
-			producerResult
+			producerResult,
+			streamClosed: options.close
 		};
 		return message;
 	}
@@ -1079,6 +1217,81 @@ var FileBackedStreamStore = class {
 			releaseLock();
 		}
 	}
+	/**
+	* Close a stream without appending data.
+	* @returns The final offset, or null if stream doesn't exist
+	*/
+	closeStream(streamPath) {
+		const streamMeta = this.getMetaIfNotExpired(streamPath);
+		if (!streamMeta) return null;
+		const alreadyClosed = streamMeta.closed ?? false;
+		const key = `stream:${streamPath}`;
+		const updatedMeta = {
+			...streamMeta,
+			closed: true
+		};
+		this.db.putSync(key, updatedMeta);
+		this.notifyLongPollsClosed(streamPath);
+		return {
+			finalOffset: streamMeta.currentOffset,
+			alreadyClosed
+		};
+	}
+	/**
+	* Close a stream with producer headers for idempotent close-only operations.
+	* Participates in producer sequencing for deduplication.
+	* @returns The final offset and producer result, or null if stream doesn't exist
+	*/
+	async closeStreamWithProducer(streamPath, options) {
+		const releaseLock = await this.acquireProducerLock(streamPath, options.producerId);
+		try {
+			const streamMeta = this.getMetaIfNotExpired(streamPath);
+			if (!streamMeta) return null;
+			if (streamMeta.closed) {
+				if (streamMeta.closedBy && streamMeta.closedBy.producerId === options.producerId && streamMeta.closedBy.epoch === options.producerEpoch && streamMeta.closedBy.seq === options.producerSeq) return {
+					finalOffset: streamMeta.currentOffset,
+					alreadyClosed: true,
+					producerResult: {
+						status: `duplicate`,
+						lastSeq: options.producerSeq
+					}
+				};
+				return {
+					finalOffset: streamMeta.currentOffset,
+					alreadyClosed: true,
+					producerResult: { status: `stream_closed` }
+				};
+			}
+			const producerResult = this.validateProducer(streamMeta, options.producerId, options.producerEpoch, options.producerSeq);
+			if (producerResult.status !== `accepted`) return {
+				finalOffset: streamMeta.currentOffset,
+				alreadyClosed: streamMeta.closed ?? false,
+				producerResult
+			};
+			const key = `stream:${streamPath}`;
+			const updatedProducers = { ...streamMeta.producers };
+			updatedProducers[producerResult.producerId] = producerResult.proposedState;
+			const updatedMeta = {
+				...streamMeta,
+				closed: true,
+				closedBy: {
+					producerId: options.producerId,
+					epoch: options.producerEpoch,
+					seq: options.producerSeq
+				},
+				producers: updatedProducers
+			};
+			this.db.putSync(key, updatedMeta);
+			this.notifyLongPollsClosed(streamPath);
+			return {
+				finalOffset: streamMeta.currentOffset,
+				alreadyClosed: false,
+				producerResult
+			};
+		} finally {
+			releaseLock();
+		}
+	}
 	read(streamPath, offset) {
 		const streamMeta = this.getMetaIfNotExpired(streamPath);
 		if (!streamMeta) throw new Error(`Stream not found: ${streamPath}`);
@@ -1134,17 +1347,30 @@ var FileBackedStreamStore = class {
 	async waitForMessages(streamPath, offset, timeoutMs) {
 		const streamMeta = this.getMetaIfNotExpired(streamPath);
 		if (!streamMeta) throw new Error(`Stream not found: ${streamPath}`);
+		if (streamMeta.closed && offset === streamMeta.currentOffset) return {
+			messages: [],
+			timedOut: false,
+			streamClosed: true
+		};
 		const { messages } = this.read(streamPath, offset);
 		if (messages.length > 0) return {
 			messages,
-			timedOut: false
+			timedOut: false,
+			streamClosed: streamMeta.closed
+		};
+		if (streamMeta.closed) return {
+			messages: [],
+			timedOut: false,
+			streamClosed: true
 		};
 		return new Promise((resolve) => {
 			const timeoutId = setTimeout(() => {
 				this.removePendingLongPoll(pending);
+				const currentMeta = this.getMetaIfNotExpired(streamPath);
 				resolve({
 					messages: [],
-					timedOut: true
+					timedOut: true,
+					streamClosed: currentMeta?.closed
 				});
 			}, timeoutMs);
 			const pending = {
@@ -1153,9 +1379,11 @@ var FileBackedStreamStore = class {
 				resolve: (msgs) => {
 					clearTimeout(timeoutId);
 					this.removePendingLongPoll(pending);
+					const currentMeta = this.getMetaIfNotExpired(streamPath);
 					resolve({
 						messages: msgs,
-						timedOut: false
+						timedOut: false,
+						streamClosed: currentMeta?.closed
 					});
 				},
 				timeoutId
@@ -1228,6 +1456,14 @@ var FileBackedStreamStore = class {
 			if (messages.length > 0) pending.resolve(messages);
 		}
 	}
+	/**
+	* Notify pending long-polls that a stream has been closed.
+	* They should wake up immediately and return Stream-Closed: true.
+	*/
+	notifyLongPollsClosed(streamPath) {
+		const toNotify = this.pendingLongPolls.filter((p) => p.path === streamPath);
+		for (const pending of toNotify) pending.resolve([]);
+	}
 	cancelLongPollsForStream(streamPath) {
 		const toCancel = this.pendingLongPolls.filter((p) => p.path === streamPath);
 		for (const pending of toCancel) {
@@ -1352,6 +1588,7 @@ const STREAM_UP_TO_DATE_HEADER = `Stream-Up-To-Date`;
 const STREAM_SEQ_HEADER = `Stream-Seq`;
 const STREAM_TTL_HEADER = `Stream-TTL`;
 const STREAM_EXPIRES_AT_HEADER = `Stream-Expires-At`;
+const STREAM_SSE_DATA_ENCODING_HEADER = `Stream-SSE-Data-Encoding`;
 const PRODUCER_ID_HEADER = `Producer-Id`;
 const PRODUCER_EPOCH_HEADER = `Producer-Epoch`;
 const PRODUCER_SEQ_HEADER = `Producer-Seq`;
@@ -1360,6 +1597,8 @@ const PRODUCER_RECEIVED_SEQ_HEADER = `Producer-Received-Seq`;
 const SSE_OFFSET_FIELD = `streamNextOffset`;
 const SSE_CURSOR_FIELD = `streamCursor`;
 const SSE_UP_TO_DATE_FIELD = `upToDate`;
+const SSE_CLOSED_FIELD = `streamClosed`;
+const STREAM_CLOSED_HEADER = `Stream-Closed`;
 const OFFSET_QUERY_PARAM = `offset`;
 const LIVE_QUERY_PARAM = `live`;
 const CURSOR_QUERY_PARAM = `cursor`;
@@ -1574,8 +1813,8 @@ var DurableStreamTestServer = class {
 		const method = req.method?.toUpperCase();
 		res.setHeader(`access-control-allow-origin`, `*`);
 		res.setHeader(`access-control-allow-methods`, `GET, POST, PUT, DELETE, HEAD, OPTIONS`);
-		res.setHeader(`access-control-allow-headers`, `content-type, authorization, Stream-Seq, Stream-TTL, Stream-Expires-At, Producer-Id, Producer-Epoch, Producer-Seq`);
-		res.setHeader(`access-control-expose-headers`, `Stream-Next-Offset, Stream-Cursor, Stream-Up-To-Date, Producer-Epoch, Producer-Seq, Producer-Expected-Seq, Producer-Received-Seq, etag, content-type, content-encoding, vary`);
+		res.setHeader(`access-control-allow-headers`, `content-type, authorization, Stream-Seq, Stream-TTL, Stream-Expires-At, Stream-Closed, Producer-Id, Producer-Epoch, Producer-Seq`);
+		res.setHeader(`access-control-expose-headers`, `Stream-Next-Offset, Stream-Cursor, Stream-Up-To-Date, Stream-Closed, Producer-Epoch, Producer-Seq, Producer-Expected-Seq, Producer-Received-Seq, etag, content-type, content-encoding, vary`);
 		res.setHeader(`x-content-type-options`, `nosniff`);
 		res.setHeader(`cross-origin-resource-policy`, `cross-origin`);
 		if (method === `OPTIONS`) {
@@ -1655,6 +1894,8 @@ var DurableStreamTestServer = class {
 		if (!contentType || contentType.trim() === `` || !/^[\w-]+\/[\w-]+/.test(contentType)) contentType = `application/octet-stream`;
 		const ttlHeader = req.headers[STREAM_TTL_HEADER.toLowerCase()];
 		const expiresAtHeader = req.headers[STREAM_EXPIRES_AT_HEADER.toLowerCase()];
+		const closedHeader = req.headers[STREAM_CLOSED_HEADER.toLowerCase()];
+		const createClosed = closedHeader === `true`;
 		if (ttlHeader && expiresAtHeader) {
 			res.writeHead(400, { "content-type": `text/plain` });
 			res.end(`Cannot specify both Stream-TTL and Stream-Expires-At`);
@@ -1689,7 +1930,8 @@ var DurableStreamTestServer = class {
 			contentType,
 			ttlSeconds,
 			expiresAt: expiresAtHeader,
-			initialData: body.length > 0 ? body : void 0
+			initialData: body.length > 0 ? body : void 0,
+			closed: createClosed
 		}));
 		const stream = this.store.get(path);
 		if (isNew && this.options.onStreamCreated) await Promise.resolve(this.options.onStreamCreated({
@@ -1703,6 +1945,7 @@ var DurableStreamTestServer = class {
 			[STREAM_OFFSET_HEADER]: stream.currentOffset
 		};
 		if (isNew) headers[`location`] = `${this._url}${path}`;
+		if (stream.closed) headers[STREAM_CLOSED_HEADER] = `true`;
 		res.writeHead(isNew ? 201 : 200, headers);
 		res.end();
 	}
@@ -1721,7 +1964,9 @@ var DurableStreamTestServer = class {
 			"cache-control": `no-store`
 		};
 		if (stream.contentType) headers[`content-type`] = stream.contentType;
-		headers[`etag`] = `"${Buffer.from(path).toString(`base64`)}:-1:${stream.currentOffset}"`;
+		if (stream.closed) headers[STREAM_CLOSED_HEADER] = `true`;
+		const closedSuffix = stream.closed ? `:c` : ``;
+		headers[`etag`] = `"${Buffer.from(path).toString(`base64`)}:-1:${stream.currentOffset}${closedSuffix}"`;
 		res.writeHead(200, headers);
 		res.end();
 	}
@@ -1762,9 +2007,15 @@ var DurableStreamTestServer = class {
 			res.end(`${live === `sse` ? `SSE` : `Long-poll`} requires offset parameter`);
 			return;
 		}
+		let useBase64 = false;
+		if (live === `sse`) {
+			const ct = stream.contentType?.toLowerCase().split(`;`)[0]?.trim() ?? ``;
+			const isTextCompatible = ct.startsWith(`text/`) || ct === `application/json`;
+			useBase64 = !isTextCompatible;
+		}
 		if (live === `sse`) {
 			const sseOffset = offset === `now` ? stream.currentOffset : offset;
-			await this.handleSSE(path, stream, sseOffset, cursor, res);
+			await this.handleSSE(path, stream, sseOffset, cursor, useBase64, res);
 			return;
 		}
 		const effectiveOffset = offset === `now` ? stream.currentOffset : offset;
@@ -1775,6 +2026,7 @@ var DurableStreamTestServer = class {
 				[`cache-control`]: `no-store`
 			};
 			if (stream.contentType) headers$1[`content-type`] = stream.contentType;
+			if (stream.closed) headers$1[STREAM_CLOSED_HEADER] = `true`;
 			const isJsonMode = stream.contentType?.includes(`application/json`);
 			const responseBody = isJsonMode ? `[]` : ``;
 			res.writeHead(200, headers$1);
@@ -1784,17 +2036,40 @@ var DurableStreamTestServer = class {
 		let { messages, upToDate } = this.store.read(path, effectiveOffset);
 		const clientIsCaughtUp = effectiveOffset && effectiveOffset === stream.currentOffset || offset === `now`;
 		if (live === `long-poll` && clientIsCaughtUp && messages.length === 0) {
+			if (stream.closed) {
+				res.writeHead(204, {
+					[STREAM_OFFSET_HEADER]: stream.currentOffset,
+					[STREAM_UP_TO_DATE_HEADER]: `true`,
+					[STREAM_CLOSED_HEADER]: `true`
+				});
+				res.end();
+				return;
+			}
 			const result = await this.store.waitForMessages(path, effectiveOffset ?? stream.currentOffset, this.options.longPollTimeout);
-			if (result.timedOut) {
+			if (result.streamClosed) {
 				const responseCursor = generateResponseCursor(cursor, this.options.cursorOptions);
 				res.writeHead(204, {
 					[STREAM_OFFSET_HEADER]: effectiveOffset ?? stream.currentOffset,
 					[STREAM_UP_TO_DATE_HEADER]: `true`,
-					[STREAM_CURSOR_HEADER]: responseCursor
+					[STREAM_CURSOR_HEADER]: responseCursor,
+					[STREAM_CLOSED_HEADER]: `true`
 				});
 				res.end();
 				return;
 			}
+			if (result.timedOut) {
+				const responseCursor = generateResponseCursor(cursor, this.options.cursorOptions);
+				const currentStream$1 = this.store.get(path);
+				const timeoutHeaders = {
+					[STREAM_OFFSET_HEADER]: effectiveOffset ?? stream.currentOffset,
+					[STREAM_UP_TO_DATE_HEADER]: `true`,
+					[STREAM_CURSOR_HEADER]: responseCursor
+				};
+				if (currentStream$1?.closed) timeoutHeaders[STREAM_CLOSED_HEADER] = `true`;
+				res.writeHead(204, timeoutHeaders);
+				res.end();
+				return;
+			}
 			messages = result.messages;
 			upToDate = true;
 		}
@@ -1805,8 +2080,12 @@ var DurableStreamTestServer = class {
 		headers[STREAM_OFFSET_HEADER] = responseOffset;
 		if (live === `long-poll`) headers[STREAM_CURSOR_HEADER] = generateResponseCursor(cursor, this.options.cursorOptions);
 		if (upToDate) headers[STREAM_UP_TO_DATE_HEADER] = `true`;
+		const currentStream = this.store.get(path);
+		const clientAtTail = responseOffset === currentStream?.currentOffset;
+		if (currentStream?.closed && clientAtTail && upToDate) headers[STREAM_CLOSED_HEADER] = `true`;
 		const startOffset = offset ?? `-1`;
-		const etag = `"${Buffer.from(path).toString(`base64`)}:${startOffset}:${responseOffset}"`;
+		const closedSuffix = currentStream?.closed && clientAtTail && upToDate ? `:c` : ``;
+		const etag = `"${Buffer.from(path).toString(`base64`)}:${startOffset}:${responseOffset}${closedSuffix}"`;
 		headers[`etag`] = etag;
 		const ifNoneMatch = req.headers[`if-none-match`];
 		if (ifNoneMatch && ifNoneMatch === etag) {
@@ -1818,10 +2097,10 @@ var DurableStreamTestServer = class {
 		let finalData = responseData;
 		if (this.options.compression && responseData.length >= COMPRESSION_THRESHOLD) {
 			const acceptEncoding = req.headers[`accept-encoding`];
-			const encoding = getCompressionEncoding(acceptEncoding);
-			if (encoding) {
-				finalData = compressData(responseData, encoding);
-				headers[`content-encoding`] = encoding;
+			const compressionEncoding = getCompressionEncoding(acceptEncoding);
+			if (compressionEncoding) {
+				finalData = compressData(responseData, compressionEncoding);
+				headers[`content-encoding`] = compressionEncoding;
 				headers[`vary`] = `accept-encoding`;
 			}
 		}
@@ -1832,16 +2111,18 @@ var DurableStreamTestServer = class {
 	/**
 	* Handle SSE (Server-Sent Events) mode
 	*/
-	async handleSSE(path, stream, initialOffset, cursor, res) {
+	async handleSSE(path, stream, initialOffset, cursor, useBase64, res) {
 		this.activeSSEResponses.add(res);
-		res.writeHead(200, {
+		const sseHeaders = {
 			"content-type": `text/event-stream`,
 			"cache-control": `no-cache`,
 			connection: `keep-alive`,
 			"access-control-allow-origin": `*`,
 			"x-content-type-options": `nosniff`,
 			"cross-origin-resource-policy": `cross-origin`
-		});
+		};
+		if (useBase64) sseHeaders[STREAM_SSE_DATA_ENCODING_HEADER] = `base64`;
+		res.writeHead(200, sseHeaders);
 		const fault = res._injectedFault;
 		if (fault?.injectSseEvent) {
 			res.write(`event: ${fault.injectSseEvent.eventType}\n`);
@@ -1859,7 +2140,8 @@ var DurableStreamTestServer = class {
 			const { messages, upToDate } = this.store.read(path, currentOffset);
 			for (const message of messages) {
 				let dataPayload;
-				if (isJsonStream) {
+				if (useBase64) dataPayload = Buffer.from(message.data).toString(`base64`);
+				else if (isJsonStream) {
 					const jsonBytes = this.store.formatResponse(path, [message]);
 					dataPayload = decoder.decode(jsonBytes);
 				} else dataPayload = decoder.decode(message.data);
@@ -1867,28 +2149,60 @@ var DurableStreamTestServer = class {
 				res.write(encodeSSEData(dataPayload));
 				currentOffset = message.offset;
 			}
-			const controlOffset = messages[messages.length - 1]?.offset ?? stream.currentOffset;
+			const currentStream = this.store.get(path);
+			const controlOffset = messages[messages.length - 1]?.offset ?? currentStream.currentOffset;
+			const streamIsClosed = currentStream?.closed ?? false;
+			const clientAtTail = controlOffset === currentStream.currentOffset;
 			const responseCursor = generateResponseCursor(cursor, this.options.cursorOptions);
-			const controlData = {
-				[SSE_OFFSET_FIELD]: controlOffset,
-				[SSE_CURSOR_FIELD]: responseCursor
-			};
-			if (upToDate) controlData[SSE_UP_TO_DATE_FIELD] = true;
+			const controlData = { [SSE_OFFSET_FIELD]: controlOffset };
+			if (streamIsClosed && clientAtTail) controlData[SSE_CLOSED_FIELD] = true;
+			else {
+				controlData[SSE_CURSOR_FIELD] = responseCursor;
+				if (upToDate) controlData[SSE_UP_TO_DATE_FIELD] = true;
+			}
 			res.write(`event: control\n`);
 			res.write(encodeSSEData(JSON.stringify(controlData)));
+			if (streamIsClosed && clientAtTail) break;
 			currentOffset = controlOffset;
 			if (upToDate) {
+				if (currentStream?.closed) {
+					const finalControlData = {
+						[SSE_OFFSET_FIELD]: currentOffset,
+						[SSE_CLOSED_FIELD]: true
+					};
+					res.write(`event: control\n`);
+					res.write(encodeSSEData(JSON.stringify(finalControlData)));
+					break;
+				}
 				const result = await this.store.waitForMessages(path, currentOffset, this.options.longPollTimeout);
 				if (this.isShuttingDown || !isConnected) break;
+				if (result.streamClosed) {
+					const finalControlData = {
+						[SSE_OFFSET_FIELD]: currentOffset,
+						[SSE_CLOSED_FIELD]: true
+					};
+					res.write(`event: control\n`);
+					res.write(encodeSSEData(JSON.stringify(finalControlData)));
+					break;
+				}
 				if (result.timedOut) {
 					const keepAliveCursor = generateResponseCursor(cursor, this.options.cursorOptions);
+					const streamAfterWait = this.store.get(path);
+					if (streamAfterWait?.closed) {
+						const closedControlData = {
+							[SSE_OFFSET_FIELD]: currentOffset,
+							[SSE_CLOSED_FIELD]: true
+						};
+						res.write(`event: control\n`);
+						res.write(encodeSSEData(JSON.stringify(closedControlData)));
+						break;
+					}
 					const keepAliveData = {
 						[SSE_OFFSET_FIELD]: currentOffset,
 						[SSE_CURSOR_FIELD]: keepAliveCursor,
 						[SSE_UP_TO_DATE_FIELD]: true
 					};
-					res.write(`event: control\n`);
-					res.write(encodeSSEData(JSON.stringify(keepAliveData)));
+					res.write(`event: control\n` + encodeSSEData(JSON.stringify(keepAliveData)));
 				}
 			}
 		}
@@ -1901,20 +2215,11 @@ var DurableStreamTestServer = class {
 	async handleAppend(path, req, res) {
 		const contentType = req.headers[`content-type`];
 		const seq = req.headers[STREAM_SEQ_HEADER.toLowerCase()];
+		const closedHeader = req.headers[STREAM_CLOSED_HEADER.toLowerCase()];
+		const closeStream = closedHeader === `true`;
 		const producerId = req.headers[PRODUCER_ID_HEADER.toLowerCase()];
 		const producerEpochStr = req.headers[PRODUCER_EPOCH_HEADER.toLowerCase()];
 		const producerSeqStr = req.headers[PRODUCER_SEQ_HEADER.toLowerCase()];
-		const body = await this.readBody(req);
-		if (body.length === 0) {
-			res.writeHead(400, { "content-type": `text/plain` });
-			res.end(`Empty body`);
-			return;
-		}
-		if (!contentType) {
-			res.writeHead(400, { "content-type": `text/plain` });
-			res.end(`Content-Type header is required`);
-			return;
-		}
 		const hasProducerHeaders = producerId !== void 0 || producerEpochStr !== void 0 || producerSeqStr !== void 0;
 		const hasAllProducerHeaders = producerId !== void 0 && producerEpochStr !== void 0 && producerSeqStr !== void 0;
 		if (hasProducerHeaders && !hasAllProducerHeaders) {
@@ -1954,34 +2259,148 @@ var DurableStreamTestServer = class {
 				return;
 			}
 		}
+		const body = await this.readBody(req);
+		if (body.length === 0 && closeStream) {
+			if (hasAllProducerHeaders) {
+				const closeResult$1 = await this.store.closeStreamWithProducer(path, {
+					producerId,
+					producerEpoch,
+					producerSeq
+				});
+				if (!closeResult$1) {
+					res.writeHead(404, { "content-type": `text/plain` });
+					res.end(`Stream not found`);
+					return;
+				}
+				if (closeResult$1.producerResult?.status === `duplicate`) {
+					res.writeHead(204, {
+						[STREAM_OFFSET_HEADER]: closeResult$1.finalOffset,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_EPOCH_HEADER]: producerEpoch.toString(),
+						[PRODUCER_SEQ_HEADER]: closeResult$1.producerResult.lastSeq.toString()
+					});
+					res.end();
+					return;
+				}
+				if (closeResult$1.producerResult?.status === `stale_epoch`) {
+					res.writeHead(403, {
+						"content-type": `text/plain`,
+						[PRODUCER_EPOCH_HEADER]: closeResult$1.producerResult.currentEpoch.toString()
+					});
+					res.end(`Stale producer epoch`);
+					return;
+				}
+				if (closeResult$1.producerResult?.status === `invalid_epoch_seq`) {
+					res.writeHead(400, { "content-type": `text/plain` });
+					res.end(`New epoch must start with sequence 0`);
+					return;
+				}
+				if (closeResult$1.producerResult?.status === `sequence_gap`) {
+					res.writeHead(409, {
+						"content-type": `text/plain`,
+						[PRODUCER_EXPECTED_SEQ_HEADER]: closeResult$1.producerResult.expectedSeq.toString(),
+						[PRODUCER_RECEIVED_SEQ_HEADER]: closeResult$1.producerResult.receivedSeq.toString()
+					});
+					res.end(`Producer sequence gap`);
+					return;
+				}
+				if (closeResult$1.producerResult?.status === `stream_closed`) {
+					const stream = this.store.get(path);
+					res.writeHead(409, {
+						"content-type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[STREAM_OFFSET_HEADER]: stream?.currentOffset ?? ``
+					});
+					res.end(`Stream is closed`);
+					return;
+				}
+				res.writeHead(204, {
+					[STREAM_OFFSET_HEADER]: closeResult$1.finalOffset,
+					[STREAM_CLOSED_HEADER]: `true`,
+					[PRODUCER_EPOCH_HEADER]: producerEpoch.toString(),
+					[PRODUCER_SEQ_HEADER]: producerSeq.toString()
+				});
+				res.end();
+				return;
+			}
+			const closeResult = this.store.closeStream(path);
+			if (!closeResult) {
+				res.writeHead(404, { "content-type": `text/plain` });
+				res.end(`Stream not found`);
+				return;
+			}
+			res.writeHead(204, {
+				[STREAM_OFFSET_HEADER]: closeResult.finalOffset,
+				[STREAM_CLOSED_HEADER]: `true`
+			});
+			res.end();
+			return;
+		}
+		if (body.length === 0) {
+			res.writeHead(400, { "content-type": `text/plain` });
+			res.end(`Empty body`);
+			return;
+		}
+		if (!contentType) {
+			res.writeHead(400, { "content-type": `text/plain` });
+			res.end(`Content-Type header is required`);
+			return;
+		}
 		const appendOptions = {
 			seq,
 			contentType,
 			producerId,
 			producerEpoch,
-			producerSeq
+			producerSeq,
+			close: closeStream
 		};
 		let result;
 		if (producerId !== void 0) result = await this.store.appendWithProducer(path, body, appendOptions);
 		else result = await Promise.resolve(this.store.append(path, body, appendOptions));
-		if (result && typeof result === `object` && `producerResult` in result) {
-			const { message: message$1, producerResult } = result;
+		if (result && typeof result === `object` && `message` in result) {
+			const { message: message$1, producerResult, streamClosed } = result;
+			if (streamClosed && !message$1) {
+				if (producerResult?.status === `duplicate`) {
+					const stream = this.store.get(path);
+					res.writeHead(204, {
+						[STREAM_OFFSET_HEADER]: stream?.currentOffset ?? ``,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_EPOCH_HEADER]: producerEpoch.toString(),
+						[PRODUCER_SEQ_HEADER]: producerResult.lastSeq.toString()
+					});
+					res.end();
+					return;
+				}
+				const closedStream = this.store.get(path);
+				res.writeHead(409, {
+					"content-type": `text/plain`,
+					[STREAM_CLOSED_HEADER]: `true`,
+					[STREAM_OFFSET_HEADER]: closedStream?.currentOffset ?? ``
+				});
+				res.end(`Stream is closed`);
+				return;
+			}
 			if (!producerResult || producerResult.status === `accepted`) {
-				const responseHeaders = { [STREAM_OFFSET_HEADER]: message$1.offset };
-				if (producerEpoch !== void 0) responseHeaders[PRODUCER_EPOCH_HEADER] = producerEpoch.toString();
-				if (producerSeq !== void 0) responseHeaders[PRODUCER_SEQ_HEADER] = producerSeq.toString();
-				res.writeHead(200, responseHeaders);
+				const responseHeaders$1 = { [STREAM_OFFSET_HEADER]: message$1.offset };
+				if (producerEpoch !== void 0) responseHeaders$1[PRODUCER_EPOCH_HEADER] = producerEpoch.toString();
+				if (producerSeq !== void 0) responseHeaders$1[PRODUCER_SEQ_HEADER] = producerSeq.toString();
+				if (streamClosed) responseHeaders$1[STREAM_CLOSED_HEADER] = `true`;
+				const statusCode = producerId !== void 0 ? 200 : 204;
+				res.writeHead(statusCode, responseHeaders$1);
 				res.end();
 				return;
 			}
 			switch (producerResult.status) {
-				case `duplicate`:
-					res.writeHead(204, {
+				case `duplicate`: {
+					const dupHeaders = {
 						[PRODUCER_EPOCH_HEADER]: producerEpoch.toString(),
 						[PRODUCER_SEQ_HEADER]: producerResult.lastSeq.toString()
-					});
+					};
+					if (streamClosed) dupHeaders[STREAM_CLOSED_HEADER] = `true`;
+					res.writeHead(204, dupHeaders);
 					res.end();
 					return;
+				}
 				case `stale_epoch`: {
 					res.writeHead(403, {
 						"content-type": `text/plain`,
@@ -2005,7 +2424,9 @@ var DurableStreamTestServer = class {
 			}
 		}
 		const message = result;
-		res.writeHead(204, { [STREAM_OFFSET_HEADER]: message.offset });
+		const responseHeaders = { [STREAM_OFFSET_HEADER]: message.offset };
+		if (closeStream) responseHeaders[STREAM_CLOSED_HEADER] = `true`;
+		res.writeHead(204, responseHeaders);
 		res.end();
 	}
 	/**