@durable-streams/server-conformance-tests 0.2.3 → 0.3.0

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

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test, vi } 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";
 
@@ -991,17 +991,23 @@ function runConformanceTests(options) {
 				body: `historical`
 			});
 			const longPollPromise = fetch(`${getBaseUrl()}${streamPath}?offset=now&live=long-poll`, { method: `GET` });
-			await new Promise((r) => setTimeout(r, 100));
-			await fetch(`${getBaseUrl()}${streamPath}`, {
-				method: `POST`,
-				headers: { "Content-Type": `text/plain` },
-				body: `new data`
-			});
-			const response = await longPollPromise;
-			expect(response.status).toBe(200);
-			const text = await response.text();
-			expect(text).toBe(`new data`);
-			expect(response.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+			const interval = setInterval(() => {
+				fetch(`${getBaseUrl()}${streamPath}`, {
+					method: `POST`,
+					headers: { "Content-Type": `text/plain` },
+					body: `new data`
+				});
+			}, 50);
+			try {
+				const response = await longPollPromise;
+				expect(response.status).toBe(200);
+				const text = await response.text();
+				expect(text).toContain(`new data`);
+				expect(text).not.toContain(`historical`);
+				expect(response.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+			} finally {
+				clearInterval(interval);
+			}
 		});
 		test(`should support offset=now with SSE mode`, async () => {
 			const streamPath = `/v1/stream/offset-now-sse-test-${Date.now()}`;
@@ -1536,10 +1542,7 @@ function runConformanceTests(options) {
 			});
 			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);
