@durable-streams/server-conformance-tests 0.1.2 → 0.1.4

package/dist/cli.cjs

@@ -86,14 +86,19 @@ function getTestRunnerPath() {
 	if ((0, node_fs.existsSync)(runnerInDist)) return runnerInDist;
 	return runnerInSrc;
 }
+function findVitestBinary() {
+	const possiblePaths = [
+		(0, node_path.join)(__dirname$1, `..`, `node_modules`, `.bin`, `vitest`),
+		(0, node_path.join)(__dirname$1, `..`, `..`, `..`, `..`, `.bin`, `vitest`),
+		(0, node_path.join)(__dirname$1, `..`, `..`, `..`, `node_modules`, `.bin`, `vitest`)
+	];
+	for (const vitestPath of possiblePaths) if ((0, node_fs.existsSync)(vitestPath)) return vitestPath;
+	return `vitest`;
+}
 function runTests(baseUrl) {
 	return new Promise((resolvePromise) => {
 		const runnerPath = getTestRunnerPath();
-		const vitestBin = (0, node_path.join)(__dirname$1, `..`, `node_modules`, `.bin`, `vitest`);
-		const vitestBinAlt = (0, node_path.join)(__dirname$1, `..`, `..`, `..`, `node_modules`, `.bin`, `vitest`);
-		let vitestPath = `vitest`;
-		if ((0, node_fs.existsSync)(vitestBin)) vitestPath = vitestBin;
-		else if ((0, node_fs.existsSync)(vitestBinAlt)) vitestPath = vitestBinAlt;
+		const vitestPath = findVitestBinary();
 		const args = [
 			`run`,
 			runnerPath,
@@ -130,11 +135,7 @@ async function runWatch(baseUrl, watchPaths) {
 	const DEBOUNCE_MS = 300;
 	const spawnTests = () => {
 		const runnerPath = getTestRunnerPath();
-		const vitestBin = (0, node_path.join)(__dirname$1, `..`, `node_modules`, `.bin`, `vitest`);
-		const vitestBinAlt = (0, node_path.join)(__dirname$1, `..`, `..`, `..`, `node_modules`, `.bin`, `vitest`);
-		let vitestPath = `vitest`;
-		if ((0, node_fs.existsSync)(vitestBin)) vitestPath = vitestBin;
-		else if ((0, node_fs.existsSync)(vitestBinAlt)) vitestPath = vitestBinAlt;
+		const vitestPath = findVitestBinary();
 		const args = [
 			`run`,
 			runnerPath,

package/dist/cli.js

@@ -84,14 +84,19 @@ function getTestRunnerPath() {
 	if (existsSync(runnerInDist)) return runnerInDist;
 	return runnerInSrc;
 }
+function findVitestBinary() {
+	const possiblePaths = [
+		join(__dirname, `..`, `node_modules`, `.bin`, `vitest`),
+		join(__dirname, `..`, `..`, `..`, `..`, `.bin`, `vitest`),
+		join(__dirname, `..`, `..`, `..`, `node_modules`, `.bin`, `vitest`)
+	];
+	for (const vitestPath of possiblePaths) if (existsSync(vitestPath)) return vitestPath;
+	return `vitest`;
+}
 function runTests(baseUrl) {
 	return new Promise((resolvePromise) => {
 		const runnerPath = getTestRunnerPath();
-		const vitestBin = join(__dirname, `..`, `node_modules`, `.bin`, `vitest`);
-		const vitestBinAlt = join(__dirname, `..`, `..`, `..`, `node_modules`, `.bin`, `vitest`);
-		let vitestPath = `vitest`;
-		if (existsSync(vitestBin)) vitestPath = vitestBin;
-		else if (existsSync(vitestBinAlt)) vitestPath = vitestBinAlt;
+		const vitestPath = findVitestBinary();
 		const args = [
 			`run`,
 			runnerPath,
@@ -128,11 +133,7 @@ async function runWatch(baseUrl, watchPaths) {
 	const DEBOUNCE_MS = 300;
 	const spawnTests = () => {
 		const runnerPath = getTestRunnerPath();
-		const vitestBin = join(__dirname, `..`, `node_modules`, `.bin`, `vitest`);
-		const vitestBinAlt = join(__dirname, `..`, `..`, `..`, `node_modules`, `.bin`, `vitest`);
-		let vitestPath = `vitest`;
-		if (existsSync(vitestBin)) vitestPath = vitestBin;
-		else if (existsSync(vitestBinAlt)) vitestPath = vitestBinAlt;
+		const vitestPath = findVitestBinary();
 		const args = [
 			`run`,
 			runnerPath,

package/dist/index.cjs

@@ -1,3 +1,3 @@
-const require_src = require('./src-mPjxiipV.cjs');
+const require_src = require('./src-DK3GDgwo.cjs');
 
 exports.runConformanceTests = require_src.runConformanceTests

package/dist/index.js

@@ -1,3 +1,3 @@
-import { runConformanceTests } from "./src-DRIMnUPk.js";
+import { runConformanceTests } from "./src-DcbQ_SIQ.js";
 
 export { runConformanceTests };

package/dist/{src-mPjxiipV.cjs → src-DK3GDgwo.cjs}

@@ -1212,6 +1212,153 @@ function runConformanceTests(options) {
 			if (expiresHeader) (0, vitest.expect)(expiresHeader).toBeDefined();
 		});
 	});
+	(0, vitest.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)}`;
+		vitest.test.concurrent(`should return 404 on HEAD after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-expire-head`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				}
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			(0, vitest.expect)(headBefore.status).toBe(200);
+			await sleep(1500);
+			const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			(0, vitest.expect)(headAfter.status).toBe(404);
+		});
+		vitest.test.concurrent(`should return 404 on GET after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-expire-get`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				},
+				body: `test data`
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			(0, vitest.expect)(getBefore.status).toBe(200);
+			await sleep(1500);
+			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			(0, vitest.expect)(getAfter.status).toBe(404);
+		});
+		vitest.test.concurrent(`should return 404 on POST append after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-expire-post`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				}
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `appended data`
+			});
+			(0, vitest.expect)([200, 204]).toContain(postBefore.status);
+			await sleep(1500);
+			const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `more data`
+			});
+			(0, vitest.expect)(postAfter.status).toBe(404);
+		});
+		vitest.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 createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				}
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			(0, vitest.expect)(headBefore.status).toBe(200);
+			await sleep(1500);
+			const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			(0, vitest.expect)(headAfter.status).toBe(404);
+		});
+		vitest.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 createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				},
+				body: `test data`
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			(0, vitest.expect)(getBefore.status).toBe(200);
+			await sleep(1500);
+			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			(0, vitest.expect)(getAfter.status).toBe(404);
+		});
+		vitest.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 createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				}
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `appended data`
+			});
+			(0, vitest.expect)([200, 204]).toContain(postBefore.status);
+			await sleep(1500);
+			const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `more data`
+			});
+			(0, vitest.expect)(postAfter.status).toBe(404);
+		});
+		vitest.test.concurrent(`should allow recreating stream after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-recreate`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				},
+				body: `original data`
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			await sleep(1500);
+			const recreateResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `application/json`,
+					"Stream-TTL": `3600`
+				},
+				body: `["new data"]`
+			});
+			(0, vitest.expect)(recreateResponse.status).toBe(201);
+			const getResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			(0, vitest.expect)(getResponse.status).toBe(200);
+			const body = await getResponse.text();
+			(0, vitest.expect)(body).toContain(`new data`);
+		});
+	});
 	(0, vitest.describe)(`Caching and ETag`, () => {
 		(0, vitest.test)(`should generate ETag on GET responses`, async () => {
 			const streamPath = `/v1/stream/etag-generate-test-${Date.now()}`;

package/dist/{src-DRIMnUPk.js → src-DcbQ_SIQ.js}

@@ -1210,6 +1210,153 @@ function runConformanceTests(options) {
 			if (expiresHeader) expect(expiresHeader).toBeDefined();
 		});
 	});
+	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)}`;
+		test.concurrent(`should return 404 on HEAD after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-expire-head`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				}
+			});
+			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);
+		});
+		test.concurrent(`should return 404 on GET after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-expire-get`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				},
+				body: `test data`
+			});
+			expect(createResponse.status).toBe(201);
+			const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getBefore.status).toBe(200);
+			await sleep(1500);
+			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 () => {
+			const streamPath = uniquePath(`ttl-expire-post`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				}
+			});
+			expect(createResponse.status).toBe(201);
+			const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `appended data`
+			});
+			expect([200, 204]).toContain(postBefore.status);
+			await sleep(1500);
+			const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `more data`
+			});
+			expect(postAfter.status).toBe(404);
+		});
+		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 createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				}
+			});
+			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);
+		});
+		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 createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				},
+				body: `test data`
+			});
+			expect(createResponse.status).toBe(201);
+			const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getBefore.status).toBe(200);
+			await sleep(1500);
+			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 createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				}
+			});
+			expect(createResponse.status).toBe(201);
+			const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `appended data`
+			});
+			expect([200, 204]).toContain(postBefore.status);
+			await sleep(1500);
+			const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `more data`
+			});
+			expect(postAfter.status).toBe(404);
+		});
+		test.concurrent(`should allow recreating stream after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-recreate`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				},
+				body: `original data`
+			});
+			expect(createResponse.status).toBe(201);
+			await sleep(1500);
+			const recreateResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `application/json`,
+					"Stream-TTL": `3600`
+				},
+				body: `["new data"]`
+			});
+			expect(recreateResponse.status).toBe(201);
+			const getResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getResponse.status).toBe(200);
+			const body = await getResponse.text();
+			expect(body).toContain(`new data`);
+		});
+	});
 	describe(`Caching and ETag`, () => {
 		test(`should generate ETag on GET responses`, async () => {
 			const streamPath = `/v1/stream/etag-generate-test-${Date.now()}`;

package/dist/test-runner.cjs

@@ -1,5 +1,5 @@
 "use strict";
-const require_src = require('./src-mPjxiipV.cjs');
+const require_src = require('./src-DK3GDgwo.cjs');
 
 //#region src/test-runner.ts
 const baseUrl = process.env.CONFORMANCE_TEST_URL;

package/dist/test-runner.js

@@ -1,4 +1,4 @@
-import { runConformanceTests } from "./src-DRIMnUPk.js";
+import { runConformanceTests } from "./src-DcbQ_SIQ.js";
 
 //#region src/test-runner.ts
 const baseUrl = process.env.CONFORMANCE_TEST_URL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@durable-streams/server-conformance-tests",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Conformance test suite for Durable Streams server implementations",
   "author": "Durable Stream contributors",
   "license": "Apache-2.0",
@@ -23,6 +23,7 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
+    "server-conformance-tests": "./dist/cli.js",
     "durable-streams-server-conformance": "./dist/cli.js",
     "durable-streams-server-conformance-dev": "./bin/conformance-dev.mjs"
   },
@@ -47,7 +48,7 @@
   ],
   "dependencies": {
     "fast-check": "^4.4.0",
-    "vitest": "^3.2.4",
+    "vitest": "^4.0.0",
     "@durable-streams/client": "0.1.2"
   },
   "devDependencies": {

package/src/cli.ts

@@ -131,28 +131,31 @@ function getTestRunnerPath(): string {
   return runnerInSrc
 }
 
+// Find vitest binary in various possible locations
+function findVitestBinary(): string {
+  const possiblePaths = [
+    // Package's own node_modules (bundled dependency)
+    join(__dirname, `..`, `node_modules`, `.bin`, `vitest`),
+    // Hoisted location for scoped packages (@scope/package-name/dist -> node_modules/.bin)
+    join(__dirname, `..`, `..`, `..`, `..`, `.bin`, `vitest`),
+    // Monorepo root node_modules (for development)
+    join(__dirname, `..`, `..`, `..`, `node_modules`, `.bin`, `vitest`),
+  ]
+
+  for (const vitestPath of possiblePaths) {
+    if (existsSync(vitestPath)) {
+      return vitestPath
+    }
+  }
+
+  // Fallback to vitest in PATH
+  return `vitest`
+}
+
 function runTests(baseUrl: string): Promise<number> {
   return new Promise((resolvePromise) => {
     const runnerPath = getTestRunnerPath()
-
-    // Find vitest binary
-    const vitestBin = join(__dirname, `..`, `node_modules`, `.bin`, `vitest`)
-    const vitestBinAlt = join(
-      __dirname,
-      `..`,
-      `..`,
-      `..`,
-      `node_modules`,
-      `.bin`,
-      `vitest`
-    )
-
-    let vitestPath = `vitest`
-    if (existsSync(vitestBin)) {
-      vitestPath = vitestBin
-    } else if (existsSync(vitestBinAlt)) {
-      vitestPath = vitestBinAlt
-    }
+    const vitestPath = findVitestBinary()
 
     const args = [
       `run`,
@@ -199,25 +202,7 @@ async function runWatch(
 
   const spawnTests = (): ChildProcess => {
     const runnerPath = getTestRunnerPath()
-
-    // Find vitest binary
-    const vitestBin = join(__dirname, `..`, `node_modules`, `.bin`, `vitest`)
-    const vitestBinAlt = join(
-      __dirname,
-      `..`,
-      `..`,
-      `..`,
-      `node_modules`,
-      `.bin`,
-      `vitest`
-    )
-
-    let vitestPath = `vitest`
-    if (existsSync(vitestBin)) {
-      vitestPath = vitestBin
-    } else if (existsSync(vitestBinAlt)) {
-      vitestPath = vitestBinAlt
-    }
+    const vitestPath = findVitestBinary()
 
     const args = [
       `run`,

package/src/index.ts

@@ -1898,6 +1898,260 @@ export function runConformanceTests(options: ConformanceTestOptions): void {
     })
   })
 
+  // ============================================================================
+  // TTL Expiration Behavior Tests
+  // ============================================================================
+
+  describe(`TTL Expiration Behavior`, () => {
+    // Helper function to wait for a specified duration
+    const sleep = (ms: number) =>
+      new Promise((resolve) => setTimeout(resolve, ms))
+
+    // Helper to generate unique stream paths for concurrent tests
+    const uniquePath = (prefix: string) =>
+      `/v1/stream/${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`
+
+    // Run tests concurrently to avoid 6x 1.5s wait time
+    test.concurrent(`should return 404 on HEAD after TTL expires`, async () => {
+      const streamPath = uniquePath(`ttl-expire-head`)
+
+      // Create stream with 1 second TTL
+      const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `PUT`,
+        headers: {
+          "Content-Type": `text/plain`,
+          "Stream-TTL": `1`,
+        },
+      })
+      expect(createResponse.status).toBe(201)
+
+      // Verify stream exists immediately
+      const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `HEAD`,
+      })
+      expect(headBefore.status).toBe(200)
+
+      // Wait for TTL to expire (1 second + buffer)
+      await sleep(1500)
+
+      // Stream should no longer exist
+      const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `HEAD`,
+      })
+      expect(headAfter.status).toBe(404)
+    })
+
+    test.concurrent(`should return 404 on GET after TTL expires`, async () => {
+      const streamPath = uniquePath(`ttl-expire-get`)
+
+      // Create stream with 1 second TTL and some data
+      const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `PUT`,
+        headers: {
+          "Content-Type": `text/plain`,
+          "Stream-TTL": `1`,
+        },
+        body: `test data`,
+      })
+      expect(createResponse.status).toBe(201)
+
+      // Verify stream is readable immediately
+      const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `GET`,
+      })
+      expect(getBefore.status).toBe(200)
+
+      // Wait for TTL to expire
+      await sleep(1500)
+
+      // Stream should no longer exist
+      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 () => {
+        const streamPath = uniquePath(`ttl-expire-post`)
+
+        // Create stream with 1 second TTL
+        const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `text/plain`,
+            "Stream-TTL": `1`,
+          },
+        })
+        expect(createResponse.status).toBe(201)
+
+        // Verify append works immediately
+        const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `POST`,
+          headers: { "Content-Type": `text/plain` },
+          body: `appended data`,
+        })
+        expect([200, 204]).toContain(postBefore.status)
+
+        // Wait for TTL to expire
+        await sleep(1500)
+
+        // Append should fail - stream no longer exists
+        const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `POST`,
+          headers: { "Content-Type": `text/plain` },
+          body: `more data`,
+        })
+        expect(postAfter.status).toBe(404)
+      }
+    )
+
+    test.concurrent(
+      `should return 404 on HEAD after Expires-At passes`,
+      async () => {
+        const streamPath = uniquePath(`expires-at-head`)
+
+        // Create stream that expires in 1 second
+        const expiresAt = new Date(Date.now() + 1000).toISOString()
+        const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `text/plain`,
+            "Stream-Expires-At": expiresAt,
+          },
+        })
+        expect(createResponse.status).toBe(201)
+
+        // Verify stream exists immediately
+        const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `HEAD`,
+        })
+        expect(headBefore.status).toBe(200)
+
+        // Wait for expiry time to pass
+        await sleep(1500)
+
+        // Stream should no longer exist
+        const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `HEAD`,
+        })
+        expect(headAfter.status).toBe(404)
+      }
+    )
+
+    test.concurrent(
+      `should return 404 on GET after Expires-At passes`,
+      async () => {
+        const streamPath = uniquePath(`expires-at-get`)
+
+        // Create stream that expires in 1 second
+        const expiresAt = new Date(Date.now() + 1000).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)
+
+        // Verify stream is readable immediately
+        const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `GET`,
+        })
+        expect(getBefore.status).toBe(200)
+
+        // Wait for expiry time to pass
+        await sleep(1500)
+
+        // Stream should no longer exist
+        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`)
+
+        // Create stream that expires in 1 second
+        const expiresAt = new Date(Date.now() + 1000).toISOString()
+        const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `text/plain`,
+            "Stream-Expires-At": expiresAt,
+          },
+        })
+        expect(createResponse.status).toBe(201)
+
+        // Verify append works immediately
+        const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `POST`,
+          headers: { "Content-Type": `text/plain` },
+          body: `appended data`,
+        })
+        expect([200, 204]).toContain(postBefore.status)
+
+        // Wait for expiry time to pass
+        await sleep(1500)
+
+        // Append should fail - stream no longer exists
+        const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `POST`,
+          headers: { "Content-Type": `text/plain` },
+          body: `more data`,
+        })
+        expect(postAfter.status).toBe(404)
+      }
+    )
+
+    test.concurrent(
+      `should allow recreating stream after TTL expires`,
+      async () => {
+        const streamPath = uniquePath(`ttl-recreate`)
+
+        // Create stream with 1 second TTL
+        const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `text/plain`,
+            "Stream-TTL": `1`,
+          },
+          body: `original data`,
+        })
+        expect(createResponse.status).toBe(201)
+
+        // Wait for TTL to expire
+        await sleep(1500)
+
+        // Recreate stream with different config - should succeed (201)
+        const recreateResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `application/json`,
+            "Stream-TTL": `3600`,
+          },
+          body: `["new data"]`,
+        })
+        expect(recreateResponse.status).toBe(201)
+
+        // Verify the new stream is accessible
+        const getResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `GET`,
+        })
+        expect(getResponse.status).toBe(200)
+        const body = await getResponse.text()
+        expect(body).toContain(`new data`)
+      }
+    )
+  })
+
   // ============================================================================
   // Caching and ETag Tests
   // ============================================================================