@durable-streams/server 0.1.2 → 0.1.4

package/dist/index.js

@@ -65,12 +65,40 @@ var StreamStore = class {
 	streams = new Map();
 	pendingLongPolls = [];
 	/**
+	* Check if a stream is expired based on TTL or Expires-At.
+	*/
+	isExpired(stream) {
+		const now = Date.now();
+		if (stream.expiresAt) {
+			const expiryTime = new Date(stream.expiresAt).getTime();
+			if (!Number.isFinite(expiryTime) || now >= expiryTime) return true;
+		}
+		if (stream.ttlSeconds !== void 0) {
+			const expiryTime = stream.createdAt + stream.ttlSeconds * 1e3;
+			if (now >= expiryTime) return true;
+		}
+		return false;
+	}
+	/**
+	* Get a stream, deleting it if expired.
+	* Returns undefined if stream doesn't exist or is expired.
+	*/
+	getIfNotExpired(path$2) {
+		const stream = this.streams.get(path$2);
+		if (!stream) return void 0;
+		if (this.isExpired(stream)) {
+			this.delete(path$2);
+			return void 0;
+		}
+		return stream;
+	}
+	/**
 	* Create a new stream.
 	* @throws Error if stream already exists with different config
 	* @returns existing stream if config matches (idempotent)
 	*/
 	create(path$2, options = {}) {
-		const existing = this.streams.get(path$2);
+		const existing = this.getIfNotExpired(path$2);
 		if (existing) {
 			const contentTypeMatches = (normalizeContentType(options.contentType) || `application/octet-stream`) === (normalizeContentType(existing.contentType) || `application/octet-stream`);
 			const ttlMatches = options.ttlSeconds === existing.ttlSeconds;
@@ -93,15 +121,16 @@ var StreamStore = class {
 	}
 	/**
 	* Get a stream by path.
+	* Returns undefined if stream doesn't exist or is expired.
 	*/
 	get(path$2) {
-		return this.streams.get(path$2);
+		return this.getIfNotExpired(path$2);
 	}
 	/**
-	* Check if a stream exists.
+	* Check if a stream exists (and is not expired).
 	*/
 	has(path$2) {
-		return this.streams.has(path$2);
+		return this.getIfNotExpired(path$2) !== void 0;
 	}
 	/**
 	* Delete a stream.
@@ -112,12 +141,12 @@ var StreamStore = class {
 	}
 	/**
 	* Append data to a stream.
-	* @throws Error if stream doesn't exist
+	* @throws Error if stream doesn't exist or is expired
 	* @throws Error if seq is lower than lastSeq
 	* @throws Error if JSON mode and array is empty
 	*/
 	append(path$2, data, options = {}) {
-		const stream = this.streams.get(path$2);
+		const stream = this.getIfNotExpired(path$2);
 		if (!stream) throw new Error(`Stream not found: ${path$2}`);
 		if (options.contentType && stream.contentType) {
 			const providedType = normalizeContentType(options.contentType);
@@ -134,9 +163,10 @@ var StreamStore = class {
 	}
 	/**
 	* Read messages from a stream starting at the given offset.
+	* @throws Error if stream doesn't exist or is expired
 	*/
 	read(path$2, offset) {
-		const stream = this.streams.get(path$2);
+		const stream = this.getIfNotExpired(path$2);
 		if (!stream) throw new Error(`Stream not found: ${path$2}`);
 		if (!offset || offset === `-1`) return {
 			messages: [...stream.messages],
@@ -155,9 +185,10 @@ var StreamStore = class {
 	/**
 	* Format messages for response.
 	* For JSON mode, wraps concatenated data in array brackets.
+	* @throws Error if stream doesn't exist or is expired
 	*/
 	formatResponse(path$2, messages) {
-		const stream = this.streams.get(path$2);
+		const stream = this.getIfNotExpired(path$2);
 		if (!stream) throw new Error(`Stream not found: ${path$2}`);
 		const totalSize = messages.reduce((sum, m) => sum + m.data.length, 0);
 		const concatenated = new Uint8Array(totalSize);
@@ -171,9 +202,10 @@ var StreamStore = class {
 	}
 	/**
 	* Wait for new messages (long-poll).
+	* @throws Error if stream doesn't exist or is expired
 	*/
 	async waitForMessages(path$2, offset, timeoutMs) {
-		const stream = this.streams.get(path$2);
+		const stream = this.getIfNotExpired(path$2);
 		if (!stream) throw new Error(`Stream not found: ${path$2}`);
 		const { messages } = this.read(path$2, offset);
 		if (messages.length > 0) return {
@@ -206,9 +238,10 @@ var StreamStore = class {
 	}
 	/**
 	* Get the current offset for a stream.
+	* Returns undefined if stream doesn't exist or is expired.
 	*/
 	getCurrentOffset(path$2) {
-		return this.streams.get(path$2)?.currentOffset;
+		return this.getIfNotExpired(path$2)?.currentOffset;
 	}
 	/**
 	* Clear all streams.
@@ -582,6 +615,35 @@ var FileBackedStreamStore = class {
 		};
 	}
 	/**
+	* Check if a stream is expired based on TTL or Expires-At.
+	*/
+	isExpired(meta) {
+		const now = Date.now();
+		if (meta.expiresAt) {
+			const expiryTime = new Date(meta.expiresAt).getTime();
+			if (!Number.isFinite(expiryTime) || now >= expiryTime) return true;
+		}
+		if (meta.ttlSeconds !== void 0) {
+			const expiryTime = meta.createdAt + meta.ttlSeconds * 1e3;
+			if (now >= expiryTime) return true;
+		}
+		return false;
+	}
+	/**
+	* Get stream metadata, deleting it if expired.
+	* Returns undefined if stream doesn't exist or is expired.
+	*/
+	getMetaIfNotExpired(streamPath) {
+		const key = `stream:${streamPath}`;
+		const meta = this.db.get(key);
+		if (!meta) return void 0;
+		if (this.isExpired(meta)) {
+			this.delete(streamPath);
+			return void 0;
+		}
+		return meta;
+	}
+	/**
 	* Close the store, closing all file handles and database.
 	* All data is already fsynced on each append, so no final flush needed.
 	*/
@@ -590,8 +652,7 @@ var FileBackedStreamStore = class {
 		await this.db.close();
 	}
 	async create(streamPath, options = {}) {
-		const key = `stream:${streamPath}`;
-		const existing = this.db.get(key);
+		const existing = this.getMetaIfNotExpired(streamPath);
 		if (existing) {
 			const normalizeMimeType = (ct) => (ct ?? `application/octet-stream`).toLowerCase();
 			const contentTypeMatches = normalizeMimeType(options.contentType) === normalizeMimeType(existing.contentType);
@@ -600,6 +661,7 @@ var FileBackedStreamStore = class {
 			if (contentTypeMatches && ttlMatches && expiresMatches) return this.streamMetaToStream(existing);
 			else throw new Error(`Stream already exists with different configuration: ${streamPath}`);
 		}
+		const key = `stream:${streamPath}`;
 		const streamMeta = {
 			path: streamPath,
 			contentType: options.contentType,
@@ -633,13 +695,11 @@ var FileBackedStreamStore = class {
 		return this.streamMetaToStream(streamMeta);
 	}
 	get(streamPath) {
-		const key = `stream:${streamPath}`;
-		const meta = this.db.get(key);
+		const meta = this.getMetaIfNotExpired(streamPath);
 		return meta ? this.streamMetaToStream(meta) : void 0;
 	}
 	has(streamPath) {
-		const key = `stream:${streamPath}`;
-		return this.db.get(key) !== void 0;
+		return this.getMetaIfNotExpired(streamPath) !== void 0;
 	}
 	delete(streamPath) {
 		const key = `stream:${streamPath}`;
@@ -657,8 +717,7 @@ var FileBackedStreamStore = class {
 		return true;
 	}
 	async append(streamPath, data, options = {}) {
-		const key = `stream:${streamPath}`;
-		const streamMeta = this.db.get(key);
+		const streamMeta = this.getMetaIfNotExpired(streamPath);
 		if (!streamMeta) throw new Error(`Stream not found: ${streamPath}`);
 		if (options.contentType && streamMeta.contentType) {
 			const providedType = normalizeContentType(options.contentType);
@@ -706,13 +765,13 @@ var FileBackedStreamStore = class {
 			lastSeq: options.seq ?? streamMeta.lastSeq,
 			totalBytes: streamMeta.totalBytes + processedData.length + 5
 		};
+		const key = `stream:${streamPath}`;
 		this.db.putSync(key, updatedMeta);
 		this.notifyLongPolls(streamPath);
 		return message;
 	}
 	read(streamPath, offset) {
-		const key = `stream:${streamPath}`;
-		const streamMeta = this.db.get(key);
+		const streamMeta = this.getMetaIfNotExpired(streamPath);
 		if (!streamMeta) throw new Error(`Stream not found: ${streamPath}`);
 		const startOffset = offset ?? `0000000000000000_0000000000000000`;
 		const startParts = startOffset.split(`_`).map(Number);
@@ -764,8 +823,7 @@ var FileBackedStreamStore = class {
 		};
 	}
 	async waitForMessages(streamPath, offset, timeoutMs) {
-		const key = `stream:${streamPath}`;
-		const streamMeta = this.db.get(key);
+		const streamMeta = this.getMetaIfNotExpired(streamPath);
 		if (!streamMeta) throw new Error(`Stream not found: ${streamPath}`);
 		const { messages } = this.read(streamPath, offset);
 		if (messages.length > 0) return {
@@ -799,10 +857,10 @@ var FileBackedStreamStore = class {
 	/**
 	* Format messages for response.
 	* For JSON mode, wraps concatenated data in array brackets.
+	* @throws Error if stream doesn't exist or is expired
 	*/
 	formatResponse(streamPath, messages) {
-		const key = `stream:${streamPath}`;
-		const streamMeta = this.db.get(key);
+		const streamMeta = this.getMetaIfNotExpired(streamPath);
 		if (!streamMeta) throw new Error(`Stream not found: ${streamPath}`);
 		const totalSize = messages.reduce((sum, m) => sum + m.data.length, 0);
 		const concatenated = new Uint8Array(totalSize);
@@ -815,8 +873,7 @@ var FileBackedStreamStore = class {
 		return concatenated;
 	}
 	getCurrentOffset(streamPath) {
-		const key = `stream:${streamPath}`;
-		const streamMeta = this.db.get(key);
+		const streamMeta = this.getMetaIfNotExpired(streamPath);
 		return streamMeta?.currentOffset;
 	}
 	clear() {
@@ -995,10 +1052,12 @@ const CURSOR_QUERY_PARAM = `cursor`;
 /**
 * Encode data for SSE format.
 * Per SSE spec, each line in the payload needs its own "data:" prefix.
-* Newlines in the payload become separate data: lines.
+* Line terminators in the payload (CR, LF, or CRLF) become separate data: lines.
+* This prevents CRLF injection attacks where malicious payloads could inject
+* fake SSE events using CR-only line terminators.
 */
 function encodeSSEData(payload) {
-	const lines = payload.split(`\n`);
+	const lines = payload.split(/\r\n|\r|\n/);
 	return lines.map((line) => `data: ${line}`).join(`\n`) + `\n\n`;
 }
 /**
@@ -1037,8 +1096,8 @@ var DurableStreamTestServer = class {
 	_url = null;
 	activeSSEResponses = new Set();
 	isShuttingDown = false;
-	/** Injected errors for testing retry/resilience */
-	injectedErrors = new Map();
+	/** Injected faults for testing retry/resilience */
+	injectedFaults = new Map();
 	constructor(options = {}) {
 		if (options.dataDir) this.store = new FileBackedStreamStore({ dataDir: options.dataDir });
 		else this.store = new StreamStore();
@@ -1123,30 +1182,71 @@ var DurableStreamTestServer = class {
 	/**
 	* Inject an error to be returned on the next N requests to a path.
 	* Used for testing retry/resilience behavior.
+	* @deprecated Use injectFault for full fault injection capabilities
 	*/
 	injectError(path$2, status, count = 1, retryAfter) {
-		this.injectedErrors.set(path$2, {
+		this.injectedFaults.set(path$2, {
 			status,
 			count,
 			retryAfter
 		});
 	}
 	/**
-	* Clear all injected errors.
+	* Inject a fault to be triggered on the next N requests to a path.
+	* Supports various fault types: delays, connection drops, body corruption, etc.
 	*/
-	clearInjectedErrors() {
-		this.injectedErrors.clear();
+	injectFault(path$2, fault) {
+		this.injectedFaults.set(path$2, {
+			count: 1,
+			...fault
+		});
+	}
+	/**
+	* Clear all injected faults.
+	*/
+	clearInjectedFaults() {
+		this.injectedFaults.clear();
 	}
 	/**
-	* Check if there's an injected error for this path and consume it.
-	* Returns the error config if one should be returned, null otherwise.
+	* Check if there's an injected fault for this path/method and consume it.
+	* Returns the fault config if one should be triggered, null otherwise.
 	*/
-	consumeInjectedError(path$2) {
-		const error = this.injectedErrors.get(path$2);
-		if (!error) return null;
-		error.count--;
-		if (error.count <= 0) this.injectedErrors.delete(path$2);
-		return error;
+	consumeInjectedFault(path$2, method) {
+		const fault = this.injectedFaults.get(path$2);
+		if (!fault) return null;
+		if (fault.method && fault.method.toUpperCase() !== method.toUpperCase()) return null;
+		if (fault.probability !== void 0 && Math.random() > fault.probability) return null;
+		fault.count--;
+		if (fault.count <= 0) this.injectedFaults.delete(path$2);
+		return fault;
+	}
+	/**
+	* Apply delay from fault config (including jitter).
+	*/
+	async applyFaultDelay(fault) {
+		if (fault.delayMs !== void 0 && fault.delayMs > 0) {
+			const jitter = fault.jitterMs ? Math.random() * fault.jitterMs : 0;
+			await new Promise((resolve) => setTimeout(resolve, fault.delayMs + jitter));
+		}
+	}
+	/**
+	* Apply body modifications from stored fault (truncation, corruption).
+	* Returns modified body, or original if no modifications needed.
+	*/
+	applyFaultBodyModification(res, body) {
+		const fault = res._injectedFault;
+		if (!fault) return body;
+		let modified = body;
+		if (fault.truncateBodyBytes !== void 0 && modified.length > fault.truncateBodyBytes) modified = modified.slice(0, fault.truncateBodyBytes);
+		if (fault.corruptBody && modified.length > 0) {
+			modified = new Uint8Array(modified);
+			const numCorrupt = Math.max(1, Math.floor(modified.length * .03));
+			for (let i = 0; i < numCorrupt; i++) {
+				const pos = Math.floor(Math.random() * modified.length);
+				modified[pos] = modified[pos] ^ 1 << Math.floor(Math.random() * 8);
+			}
+		}
+		return modified;
 	}
 	async handleRequest(req, res) {
 		const url = new URL(req.url ?? `/`, `http://${req.headers.host}`);
@@ -1156,6 +1256,8 @@ var DurableStreamTestServer = class {
 		res.setHeader(`access-control-allow-methods`, `GET, POST, PUT, DELETE, HEAD, OPTIONS`);
 		res.setHeader(`access-control-allow-headers`, `content-type, authorization, Stream-Seq, Stream-TTL, Stream-Expires-At`);
 		res.setHeader(`access-control-expose-headers`, `Stream-Next-Offset, Stream-Cursor, Stream-Up-To-Date, etag, content-type, content-encoding, vary`);
+		res.setHeader(`x-content-type-options`, `nosniff`);
+		res.setHeader(`cross-origin-resource-policy`, `cross-origin`);
 		if (method === `OPTIONS`) {
 			res.writeHead(204);
 			res.end();
@@ -1165,13 +1267,21 @@ var DurableStreamTestServer = class {
 			await this.handleTestInjectError(method, req, res);
 			return;
 		}
-		const injectedError = this.consumeInjectedError(path$2);
-		if (injectedError) {
-			const headers = { "content-type": `text/plain` };
-			if (injectedError.retryAfter !== void 0) headers[`retry-after`] = injectedError.retryAfter.toString();
-			res.writeHead(injectedError.status, headers);
-			res.end(`Injected error for testing`);
-			return;
+		const fault = this.consumeInjectedFault(path$2, method ?? `GET`);
+		if (fault) {
+			await this.applyFaultDelay(fault);
+			if (fault.dropConnection) {
+				res.socket?.destroy();
+				return;
+			}
+			if (fault.status !== void 0) {
+				const headers = { "content-type": `text/plain` };
+				if (fault.retryAfter !== void 0) headers[`retry-after`] = fault.retryAfter.toString();
+				res.writeHead(fault.status, headers);
+				res.end(`Injected error for testing`);
+				return;
+			}
+			if (fault.truncateBodyBytes !== void 0 || fault.corruptBody) res._injectedFault = fault;
 		}
 		try {
 			switch (method) {
@@ -1286,7 +1396,10 @@ var DurableStreamTestServer = class {
 			res.end();
 			return;
 		}
-		const headers = { [STREAM_OFFSET_HEADER]: stream.currentOffset };
+		const headers = {
+			[STREAM_OFFSET_HEADER]: stream.currentOffset,
+			"cache-control": `no-store`
+		};
 		if (stream.contentType) headers[`content-type`] = stream.contentType;
 		headers[`etag`] = `"${Buffer.from(path$2).toString(`base64`)}:-1:${stream.currentOffset}"`;
 		res.writeHead(200, headers);
@@ -1377,6 +1490,7 @@ var DurableStreamTestServer = class {
 				headers[`vary`] = `accept-encoding`;
 			}
 		}
+		finalData = this.applyFaultBodyModification(res, finalData);
 		res.writeHead(200, headers);
 		res.end(Buffer.from(finalData));
 	}
@@ -1389,7 +1503,9 @@ var DurableStreamTestServer = class {
 			"content-type": `text/event-stream`,
 			"cache-control": `no-cache`,
 			connection: `keep-alive`,
-			"access-control-allow-origin": `*`
+			"access-control-allow-origin": `*`,
+			"x-content-type-options": `nosniff`,
+			"cross-origin-resource-policy": `cross-origin`
 		});
 		let currentOffset = initialOffset;
 		let isConnected = true;
@@ -1460,7 +1576,7 @@ var DurableStreamTestServer = class {
 			seq,
 			contentType
 		}));
-		res.writeHead(200, { [STREAM_OFFSET_HEADER]: message.offset });
+		res.writeHead(204, { [STREAM_OFFSET_HEADER]: message.offset });
 		res.end();
 	}
 	/**
@@ -1491,12 +1607,29 @@ var DurableStreamTestServer = class {
 			const body = await this.readBody(req);
 			try {
 				const config = JSON.parse(new TextDecoder().decode(body));
-				if (!config.path || !config.status) {
+				if (!config.path) {
 					res.writeHead(400, { "content-type": `text/plain` });
-					res.end(`Missing required fields: path, status`);
+					res.end(`Missing required field: path`);
 					return;
 				}
-				this.injectError(config.path, config.status, config.count ?? 1, config.retryAfter);
+				const hasFaultType = config.status !== void 0 || config.delayMs !== void 0 || config.dropConnection || config.truncateBodyBytes !== void 0 || config.corruptBody;
+				if (!hasFaultType) {
+					res.writeHead(400, { "content-type": `text/plain` });
+					res.end(`Must specify at least one fault type: status, delayMs, dropConnection, truncateBodyBytes, or corruptBody`);
+					return;
+				}
+				this.injectFault(config.path, {
+					status: config.status,
+					count: config.count ?? 1,
+					retryAfter: config.retryAfter,
+					delayMs: config.delayMs,
+					dropConnection: config.dropConnection,
+					truncateBodyBytes: config.truncateBodyBytes,
+					probability: config.probability,
+					method: config.method,
+					corruptBody: config.corruptBody,
+					jitterMs: config.jitterMs
+				});
 				res.writeHead(200, { "content-type": `application/json` });
 				res.end(JSON.stringify({ ok: true }));
 			} catch {
@@ -1504,7 +1637,7 @@ var DurableStreamTestServer = class {
 				res.end(`Invalid JSON body`);
 			}
 		} else if (method === `DELETE`) {
-			this.clearInjectedErrors();
+			this.clearInjectedFaults();
 			res.writeHead(200, { "content-type": `application/json` });
 			res.end(JSON.stringify({ ok: true }));
 		} else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@durable-streams/server",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Node.js reference server implementation for Durable Streams",
   "author": "Durable Stream contributors",
   "license": "Apache-2.0",
@@ -39,15 +39,15 @@
   "dependencies": {
     "@neophi/sieve-cache": "^1.0.0",
     "lmdb": "^3.3.0",
-    "@durable-streams/client": "0.1.2",
-    "@durable-streams/state": "0.1.2"
+    "@durable-streams/client": "0.1.3",
+    "@durable-streams/state": "0.1.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "tsdown": "^0.9.0",
     "typescript": "^5.0.0",
-    "vitest": "^3.2.4",
-    "@durable-streams/server-conformance-tests": "0.1.2"
+    "vitest": "^4.0.0",
+    "@durable-streams/server-conformance-tests": "0.1.6"
   },
   "files": [
     "dist",

package/src/file-store.ts

@@ -332,6 +332,50 @@ export class FileBackedStreamStore {
     }
   }
 
+  /**
+   * Check if a stream is expired based on TTL or Expires-At.
+   */
+  private isExpired(meta: StreamMetadata): boolean {
+    const now = Date.now()
+
+    // Check absolute expiry time
+    if (meta.expiresAt) {
+      const expiryTime = new Date(meta.expiresAt).getTime()
+      // Treat invalid dates (NaN) as expired (fail closed)
+      if (!Number.isFinite(expiryTime) || now >= expiryTime) {
+        return true
+      }
+    }
+
+    // Check TTL (relative to creation time)
+    if (meta.ttlSeconds !== undefined) {
+      const expiryTime = meta.createdAt + meta.ttlSeconds * 1000
+      if (now >= expiryTime) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * Get stream metadata, deleting it if expired.
+   * Returns undefined if stream doesn't exist or is expired.
+   */
+  private getMetaIfNotExpired(streamPath: string): StreamMetadata | undefined {
+    const key = `stream:${streamPath}`
+    const meta = this.db.get(key) as StreamMetadata | undefined
+    if (!meta) {
+      return undefined
+    }
+    if (this.isExpired(meta)) {
+      // Delete expired stream
+      this.delete(streamPath)
+      return undefined
+    }
+    return meta
+  }
+
   /**
    * Close the store, closing all file handles and database.
    * All data is already fsynced on each append, so no final flush needed.
@@ -354,8 +398,8 @@ export class FileBackedStreamStore {
       initialData?: Uint8Array
     } = {}
   ): Promise<Stream> {
-    const key = `stream:${streamPath}`
-    const existing = this.db.get(key) as StreamMetadata | undefined
+    // Use getMetaIfNotExpired to treat expired streams as non-existent
+    const existing = this.getMetaIfNotExpired(streamPath)
 
     if (existing) {
       // Check if config matches (idempotent create)
@@ -379,6 +423,9 @@ export class FileBackedStreamStore {
       }
     }
 
+    // Define key for LMDB operations
+    const key = `stream:${streamPath}`
+
     // Initialize metadata
     const streamMeta: StreamMetadata = {
       path: streamPath,
@@ -430,14 +477,12 @@ export class FileBackedStreamStore {
   }
 
   get(streamPath: string): Stream | undefined {
-    const key = `stream:${streamPath}`
-    const meta = this.db.get(key) as StreamMetadata | undefined
+    const meta = this.getMetaIfNotExpired(streamPath)
     return meta ? this.streamMetaToStream(meta) : undefined
   }
 
   has(streamPath: string): boolean {
-    const key = `stream:${streamPath}`
-    return this.db.get(key) !== undefined
+    return this.getMetaIfNotExpired(streamPath) !== undefined
   }
 
   delete(streamPath: string): boolean {
@@ -489,8 +534,7 @@ export class FileBackedStreamStore {
       isInitialCreate?: boolean
     } = {}
   ): Promise<StreamMessage | null> {
-    const key = `stream:${streamPath}`
-    const streamMeta = this.db.get(key) as StreamMetadata | undefined
+    const streamMeta = this.getMetaIfNotExpired(streamPath)
 
     if (!streamMeta) {
       throw new Error(`Stream not found: ${streamPath}`)
@@ -583,6 +627,7 @@ export class FileBackedStreamStore {
       lastSeq: options.seq ?? streamMeta.lastSeq,
       totalBytes: streamMeta.totalBytes + processedData.length + 5, // +4 for length, +1 for newline
     }
+    const key = `stream:${streamPath}`
     this.db.putSync(key, updatedMeta)
 
     // 5. Notify long-polls (data is now readable from disk)
@@ -596,8 +641,7 @@ export class FileBackedStreamStore {
     streamPath: string,
     offset?: string
   ): { messages: Array<StreamMessage>; upToDate: boolean } {
-    const key = `stream:${streamPath}`
-    const streamMeta = this.db.get(key) as StreamMetadata | undefined
+    const streamMeta = this.getMetaIfNotExpired(streamPath)
 
     if (!streamMeta) {
       throw new Error(`Stream not found: ${streamPath}`)
@@ -690,8 +734,7 @@ export class FileBackedStreamStore {
     offset: string,
     timeoutMs: number
   ): Promise<{ messages: Array<StreamMessage>; timedOut: boolean }> {
-    const key = `stream:${streamPath}`
-    const streamMeta = this.db.get(key) as StreamMetadata | undefined
+    const streamMeta = this.getMetaIfNotExpired(streamPath)
 
     if (!streamMeta) {
       throw new Error(`Stream not found: ${streamPath}`)
@@ -729,13 +772,13 @@ export class FileBackedStreamStore {
   /**
    * Format messages for response.
    * For JSON mode, wraps concatenated data in array brackets.
+   * @throws Error if stream doesn't exist or is expired
    */
   formatResponse(
     streamPath: string,
     messages: Array<StreamMessage>
   ): Uint8Array {
-    const key = `stream:${streamPath}`
-    const streamMeta = this.db.get(key) as StreamMetadata | undefined
+    const streamMeta = this.getMetaIfNotExpired(streamPath)
 
     if (!streamMeta) {
       throw new Error(`Stream not found: ${streamPath}`)
@@ -759,8 +802,7 @@ export class FileBackedStreamStore {
   }
 
   getCurrentOffset(streamPath: string): string | undefined {
-    const key = `stream:${streamPath}`
-    const streamMeta = this.db.get(key) as StreamMetadata | undefined
+    const streamMeta = this.getMetaIfNotExpired(streamPath)
     return streamMeta?.currentOffset
   }