@durable-streams/server-conformance-tests 0.1.0

package/dist/src-DRIMnUPk.js

@@ -0,0 +1,2326 @@
+import { describe, expect, test } from "vitest";
+import * as fc from "fast-check";
+import { DurableStream, STREAM_OFFSET_HEADER, STREAM_SEQ_HEADER, STREAM_UP_TO_DATE_HEADER } from "@durable-streams/client";
+
+//#region src/index.ts
+/**
+* Helper to fetch SSE stream and read until a condition is met.
+* Handles AbortController, timeout, and cleanup automatically.
+*/
+async function fetchSSE(url, opts = {}) {
+	const { timeoutMs = 2e3, maxChunks = 10, untilContent, headers = {}, signal } = opts;
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+	if (signal) signal.addEventListener(`abort`, () => controller.abort());
+	try {
+		const response = await fetch(url, {
+			method: `GET`,
+			headers,
+			signal: controller.signal
+		});
+		if (!response.body) {
+			clearTimeout(timeoutId);
+			return {
+				response,
+				received: ``
+			};
+		}
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let received = ``;
+		let untilContentIndex = -1;
+		for (let i = 0; i < maxChunks; i++) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			received += decoder.decode(value, { stream: true });
+			if (untilContent && received.includes(untilContent) && untilContentIndex < 0) untilContentIndex = received.indexOf(untilContent);
+			const normalized = received.replace(/\r\n/g, `\n`);
+			if (untilContentIndex >= 0 && normalized.lastIndexOf(`\n\n`) > untilContentIndex) break;
+		}
+		clearTimeout(timeoutId);
+		reader.cancel();
+		return {
+			response,
+			received
+		};
+	} catch (e) {
+		clearTimeout(timeoutId);
+		if (e instanceof Error && e.name === `AbortError`) return {
+			response: new Response(),
+			received: ``
+		};
+		throw e;
+	}
+}
+/**
+* Parse SSE events from raw SSE text.
+* Handles multi-line data correctly by joining data: lines per the SSE spec.
+* Returns an array of parsed events with type and data.
+*/
+function parseSSEEvents(sseText) {
+	const events = [];
+	const normalized = sseText.replace(/\r\n/g, `\n`);
+	const eventBlocks = normalized.split(`\n\n`).filter((block) => block.trim());
+	for (const block of eventBlocks) {
+		const lines = block.split(`\n`);
+		let eventType = ``;
+		const dataLines = [];
+		for (const line of lines) if (line.startsWith(`event:`)) eventType = line.slice(6).trim();
+		else if (line.startsWith(`data:`)) {
+			const content = line.slice(5);
+			dataLines.push(content.startsWith(` `) ? content.slice(1) : content);
+		}
+		if (eventType && dataLines.length > 0) events.push({
+			type: eventType,
+			data: dataLines.join(`\n`)
+		});
+	}
+	return events;
+}
+/**
+* Run the full conformance test suite against a server
+*/
+function runConformanceTests(options) {
+	const getBaseUrl = () => options.baseUrl;
+	describe(`Basic Stream Operations`, () => {
+		test(`should create a stream`, async () => {
+			const streamPath = `/v1/stream/create-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			expect(stream.url).toBe(`${getBaseUrl()}${streamPath}`);
+		});
+		test(`should allow idempotent create with same config`, async () => {
+			const streamPath = `/v1/stream/duplicate-test-${Date.now()}`;
+			await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+		});
+		test(`should reject create with different config (409)`, async () => {
+			const streamPath = `/v1/stream/config-mismatch-test-${Date.now()}`;
+			await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			await expect(DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			})).rejects.toThrow();
+		});
+		test(`should delete a stream`, async () => {
+			const streamPath = `/v1/stream/delete-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			await stream.delete();
+			await expect(stream.stream({ live: false })).rejects.toThrow();
+		});
+		test(`should properly isolate recreated stream after delete`, async () => {
+			const streamPath = `/v1/stream/delete-recreate-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `old data`
+			});
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` more old data`
+			});
+			const readOld = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const oldText = await readOld.text();
+			expect(oldText).toBe(`old data more old data`);
+			const deleteResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `DELETE` });
+			expect(deleteResponse.status).toBe(204);
+			const recreateResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `new data`
+			});
+			expect(recreateResponse.status).toBe(201);
+			const readNew = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const newText = await readNew.text();
+			expect(newText).toBe(`new data`);
+			expect(newText).not.toContain(`old data`);
+			expect(readNew.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` appended`
+			});
+			const finalRead = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const finalText = await finalRead.text();
+			expect(finalText).toBe(`new data appended`);
+		});
+	});
+	describe(`Append Operations`, () => {
+		test(`should append string data`, async () => {
+			const streamPath = `/v1/stream/append-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			await stream.append(`hello world`);
+			const res = await stream.stream({ live: false });
+			const text = await res.text();
+			expect(text).toBe(`hello world`);
+		});
+		test(`should append multiple chunks`, async () => {
+			const streamPath = `/v1/stream/multi-append-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			await stream.append(`chunk1`);
+			await stream.append(`chunk2`);
+			await stream.append(`chunk3`);
+			const res = await stream.stream({ live: false });
+			const text = await res.text();
+			expect(text).toBe(`chunk1chunk2chunk3`);
+		});
+		test(`should enforce sequence ordering with seq`, async () => {
+			const streamPath = `/v1/stream/seq-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			await stream.append(`first`, { seq: `001` });
+			await stream.append(`second`, { seq: `002` });
+			await expect(stream.append(`invalid`, { seq: `001` })).rejects.toThrow();
+		});
+	});
+	describe(`Read Operations`, () => {
+		test(`should read empty stream`, async () => {
+			const streamPath = `/v1/stream/read-empty-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			const res = await stream.stream({ live: false });
+			const body = await res.body();
+			expect(body.length).toBe(0);
+			expect(res.upToDate).toBe(true);
+		});
+		test(`should read stream with data`, async () => {
+			const streamPath = `/v1/stream/read-data-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			await stream.append(`hello`);
+			const res = await stream.stream({ live: false });
+			const text = await res.text();
+			expect(text).toBe(`hello`);
+			expect(res.upToDate).toBe(true);
+		});
+		test(`should read from offset`, async () => {
+			const streamPath = `/v1/stream/read-offset-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			await stream.append(`first`);
+			const res1 = await stream.stream({ live: false });
+			await res1.text();
+			const firstOffset = res1.offset;
+			await stream.append(`second`);
+			const res2 = await stream.stream({
+				offset: firstOffset,
+				live: false
+			});
+			const text = await res2.text();
+			expect(text).toBe(`second`);
+		});
+	});
+	describe(`Long-Poll Operations`, () => {
+		test(`should wait for new data with long-poll`, async () => {
+			const streamPath = `/v1/stream/longpoll-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			const receivedData = [];
+			const readPromise = (async () => {
+				const res = await stream.stream({ live: `long-poll` });
+				await new Promise((resolve) => {
+					const unsubscribe = res.subscribeBytes(async (chunk) => {
+						if (chunk.data.length > 0) receivedData.push(new TextDecoder().decode(chunk.data));
+						if (receivedData.length >= 1) {
+							unsubscribe();
+							res.cancel();
+							resolve();
+						}
+					});
+				});
+			})();
+			await new Promise((resolve) => setTimeout(resolve, 500));
+			await stream.append(`new data`);
+			await readPromise;
+			expect(receivedData).toContain(`new data`);
+		}, 1e4);
+		test(`should return immediately if data already exists`, async () => {
+			const streamPath = `/v1/stream/longpoll-immediate-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `text/plain`
+			});
+			await stream.append(`existing data`);
+			const res = await stream.stream({ live: false });
+			const text = await res.text();
+			expect(text).toBe(`existing data`);
+		});
+	});
+	describe(`HTTP Protocol`, () => {
+		test(`should return correct headers on PUT`, async () => {
+			const streamPath = `/v1/stream/put-headers-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			expect(response.status).toBe(201);
+			expect(response.headers.get(`content-type`)).toBe(`text/plain`);
+			expect(response.headers.get(STREAM_OFFSET_HEADER)).toBeDefined();
+		});
+		test(`should return 200 on idempotent PUT with same config`, async () => {
+			const streamPath = `/v1/stream/duplicate-put-test-${Date.now()}`;
+			const firstResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			expect(firstResponse.status).toBe(201);
+			const secondResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			expect([200, 204]).toContain(secondResponse.status);
+		});
+		test(`should return 409 on PUT with different config`, async () => {
+			const streamPath = `/v1/stream/config-conflict-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` }
+			});
+			expect(response.status).toBe(409);
+		});
+		test(`should return correct headers on POST`, async () => {
+			const streamPath = `/v1/stream/post-headers-test-${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: `hello world`
+			});
+			expect([200, 204]).toContain(response.status);
+			expect(response.headers.get(STREAM_OFFSET_HEADER)).toBeDefined();
+		});
+		test(`should return 404 on POST to non-existent stream`, async () => {
+			const streamPath = `/v1/stream/post-404-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `data`
+			});
+			expect(response.status).toBe(404);
+		});
+		test(`should return 409 on content-type mismatch`, async () => {
+			const streamPath = `/v1/stream/content-type-mismatch-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `application/json` },
+				body: `{}`
+			});
+			expect(response.status).toBe(409);
+		});
+		test(`should return correct headers on GET`, async () => {
+			const streamPath = `/v1/stream/get-headers-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(response.status).toBe(200);
+			expect(response.headers.get(`content-type`)).toBe(`text/plain`);
+			const nextOffset = response.headers.get(STREAM_OFFSET_HEADER);
+			expect(nextOffset).toBeDefined();
+			expect(response.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+			const etag = response.headers.get(`etag`);
+			expect(etag).toBeDefined();
+			const text = await response.text();
+			expect(text).toBe(`test data`);
+		});
+		test(`should return empty body with up-to-date for empty stream`, async () => {
+			const streamPath = `/v1/stream/get-empty-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(response.status).toBe(200);
+			expect(response.headers.get(STREAM_OFFSET_HEADER)).toBeDefined();
+			expect(response.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+			const text = await response.text();
+			expect(text).toBe(``);
+		});
+		test(`should read from offset`, async () => {
+			const streamPath = `/v1/stream/get-offset-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `first`
+			});
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `second`
+			});
+			const firstResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const firstText = await firstResponse.text();
+			expect(firstText).toBe(`firstsecond`);
+			const streamPath2 = `/v1/stream/get-offset-test2-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath2}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `first`
+			});
+			const middleResponse = await fetch(`${getBaseUrl()}${streamPath2}`, { method: `GET` });
+			const middleOffset = middleResponse.headers.get(STREAM_OFFSET_HEADER);
+			await fetch(`${getBaseUrl()}${streamPath2}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `second`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath2}?offset=${middleOffset}`, { method: `GET` });
+			expect(response.status).toBe(200);
+			const text = await response.text();
+			expect(text).toBe(`second`);
+		});
+		test(`should return 404 on DELETE non-existent stream`, async () => {
+			const streamPath = `/v1/stream/delete-404-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `DELETE` });
+			expect(response.status).toBe(404);
+		});
+		test(`should return 204 on successful DELETE`, async () => {
+			const streamPath = `/v1/stream/delete-success-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `DELETE` });
+			expect(response.status).toBe(204);
+			const readResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(readResponse.status).toBe(404);
+		});
+		test(`should enforce sequence ordering`, async () => {
+			const streamPath = `/v1/stream/seq-test-${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_SEQ_HEADER]: `001`
+				},
+				body: `first`
+			});
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_SEQ_HEADER]: `002`
+				},
+				body: `second`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_SEQ_HEADER]: `001`
+				},
+				body: `invalid`
+			});
+			expect(response.status).toBe(409);
+		});
+		test(`should enforce lexicographic seq ordering ("2" then "10" rejects)`, async () => {
+			const streamPath = `/v1/stream/seq-lexicographic-test-${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_SEQ_HEADER]: `2`
+				},
+				body: `first`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_SEQ_HEADER]: `10`
+				},
+				body: `second`
+			});
+			expect(response.status).toBe(409);
+		});
+		test(`should allow lexicographic seq ordering ("09" then "10" succeeds)`, async () => {
+			const streamPath = `/v1/stream/seq-padded-test-${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_SEQ_HEADER]: `09`
+				},
+				body: `first`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_SEQ_HEADER]: `10`
+				},
+				body: `second`
+			});
+			expect([200, 204]).toContain(response.status);
+		});
+		test(`should reject duplicate seq values`, async () => {
+			const streamPath = `/v1/stream/seq-duplicate-test-${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_SEQ_HEADER]: `001`
+				},
+				body: `first`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_SEQ_HEADER]: `001`
+				},
+				body: `duplicate`
+			});
+			expect(response.status).toBe(409);
+		});
+	});
+	describe(`TTL and Expiry Validation`, () => {
+		test(`should reject both TTL and Expires-At (400)`, async () => {
+			const streamPath = `/v1/stream/ttl-expires-conflict-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `3600`,
+					"Stream-Expires-At": new Date(Date.now() + 36e5).toISOString()
+				}
+			});
+			expect(response.status).toBe(400);
+		});
+		test(`should reject invalid TTL (non-integer)`, async () => {
+			const streamPath = `/v1/stream/ttl-invalid-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `abc`
+				}
+			});
+			expect(response.status).toBe(400);
+		});
+		test(`should reject negative TTL`, async () => {
+			const streamPath = `/v1/stream/ttl-negative-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `-1`
+				}
+			});
+			expect(response.status).toBe(400);
+		});
+		test(`should accept valid TTL`, async () => {
+			const streamPath = `/v1/stream/ttl-valid-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `3600`
+				}
+			});
+			expect([200, 201]).toContain(response.status);
+		});
+		test(`should accept valid Expires-At`, async () => {
+			const streamPath = `/v1/stream/expires-valid-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": new Date(Date.now() + 36e5).toISOString()
+				}
+			});
+			expect([200, 201]).toContain(response.status);
+		});
+	});
+	describe(`Case-Insensitivity`, () => {
+		test(`should treat content-type case-insensitively`, async () => {
+			const streamPath = `/v1/stream/case-content-type-test-${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: `test`
+			});
+			expect([200, 204]).toContain(response.status);
+		});
+		test(`should allow idempotent create with different case content-type`, async () => {
+			const streamPath = `/v1/stream/case-idempotent-test-${Date.now()}`;
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` }
+			});
+			expect(response1.status).toBe(201);
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `APPLICATION/JSON` }
+			});
+			expect([200, 204]).toContain(response2.status);
+		});
+		test(`should accept headers with different casing`, async () => {
+			const streamPath = `/v1/stream/case-header-test-${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`,
+					"stream-seq": `001`
+				},
+				body: `test`
+			});
+			expect([200, 204]).toContain(response.status);
+		});
+	});
+	describe(`Content-Type Validation`, () => {
+		test(`should enforce content-type match on append`, async () => {
+			const streamPath = `/v1/stream/content-type-enforcement-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `application/json` },
+				body: `{"test": true}`
+			});
+			expect(response.status).toBe(409);
+		});
+		test(`should allow append with matching content-type`, async () => {
+			const streamPath = `/v1/stream/content-type-match-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `application/json` },
+				body: `{"test": true}`
+			});
+			expect([200, 204]).toContain(response.status);
+		});
+		test(`should return stream content-type on GET`, async () => {
+			const streamPath = `/v1/stream/content-type-get-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` },
+				body: `{"initial": true}`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(response.status).toBe(200);
+			expect(response.headers.get(`content-type`)).toBe(`application/json`);
+		});
+	});
+	describe(`HEAD Metadata`, () => {
+		test(`should return metadata without body`, async () => {
+			const streamPath = `/v1/stream/head-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			expect(response.status).toBe(200);
+			expect(response.headers.get(`content-type`)).toBe(`text/plain`);
+			expect(response.headers.get(STREAM_OFFSET_HEADER)).toBeDefined();
+			const text = await response.text();
+			expect(text).toBe(``);
+		});
+		test(`should return 404 for non-existent stream`, async () => {
+			const streamPath = `/v1/stream/head-404-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			expect(response.status).toBe(404);
+		});
+		test(`should return tail offset`, async () => {
+			const streamPath = `/v1/stream/head-offset-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			const offset1 = response1.headers.get(STREAM_OFFSET_HEADER);
+			expect(offset1).toBeDefined();
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test`
+			});
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			const offset2 = response2.headers.get(STREAM_OFFSET_HEADER);
+			expect(offset2).toBeDefined();
+			expect(offset2).not.toBe(offset1);
+		});
+	});
+	describe(`Offset Validation and Resumability`, () => {
+		test(`should accept -1 as sentinel for stream beginning`, async () => {
+			const streamPath = `/v1/stream/offset-sentinel-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}?offset=-1`, { method: `GET` });
+			expect(response.status).toBe(200);
+			const text = await response.text();
+			expect(text).toBe(`test data`);
+			expect(response.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+		});
+		test(`should return same data for offset=-1 and no offset`, async () => {
+			const streamPath = `/v1/stream/offset-sentinel-equiv-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `hello world`
+			});
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const text1 = await response1.text();
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}?offset=-1`, { method: `GET` });
+			const text2 = await response2.text();
+			expect(text1).toBe(text2);
+			expect(text1).toBe(`hello world`);
+		});
+		test(`should reject malformed offset (contains comma)`, async () => {
+			const streamPath = `/v1/stream/offset-comma-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}?offset=0,1`, { method: `GET` });
+			expect(response.status).toBe(400);
+		});
+		test(`should reject offset with spaces`, async () => {
+			const streamPath = `/v1/stream/offset-spaces-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}?offset=0 1`, { method: `GET` });
+			expect(response.status).toBe(400);
+		});
+		test(`should support resumable reads (no duplicate data)`, async () => {
+			const streamPath = `/v1/stream/resumable-test-${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: `chunk1`
+			});
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const text1 = await response1.text();
+			const offset1 = response1.headers.get(STREAM_OFFSET_HEADER);
+			expect(text1).toBe(`chunk1`);
+			expect(offset1).toBeDefined();
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `chunk2`
+			});
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}?offset=${offset1}`, { method: `GET` });
+			const text2 = await response2.text();
+			expect(text2).toBe(`chunk2`);
+		});
+		test(`should return empty response when reading from tail offset`, async () => {
+			const streamPath = `/v1/stream/tail-read-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test`
+			});
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const tailOffset = response1.headers.get(STREAM_OFFSET_HEADER);
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}?offset=${tailOffset}`, { method: `GET` });
+			expect(response2.status).toBe(200);
+			const text = await response2.text();
+			expect(text).toBe(``);
+			expect(response2.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+		});
+	});
+	describe(`Protocol Edge Cases`, () => {
+		test(`should reject empty POST body with 400`, async () => {
+			const streamPath = `/v1/stream/empty-append-test-${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(`should handle PUT with initial body correctly`, async () => {
+			const streamPath = `/v1/stream/put-initial-body-test-${Date.now()}`;
+			const initialData = `initial stream content`;
+			const putResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: initialData
+			});
+			expect(putResponse.status).toBe(201);
+			const nextOffset = putResponse.headers.get(STREAM_OFFSET_HEADER);
+			expect(nextOffset).toBeDefined();
+			const getResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const text = await getResponse.text();
+			expect(text).toBe(initialData);
+			expect(getResponse.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+		});
+		test(`should preserve data immutability by position`, async () => {
+			const streamPath = `/v1/stream/immutability-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `chunk1`
+			});
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const text1 = await response1.text();
+			const offset1 = response1.headers.get(STREAM_OFFSET_HEADER);
+			expect(text1).toBe(`chunk1`);
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `chunk2`
+			});
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `chunk3`
+			});
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}?offset=${offset1}`, { method: `GET` });
+			const text2 = await response2.text();
+			expect(text2).toBe(`chunk2chunk3`);
+		});
+		test(`should generate unique, monotonically increasing offsets`, async () => {
+			const streamPath = `/v1/stream/monotonic-offset-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const offsets = [];
+			for (let i = 0; i < 5; i++) {
+				const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { "Content-Type": `text/plain` },
+					body: `chunk${i}`
+				});
+				const offset = response.headers.get(STREAM_OFFSET_HEADER);
+				expect(offset).toBeDefined();
+				offsets.push(offset);
+			}
+			for (let i = 1; i < offsets.length; i++) expect(offsets[i] > offsets[i - 1]).toBe(true);
+		});
+		test(`should reject empty offset parameter`, async () => {
+			const streamPath = `/v1/stream/empty-offset-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}?offset=`, { method: `GET` });
+			expect(response.status).toBe(400);
+		});
+		test(`should reject multiple offset parameters`, async () => {
+			const streamPath = `/v1/stream/multi-offset-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}?offset=a&offset=b`, { method: `GET` });
+			expect(response.status).toBe(400);
+		});
+		test(`should enforce case-sensitive seq ordering`, async () => {
+			const streamPath = `/v1/stream/case-seq-test-${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_SEQ_HEADER]: `a`
+				},
+				body: `first`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_SEQ_HEADER]: `B`
+				},
+				body: `second`
+			});
+			expect(response.status).toBe(409);
+		});
+		test(`should handle binary data with integrity`, async () => {
+			const streamPath = `/v1/stream/binary-test-${Date.now()}`;
+			const binaryData = new Uint8Array([
+				0,
+				1,
+				2,
+				127,
+				128,
+				254,
+				255
+			]);
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/octet-stream` },
+				body: binaryData
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const buffer = await response.arrayBuffer();
+			const result = new Uint8Array(buffer);
+			expect(result.length).toBe(binaryData.length);
+			for (let i = 0; i < binaryData.length; i++) expect(result[i]).toBe(binaryData[i]);
+		});
+		test(`should return Location header on 201`, async () => {
+			const streamPath = `/v1/stream/location-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			expect(response.status).toBe(201);
+			const location = response.headers.get(`location`);
+			expect(location).toBeDefined();
+			expect(location).toBe(`${getBaseUrl()}${streamPath}`);
+		});
+		test(`should reject missing Content-Type on POST`, async () => {
+			const streamPath = `/v1/stream/missing-ct-post-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				body: new Blob([`data`], { type: `` })
+			});
+			expect(response.status).toBe(400);
+		});
+		test(`should accept PUT without Content-Type (use default)`, async () => {
+			const streamPath = `/v1/stream/no-ct-put-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `PUT` });
+			expect([200, 201]).toContain(response.status);
+			const contentType = response.headers.get(`content-type`);
+			expect(contentType).toBeDefined();
+		});
+		test(`should ignore unknown query parameters`, async () => {
+			const streamPath = `/v1/stream/unknown-param-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}?offset=-1&foo=bar&baz=qux`, { method: `GET` });
+			expect(response.status).toBe(200);
+			const text = await response.text();
+			expect(text).toBe(`test data`);
+		});
+	});
+	describe(`Long-Poll Edge Cases`, () => {
+		test(`should require offset parameter for long-poll`, async () => {
+			const streamPath = `/v1/stream/longpoll-no-offset-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}?live=long-poll`, { method: `GET` });
+			expect(response.status).toBe(400);
+		});
+		test(`should generate Stream-Cursor header on long-poll responses`, async () => {
+			const streamPath = `/v1/stream/longpoll-cursor-gen-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}?offset=-1&live=long-poll`, { method: `GET` });
+			expect(response.status).toBe(200);
+			const cursor = response.headers.get(`Stream-Cursor`);
+			expect(cursor).toBeDefined();
+			expect(cursor).not.toBeNull();
+			expect(/^\d+$/.test(cursor)).toBe(true);
+		});
+		test(`should echo cursor and handle collision with jitter`, async () => {
+			const streamPath = `/v1/stream/longpoll-cursor-collision-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}?offset=-1&live=long-poll`, { method: `GET` });
+			expect(response1.status).toBe(200);
+			const cursor1 = response1.headers.get(`Stream-Cursor`);
+			expect(cursor1).toBeDefined();
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}?offset=-1&live=long-poll&cursor=${cursor1}`, { method: `GET` });
+			expect(response2.status).toBe(200);
+			const cursor2 = response2.headers.get(`Stream-Cursor`);
+			expect(cursor2).toBeDefined();
+			expect(parseInt(cursor2, 10)).toBeGreaterThan(parseInt(cursor1, 10));
+		});
+		test(`should return Stream-Cursor, Stream-Up-To-Date and Stream-Next-Offset on 204 timeout`, async () => {
+			const streamPath = `/v1/stream/longpoll-204-headers-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const headResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			const tailOffset = headResponse.headers.get(STREAM_OFFSET_HEADER);
+			expect(tailOffset).toBeDefined();
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), 5e3);
+			try {
+				const response = await fetch(`${getBaseUrl()}${streamPath}?offset=${tailOffset}&live=long-poll`, {
+					method: `GET`,
+					signal: controller.signal
+				});
+				clearTimeout(timeoutId);
+				if (response.status === 204) {
+					expect(response.headers.get(STREAM_OFFSET_HEADER)).toBeDefined();
+					expect(response.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+					const cursor = response.headers.get(`Stream-Cursor`);
+					expect(cursor).toBeDefined();
+					expect(/^\d+$/.test(cursor)).toBe(true);
+				}
+				expect([200, 204]).toContain(response.status);
+			} catch (e) {
+				clearTimeout(timeoutId);
+				if (e instanceof Error && e.name !== `AbortError`) throw e;
+			}
+		}, 1e4);
+	});
+	describe(`TTL and Expiry Edge Cases`, () => {
+		test(`should reject TTL with leading zeros`, async () => {
+			const streamPath = `/v1/stream/ttl-leading-zeros-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `00060`
+				}
+			});
+			expect(response.status).toBe(400);
+		});
+		test(`should reject TTL with plus sign`, async () => {
+			const streamPath = `/v1/stream/ttl-plus-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `+60`
+				}
+			});
+			expect(response.status).toBe(400);
+		});
+		test(`should reject TTL with float value`, async () => {
+			const streamPath = `/v1/stream/ttl-float-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `60.5`
+				}
+			});
+			expect(response.status).toBe(400);
+		});
+		test(`should reject TTL with scientific notation`, async () => {
+			const streamPath = `/v1/stream/ttl-scientific-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1e3`
+				}
+			});
+			expect(response.status).toBe(400);
+		});
+		test(`should reject invalid Expires-At timestamp`, async () => {
+			const streamPath = `/v1/stream/expires-invalid-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": `not-a-timestamp`
+				}
+			});
+			expect(response.status).toBe(400);
+		});
+		test(`should accept Expires-At with Z timezone`, async () => {
+			const streamPath = `/v1/stream/expires-z-test-${Date.now()}`;
+			const expiresAt = new Date(Date.now() + 36e5).toISOString();
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				}
+			});
+			expect([200, 201]).toContain(response.status);
+		});
+		test(`should accept Expires-At with timezone offset`, async () => {
+			const streamPath = `/v1/stream/expires-offset-test-${Date.now()}`;
+			const date = new Date(Date.now() + 36e5);
+			const expiresAt = date.toISOString().replace(`Z`, `+00:00`);
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				}
+			});
+			expect([200, 201]).toContain(response.status);
+		});
+		test(`should handle idempotent PUT with same TTL`, async () => {
+			const streamPath = `/v1/stream/ttl-idempotent-test-${Date.now()}`;
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `3600`
+				}
+			});
+			expect(response1.status).toBe(201);
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `3600`
+				}
+			});
+			expect([200, 204]).toContain(response2.status);
+		});
+		test(`should reject idempotent PUT with different TTL`, async () => {
+			const streamPath = `/v1/stream/ttl-conflict-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `3600`
+				}
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `7200`
+				}
+			});
+			expect(response.status).toBe(409);
+		});
+	});
+	describe(`HEAD Metadata Edge Cases`, () => {
+		test(`should return TTL metadata if configured`, async () => {
+			const streamPath = `/v1/stream/head-ttl-metadata-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `3600`
+				}
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			const ttl = response.headers.get(`Stream-TTL`);
+			if (ttl) {
+				expect(parseInt(ttl)).toBeGreaterThan(0);
+				expect(parseInt(ttl)).toBeLessThanOrEqual(3600);
+			}
+		});
+		test(`should return Expires-At metadata if configured`, async () => {
+			const streamPath = `/v1/stream/head-expires-metadata-test-${Date.now()}`;
+			const expiresAt = new Date(Date.now() + 36e5).toISOString();
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				}
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			const expiresHeader = response.headers.get(`Stream-Expires-At`);
+			if (expiresHeader) expect(expiresHeader).toBeDefined();
+		});
+	});
+	describe(`Caching and ETag`, () => {
+		test(`should generate ETag on GET responses`, async () => {
+			const streamPath = `/v1/stream/etag-generate-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(response.status).toBe(200);
+			const etag = response.headers.get(`etag`);
+			expect(etag).toBeDefined();
+			expect(etag.length).toBeGreaterThan(0);
+		});
+		test(`should return 304 Not Modified for matching If-None-Match`, async () => {
+			const streamPath = `/v1/stream/etag-304-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const etag = response1.headers.get(`etag`);
+			expect(etag).toBeDefined();
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `GET`,
+				headers: { "If-None-Match": etag }
+			});
+			expect(response2.status).toBe(304);
+			const text = await response2.text();
+			expect(text).toBe(``);
+		});
+		test(`should return 200 for non-matching If-None-Match`, async () => {
+			const streamPath = `/v1/stream/etag-mismatch-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `GET`,
+				headers: { "If-None-Match": `"wrong-etag"` }
+			});
+			expect(response.status).toBe(200);
+			const text = await response.text();
+			expect(text).toBe(`test data`);
+		});
+		test(`should return new ETag after data changes`, async () => {
+			const streamPath = `/v1/stream/etag-change-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `initial`
+			});
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const etag1 = response1.headers.get(`etag`);
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` more`
+			});
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const etag2 = response2.headers.get(`etag`);
+			expect(etag1).not.toBe(etag2);
+			const response3 = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `GET`,
+				headers: { "If-None-Match": etag1 }
+			});
+			expect(response3.status).toBe(200);
+		});
+	});
+	describe(`Chunking and Large Payloads`, () => {
+		test(`should handle chunk-size pagination correctly`, async () => {
+			const streamPath = `/v1/stream/chunk-pagination-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/octet-stream` }
+			});
+			const largeData = new Uint8Array(100 * 1024);
+			for (let i = 0; i < largeData.length; i++) largeData[i] = i % 256;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `application/octet-stream` },
+				body: largeData
+			});
+			const accumulated = [];
+			let currentOffset = null;
+			let previousOffset = null;
+			let iterations = 0;
+			const maxIterations = 1e3;
+			while (iterations < maxIterations) {
+				iterations++;
+				const url = currentOffset ? `${getBaseUrl()}${streamPath}?offset=${encodeURIComponent(currentOffset)}` : `${getBaseUrl()}${streamPath}`;
+				const response = await fetch(url, { method: `GET` });
+				expect(response.status).toBe(200);
+				const buffer = await response.arrayBuffer();
+				const data = new Uint8Array(buffer);
+				if (data.length > 0) accumulated.push(...Array.from(data));
+				const nextOffset = response.headers.get(STREAM_OFFSET_HEADER);
+				const upToDate = response.headers.get(STREAM_UP_TO_DATE_HEADER);
+				if (upToDate === `true` && data.length === 0) break;
+				expect(nextOffset).toBeDefined();
+				if (nextOffset === currentOffset && data.length === 0) break;
+				if (previousOffset && nextOffset) expect(nextOffset >= previousOffset).toBe(true);
+				previousOffset = currentOffset;
+				currentOffset = nextOffset;
+			}
+			const result = new Uint8Array(accumulated);
+			expect(result.length).toBe(largeData.length);
+			for (let i = 0; i < largeData.length; i++) expect(result[i]).toBe(largeData[i]);
+		});
+		test(`should handle large payload appropriately`, async () => {
+			const streamPath = `/v1/stream/large-payload-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/octet-stream` }
+			});
+			const largeData = new Uint8Array(10 * 1024 * 1024);
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `application/octet-stream` },
+				body: largeData
+			});
+			expect([
+				200,
+				204,
+				413
+			]).toContain(response.status);
+		}, 3e4);
+	});
+	describe(`Read-Your-Writes Consistency`, () => {
+		test(`should immediately read message after append`, async () => {
+			const streamPath = `/v1/stream/ryw-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `initial`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const text = await response.text();
+			expect(text).toBe(`initial`);
+		});
+		test(`should immediately read multiple appends`, async () => {
+			const streamPath = `/v1/stream/ryw-multi-test-${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: `msg1`
+			});
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `msg2`
+			});
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `msg3`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const text = await response.text();
+			expect(text).toBe(`msg1msg2msg3`);
+		});
+		test(`should serve offset-based reads immediately after append`, async () => {
+			const streamPath = `/v1/stream/ryw-offset-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `first`
+			});
+			const response1 = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			const offset1 = response1.headers.get(STREAM_OFFSET_HEADER);
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `second`
+			});
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `third`
+			});
+			const response2 = await fetch(`${getBaseUrl()}${streamPath}?offset=${offset1}`, { method: `GET` });
+			const text = await response2.text();
+			expect(text).toBe(`secondthird`);
+		});
+	});
+	describe(`SSE Mode`, () => {
+		test(`should return text/event-stream content-type for SSE requests`, async () => {
+			const streamPath = `/v1/stream/sse-content-type-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const { response } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, {
+				headers: { Accept: `text/event-stream` },
+				maxChunks: 0
+			});
+			expect(response.status).toBe(200);
+			expect(response.headers.get(`content-type`)).toBe(`text/event-stream`);
+		});
+		test(`should accept live=sse query parameter for application/json`, async () => {
+			const streamPath = `/v1/stream/sse-json-test-${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`, {
+				headers: { Accept: `text/event-stream` },
+				maxChunks: 0
+			});
+			expect(response.status).toBe(200);
+			expect(response.headers.get(`content-type`)).toBe(`text/event-stream`);
+		});
+		test(`should require offset parameter for SSE mode`, async () => {
+			const streamPath = `/v1/stream/sse-no-offset-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			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}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `message one`
+			});
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `message two`
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `message two` });
+			expect(response.status).toBe(200);
+			expect(received).toContain(`event:`);
+			expect(received).toContain(`data:`);
+		});
+		test(`should send control events with offset`, async () => {
+			const streamPath = `/v1/stream/sse-control-event-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			expect(received).toContain(`event: control`);
+			expect(received).toContain(`streamNextOffset`);
+		});
+		test(`should generate streamCursor in SSE control events`, async () => {
+			const streamPath = `/v1/stream/sse-cursor-gen-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `streamCursor` });
+			expect(response.status).toBe(200);
+			const controlMatch = received.match(/event: control\s*\ndata: ({[^}]+})/);
+			expect(controlMatch).toBeDefined();
+			const controlData = JSON.parse(controlMatch[1]);
+			expect(controlData.streamCursor).toBeDefined();
+			expect(/^\d+$/.test(controlData.streamCursor)).toBe(true);
+		});
+		test(`should handle cursor collision with jitter in SSE mode`, async () => {
+			const streamPath = `/v1/stream/sse-cursor-collision-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const { received: received1 } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `streamCursor` });
+			const controlMatch1 = received1.match(/event: control\s*\ndata: ({[^}]+})/);
+			expect(controlMatch1).toBeDefined();
+			const cursor1 = JSON.parse(controlMatch1[1]).streamCursor;
+			const { received: received2 } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse&cursor=${cursor1}`, { untilContent: `streamCursor` });
+			const controlMatch2 = received2.match(/event: control\s*\ndata: ({[^}]+})/);
+			expect(controlMatch2).toBeDefined();
+			const cursor2 = JSON.parse(controlMatch2[1]).streamCursor;
+			expect(parseInt(cursor2, 10)).toBeGreaterThan(parseInt(cursor1, 10));
+		});
+		test(`should wrap JSON data in arrays for SSE and produce valid JSON`, async () => {
+			const streamPath = `/v1/stream/sse-json-wrap-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` },
+				body: JSON.stringify({
+					id: 1,
+					message: `hello`
+				})
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: data` });
+			expect(response.status).toBe(200);
+			expect(received).toContain(`event: data`);
+			const events = parseSSEEvents(received);
+			const dataEvent = events.find((e) => e.type === `data`);
+			expect(dataEvent).toBeDefined();
+			const parsed = JSON.parse(dataEvent.data);
+			expect(parsed).toEqual([{
+				id: 1,
+				message: `hello`
+			}]);
+		});
+		test(`should handle SSE for empty stream with correct offset`, async () => {
+			const streamPath = `/v1/stream/sse-empty-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const httpResponse = await fetch(`${getBaseUrl()}${streamPath}`);
+			const httpOffset = httpResponse.headers.get(`Stream-Next-Offset`);
+			expect(httpOffset).toBeDefined();
+			expect(httpOffset).not.toBe(`-1`);
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			expect(received).toContain(`event: control`);
+			const controlLine = received.split(`\n`).find((l) => l.startsWith(`data: `) && l.includes(`streamNextOffset`));
+			expect(controlLine).toBeDefined();
+			const controlPayload = controlLine.slice(`data: `.length);
+			const controlData = JSON.parse(controlPayload);
+			expect(controlData[`streamNextOffset`]).toBe(httpOffset);
+		});
+		test(`should send upToDate flag in SSE control events when caught up`, async () => {
+			const streamPath = `/v1/stream/sse-uptodate-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `"upToDate"` });
+			expect(response.status).toBe(200);
+			const controlLine = received.split(`\n`).find((l) => l.startsWith(`data: `) && l.includes(`streamNextOffset`));
+			expect(controlLine).toBeDefined();
+			const controlPayload = controlLine.slice(`data: `.length);
+			const controlData = JSON.parse(controlPayload);
+			expect(controlData.upToDate).toBe(true);
+		});
+		test(`should have correct SSE headers (no Content-Length, proper Cache-Control)`, async () => {
+			const streamPath = `/v1/stream/sse-headers-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `test data`
+			});
+			const { response } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `test data` });
+			expect(response.status).toBe(200);
+			expect(response.headers.get(`content-type`)).toBe(`text/event-stream`);
+			expect(response.headers.get(`content-length`)).toBeNull();
+			const cacheControl = response.headers.get(`cache-control`);
+			expect(cacheControl).toContain(`no-cache`);
+		});
+		test(`should handle newlines in text/plain payloads`, async () => {
+			const streamPath = `/v1/stream/sse-newline-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `line1\nline2\nline3`
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			expect(received).toContain(`event: data`);
+			expect(received).toContain(`data: line1`);
+			expect(received).toContain(`data: line2`);
+			expect(received).toContain(`data: line3`);
+		});
+		test(`should generate unique, monotonically increasing offsets in SSE mode`, async () => {
+			const streamPath = `/v1/stream/sse-monotonic-offset-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			for (let i = 0; i < 5; i++) await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `message ${i}`
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response.status).toBe(200);
+			const controlLines = received.split(`\n`).filter((l) => l.startsWith(`data: `) && l.includes(`streamNextOffset`));
+			const offsets = [];
+			for (const line of controlLines) {
+				const payload = line.slice(`data: `.length);
+				const data = JSON.parse(payload);
+				offsets.push(data[`streamNextOffset`]);
+			}
+			for (let i = 1; i < offsets.length; i++) expect(offsets[i] > offsets[i - 1]).toBe(true);
+		});
+		test(`should support reconnection with last known offset`, async () => {
+			const streamPath = `/v1/stream/sse-reconnect-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `message 1`
+			});
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `message 2`
+			});
+			let lastOffset = null;
+			const { response: response1, received: received1 } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
+			expect(response1.status).toBe(200);
+			const controlLine = received1.split(`\n`).find((l) => l.startsWith(`data: `) && l.includes(`streamNextOffset`));
+			const controlPayload = controlLine.slice(`data: `.length);
+			lastOffset = JSON.parse(controlPayload)[`streamNextOffset`];
+			expect(lastOffset).toBeDefined();
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `message 3`
+			});
+			const { response: response2, received: received2 } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=${lastOffset}&live=sse`, { untilContent: `message 3` });
+			expect(response2.status).toBe(200);
+			expect(received2).toContain(`message 3`);
+			expect(received2).not.toContain(`message 1`);
+			expect(received2).not.toContain(`message 2`);
+		});
+	});
+	describe(`JSON Mode`, () => {
+		test(`should allow PUT with empty array body (creates empty stream)`, async () => {
+			const streamPath = `/v1/stream/json-put-empty-array-test-${Date.now()}`;
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` },
+				body: `[]`
+			});
+			expect(response.status).toBe(201);
+			const readResponse = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await readResponse.json();
+			expect(data).toEqual([]);
+			expect(readResponse.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+		});
+		test(`should reject POST with empty array body`, async () => {
+			const streamPath = `/v1/stream/json-post-empty-array-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `application/json` },
+				body: `[]`
+			});
+			expect(response.status).toBe(400);
+		});
+		test(`should handle content-type with charset parameter`, async () => {
+			const streamPath = `/v1/stream/json-charset-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json; charset=utf-8` }
+			});
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `application/json; charset=utf-8` },
+				body: JSON.stringify({ message: `hello` })
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(Array.isArray(data)).toBe(true);
+			expect(data).toEqual([{ message: `hello` }]);
+		});
+		test(`should wrap single JSON value in array`, async () => {
+			const streamPath = `/v1/stream/json-single-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append({ message: `hello` });
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(Array.isArray(data)).toBe(true);
+			expect(data).toEqual([{ message: `hello` }]);
+		});
+		test(`should store arrays as single messages`, async () => {
+			const streamPath = `/v1/stream/json-array-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append([
+				{ id: 1 },
+				{ id: 2 },
+				{ id: 3 }
+			]);
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(Array.isArray(data)).toBe(true);
+			expect(data).toEqual([[
+				{ id: 1 },
+				{ id: 2 },
+				{ id: 3 }
+			]]);
+		});
+		test(`should concatenate multiple appends into single array`, async () => {
+			const streamPath = `/v1/stream/json-concat-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append({ event: `first` });
+			await stream.append({ event: `second` });
+			await stream.append({ event: `third` });
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(Array.isArray(data)).toBe(true);
+			expect(data).toEqual([
+				{ event: `first` },
+				{ event: `second` },
+				{ event: `third` }
+			]);
+		});
+		test(`should handle mixed single values and arrays`, async () => {
+			const streamPath = `/v1/stream/json-mixed-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append({ type: `single` });
+			await stream.append([{
+				type: `array`,
+				id: 1
+			}, {
+				type: `array`,
+				id: 2
+			}]);
+			await stream.append({ type: `single-again` });
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(data).toEqual([
+				{ type: `single` },
+				[{
+					type: `array`,
+					id: 1
+				}, {
+					type: `array`,
+					id: 2
+				}],
+				{ type: `single-again` }
+			]);
+		});
+		test(`should reject invalid JSON with 400`, async () => {
+			const streamPath = `/v1/stream/json-invalid-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `application/json` },
+				body: `{ invalid json }`
+			});
+			expect(response.status).toBe(400);
+			expect(response.ok).toBe(false);
+		});
+		test(`should handle various JSON value types`, async () => {
+			const streamPath = `/v1/stream/json-types-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append(`string value`);
+			await stream.append(42);
+			await stream.append(true);
+			await stream.append(null);
+			await stream.append({ object: `value` });
+			await stream.append([
+				1,
+				2,
+				3
+			]);
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(data).toEqual([
+				`string value`,
+				42,
+				true,
+				null,
+				{ object: `value` },
+				[
+					1,
+					2,
+					3
+				]
+			]);
+		});
+		test(`should preserve JSON structure and nesting`, async () => {
+			const streamPath = `/v1/stream/json-nested-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append({
+				user: {
+					id: 123,
+					name: `Alice`,
+					tags: [`admin`, `verified`]
+				},
+				timestamp: `2024-01-01T00:00:00Z`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(data).toEqual([{
+				user: {
+					id: 123,
+					name: `Alice`,
+					tags: [`admin`, `verified`]
+				},
+				timestamp: `2024-01-01T00:00:00Z`
+			}]);
+		});
+		test(`should work with client json() iterator`, async () => {
+			const streamPath = `/v1/stream/json-iterator-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append({ id: 1 });
+			await stream.append({ id: 2 });
+			await stream.append({ id: 3 });
+			const res = await stream.stream({ live: false });
+			const items = await res.json();
+			expect(items).toEqual([
+				{ id: 1 },
+				{ id: 2 },
+				{ id: 3 }
+			]);
+		});
+		test(`should reject empty JSON arrays with 400`, async () => {
+			const streamPath = `/v1/stream/json-empty-array-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` }
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `application/json` },
+				body: `[]`
+			});
+			expect(response.status).toBe(400);
+			expect(response.ok).toBe(false);
+		});
+		test(`should store nested arrays as single messages`, async () => {
+			const streamPath = `/v1/stream/json-nested-arrays-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append([[1, 2], [3, 4]]);
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(data).toEqual([[[1, 2], [3, 4]]]);
+		});
+		test(`should store arrays as values when double-wrapped`, async () => {
+			const streamPath = `/v1/stream/json-wrapped-array-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append([[
+				1,
+				2,
+				3
+			]]);
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(data).toEqual([[[
+				1,
+				2,
+				3
+			]]]);
+			expect(data.length).toBe(1);
+		});
+		test(`should store primitive arrays as single messages`, async () => {
+			const streamPath = `/v1/stream/json-primitive-array-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append([
+				1,
+				2,
+				3
+			]);
+			await stream.append([
+				`a`,
+				`b`,
+				`c`
+			]);
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(data).toEqual([[
+				1,
+				2,
+				3
+			], [
+				`a`,
+				`b`,
+				`c`
+			]]);
+		});
+		test(`should handle mixed batching - single values, arrays, and nested arrays`, async () => {
+			const streamPath = `/v1/stream/json-mixed-batching-test-${Date.now()}`;
+			const stream = await DurableStream.create({
+				url: `${getBaseUrl()}${streamPath}`,
+				contentType: `application/json`
+			});
+			await stream.append({ single: 1 });
+			await stream.append([{ batch: 2 }, { batch: 3 }]);
+			await stream.append([[`nested`, `array`]]);
+			await stream.append(42);
+			const response = await fetch(`${getBaseUrl()}${streamPath}`);
+			const data = await response.json();
+			expect(data).toEqual([
+				{ single: 1 },
+				[{ batch: 2 }, { batch: 3 }],
+				[[`nested`, `array`]],
+				42
+			]);
+			expect(data.length).toBe(4);
+		});
+	});
+	describe(`Property-Based Tests (fast-check)`, () => {
+		describe(`Byte-Exactness Property`, () => {
+			test(`arbitrary byte sequences are preserved exactly`, async () => {
+				await fc.assert(fc.asyncProperty(
+					// Generate 1-10 chunks of arbitrary bytes (1-500 bytes each)
+					fc.array(fc.uint8Array({
+						minLength: 1,
+						maxLength: 500
+					}), {
+						minLength: 1,
+						maxLength: 10
+					}),
+					async (chunks) => {
+						const streamPath = `/v1/stream/fc-byte-exactness-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+						const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `PUT`,
+							headers: { "Content-Type": `application/octet-stream` }
+						});
+						expect([
+							200,
+							201,
+							204
+						]).toContain(createResponse.status);
+						for (const chunk of chunks) {
+							const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+								method: `POST`,
+								headers: { "Content-Type": `application/octet-stream` },
+								body: chunk
+							});
+							expect([200, 204]).toContain(response.status);
+						}
+						const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+						const expected = new Uint8Array(totalLength);
+						let offset = 0;
+						for (const chunk of chunks) {
+							expected.set(chunk, offset);
+							offset += chunk.length;
+						}
+						const accumulated = [];
+						let currentOffset = null;
+						let iterations = 0;
+						while (iterations < 100) {
+							iterations++;
+							const url = currentOffset ? `${getBaseUrl()}${streamPath}?offset=${encodeURIComponent(currentOffset)}` : `${getBaseUrl()}${streamPath}`;
+							const response = await fetch(url, { method: `GET` });
+							expect(response.status).toBe(200);
+							const buffer = await response.arrayBuffer();
+							const data = new Uint8Array(buffer);
+							if (data.length > 0) accumulated.push(...Array.from(data));
+							const nextOffset = response.headers.get(STREAM_OFFSET_HEADER);
+							const upToDate = response.headers.get(STREAM_UP_TO_DATE_HEADER);
+							if (upToDate === `true` && data.length === 0) break;
+							if (nextOffset === currentOffset) break;
+							currentOffset = nextOffset;
+						}
+						const result = new Uint8Array(accumulated);
+						expect(result.length).toBe(expected.length);
+						for (let i = 0; i < expected.length; i++) expect(result[i]).toBe(expected[i]);
+						return true;
+					}
+), { numRuns: 20 });
+			});
+			test(`single byte values cover full range (0-255)`, async () => {
+				await fc.assert(fc.asyncProperty(
+					// Generate a byte value from 0-255
+					fc.integer({
+						min: 0,
+						max: 255
+					}),
+					async (byteValue) => {
+						const streamPath = `/v1/stream/fc-single-byte-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+						await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `PUT`,
+							headers: { "Content-Type": `application/octet-stream` }
+						});
+						const chunk = new Uint8Array([byteValue]);
+						await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `POST`,
+							headers: { "Content-Type": `application/octet-stream` },
+							body: chunk
+						});
+						const response = await fetch(`${getBaseUrl()}${streamPath}`);
+						const buffer = await response.arrayBuffer();
+						const result = new Uint8Array(buffer);
+						expect(result.length).toBe(1);
+						expect(result[0]).toBe(byteValue);
+						return true;
+					}
+), { numRuns: 50 });
+			});
+		});
+		describe(`Operation Sequence Properties`, () => {
+			test(`random operation sequences maintain stream invariants`, async () => {
+				await fc.assert(fc.asyncProperty(
+					// Generate a sequence of operations
+					fc.array(fc.oneof(
+						// Append operation with random data
+						fc.uint8Array({
+							minLength: 1,
+							maxLength: 200
+						}).map((data) => ({
+							type: `append`,
+							data
+						})),
+						// Full read operation
+						fc.constant({ type: `read` }),
+						// Read from a saved offset (index into saved offsets array)
+						fc.integer({
+							min: 0,
+							max: 20
+						}).map((idx) => ({
+							type: `readFromOffset`,
+							offsetIndex: idx
+						}))
+), {
+						minLength: 5,
+						maxLength: 30
+					}),
+					async (operations) => {
+						const streamPath = `/v1/stream/fc-ops-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+						await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `PUT`,
+							headers: { "Content-Type": `application/octet-stream` }
+						});
+						const appendedData = [];
+						const savedOffsets = [];
+						for (const op of operations) if (op.type === `append`) {
+							const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+								method: `POST`,
+								headers: { "Content-Type": `application/octet-stream` },
+								body: op.data
+							});
+							expect([200, 204]).toContain(response.status);
+							appendedData.push(...Array.from(op.data));
+							const offset = response.headers.get(STREAM_OFFSET_HEADER);
+							if (offset) savedOffsets.push(offset);
+						} else if (op.type === `read`) {
+							const accumulated = [];
+							let currentOffset = null;
+							let iterations = 0;
+							while (iterations < 100) {
+								iterations++;
+								const url = currentOffset ? `${getBaseUrl()}${streamPath}?offset=${encodeURIComponent(currentOffset)}` : `${getBaseUrl()}${streamPath}`;
+								const response = await fetch(url, { method: `GET` });
+								const buffer = await response.arrayBuffer();
+								const data = new Uint8Array(buffer);
+								if (data.length > 0) accumulated.push(...Array.from(data));
+								const nextOffset = response.headers.get(STREAM_OFFSET_HEADER);
+								const upToDate = response.headers.get(STREAM_UP_TO_DATE_HEADER);
+								if (upToDate === `true` && data.length === 0) break;
+								if (nextOffset === currentOffset) break;
+								currentOffset = nextOffset;
+							}
+							expect(accumulated.length).toBe(appendedData.length);
+							for (let i = 0; i < appendedData.length; i++) expect(accumulated[i]).toBe(appendedData[i]);
+						} else {
+							if (savedOffsets.length === 0) continue;
+							const offsetIdx = op.offsetIndex % savedOffsets.length;
+							const offset = savedOffsets[offsetIdx];
+							const response = await fetch(`${getBaseUrl()}${streamPath}?offset=${encodeURIComponent(offset)}`, { method: `GET` });
+							expect(response.status).toBe(200);
+							const nextOffset = response.headers.get(STREAM_OFFSET_HEADER);
+							if (nextOffset) expect(nextOffset >= offset).toBe(true);
+						}
+						return true;
+					}
+), { numRuns: 15 });
+			});
+			test(`offsets are always monotonically increasing`, async () => {
+				await fc.assert(fc.asyncProperty(
+					// Generate multiple chunks to append
+					fc.array(fc.uint8Array({
+						minLength: 1,
+						maxLength: 100
+					}), {
+						minLength: 2,
+						maxLength: 15
+					}),
+					async (chunks) => {
+						const streamPath = `/v1/stream/fc-monotonic-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+						await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `PUT`,
+							headers: { "Content-Type": `application/octet-stream` }
+						});
+						const offsets = [];
+						for (const chunk of chunks) {
+							const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+								method: `POST`,
+								headers: { "Content-Type": `application/octet-stream` },
+								body: chunk
+							});
+							const offset = response.headers.get(STREAM_OFFSET_HEADER);
+							expect(offset).toBeDefined();
+							offsets.push(offset);
+						}
+						for (let i = 1; i < offsets.length; i++) expect(offsets[i] > offsets[i - 1]).toBe(true);
+						return true;
+					}
+), { numRuns: 25 });
+			});
+			test(`read-your-writes: data is immediately visible after append`, async () => {
+				await fc.assert(fc.asyncProperty(fc.uint8Array({
+					minLength: 1,
+					maxLength: 500
+				}), async (data) => {
+					const streamPath = `/v1/stream/fc-ryw-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+					await fetch(`${getBaseUrl()}${streamPath}`, {
+						method: `PUT`,
+						headers: { "Content-Type": `application/octet-stream` }
+					});
+					const appendResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+						method: `POST`,
+						headers: { "Content-Type": `application/octet-stream` },
+						body: data
+					});
+					expect([200, 204]).toContain(appendResponse.status);
+					const readResponse = await fetch(`${getBaseUrl()}${streamPath}`);
+					expect(readResponse.status).toBe(200);
+					const buffer = await readResponse.arrayBuffer();
+					const result = new Uint8Array(buffer);
+					expect(result.length).toBe(data.length);
+					for (let i = 0; i < data.length; i++) expect(result[i]).toBe(data[i]);
+					return true;
+				}), { numRuns: 30 });
+			});
+		});
+		describe(`Immutability Properties`, () => {
+			test(`data at offset never changes after additional appends`, async () => {
+				await fc.assert(fc.asyncProperty(
+					// Initial data and additional data to append
+					fc.uint8Array({
+						minLength: 1,
+						maxLength: 200
+					}),
+					fc.array(fc.uint8Array({
+						minLength: 1,
+						maxLength: 100
+					}), {
+						minLength: 1,
+						maxLength: 5
+					}),
+					async (initialData, additionalChunks) => {
+						const streamPath = `/v1/stream/fc-immutable-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+						await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `PUT`,
+							headers: { "Content-Type": `application/octet-stream` }
+						});
+						await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `POST`,
+							headers: { "Content-Type": `application/octet-stream` },
+							body: initialData
+						});
+						const initialRead = await fetch(`${getBaseUrl()}${streamPath}`);
+						const initialBuffer = await initialRead.arrayBuffer();
+						const initialResult = new Uint8Array(initialBuffer);
+						for (const chunk of additionalChunks) await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `POST`,
+							headers: { "Content-Type": `application/octet-stream` },
+							body: chunk
+						});
+						const rereadResponse = await fetch(`${getBaseUrl()}${streamPath}`);
+						const rereadBuffer = await rereadResponse.arrayBuffer();
+						const rereadResult = new Uint8Array(rereadBuffer);
+						expect(rereadResult.length).toBeGreaterThanOrEqual(initialResult.length);
+						for (let i = 0; i < initialResult.length; i++) expect(rereadResult[i]).toBe(initialResult[i]);
+						return true;
+					}
+), { numRuns: 20 });
+			});
+		});
+		describe(`Offset Validation Properties`, () => {
+			test(`should reject offsets with invalid characters`, async () => {
+				await fc.assert(fc.asyncProperty(
+					// Generate strings with at least one invalid character
+					fc.oneof(
+						// Strings with spaces
+						fc.tuple(fc.string(), fc.string()).map(([a, b]) => `${a} ${b}`),
+						// Strings with path traversal
+						fc.string().map((s) => `../${s}`),
+						fc.string().map((s) => `${s}/..`),
+						// Strings with null bytes
+						fc.string().map((s) => `${s}\u0000`),
+						// Strings with newlines
+						fc.string().map((s) => `${s}\n`),
+						fc.string().map((s) => `${s}\r\n`),
+						// Strings with commas
+						fc.tuple(fc.string(), fc.string()).map(([a, b]) => `${a},${b}`),
+						// Strings with slashes
+						fc.tuple(fc.string(), fc.string()).map(([a, b]) => `${a}/${b}`)
+),
+					async (badOffset) => {
+						const streamPath = `/v1/stream/fc-bad-offset-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+						await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `PUT`,
+							headers: { "Content-Type": `text/plain` },
+							body: `test`
+						});
+						const response = await fetch(`${getBaseUrl()}${streamPath}?offset=${encodeURIComponent(badOffset)}`, { method: `GET` });
+						expect(response.status).toBe(400);
+						return true;
+					}
+), { numRuns: 30 });
+			});
+		});
+		describe(`Sequence Ordering Properties`, () => {
+			test(`lexicographically ordered seq values are accepted`, async () => {
+				await fc.assert(fc.asyncProperty(
+					// Generate a sorted array of unique lexicographic strings
+					fc.array(fc.stringMatching(/^[0-9a-zA-Z]+$/), {
+						minLength: 2,
+						maxLength: 10
+					}).map((arr) => [...new Set(arr)].sort()).filter((arr) => arr.length >= 2),
+					async (seqValues) => {
+						const streamPath = `/v1/stream/fc-seq-order-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+						await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `PUT`,
+							headers: { "Content-Type": `text/plain` }
+						});
+						for (const seq of seqValues) {
+							const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+								method: `POST`,
+								headers: {
+									"Content-Type": `text/plain`,
+									[STREAM_SEQ_HEADER]: seq
+								},
+								body: `data-${seq}`
+							});
+							expect([200, 204]).toContain(response.status);
+						}
+						return true;
+					}
+), { numRuns: 20 });
+			});
+			test(`out-of-order seq values are rejected`, async () => {
+				await fc.assert(fc.asyncProperty(
+					// Generate two strings where the first is lexicographically greater
+					fc.tuple(fc.stringMatching(/^[0-9a-zA-Z]+$/), fc.stringMatching(/^[0-9a-zA-Z]+$/)).filter(([a, b]) => a > b && a.length > 0 && b.length > 0),
+					async ([firstSeq, secondSeq]) => {
+						const streamPath = `/v1/stream/fc-seq-reject-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+						await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `PUT`,
+							headers: { "Content-Type": `text/plain` }
+						});
+						const response1 = await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `POST`,
+							headers: {
+								"Content-Type": `text/plain`,
+								[STREAM_SEQ_HEADER]: firstSeq
+							},
+							body: `first`
+						});
+						expect([200, 204]).toContain(response1.status);
+						const response2 = await fetch(`${getBaseUrl()}${streamPath}`, {
+							method: `POST`,
+							headers: {
+								"Content-Type": `text/plain`,
+								[STREAM_SEQ_HEADER]: secondSeq
+							},
+							body: `second`
+						});
+						expect(response2.status).toBe(409);
+						return true;
+					}
+), { numRuns: 25 });
+			});
+		});
+	});
+}
+
+//#endregion
+export { runConformanceTests };