@durable-streams/server-conformance-tests 0.2.0 → 0.2.2

package/dist/{src-Pd7PHJOG.js → src-D-K9opVc.js}

@@ -1932,19 +1932,6 @@ function runConformanceTests(options) {
 			const response = await fetch(`${getBaseUrl()}${streamPath}?live=sse`, { method: `GET` });
 			expect(response.status).toBe(400);
 		});
-		test(`client should reject SSE mode for incompatible content types`, async () => {
-			const streamPath = `/v1/stream/sse-binary-test-${Date.now()}`;
-			const stream = await DurableStream.create({
-				url: `${getBaseUrl()}${streamPath}`,
-				contentType: `application/octet-stream`
-			});
-			await stream.append(new Uint8Array([
-				1,
-				2,
-				3
-			]));
-			await expect(stream.stream({ live: `sse` })).rejects.toThrow();
-		});
 		test(`should stream data events via SSE`, async () => {
 			const streamPath = `/v1/stream/sse-data-stream-test-${Date.now()}`;
 			await fetch(`${getBaseUrl()}${streamPath}`, {
@@ -2207,10 +2194,11 @@ function runConformanceTests(options) {
 				body: `message 2`
 			});
 			let lastOffset = null;
-			const { response: response1, received: received1 } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			const { response: response1, received: received1 } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `upToDate` });
 			expect(response1.status).toBe(200);
-			const controlLine = received1.split(`\n`).find((l) => l.startsWith(`data:`) && l.includes(`streamNextOffset`));
-			const controlPayload = controlLine.slice(`data:`.length);
+			const controlLines = received1.split(`\n`).filter((l) => l.startsWith(`data:`) && l.includes(`streamNextOffset`));
+			const lastControlLine = controlLines[controlLines.length - 1];
+			const controlPayload = lastControlLine.slice(`data:`.length);
 			lastOffset = JSON.parse(controlPayload)[`streamNextOffset`];
 			expect(lastOffset).toBeDefined();
 			await fetch(`${getBaseUrl()}${streamPath}`, {
@@ -2224,6 +2212,242 @@ function runConformanceTests(options) {
 			expect(received2).not.toContain(`message 1`);
 			expect(received2).not.toContain(`message 2`);
 		});
+		test(`should auto-detect binary streams and return base64 encoded data in SSE mode`, async () => {
+			const streamPath = `/v1/stream/sse-binary-base64-${Date.now()}`;
+			const binaryData = new Uint8Array([
+				72,
+				101,
+				108,
+				108,
+				111
+			]);
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/octet-stream` },
+				body: binaryData
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			expect(response.headers.get(`content-type`)).toBe(`text/event-stream`);
+			const events = parseSSEEvents(received);
+			const dataEvents = events.filter((e) => e.type === `data`);
+			const controlEvents = events.filter((e) => e.type === `control`);
+			expect(dataEvents.length).toBe(1);
+			expect(controlEvents.length).toBe(1);
+			const base64Data = dataEvents[0].data.replace(/[\n\r\s]/g, ``);
+			expect(base64Data).toBe(`SGVsbG8=`);
+			const controlData = JSON.parse(controlEvents[0].data);
+			expect(controlData.streamNextOffset).toBeDefined();
+		});
+		test(`should include Stream-SSE-Data-Encoding header for binary streams`, async () => {
+			const streamPath = `/v1/stream/sse-encoding-header-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/octet-stream` },
+				body: new Uint8Array([
+					1,
+					2,
+					3
+				])
+			});
+			const { response } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			const encodingHeader = response.headers.get(`stream-sse-data-encoding`);
+			expect(encodingHeader).toBe(`base64`);
+		});
+		test(`should NOT include Stream-SSE-Data-Encoding header for text/plain streams`, async () => {
+			const streamPath = `/v1/stream/sse-text-no-encoding-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `hello world`
+			});
+			const { response } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			const encodingHeader = response.headers.get(`stream-sse-data-encoding`);
+			expect(encodingHeader).toBeNull();
+		});
+		test(`should NOT include Stream-SSE-Data-Encoding header for application/json streams`, async () => {
+			const streamPath = `/v1/stream/sse-json-no-encoding-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` },
+				body: JSON.stringify({ message: `hello` })
+			});
+			const { response } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			const encodingHeader = response.headers.get(`stream-sse-data-encoding`);
+			expect(encodingHeader).toBeNull();
+		});
+		test(`should base64 encode data events only, control events remain JSON`, async () => {
+			const streamPath = `/v1/stream/sse-base64-data-only-${Date.now()}`;
+			const binaryData = new Uint8Array([
+				255,
+				254,
+				253
+			]);
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/octet-stream` },
+				body: binaryData
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			const events = parseSSEEvents(received);
+			const controlEvents = events.filter((e) => e.type === `control`);
+			expect(controlEvents.length).toBe(1);
+			const controlData = JSON.parse(controlEvents[0].data);
+			expect(controlData.streamNextOffset).toBeDefined();
+			expect(typeof controlData.streamNextOffset).toBe(`string`);
+			expect(controlData.streamCursor).toBeDefined();
+		});
+		test(`should handle empty binary payload with auto-detected base64 encoding`, async () => {
+			const streamPath = `/v1/stream/sse-base64-empty-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/octet-stream` }
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			const events = parseSSEEvents(received);
+			const controlEvents = events.filter((e) => e.type === `control`);
+			expect(controlEvents.length).toBeGreaterThanOrEqual(1);
+			const controlData = JSON.parse(controlEvents[0].data);
+			expect(controlData.upToDate).toBe(true);
+		});
+		test(`should handle large binary payload with auto-detected base64 encoding`, async () => {
+			const streamPath = `/v1/stream/sse-base64-large-${Date.now()}`;
+			const binaryData = new Uint8Array(1024);
+			for (let i = 0; i < 1024; i++) binaryData[i] = i % 256;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/octet-stream` },
+				body: binaryData
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, {
+				untilContent: `event: control`,
+				timeoutMs: 5e3
+			});
+			expect(response.status).toBe(200);
+			const events = parseSSEEvents(received);
+			const dataEvents = events.filter((e) => e.type === `data`);
+			expect(dataEvents.length).toBe(1);
+			const base64Data = dataEvents[0].data.replace(/[\n\r\s]/g, ``);
+			const decoded = Uint8Array.from(atob(base64Data), (c) => c.charCodeAt(0));
+			expect(decoded.length).toBe(1024);
+			for (let i = 0; i < 1024; i++) expect(decoded[i]).toBe(i % 256);
+		});
+		test(`should handle binary data with special bytes using auto-detected base64 encoding`, async () => {
+			const streamPath = `/v1/stream/sse-base64-special-bytes-${Date.now()}`;
+			const binaryData = new Uint8Array([
+				0,
+				10,
+				13,
+				255,
+				254,
+				0,
+				10,
+				13
+			]);
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/octet-stream` },
+				body: binaryData
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			const events = parseSSEEvents(received);
+			const dataEvents = events.filter((e) => e.type === `data`);
+			expect(dataEvents.length).toBe(1);
+			const base64Data = dataEvents[0].data.replace(/[\n\r\s]/g, ``);
+			const decoded = Uint8Array.from(atob(base64Data), (c) => c.charCodeAt(0));
+			expect(decoded.length).toBe(8);
+			expect(decoded[0]).toBe(0);
+			expect(decoded[1]).toBe(10);
+			expect(decoded[2]).toBe(13);
+			expect(decoded[3]).toBe(255);
+			expect(decoded[4]).toBe(254);
+		});
+		test(`should auto-detect base64 encoding for application/x-protobuf streams`, async () => {
+			const streamPath = `/v1/stream/sse-base64-protobuf-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/x-protobuf` },
+				body: new Uint8Array([
+					8,
+					6,
+					18,
+					4,
+					110,
+					97,
+					109,
+					101
+				])
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			const events = parseSSEEvents(received);
+			const dataEvents = events.filter((e) => e.type === `data`);
+			expect(dataEvents.length).toBe(1);
+			const base64Data = dataEvents[0].data.replace(/[\n\r\s]/g, ``);
+			const decoded = Uint8Array.from(atob(base64Data), (c) => c.charCodeAt(0));
+			expect(decoded.length).toBe(8);
+			expect(decoded[0]).toBe(8);
+			expect(decoded[7]).toBe(101);
+		});
+		test(`should auto-detect base64 encoding for image/png streams`, async () => {
+			const streamPath = `/v1/stream/sse-base64-image-${Date.now()}`;
+			const pngHeader = new Uint8Array([
+				137,
+				80,
+				78,
+				71,
+				13,
+				10,
+				26,
+				10
+			]);
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `image/png` },
+				body: pngHeader
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			const events = parseSSEEvents(received);
+			const dataEvents = events.filter((e) => e.type === `data`);
+			expect(dataEvents.length).toBe(1);
+			const base64Data = dataEvents[0].data.replace(/[\n\r\s]/g, ``);
+			const decoded = Uint8Array.from(atob(base64Data), (c) => c.charCodeAt(0));
+			expect(decoded.length).toBe(8);
+			expect(decoded[0]).toBe(137);
+			expect(decoded[1]).toBe(80);
+			expect(decoded[2]).toBe(78);
+			expect(decoded[3]).toBe(71);
+		});
+		test(`should handle offset=now with auto-detected base64 encoding for binary streams`, async () => {
+			const streamPath = `/v1/stream/sse-base64-offset-now-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/octet-stream` },
+				body: new Uint8Array([
+					1,
+					2,
+					3
+				])
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=now&live=sse`, { untilContent: `"upToDate"` });
+			expect(response.status).toBe(200);
+			const controlMatch = received.match(/event: control\s*\n\s*data:({[^}]+})/);
+			expect(controlMatch).toBeDefined();
+			if (controlMatch && controlMatch[1]) {
+				const controlData = JSON.parse(controlMatch[1]);
+				expect(controlData[`upToDate`]).toBe(true);
+			}
+			const events = parseSSEEvents(received);
+			const dataEvents = events.filter((e) => e.type === `data`);
+			expect(dataEvents.length).toBe(0);
+		});
 	});
 	describe(`JSON Mode`, () => {
 		test(`should allow PUT with empty array body (creates empty stream)`, async () => {
@@ -2745,7 +2969,7 @@ function runConformanceTests(options) {
 						return true;
 					}
 ), { numRuns: 25 });
-			}, 15e3);
+			});
 			test(`read-your-writes: data is immediately visible after append`, async () => {
 				await fc.assert(fc.asyncProperty(fc.uint8Array({
 					minLength: 1,
@@ -3085,7 +3309,7 @@ function runConformanceTests(options) {
 						return true;
 					}
 ), { numRuns: 15 });
-			}, 15e3);
+			});
 			test(`content hash changes with each append`, async () => {
 				const streamPath = `/v1/stream/hash-changes-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 				await fetch(`${getBaseUrl()}${streamPath}`, {
@@ -4078,6 +4302,724 @@ function runConformanceTests(options) {
 			expect(r.status).toBe(400);
 		});
 	});
+	describe(`Stream Closure`, () => {
+		const STREAM_CLOSED_HEADER = `Stream-Closed`;
+		describe(`Create with Stream-Closed`, () => {
+			test(`create-closed-stream: PUT with Stream-Closed: true creates closed stream`, async () => {
+				const streamPath = `/v1/stream/create-closed-${Date.now()}`;
+				const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`
+					}
+				});
+				expect(response.status).toBe(201);
+				expect(response.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				expect(response.headers.get(STREAM_OFFSET_HEADER)).toBeTruthy();
+			});
+			test(`create-closed-stream-with-body: PUT with body + Stream-Closed: true`, async () => {
+				const streamPath = `/v1/stream/create-closed-body-${Date.now()}`;
+				const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`
+					},
+					body: `initial content`
+				});
+				expect(response.status).toBe(201);
+				expect(response.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				const readResponse = await fetch(`${getBaseUrl()}${streamPath}`);
+				const content = await readResponse.text();
+				expect(content).toBe(`initial content`);
+				expect(readResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`create-closed-returns-header: Response includes Stream-Closed: true`, async () => {
+				const streamPath = `/v1/stream/create-closed-header-${Date.now()}`;
+				const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`
+					}
+				});
+				expect(response.status).toBe(201);
+				expect(response.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+		});
+		describe(`Close Operations`, () => {
+			test(`close-stream-empty-post: POST with Stream-Closed: true, empty body closes stream`, async () => {
+				const streamPath = `/v1/stream/close-empty-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				expect(closeResponse.status).toBe(204);
+				expect(closeResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`close-with-final-append: POST with body + Stream-Closed: true`, async () => {
+				const streamPath = `/v1/stream/close-final-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { "Content-Type": `text/plain` },
+					body: `first message`
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`
+					},
+					body: `final message`
+				});
+				expect(closeResponse.status).toBe(204);
+				expect(closeResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				const readResponse = await fetch(`${getBaseUrl()}${streamPath}`);
+				const content = await readResponse.text();
+				expect(content).toBe(`first messagefinal message`);
+			});
+			test(`close-returns-offset-and-header: Response includes Stream-Next-Offset and Stream-Closed: true`, async () => {
+				const streamPath = `/v1/stream/close-returns-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` },
+					body: `content`
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				expect(closeResponse.status).toBe(204);
+				expect(closeResponse.headers.get(STREAM_OFFSET_HEADER)).toBeTruthy();
+				expect(closeResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`close-idempotent: Closing already-closed stream (empty body) returns 204`, async () => {
+				const streamPath = `/v1/stream/close-idempotent-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				const firstClose = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				expect(firstClose.status).toBe(204);
+				const secondClose = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				expect(secondClose.status).toBe(204);
+				expect(secondClose.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`close-only-ignores-content-type: Close-only with mismatched Content-Type still succeeds`, async () => {
+				const streamPath = `/v1/stream/close-ignores-ct-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `application/json` }
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`
+					}
+				});
+				expect(closeResponse.status).toBe(204);
+				expect(closeResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`append-to-closed-stream-409: Append to closed stream returns 409 with Stream-Closed: true header`, async () => {
+				const streamPath = `/v1/stream/append-closed-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const appendResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { "Content-Type": `text/plain` },
+					body: `should fail`
+				});
+				expect(appendResponse.status).toBe(409);
+				expect(appendResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`append-and-close-to-closed-stream-409: POST with body + Stream-Closed: true to already-closed stream returns 409`, async () => {
+				const streamPath = `/v1/stream/append-close-closed-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`
+					},
+					body: `should fail`
+				});
+				expect(response.status).toBe(409);
+				expect(response.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+		});
+		describe(`HEAD with Stream Closure`, () => {
+			test(`head-closed-stream: HEAD returns Stream-Closed: true header`, async () => {
+				const streamPath = `/v1/stream/head-closed-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const headResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+				expect(headResponse.status).toBe(200);
+				expect(headResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`head-open-stream-no-closed-header: HEAD on open stream does NOT have Stream-Closed header`, async () => {
+				const streamPath = `/v1/stream/head-open-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				const headResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+				expect(headResponse.status).toBe(200);
+				expect(headResponse.headers.get(STREAM_CLOSED_HEADER)).toBeNull();
+			});
+		});
+		describe(`Read Closed Streams (Catch-up)`, () => {
+			test(`read-closed-stream-at-tail: Returns Stream-Closed: true at tail of closed stream`, async () => {
+				const streamPath = `/v1/stream/read-closed-tail-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` },
+					body: `content`
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const readResponse = await fetch(`${getBaseUrl()}${streamPath}`);
+				expect(readResponse.status).toBe(200);
+				expect(await readResponse.text()).toBe(`content`);
+				expect(readResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				expect(readResponse.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+			});
+			test(`read-closed-stream-partial-no-closed: Partial read of closed stream does NOT include Stream-Closed`, async () => {
+				const streamPath = `/v1/stream/read-closed-partial-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` },
+					body: `first`
+				});
+				const appendResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { "Content-Type": `text/plain` },
+					body: `second`
+				});
+				const secondOffset = appendResponse.headers.get(STREAM_OFFSET_HEADER);
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const partialRead = await fetch(`${getBaseUrl()}${streamPath}?offset=-1`);
+				const partialContent = await partialRead.text();
+				const nextOffset = partialRead.headers.get(STREAM_OFFSET_HEADER);
+				if (nextOffset === secondOffset) expect(partialRead.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				else if (partialContent.length < `firstsecond`.length && partialContent.length > 0) expect(partialRead.headers.get(STREAM_CLOSED_HEADER)).toBeNull();
+				if (partialContent === `firstsecond`) expect(partialRead.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`read-closed-stream-empty-body-eof: At tail of closed stream: 200 OK, empty body, Stream-Closed: true`, async () => {
+				const streamPath = `/v1/stream/read-closed-eof-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` },
+					body: `content`
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const tailOffset = closeResponse.headers.get(STREAM_OFFSET_HEADER);
+				const eofRead = await fetch(`${getBaseUrl()}${streamPath}?offset=${tailOffset}`);
+				expect(eofRead.status).toBe(200);
+				expect(await eofRead.text()).toBe(``);
+				expect(eofRead.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				expect(eofRead.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+			});
+		});
+		describe(`Long-poll with Stream Closure`, () => {
+			test(`longpoll-closed-stream-immediate: No wait when closed stream at tail, returns immediately`, async () => {
+				const streamPath = `/v1/stream/longpoll-closed-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const tailOffset = closeResponse.headers.get(STREAM_OFFSET_HEADER);
+				const startTime = Date.now();
+				const longpollResponse = await fetch(`${getBaseUrl()}${streamPath}?offset=${tailOffset}&live=long-poll`);
+				const elapsed = Date.now() - startTime;
+				expect(longpollResponse.status).toBe(204);
+				expect(longpollResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				expect(elapsed).toBeLessThan(5e3);
+			}, getLongPollTestTimeoutMs());
+			test(`longpoll-closed-returns-204-with-header: Returns 204 with Stream-Closed: true`, async () => {
+				const streamPath = `/v1/stream/longpoll-closed-204-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` },
+					body: `data`
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const tailOffset = closeResponse.headers.get(STREAM_OFFSET_HEADER);
+				const response = await fetch(`${getBaseUrl()}${streamPath}?offset=${tailOffset}&live=long-poll`);
+				expect(response.status).toBe(204);
+				expect(response.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				expect(response.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+				expect(response.headers.get(STREAM_OFFSET_HEADER)).toBeTruthy();
+			}, getLongPollTestTimeoutMs());
+		});
+		describe(`SSE with Stream Closure`, () => {
+			test(`sse-closed-stream-control-event: Final control event has streamClosed: true`, async () => {
+				const streamPath = `/v1/stream/sse-closed-control-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` },
+					body: `content`
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const tailOffset = closeResponse.headers.get(STREAM_OFFSET_HEADER);
+				const { received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=${tailOffset}&live=sse`, {
+					timeoutMs: 5e3,
+					untilContent: `streamClosed`
+				});
+				const events = parseSSEEvents(received);
+				const controlEvents = events.filter((e) => e.type === `control`);
+				expect(controlEvents.length).toBeGreaterThan(0);
+				const lastControl = controlEvents[controlEvents.length - 1];
+				const controlData = JSON.parse(lastControl.data);
+				expect(controlData.streamClosed).toBe(true);
+			});
+			test(`sse-closed-stream-no-cursor: streamCursor omitted when streamClosed is true`, async () => {
+				const streamPath = `/v1/stream/sse-closed-no-cursor-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const tailOffset = closeResponse.headers.get(STREAM_OFFSET_HEADER);
+				const { received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=${tailOffset}&live=sse`, {
+					timeoutMs: 5e3,
+					untilContent: `streamClosed`
+				});
+				const events = parseSSEEvents(received);
+				const controlEvents = events.filter((e) => e.type === `control`);
+				expect(controlEvents.length).toBeGreaterThan(0);
+				const lastControl = controlEvents[controlEvents.length - 1];
+				const controlData = JSON.parse(lastControl.data);
+				expect(controlData.streamClosed).toBe(true);
+				expect(controlData.streamCursor).toBeUndefined();
+			});
+			test(`sse-closed-stream-connection-closes: Connection closes after final event`, async () => {
+				const streamPath = `/v1/stream/sse-closed-conn-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` },
+					body: `data`
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const controller = new AbortController();
+				const startTime = Date.now();
+				try {
+					const response = await fetch(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { signal: controller.signal });
+					if (response.body) {
+						const reader = response.body.getReader();
+						let received = ``;
+						let chunkCount = 0;
+						while (chunkCount < 20) {
+							const { done, value } = await reader.read();
+							if (done) break;
+							received += new TextDecoder().decode(value);
+							chunkCount++;
+						}
+						expect(received).toContain(`streamClosed`);
+					}
+				} catch {} finally {
+					controller.abort();
+				}
+				const elapsed = Date.now() - startTime;
+				expect(elapsed).toBeLessThan(1e4);
+			});
+		});
+		describe(`Idempotent Producers with Stream Closure`, () => {
+			const PRODUCER_ID_HEADER = `Producer-Id`;
+			const PRODUCER_EPOCH_HEADER = `Producer-Epoch`;
+			const PRODUCER_SEQ_HEADER = `Producer-Seq`;
+			test(`idempotent-close-with-append: Close with final append using producer headers`, async () => {
+				const streamPath = `/v1/stream/idempotent-close-append-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `final message`
+				});
+				expect(closeResponse.status).toBe(200);
+				expect(closeResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				expect(closeResponse.headers.get(PRODUCER_EPOCH_HEADER)).toBe(`0`);
+				expect(closeResponse.headers.get(PRODUCER_SEQ_HEADER)).toBe(`0`);
+				const readResponse = await fetch(`${getBaseUrl()}${streamPath}`);
+				expect(await readResponse.text()).toBe(`final message`);
+			});
+			test(`idempotent-close-only-with-producer-headers: Close-only with producer headers updates state`, async () => {
+				const streamPath = `/v1/stream/idempotent-close-only-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `message`
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `1`
+					}
+				});
+				expect(closeResponse.status).toBe(204);
+				expect(closeResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				expect(closeResponse.headers.get(PRODUCER_EPOCH_HEADER)).toBe(`0`);
+				expect(closeResponse.headers.get(PRODUCER_SEQ_HEADER)).toBe(`1`);
+			});
+			test(`idempotent-close-duplicate-returns-204: Duplicate close (same tuple) returns 204`, async () => {
+				const streamPath = `/v1/stream/idempotent-close-dup-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				const firstClose = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `final`
+				});
+				expect(firstClose.status).toBe(200);
+				const duplicateClose = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `final`
+				});
+				expect(duplicateClose.status).toBe(204);
+				expect(duplicateClose.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`idempotent-close-different-tuple-returns-409: Different producer/seq gets 409`, async () => {
+				const streamPath = `/v1/stream/idempotent-close-diff-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `producer-A`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `final`
+				});
+				const differentProducer = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `producer-B`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `should fail`
+				});
+				expect(differentProducer.status).toBe(409);
+				expect(differentProducer.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`idempotent-close-different-seq-returns-409: Same producer, different seq gets 409`, async () => {
+				const streamPath = `/v1/stream/idempotent-close-diff-seq-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `final`
+				});
+				const differentSeq = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `1`
+					},
+					body: `should fail`
+				});
+				expect(differentSeq.status).toBe(409);
+				expect(differentSeq.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+			test(`idempotent-close-only-duplicate-returns-204: Duplicate close-only (no body) returns 204`, async () => {
+				const streamPath = `/v1/stream/idempotent-close-only-dup-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				const firstClose = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					}
+				});
+				expect(firstClose.status).toBe(204);
+				const duplicateClose = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					}
+				});
+				expect(duplicateClose.status).toBe(204);
+				expect(duplicateClose.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+			});
+		});
+		describe(`Edge Cases`, () => {
+			const PRODUCER_ID_HEADER = `Producer-Id`;
+			const PRODUCER_EPOCH_HEADER = `Producer-Epoch`;
+			const PRODUCER_SEQ_HEADER = `Producer-Seq`;
+			test(`409-includes-stream-offset: 409 for closed stream includes Stream-Next-Offset header`, async () => {
+				const streamPath = `/v1/stream/409-offset-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` },
+					body: `some content`
+				});
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const finalOffset = closeResponse.headers.get(STREAM_OFFSET_HEADER);
+				expect(finalOffset).toBeTruthy();
+				const appendResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { "Content-Type": `text/plain` },
+					body: `should fail`
+				});
+				expect(appendResponse.status).toBe(409);
+				expect(appendResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				expect(appendResponse.headers.get(STREAM_OFFSET_HEADER)).toBe(finalOffset);
+			});
+			test(`close-nonexistent-stream-404: POST with Stream-Closed to nonexistent stream returns 404`, async () => {
+				const streamPath = `/v1/stream/nonexistent-close-${Date.now()}`;
+				const closeResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				expect(closeResponse.status).toBe(404);
+			});
+			test(`offset-now-on-closed-stream: offset=now on closed stream returns Stream-Closed: true`, async () => {
+				const streamPath = `/v1/stream/offset-now-closed-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` },
+					body: `content`
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const readResponse = await fetch(`${getBaseUrl()}${streamPath}?offset=now`);
+				expect(readResponse.status).toBe(200);
+				expect(readResponse.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				expect(readResponse.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+			});
+			test(`producer-state-survives-close: Stale-epoch producer gets 403, not 409 STREAM_CLOSED`, async () => {
+				const streamPath = `/v1/stream/producer-state-close-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[PRODUCER_ID_HEADER]: `producer-A`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `first`
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `producer-A`,
+						[PRODUCER_EPOCH_HEADER]: `1`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `final`
+				});
+				const staleResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `producer-A`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `1`
+					},
+					body: `stale attempt`
+				});
+				expect([403, 409]).toContain(staleResponse.status);
+			});
+			test(`close-with-different-body-dedup: Retry close with different body deduplicates to original`, async () => {
+				const streamPath = `/v1/stream/close-dedup-body-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				const firstClose = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `body-A`
+				});
+				expect(firstClose.status).toBe(200);
+				const retryClose = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_CLOSED_HEADER]: `true`,
+						[PRODUCER_ID_HEADER]: `test-producer`,
+						[PRODUCER_EPOCH_HEADER]: `0`,
+						[PRODUCER_SEQ_HEADER]: `0`
+					},
+					body: `body-B`
+				});
+				expect(retryClose.status).toBe(204);
+				const readResponse = await fetch(`${getBaseUrl()}${streamPath}`);
+				const content = await readResponse.text();
+				expect(content).toBe(`body-A`);
+			});
+			test(`empty-post-without-stream-closed-400: POST with empty body but no Stream-Closed returns 400`, async () => {
+				const streamPath = `/v1/stream/empty-no-closed-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` }
+				});
+				const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { "Content-Type": `text/plain` },
+					body: ``
+				});
+				expect(response.status).toBe(400);
+			});
+			test(`delete-closed-stream: Deleting a closed stream removes it (returns 404 after)`, async () => {
+				const streamPath = `/v1/stream/delete-closed-${Date.now()}`;
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `PUT`,
+					headers: { "Content-Type": `text/plain` },
+					body: `content`
+				});
+				await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { [STREAM_CLOSED_HEADER]: `true` }
+				});
+				const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+				expect(headBefore.headers.get(STREAM_CLOSED_HEADER)).toBe(`true`);
+				const deleteResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `DELETE` });
+				expect([200, 204]).toContain(deleteResponse.status);
+				const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+				expect(headAfter.status).toBe(404);
+			});
+		});
+	});
 }
 
 //#endregion