-			}
+			expect(ttl).toBe(`3600`);
 		});
 		test(`should return Expires-At metadata if configured`, async () => {
 			const streamPath = `/v1/stream/head-expires-metadata-test-${Date.now()}`;
@@ -1559,6 +1562,16 @@ function runConformanceTests(options) {
 	describe(`TTL Expiration Behavior`, () => {
 		const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 		const uniquePath = (prefix) => `/v1/stream/${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+		const waitForDeletion = async (url, initialSleepMs, expectedStatuses = [404], timeoutMs = 5e3) => {
+			await sleep(initialSleepMs);
+			await vi.waitFor(async () => {
+				const head = await fetch(url, { method: `HEAD` });
+				expect(expectedStatuses).toContain(head.status);
+			}, {
+				timeout: timeoutMs,
+				interval: 200
+			});
+		};
 		test.concurrent(`should return 404 on HEAD after TTL expires`, async () => {
 			const streamPath = uniquePath(`ttl-expire-head`);
 			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
@@ -1571,11 +1584,11 @@ function runConformanceTests(options) {
 			expect(createResponse.status).toBe(201);
 			const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
 			expect(headBefore.status).toBe(200);
-			await sleep(1500);
-			const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
-			expect(headAfter.status).toBe(404);
+			await waitForDeletion(`${getBaseUrl()}${streamPath}`, 1e3);
+			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getAfter.status).toBe(404);
 		});
-		test.concurrent(`should return 404 on GET after TTL expires`, async () => {
+		test.concurrent(`should return 404 on GET after TTL expires (idle)`, async () => {
 			const streamPath = uniquePath(`ttl-expire-get`);
 			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
 				method: `PUT`,
@@ -1586,13 +1599,11 @@ function runConformanceTests(options) {
 				body: `test data`
 			});
 			expect(createResponse.status).toBe(201);
-			const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
-			expect(getBefore.status).toBe(200);
-			await sleep(1500);
+			await waitForDeletion(`${getBaseUrl()}${streamPath}`, 1e3);
 			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
 			expect(getAfter.status).toBe(404);
 		});
-		test.concurrent(`should return 404 on POST append after TTL expires`, async () => {
+		test.concurrent(`should return 404 on POST append after TTL expires (idle)`, async () => {
 			const streamPath = uniquePath(`ttl-expire-post`);
 			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
 				method: `PUT`,
@@ -1602,13 +1613,7 @@ function runConformanceTests(options) {
 				}
 			});
 			expect(createResponse.status).toBe(201);
-			const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
-				method: `POST`,
-				headers: { "Content-Type": `text/plain` },
-				body: `appended data`
-			});
-			expect(postBefore.status).toBe(204);
-			await sleep(1500);
+			await waitForDeletion(`${getBaseUrl()}${streamPath}`, 1e3);
 			const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
 				method: `POST`,
 				headers: { "Content-Type": `text/plain` },
@@ -1618,7 +1623,7 @@ function runConformanceTests(options) {
 		});
 		test.concurrent(`should return 404 on HEAD after Expires-At passes`, async () => {
 			const streamPath = uniquePath(`expires-at-head`);
-			const expiresAt = new Date(Date.now() + 1e3).toISOString();
+			const expiresAt = new Date(Date.now() + 3e3).toISOString();
 			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
 				method: `PUT`,
 				headers: {
@@ -1629,13 +1634,13 @@ function runConformanceTests(options) {
 			expect(createResponse.status).toBe(201);
 			const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
 			expect(headBefore.status).toBe(200);
-			await sleep(1500);
-			const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
-			expect(headAfter.status).toBe(404);
+			await waitForDeletion(`${getBaseUrl()}${streamPath}`, 3e3);
+			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getAfter.status).toBe(404);
 		});
 		test.concurrent(`should return 404 on GET after Expires-At passes`, async () => {
 			const streamPath = uniquePath(`expires-at-get`);
-			const expiresAt = new Date(Date.now() + 1e3).toISOString();
+			const expiresAt = new Date(Date.now() + 3e3).toISOString();
 			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
 				method: `PUT`,
 				headers: {
@@ -1647,13 +1652,13 @@ function runConformanceTests(options) {
 			expect(createResponse.status).toBe(201);
 			const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
 			expect(getBefore.status).toBe(200);
-			await sleep(1500);
+			await waitForDeletion(`${getBaseUrl()}${streamPath}`, 3e3);
 			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
 			expect(getAfter.status).toBe(404);
 		});
 		test.concurrent(`should return 404 on POST append after Expires-At passes`, async () => {
 			const streamPath = uniquePath(`expires-at-post`);
-			const expiresAt = new Date(Date.now() + 1e3).toISOString();
+			const expiresAt = new Date(Date.now() + 3e3).toISOString();
 			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
 				method: `PUT`,
 				headers: {
@@ -1668,7 +1673,7 @@ function runConformanceTests(options) {
 				body: `appended data`
 			});
 			expect(postBefore.status).toBe(204);
-			await sleep(1500);
+			await waitForDeletion(`${getBaseUrl()}${streamPath}`, 3e3);
 			const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
 				method: `POST`,
 				headers: { "Content-Type": `text/plain` },
@@ -1687,7 +1692,7 @@ function runConformanceTests(options) {
 				body: `original data`
 			});
 			expect(createResponse.status).toBe(201);
-			await sleep(1500);
+			await waitForDeletion(`${getBaseUrl()}${streamPath}`, 1e3);
 			const recreateResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
 				method: `PUT`,
 				headers: {
@@ -1702,6 +1707,81 @@ function runConformanceTests(options) {
 			const body = await getResponse.text();
 			expect(body).toContain(`new data`);
 		});
+		test.concurrent(`should extend TTL on write (sliding window)`, async () => {
+			const streamPath = uniquePath(`ttl-renew-write`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `2`
+				}
+			});
+			expect(createResponse.status).toBe(201);
+			await sleep(1500);
+			const appendResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `keep alive`
+			});
+			expect(appendResponse.status).toBe(204);
+			await sleep(1500);
+			const headResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			expect(headResponse.status).toBe(200);
+		});
+		test.concurrent(`should extend TTL on read (sliding window)`, async () => {
+			const streamPath = uniquePath(`ttl-renew-read`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `2`
+				},
+				body: `test data`
+			});
+			expect(createResponse.status).toBe(201);
+			await sleep(1500);
+			const readResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(readResponse.status).toBe(200);
+			await sleep(1500);
+			const headResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			expect(headResponse.status).toBe(200);
+		});
+		test.concurrent(`should NOT extend TTL on HEAD`, async () => {
+			const streamPath = uniquePath(`ttl-no-renew-head`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `2`
+				}
+			});
+			expect(createResponse.status).toBe(201);
+			await sleep(1500);
+			const headMid = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			expect(headMid.status).toBe(200);
+			await waitForDeletion(`${getBaseUrl()}${streamPath}`, 500);
+			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getAfter.status).toBe(404);
+		});
+		test.concurrent(`should NOT extend Expires-At on read or write`, async () => {
+			const streamPath = uniquePath(`expires-at-no-renew`);
+			const expiresAt = new Date(Date.now() + 4e3).toISOString();
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				},
+				body: `test data`
+			});
+			expect(createResponse.status).toBe(201);
+			await sleep(2e3);
+			const readResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(readResponse.status).toBe(200);
+			await waitForDeletion(`${getBaseUrl()}${streamPath}`, 2e3);
+			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getAfter.status).toBe(404);
+		});
 	});
 	describe(`Caching and ETag`, () => {
 		test(`should generate ETag on GET responses`, async () => {
@@ -2824,8 +2904,11 @@ function runConformanceTests(options) {
 						const finalResult = await readEntireStream(streamPath);
 						expect(finalResult).toEqual(expected);
 					}
-), { numRuns: 20 });
-			});
+), {
+					numRuns: 20,
+					interruptAfterTimeLimit: 1e4
+				});
+			}, 3e4);
 			test(`single byte values cover full range (0-255) with concurrent readers during write`, async () => {
 				await fc.assert(fc.asyncProperty(
 					// Generate a byte value from 0-255
@@ -2858,8 +2941,11 @@ function runConformanceTests(options) {
 						const finalResult = await readEntireStream(streamPath);
 						expect(finalResult).toEqual(expected);
 					}
-), { numRuns: 50 });
-			});
+), {
+					numRuns: 50,
+					interruptAfterTimeLimit: 1e4
+				});
+			}, 3e4);
 		});
 		describe(`Operation Sequence Properties`, () => {
 			test(`random operation sequences maintain stream invariants`, async () => {
@@ -2936,8 +3022,11 @@ function runConformanceTests(options) {
 						}
 						return true;
 					}
-), { numRuns: 15 });
-			});
+), {
+					numRuns: 15,
+					interruptAfterTimeLimit: 3e4
+				});
+			}, 6e4);
 			test(`offsets are always monotonically increasing`, async () => {
 				await fc.assert(fc.asyncProperty(
 					// Generate multiple chunks to append
@@ -5020,6 +5109,1650 @@ function runConformanceTests(options) {
 			});
 		});
 	});
+	describe(`Fork - Creation`, () => {
+		const STREAM_FORKED_FROM_HEADER = `Stream-Forked-From`;
+		const STREAM_FORK_OFFSET_HEADER = `Stream-Fork-Offset`;
+		const STREAM_CLOSED_HEADER_FORK = `Stream-Closed`;
+		const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		test(`should fork at current head (default)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-create-head-src-${id}`;
+			const forkPath = `/v1/stream/fork-create-head-fork-${id}`;
+			const createRes = await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source data`
+			});
+			expect(createRes.status).toBe(201);
+			const sourceOffset = createRes.headers.get(STREAM_OFFSET_HEADER);
+			expect(sourceOffset).toBeDefined();
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(forkRes.status).toBe(201);
+		});
+		test(`should fork at a specific offset`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-create-offset-src-${id}`;
+			const forkPath = `/v1/stream/fork-create-offset-fork-${id}`;
+			const createRes = await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `first`
+			});
+			expect(createRes.status).toBe(201);
+			const midOffset = createRes.headers.get(STREAM_OFFSET_HEADER);
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `second`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					[STREAM_FORK_OFFSET_HEADER]: midOffset
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(`first`);
+		});
+		test(`should fork at zero offset (empty inherited data)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-create-zero-src-${id}`;
+			const forkPath = `/v1/stream/fork-create-zero-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source data`
+			});
+			const zeroOffset = `0000000000000000_0000000000000000`;
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					[STREAM_FORK_OFFSET_HEADER]: zeroOffset
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(``);
+			expect(readRes.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+		});
+		test(`should fork at head offset (all source data inherited)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-create-all-src-${id}`;
+			const forkPath = `/v1/stream/fork-create-all-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `chunk1`
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `chunk2`
+			});
+			const headRes = await fetch(`${getBaseUrl()}${sourcePath}`, { method: `HEAD` });
+			const headOffset = headRes.headers.get(STREAM_OFFSET_HEADER);
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					[STREAM_FORK_OFFSET_HEADER]: headOffset
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(`chunk1chunk2`);
+		});
+		test(`should return 404 when forking a nonexistent stream`, async () => {
+			const id = uniqueId();
+			const forkPath = `/v1/stream/fork-create-404-fork-${id}`;
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: `/v1/stream/nonexistent-${id}`
+				}
+			});
+			expect(forkRes.status).toBe(404);
+		});
+		test(`should return 400 when forking at offset beyond stream length`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-create-beyond-src-${id}`;
+			const forkPath = `/v1/stream/fork-create-beyond-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `small data`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					[STREAM_FORK_OFFSET_HEADER]: `9999999999999999_9999999999999999`
+				}
+			});
+			expect(forkRes.status).toBe(400);
+		});
+		test(`should return 409 when forking to path already in use with different config`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-create-conflict-src-${id}`;
+			const forkPath = `/v1/stream/fork-create-conflict-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` }
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(forkRes.status).toBe(409);
+		});
+		test(`should fork a closed stream — fork starts open`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-create-closed-src-${id}`;
+			const forkPath = `/v1/stream/fork-create-closed-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `closed data`
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { [STREAM_CLOSED_HEADER_FORK]: `true` }
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			expect(forkRes.headers.get(STREAM_CLOSED_HEADER_FORK)).toBeNull();
+			const appendRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` fork data`
+			});
+			expect(appendRes.status).toBe(204);
+		});
+		test(`should fork an empty stream`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-create-empty-src-${id}`;
+			const forkPath = `/v1/stream/fork-create-empty-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(``);
+			expect(readRes.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+		});
+		test(`should fork preserving content-type when specified`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-create-ct-src-${id}`;
+			const forkPath = `/v1/stream/fork-create-ct-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` },
+				body: `[{"key":"value"}]`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `application/json`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			expect(forkRes.headers.get(`content-type`)).toBe(`application/json`);
+			const headRes = await fetch(`${getBaseUrl()}${forkPath}`, { method: `HEAD` });
+			expect(headRes.headers.get(`content-type`)).toBe(`application/json`);
+		});
+	});
+	describe(`Fork - Reading`, () => {
+		const STREAM_FORKED_FROM_HEADER = `Stream-Forked-From`;
+		const STREAM_FORK_OFFSET_HEADER = `Stream-Fork-Offset`;
+		const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		test(`should read entire fork (source + fork data)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-read-entire-src-${id}`;
+			const forkPath = `/v1/stream/fork-read-entire-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` fork`
+			});
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(`source fork`);
+		});
+		test(`should read only inherited portion`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-read-inherited-src-${id}`;
+			const forkPath = `/v1/stream/fork-read-inherited-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `inherited data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(`inherited data`);
+			expect(readRes.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+		});
+		test(`should read only fork's own data (starting past fork offset)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-read-own-src-${id}`;
+			const forkPath = `/v1/stream/fork-read-own-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source`
+			});
+			const sourceHead = await fetch(`${getBaseUrl()}${sourcePath}`, { method: `HEAD` });
+			const forkOffset = sourceHead.headers.get(STREAM_OFFSET_HEADER);
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `fork only`
+			});
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=${forkOffset}`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(`fork only`);
+		});
+		test(`should read across fork boundary`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-read-boundary-src-${id}`;
+			const forkPath = `/v1/stream/fork-read-boundary-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `A`
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `B`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `C`
+			});
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(`ABC`);
+		});
+		test(`should not show source appends after fork`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-read-isolation-src-${id}`;
+			const forkPath = `/v1/stream/fork-read-isolation-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `before`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` after`
+			});
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(`before`);
+		});
+		test(`should NOT include fork headers on HEAD/GET/PUT responses (forks are transparent)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-read-headers-src-${id}`;
+			const forkPath = `/v1/stream/fork-read-headers-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `data`
+			});
+			const putRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(putRes.headers.get(STREAM_FORKED_FROM_HEADER)).toBeNull();
+			expect(putRes.headers.get(STREAM_FORK_OFFSET_HEADER)).toBeNull();
+			const headRes = await fetch(`${getBaseUrl()}${forkPath}`, { method: `HEAD` });
+			expect(headRes.headers.get(STREAM_FORKED_FROM_HEADER)).toBeNull();
+			expect(headRes.headers.get(STREAM_FORK_OFFSET_HEADER)).toBeNull();
+			const getRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			await getRes.text();
+			expect(getRes.headers.get(STREAM_FORKED_FROM_HEADER)).toBeNull();
+			expect(getRes.headers.get(STREAM_FORK_OFFSET_HEADER)).toBeNull();
+		});
+	});
+	describe(`Fork - Appending`, () => {
+		const STREAM_FORKED_FROM_HEADER = `Stream-Forked-From`;
+		const STREAM_CLOSED_HEADER_FORK = `Stream-Closed`;
+		const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		test(`should append to a fork`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-append-src-${id}`;
+			const forkPath = `/v1/stream/fork-append-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			const appendRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` appended`
+			});
+			expect(appendRes.status).toBe(204);
+			expect(appendRes.headers.get(STREAM_OFFSET_HEADER)).toBeDefined();
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			const body = await readRes.text();
+			expect(body).toBe(`source appended`);
+		});
+		test(`should support idempotent producer on fork`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-append-idempotent-src-${id}`;
+			const forkPath = `/v1/stream/fork-append-idempotent-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			const append1 = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Producer-Id": `fork-producer-${id}`,
+					"Producer-Epoch": `0`,
+					"Producer-Seq": `0`
+				},
+				body: `msg1`
+			});
+			expect(append1.status).toBe(200);
+			const append1Retry = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Producer-Id": `fork-producer-${id}`,
+					"Producer-Epoch": `0`,
+					"Producer-Seq": `0`
+				},
+				body: `msg1`
+			});
+			expect(append1Retry.status).toBe(204);
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			const body = await readRes.text();
+			expect(body).toBe(`sourcemsg1`);
+		});
+		test(`should close forked stream independently`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-append-close-src-${id}`;
+			const forkPath = `/v1/stream/fork-append-close-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` final`
+			});
+			const closeRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { [STREAM_CLOSED_HEADER_FORK]: `true` }
+			});
+			expect([200, 204]).toContain(closeRes.status);
+			expect(closeRes.headers.get(STREAM_CLOSED_HEADER_FORK)).toBe(`true`);
+			const sourceHead = await fetch(`${getBaseUrl()}${sourcePath}`, { method: `HEAD` });
+			expect(sourceHead.headers.get(STREAM_CLOSED_HEADER_FORK)).toBeNull();
+		});
+		test(`should not affect fork when source is closed`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-append-src-close-src-${id}`;
+			const forkPath = `/v1/stream/fork-append-src-close-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { [STREAM_CLOSED_HEADER_FORK]: `true` }
+			});
+			const appendRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` fork data`
+			});
+			expect(appendRes.status).toBe(204);
+			const forkHead = await fetch(`${getBaseUrl()}${forkPath}`, { method: `HEAD` });
+			expect(forkHead.headers.get(STREAM_CLOSED_HEADER_FORK)).toBeNull();
+		});
+		test(`should append to source after fork — source independent`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-append-src-indep-src-${id}`;
+			const forkPath = `/v1/stream/fork-append-src-indep-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `initial`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			const appendRes = await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` extra`
+			});
+			expect(appendRes.status).toBe(204);
+			const sourceRead = await fetch(`${getBaseUrl()}${sourcePath}?offset=-1`);
+			const sourceBody = await sourceRead.text();
+			expect(sourceBody).toBe(`initial extra`);
+			const forkRead = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			const forkBody = await forkRead.text();
+			expect(forkBody).toBe(`initial`);
+		});
+	});
+	describe(`Fork - Recursive`, () => {
+		const STREAM_FORKED_FROM_HEADER = `Stream-Forked-From`;
+		const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		test(`should create a three-level fork chain`, async () => {
+			const id = uniqueId();
+			const level0 = `/v1/stream/fork-recursive-l0-${id}`;
+			const level1 = `/v1/stream/fork-recursive-l1-${id}`;
+			const level2 = `/v1/stream/fork-recursive-l2-${id}`;
+			await fetch(`${getBaseUrl()}${level0}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `L0`
+			});
+			const fork1Res = await fetch(`${getBaseUrl()}${level1}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level0
+				}
+			});
+			expect(fork1Res.status).toBe(201);
+			const fork2Res = await fetch(`${getBaseUrl()}${level2}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level1
+				}
+			});
+			expect(fork2Res.status).toBe(201);
+		});
+		test(`should fork at mid-point of inherited data`, async () => {
+			const id = uniqueId();
+			const level0 = `/v1/stream/fork-recursive-mid-l0-${id}`;
+			const level1 = `/v1/stream/fork-recursive-mid-l1-${id}`;
+			const level2 = `/v1/stream/fork-recursive-mid-l2-${id}`;
+			await fetch(`${getBaseUrl()}${level0}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `A`
+			});
+			await fetch(`${getBaseUrl()}${level0}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `B`
+			});
+			await fetch(`${getBaseUrl()}${level1}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level0
+				}
+			});
+			await fetch(`${getBaseUrl()}${level1}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `C`
+			});
+			const l1Head = await fetch(`${getBaseUrl()}${level1}`, { method: `HEAD` });
+			expect(l1Head.headers.get(STREAM_OFFSET_HEADER)).toBeDefined();
+			const fork2Res = await fetch(`${getBaseUrl()}${level2}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level1
+				}
+			});
+			expect(fork2Res.status).toBe(201);
+			const readRes = await fetch(`${getBaseUrl()}${level2}?offset=-1`);
+			const body = await readRes.text();
+			expect(body).toBe(`ABC`);
+		});
+		test(`should read correctly across three levels`, async () => {
+			const id = uniqueId();
+			const level0 = `/v1/stream/fork-recursive-read-l0-${id}`;
+			const level1 = `/v1/stream/fork-recursive-read-l1-${id}`;
+			const level2 = `/v1/stream/fork-recursive-read-l2-${id}`;
+			await fetch(`${getBaseUrl()}${level0}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `A`
+			});
+			await fetch(`${getBaseUrl()}${level1}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level0
+				}
+			});
+			await fetch(`${getBaseUrl()}${level1}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `B`
+			});
+			await fetch(`${getBaseUrl()}${level2}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level1
+				}
+			});
+			await fetch(`${getBaseUrl()}${level2}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `C`
+			});
+			const r0 = await (await fetch(`${getBaseUrl()}${level0}?offset=-1`)).text();
+			expect(r0).toBe(`A`);
+			const r1 = await (await fetch(`${getBaseUrl()}${level1}?offset=-1`)).text();
+			expect(r1).toBe(`AB`);
+			const r2 = await (await fetch(`${getBaseUrl()}${level2}?offset=-1`)).text();
+			expect(r2).toBe(`ABC`);
+		});
+		test(`should append at each level independently`, async () => {
+			const id = uniqueId();
+			const level0 = `/v1/stream/fork-recursive-indep-l0-${id}`;
+			const level1 = `/v1/stream/fork-recursive-indep-l1-${id}`;
+			const level2 = `/v1/stream/fork-recursive-indep-l2-${id}`;
+			await fetch(`${getBaseUrl()}${level0}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `X`
+			});
+			await fetch(`${getBaseUrl()}${level1}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level0
+				}
+			});
+			await fetch(`${getBaseUrl()}${level1}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `Y`
+			});
+			await fetch(`${getBaseUrl()}${level2}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level1
+				}
+			});
+			await fetch(`${getBaseUrl()}${level2}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `Z`
+			});
+			await fetch(`${getBaseUrl()}${level0}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `0`
+			});
+			await fetch(`${getBaseUrl()}${level1}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `1`
+			});
+			const r0 = await (await fetch(`${getBaseUrl()}${level0}?offset=-1`)).text();
+			expect(r0).toBe(`X0`);
+			const r1 = await (await fetch(`${getBaseUrl()}${level1}?offset=-1`)).text();
+			expect(r1).toBe(`XY1`);
+			const r2 = await (await fetch(`${getBaseUrl()}${level2}?offset=-1`)).text();
+			expect(r2).toBe(`XYZ`);
+		});
+	});
+	describe(`Fork - Live Modes`, () => {
+		const STREAM_FORKED_FROM_HEADER = `Stream-Forked-From`;
+		const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		test(`should return inherited data immediately on long-poll`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-live-inherited-src-${id}`;
+			const forkPath = `/v1/stream/fork-live-inherited-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `inherited data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), 3e3);
+			try {
+				const response = await fetch(`${getBaseUrl()}${forkPath}?offset=-1&live=long-poll`, {
+					method: `GET`,
+					signal: controller.signal
+				});
+				clearTimeout(timeoutId);
+				expect(response.status).toBe(200);
+				const body = await response.text();
+				expect(body).toBe(`inherited data`);
+				expect(response.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+			} catch (e) {
+				clearTimeout(timeoutId);
+				if (!(e instanceof Error && e.name === `AbortError`)) throw e;
+				expect(true).toBe(false);
+			}
+		});
+		test(`should wait for fork appends, not source appends, on long-poll at tail`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-live-tail-src-${id}`;
+			const forkPath = `/v1/stream/fork-live-tail-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			const forkHead = await fetch(`${getBaseUrl()}${forkPath}`, { method: `GET` });
+			await forkHead.text();
+			const forkOffset = forkHead.headers.get(STREAM_OFFSET_HEADER);
+			const longPollPromise = fetch(`${getBaseUrl()}${forkPath}?offset=${forkOffset}&live=long-poll`, { method: `GET` });
+			await new Promise((r) => setTimeout(r, 50));
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` source extra`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` fork new`
+			});
+			const response = await longPollPromise;
+			expect(response.status).toBe(200);
+			const body = await response.text();
+			expect(body).toBe(` fork new`);
+		}, getLongPollTestTimeoutMs());
+		test(`should stream fork data via SSE`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-live-sse-src-${id}`;
+			const forkPath = `/v1/stream/fork-live-sse-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `inherited`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` forked`
+			});
+			const { response, received } = await fetchSSE(`${getBaseUrl()}${forkPath}?offset=-1&live=sse`, {
+				untilContent: `forked`,
+				timeoutMs: 5e3,
+				maxChunks: 20
+			});
+			expect(response.status).toBe(200);
+			expect(received).toContain(`inherited`);
+			expect(received).toContain(`forked`);
+		});
+		test(`should handle long-poll handover at fork offset`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-live-handover-src-${id}`;
+			const forkPath = `/v1/stream/fork-live-handover-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1&live=long-poll`);
+			expect(readRes.status).toBe(200);
+			const firstBody = await readRes.text();
+			expect(firstBody).toBe(`source data`);
+			const nextOffset = readRes.headers.get(STREAM_OFFSET_HEADER);
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` fork append`
+			});
+			const readRes2 = await fetch(`${getBaseUrl()}${forkPath}?offset=${nextOffset}`);
+			expect(readRes2.status).toBe(200);
+			const secondBody = await readRes2.text();
+			expect(secondBody).toBe(` fork append`);
+		});
+	});
+	describe(`Fork - Deletion and Lifecycle`, () => {
+		const STREAM_FORKED_FROM_HEADER = `Stream-Forked-From`;
+		const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		const waitForStatus = async (url, expectedStatus, timeoutMs = 5e3) => {
+			await vi.waitFor(async () => {
+				const res = await fetch(url, { method: `HEAD` });
+				expect(res.status).toBe(expectedStatus);
+			}, {
+				timeout: timeoutMs,
+				interval: 200
+			});
+		};
+		test(`should delete fork without affecting source`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-del-src-unaffected-src-${id}`;
+			const forkPath = `/v1/stream/fork-del-src-unaffected-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `source data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			const deleteRes = await fetch(`${getBaseUrl()}${forkPath}`, { method: `DELETE` });
+			expect(deleteRes.status).toBe(204);
+			const forkRead = await fetch(`${getBaseUrl()}${forkPath}`, { method: `GET` });
+			expect(forkRead.status).toBe(404);
+			const sourceRead = await fetch(`${getBaseUrl()}${sourcePath}`, { method: `GET` });
+			expect(sourceRead.status).toBe(200);
+			const body = await sourceRead.text();
+			expect(body).toBe(`source data`);
+		});
+		test(`should soft-delete source while fork exists — fork still reads`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-del-soft-src-${id}`;
+			const forkPath = `/v1/stream/fork-del-soft-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `preserved data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			const deleteRes = await fetch(`${getBaseUrl()}${sourcePath}`, { method: `DELETE` });
+			expect(deleteRes.status).toBe(204);
+			const sourceHead = await fetch(`${getBaseUrl()}${sourcePath}`, { method: `HEAD` });
+			expect(sourceHead.status).toBe(410);
+			const forkRead = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(forkRead.status).toBe(200);
+			const body = await forkRead.text();
+			expect(body).toBe(`preserved data`);
+		});
+		test(`should block re-creation of soft-deleted source (PUT returns 409)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-del-block-recreate-src-${id}`;
+			const forkPath = `/v1/stream/fork-del-block-recreate-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `original`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, { method: `DELETE` });
+			const recreateRes = await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` }
+			});
+			expect(recreateRes.status).toBe(409);
+		});
+		test(`should return 410 for GET on soft-deleted source`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-del-soft-get-${id}`;
+			const forkPath = `/v1/stream/fork-del-soft-get-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, { method: `DELETE` });
+			const getRes = await fetch(`${getBaseUrl()}${sourcePath}?offset=-1`);
+			expect(getRes.status).toBe(410);
+		});
+		test(`should return 410 for POST on soft-deleted source`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-del-soft-post-${id}`;
+			const forkPath = `/v1/stream/fork-del-soft-post-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, { method: `DELETE` });
+			const postRes = await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `more data`
+			});
+			expect(postRes.status).toBe(410);
+		});
+		test(`should return 410 for DELETE on soft-deleted source`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-del-soft-del-${id}`;
+			const forkPath = `/v1/stream/fork-del-soft-del-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, { method: `DELETE` });
+			const deleteRes = await fetch(`${getBaseUrl()}${sourcePath}`, { method: `DELETE` });
+			expect(deleteRes.status).toBe(410);
+		});
+		test(`should return 409 for fork from soft-deleted source`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-del-soft-refork-${id}`;
+			const forkPath = `/v1/stream/fork-del-soft-refork-fork1-${id}`;
+			const fork2Path = `/v1/stream/fork-del-soft-refork-fork2-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, { method: `DELETE` });
+			const fork2Res = await fetch(`${getBaseUrl()}${fork2Path}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(fork2Res.status).toBe(409);
+		});
+		test(`should return 409 for fork with content-type mismatch`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-ct-mismatch-src-${id}`;
+			const forkPath = `/v1/stream/fork-ct-mismatch-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `data`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `application/json`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(forkRes.status).toBe(409);
+		});
+		test(`should cascade GC when last fork is deleted`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-del-cascade-src-${id}`;
+			const forkPath = `/v1/stream/fork-del-cascade-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `cascade data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, { method: `DELETE` });
+			const sourceHead1 = await fetch(`${getBaseUrl()}${sourcePath}`, { method: `HEAD` });
+			expect(sourceHead1.status).toBe(410);
+			const deleteFork = await fetch(`${getBaseUrl()}${forkPath}`, { method: `DELETE` });
+			expect(deleteFork.status).toBe(204);
+			await waitForStatus(`${getBaseUrl()}${sourcePath}`, 404);
+		});
+		test(`should cascade GC through three levels`, async () => {
+			const id = uniqueId();
+			const level0 = `/v1/stream/fork-del-cascade3-l0-${id}`;
+			const level1 = `/v1/stream/fork-del-cascade3-l1-${id}`;
+			const level2 = `/v1/stream/fork-del-cascade3-l2-${id}`;
+			await fetch(`${getBaseUrl()}${level0}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `root`
+			});
+			await fetch(`${getBaseUrl()}${level1}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level0
+				}
+			});
+			await fetch(`${getBaseUrl()}${level2}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level1
+				}
+			});
+			await fetch(`${getBaseUrl()}${level0}`, { method: `DELETE` });
+			await fetch(`${getBaseUrl()}${level1}`, { method: `DELETE` });
+			expect((await fetch(`${getBaseUrl()}${level0}`, { method: `HEAD` })).status).toBe(410);
+			expect((await fetch(`${getBaseUrl()}${level1}`, { method: `HEAD` })).status).toBe(410);
+			const deleteLevel2 = await fetch(`${getBaseUrl()}${level2}`, { method: `DELETE` });
+			expect(deleteLevel2.status).toBe(204);
+			expect((await fetch(`${getBaseUrl()}${level2}`, { method: `HEAD` })).status).toBe(404);
+			await waitForStatus(`${getBaseUrl()}${level1}`, 404);
+			await waitForStatus(`${getBaseUrl()}${level0}`, 404);
+		});
+		test(`should preserve data when deleting middle of chain`, async () => {
+			const id = uniqueId();
+			const level0 = `/v1/stream/fork-del-middle-l0-${id}`;
+			const level1 = `/v1/stream/fork-del-middle-l1-${id}`;
+			const level2 = `/v1/stream/fork-del-middle-l2-${id}`;
+			await fetch(`${getBaseUrl()}${level0}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `A`
+			});
+			await fetch(`${getBaseUrl()}${level1}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level0
+				}
+			});
+			await fetch(`${getBaseUrl()}${level1}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `B`
+			});
+			await fetch(`${getBaseUrl()}${level2}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: level1
+				}
+			});
+			await fetch(`${getBaseUrl()}${level2}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `C`
+			});
+			await fetch(`${getBaseUrl()}${level1}`, { method: `DELETE` });
+			expect((await fetch(`${getBaseUrl()}${level1}`, { method: `HEAD` })).status).toBe(410);
+			const readRes = await fetch(`${getBaseUrl()}${level2}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(`ABC`);
+			const l0Read = await fetch(`${getBaseUrl()}${level0}?offset=-1`);
+			expect(l0Read.status).toBe(200);
+			expect(await l0Read.text()).toBe(`A`);
+		});
+		test(`should keep source alive when all forks are deleted`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-del-allgone-src-${id}`;
+			const fork1Path = `/v1/stream/fork-del-allgone-f1-${id}`;
+			const fork2Path = `/v1/stream/fork-del-allgone-f2-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `alive`
+			});
+			await fetch(`${getBaseUrl()}${fork1Path}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${fork2Path}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${fork1Path}`, { method: `DELETE` });
+			await fetch(`${getBaseUrl()}${fork2Path}`, { method: `DELETE` });
+			const sourceRead = await fetch(`${getBaseUrl()}${sourcePath}?offset=-1`);
+			expect(sourceRead.status).toBe(200);
+			const body = await sourceRead.text();
+			expect(body).toBe(`alive`);
+		});
+	});
+	describe(`Fork - TTL and Expiry`, () => {
+		const STREAM_FORKED_FROM_HEADER = `Stream-Forked-From`;
+		const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+		const waitForDeletion = async (url, initialSleepMs, expectedStatuses = [404], timeoutMs = 5e3) => {
+			await sleep(initialSleepMs);
+			await vi.waitFor(async () => {
+				const head = await fetch(url, { method: `HEAD` });
+				expect(expectedStatuses).toContain(head.status);
+			}, {
+				timeout: timeoutMs,
+				interval: 200
+			});
+		};
+		test(`should inherit source expiry when none specified`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-ttl-inherit-src-${id}`;
+			const forkPath = `/v1/stream/fork-ttl-inherit-fork-${id}`;
+			const expiresAt = new Date(Date.now() + 36e5).toISOString();
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				},
+				body: `data`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			const forkHead = await fetch(`${getBaseUrl()}${forkPath}`, { method: `HEAD` });
+			expect(forkHead.status).toBe(200);
+			const forkExpires = forkHead.headers.get(`Stream-Expires-At`);
+			if (forkExpires) expect(new Date(forkExpires).getTime()).toBeLessThanOrEqual(new Date(expiresAt).getTime());
+		});
+		test(`should allow fork with shorter TTL`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-ttl-shorter-src-${id}`;
+			const forkPath = `/v1/stream/fork-ttl-shorter-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `3600`
+				},
+				body: `data`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					"Stream-TTL": `1800`
+				}
+			});
+			expect([200, 201]).toContain(forkRes.status);
+		});
+		test.concurrent(`should expire fork based on TTL (releases refcount)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-ttl-expire-src-${id}`;
+			const forkPath = `/v1/stream/fork-ttl-expire-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `60`
+				},
+				body: `data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					"Stream-TTL": `1`
+				}
+			});
+			const forkHeadBefore = await fetch(`${getBaseUrl()}${forkPath}`, { method: `HEAD` });
+			expect(forkHeadBefore.status).toBe(200);
+			await waitForDeletion(`${getBaseUrl()}${forkPath}`, 1e3);
+			const forkGetAfter = await fetch(`${getBaseUrl()}${forkPath}`, { method: `GET` });
+			expect(forkGetAfter.status).toBe(404);
+		});
+		test.concurrent(`should expire source with living forks (source goes 410)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-ttl-src-expire-src-${id}`;
+			const forkPath = `/v1/stream/fork-ttl-src-expire-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				},
+				body: `data`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await waitForDeletion(`${getBaseUrl()}${sourcePath}`, 1e3, [404, 410]);
+			const sourceGet = await fetch(`${getBaseUrl()}${sourcePath}`, { method: `GET` });
+			expect([404, 410]).toContain(sourceGet.status);
+			await waitForDeletion(`${getBaseUrl()}${forkPath}`, 0, [404, 410]);
+			const forkGet = await fetch(`${getBaseUrl()}${forkPath}`, { method: `GET` });
+			expect([404, 410]).toContain(forkGet.status);
+		});
+		test(`should inherit source TTL value when none specified`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-ttl-inherit-ttl-src-${id}`;
+			const forkPath = `/v1/stream/fork-ttl-inherit-ttl-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `3600`
+				},
+				body: `data`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			const forkHead = await fetch(`${getBaseUrl()}${forkPath}`, { method: `HEAD` });
+			expect(forkHead.status).toBe(200);
+			const forkTTL = forkHead.headers.get(`Stream-TTL`);
+			expect(forkTTL).toBe(`3600`);
+		});
+		test(`should use fork's own TTL when specified`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-own-ttl-src-${id}`;
+			const forkPath = `/v1/stream/fork-own-ttl-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `3600`
+				},
+				body: `data`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					"Stream-TTL": `7200`
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			const forkHead = await fetch(`${getBaseUrl()}${forkPath}`, { method: `HEAD` });
+			expect(forkHead.status).toBe(200);
+			const forkTTL = forkHead.headers.get(`Stream-TTL`);
+			expect(forkTTL).toBe(`7200`);
+		});
+		test.concurrent(`should allow fork to outlive source via TTL renewal`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-outlive-src-${id}`;
+			const forkPath = `/v1/stream/fork-outlive-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `2`
+				},
+				body: `source data`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					"Stream-TTL": `2`
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			await sleep(1500);
+			const forkRead = await fetch(`${getBaseUrl()}${forkPath}`, { method: `GET` });
+			expect(forkRead.status).toBe(200);
+			await waitForDeletion(`${getBaseUrl()}${sourcePath}`, 500, [404, 410]);
+			const sourceGet = await fetch(`${getBaseUrl()}${sourcePath}`, { method: `GET` });
+			expect([404, 410]).toContain(sourceGet.status);
+			const forkHead = await fetch(`${getBaseUrl()}${forkPath}`, { method: `HEAD` });
+			expect(forkHead.status).toBe(200);
+		});
+		test(`should allow fork Expires-At beyond source TTL expiry`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-expires-beyond-src-${id}`;
+			const forkPath = `/v1/stream/fork-expires-beyond-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `10`
+				},
+				body: `data`
+			});
+			const farFuture = new Date(Date.now() + 36e5).toISOString();
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					"Stream-Expires-At": farFuture
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			const forkHead = await fetch(`${getBaseUrl()}${forkPath}`, { method: `HEAD` });
+			expect(forkHead.status).toBe(200);
+			const forkExpiresAt = forkHead.headers.get(`Stream-Expires-At`);
+			if (forkExpiresAt) expect(new Date(forkExpiresAt).getTime()).toBeGreaterThan(Date.now() + 35e5);
+		});
+		test(`should allow fork TTL longer than source TTL (no capping)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-ttl-nocap-src-${id}`;
+			const forkPath = `/v1/stream/fork-ttl-nocap-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `10`
+				},
+				body: `data`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					"Stream-TTL": `99999`
+				}
+			});
+			expect([200, 201]).toContain(forkRes.status);
+			const forkHead = await fetch(`${getBaseUrl()}${forkPath}`, { method: `HEAD` });
+			expect(forkHead.status).toBe(200);
+			const forkTTL = forkHead.headers.get(`Stream-TTL`);
+			expect(forkTTL).toBe(`99999`);
+		});
+	});
+	describe(`Fork - JSON Mode`, () => {
+		const STREAM_FORKED_FROM_HEADER = `Stream-Forked-From`;
+		const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		test(`should fork a JSON stream`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-json-src-${id}`;
+			const forkPath = `/v1/stream/fork-json-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` },
+				body: `[{"event":"one"}]`
+			});
+			const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `application/json`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(forkRes.status).toBe(201);
+			expect(forkRes.headers.get(`content-type`)).toBe(`application/json`);
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			expect(readRes.headers.get(`content-type`)).toBe(`application/json`);
+			const body = JSON.parse(await readRes.text());
+			expect(Array.isArray(body)).toBe(true);
+			expect(body).toEqual([{ event: `one` }]);
+		});
+		test(`should read forked JSON across boundary`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-json-boundary-src-${id}`;
+			const forkPath = `/v1/stream/fork-json-boundary-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `application/json` },
+				body: `[{"from":"source"}]`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `application/json`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `application/json` },
+				body: `[{"from":"fork"}]`
+			});
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = JSON.parse(await readRes.text());
+			expect(Array.isArray(body)).toBe(true);
+			expect(body).toEqual([{ from: `source` }, { from: `fork` }]);
+		});
+	});
+	describe(`Fork - Edge Cases`, () => {
+		const STREAM_FORKED_FROM_HEADER = `Stream-Forked-From`;
+		const STREAM_FORK_OFFSET_HEADER = `Stream-Fork-Offset`;
+		const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		test(`should handle fork then immediately delete source`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-edge-imm-del-src-${id}`;
+			const forkPath = `/v1/stream/fork-edge-imm-del-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `ephemeral`
+			});
+			await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			await fetch(`${getBaseUrl()}${sourcePath}`, { method: `DELETE` });
+			const readRes = await fetch(`${getBaseUrl()}${forkPath}?offset=-1`);
+			expect(readRes.status).toBe(200);
+			const body = await readRes.text();
+			expect(body).toBe(`ephemeral`);
+		});
+		test(`should handle many forks of same stream (10 forks)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-edge-many-src-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `shared data`
+			});
+			const forkPaths = [];
+			for (let i = 0; i < 10; i++) {
+				const forkPath = `/v1/stream/fork-edge-many-f${i}-${id}`;
+				const forkRes = await fetch(`${getBaseUrl()}${forkPath}`, {
+					method: `PUT`,
+					headers: {
+						"Content-Type": `text/plain`,
+						[STREAM_FORKED_FROM_HEADER]: sourcePath
+					}
+				});
+				expect(forkRes.status).toBe(201);
+				forkPaths.push(forkPath);
+			}
+			for (const fp of forkPaths) {
+				const readRes = await fetch(`${getBaseUrl()}${fp}?offset=-1`);
+				expect(readRes.status).toBe(200);
+				const body = await readRes.text();
+				expect(body).toBe(`shared data`);
+			}
+			for (const fp of forkPaths) await fetch(`${getBaseUrl()}${fp}`, { method: `DELETE` });
+		});
+		test(`should fork at every offset position`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-edge-every-offset-src-${id}`;
+			const createRes = await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `A`
+			});
+			const offset0 = `0000000000000000_0000000000000000`;
+			const offset1 = createRes.headers.get(STREAM_OFFSET_HEADER);
+			const append1 = await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `B`
+			});
+			const offset2 = append1.headers.get(STREAM_OFFSET_HEADER);
+			const append2 = await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `C`
+			});
+			const offset3 = append2.headers.get(STREAM_OFFSET_HEADER);
+			const f0 = `/v1/stream/fork-edge-every-f0-${id}`;
+			const f0Res = await fetch(`${getBaseUrl()}${f0}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					[STREAM_FORK_OFFSET_HEADER]: offset0
+				}
+			});
+			expect(f0Res.status).toBe(201);
+			const f0Body = await (await fetch(`${getBaseUrl()}${f0}?offset=-1`)).text();
+			expect(f0Body).toBe(``);
+			const f1 = `/v1/stream/fork-edge-every-f1-${id}`;
+			await fetch(`${getBaseUrl()}${f1}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					[STREAM_FORK_OFFSET_HEADER]: offset1
+				}
+			});
+			const f1Body = await (await fetch(`${getBaseUrl()}${f1}?offset=-1`)).text();
+			expect(f1Body).toBe(`A`);
+			const f2 = `/v1/stream/fork-edge-every-f2-${id}`;
+			await fetch(`${getBaseUrl()}${f2}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					[STREAM_FORK_OFFSET_HEADER]: offset2
+				}
+			});
+			const f2Body = await (await fetch(`${getBaseUrl()}${f2}?offset=-1`)).text();
+			expect(f2Body).toBe(`AB`);
+			const f3 = `/v1/stream/fork-edge-every-f3-${id}`;
+			await fetch(`${getBaseUrl()}${f3}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath,
+					[STREAM_FORK_OFFSET_HEADER]: offset3
+				}
+			});
+			const f3Body = await (await fetch(`${getBaseUrl()}${f3}?offset=-1`)).text();
+			expect(f3Body).toBe(`ABC`);
+		});
+		test(`should handle idempotent fork creation (PUT twice)`, async () => {
+			const id = uniqueId();
+			const sourcePath = `/v1/stream/fork-edge-idempotent-src-${id}`;
+			const forkPath = `/v1/stream/fork-edge-idempotent-fork-${id}`;
+			await fetch(`${getBaseUrl()}${sourcePath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `data`
+			});
+			const fork1 = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(fork1.status).toBe(201);
+			const fork2 = await fetch(`${getBaseUrl()}${forkPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					[STREAM_FORKED_FROM_HEADER]: sourcePath
+				}
+			});
+			expect(fork2.status).toBe(200);
+		});
+	});
 }
 
 //#endregion