fix: ResponseCache.add() must not evict entries revalidatable via Last-Modified

add()'s expiry cleanup deleted any cache entry without an ETag as soon as it
was expired, ignoring Last-Modified entirely - unlike get(), which keeps an
expired entry with a Last-Modified date around as "stale" so it can be
revalidated with a conditional If-Modified-Since request.

This mismatch meant a response with a very small/zero max-age plus a
Last-Modified header (a common "always revalidate" pattern) was purged from
the cache immediately instead of being kept for revalidation, causing the
next request to be an ordinary uncached GET instead of a conditional one.
This also caused the intermittent SyncFetch.test.ts cache-revalidation
failures on master.

Adds deterministic regression tests in Fetch.test.ts and SyncFetch.test.ts:
an already-expired Last-Modified response with no ETag or Cache-Control
must stay cached so the next request is a conditional If-Modified-Since GET.

Author: marciomazza

packages/happy-dom/src/fetch/cache/response/ResponseCache.ts

@@ -201,8 +201,13 @@ export default class ResponseCache implements IResponseCache {
 			}
 		}
 
-		// Cache is invalid if it has expired and doesn't have an ETag.
-		if (!cachedResponse.etag && (!cachedResponse.expires || cachedResponse.expires < Date.now())) {
+		// Cache is invalid if it has expired and doesn't have an ETag
+		// or a Last-Modified date to revalidate against.
+		if (
+			!cachedResponse.etag &&
+			!cachedResponse.lastModified &&
+			(!cachedResponse.expires || cachedResponse.expires < Date.now())
+		) {
 			const entries = this.#entries.get(url);
 			if (entries) {
 				const index = entries.indexOf(cachedResponse);

packages/happy-dom/test/fetch/Fetch.test.ts

@@ -3856,6 +3856,76 @@ describe('Fetch', () => {
 			]);
 		});
 
+		it('Keeps an already-expired "Last-Modified" response in the cache so the next request revalidates it with "If-Modified-Since" (no "ETag", no "max-age").', async () => {
+			const window = new Window({ url: 'https://localhost:8080/' });
+			const url = 'https://localhost:8080/some/path';
+			const responseText = 'some text';
+			const requestArgs: Array<{
+				url: string;
+				options: { method: string; headers: { [k: string]: string } };
+			}> = [];
+
+			mockModule('https', {
+				request: (url, options) => {
+					requestArgs.push({ url, options });
+
+					return {
+						end: () => {},
+						on: (event: string, callback: (response: HTTP.IncomingMessage) => void) => {
+							if (event === 'response') {
+								if (options.headers['If-Modified-Since']) {
+									const response = <HTTP.IncomingMessage>Stream.Readable.from([]);
+
+									response.statusCode = 304;
+									response.statusMessage = 'Not Modified';
+									response.headers = {};
+									response.rawHeaders = ['last-modified', 'Mon, 11 Dec 2023 02:00:00 GMT'];
+
+									callback(response);
+								} else {
+									async function* generate(): AsyncGenerator<string> {
+										yield responseText;
+									}
+
+									const response = <HTTP.IncomingMessage>Stream.Readable.from(generate());
+
+									response.statusCode = 200;
+									response.statusMessage = 'OK';
+									response.headers = {};
+									// Already stale (Expires in the past) but revalidatable via Last-Modified, no ETag, no Cache-Control.
+									response.rawHeaders = [
+										'content-type',
+										'text/html',
+										'content-length',
+										String(responseText.length),
+										'last-modified',
+										'Mon, 11 Dec 2023 01:00:00 GMT',
+										'expires',
+										'Wed, 21 Oct 2015 07:28:00 GMT'
+									];
+
+									callback(response);
+								}
+							}
+						},
+						setTimeout: () => {}
+					};
+				}
+			});
+
+			await (await window.fetch(url)).text();
+
+			const response2 = await window.fetch(url);
+			await response2.text();
+
+			expect(requestArgs.length).toBe(2);
+			expect(requestArgs[1].options.headers['If-Modified-Since']).toBe(
+				'Mon, 11 Dec 2023 01:00:00 GMT'
+			);
+			expect(response2.status).toBe(200);
+			expect(response2.headers.get('Last-Modified')).toBe('Mon, 11 Dec 2023 02:00:00 GMT');
+		});
+
 		it('Updates cache after a failed revalidation with a "If-Modified-Since" request for a GET response with "Cache-Control" set to a "max-age".', async () => {
 			const window = new Window({ url: 'https://localhost:8080/' });
 			const url = '/some/path';

packages/happy-dom/test/fetch/SyncFetch.test.ts

@@ -3056,6 +3056,61 @@ describe('SyncFetch', () => {
 			]);
 		});
 
+		it('Keeps an already-expired "Last-Modified" response in the cache so the next request revalidates it with "If-Modified-Since" (no "ETag", no "max-age").', async () => {
+			browserFrame.url = 'https://localhost:8080/';
+
+			const url = 'https://localhost:8080/some/path';
+			const responseText = 'some text';
+			const requestArgs: string[] = [];
+
+			mockModule('child_process', {
+				execFileSync: (_command: string, args: string[]) => {
+					requestArgs.push(args[1]);
+
+					if (args[1].includes('If-Modified-Since')) {
+						return JSON.stringify({
+							error: null,
+							incomingMessage: {
+								statusCode: 304,
+								statusMessage: 'Not Modified',
+								rawHeaders: ['last-modified', 'Mon, 11 Dec 2023 02:00:00 GMT'],
+								data: ''
+							}
+						});
+					}
+					return JSON.stringify({
+						error: null,
+						incomingMessage: {
+							statusCode: 200,
+							statusMessage: 'OK',
+							// Already stale (Expires in the past) but revalidatable via Last-Modified, no ETag, no Cache-Control.
+							rawHeaders: [
+								'content-type',
+								'text/html',
+								'content-length',
+								String(responseText.length),
+								'last-modified',
+								'Mon, 11 Dec 2023 01:00:00 GMT',
+								'expires',
+								'Wed, 21 Oct 2015 07:28:00 GMT'
+							],
+							data: Buffer.from(responseText).toString('base64')
+						}
+					});
+				}
+			});
+
+			new SyncFetch({ browserFrame, window, url }).send();
+
+			const response2 = new SyncFetch({ browserFrame, window, url }).send();
+
+			expect(requestArgs.length).toBe(2);
+			expect(requestArgs[1]).toContain('If-Modified-Since');
+			expect(requestArgs[1]).toContain('Mon, 11 Dec 2023 01:00:00 GMT');
+			expect(response2.status).toBe(200);
+			expect(response2.headers.get('Last-Modified')).toBe('Mon, 11 Dec 2023 02:00:00 GMT');
+		});
+
 		it('Updates cache after a failed revalidation with a "If-Modified-Since" request for a GET response with "Cache-Control" set to a "max-age".', async () => {
 			browserFrame.url = 'https://localhost:8080/';