feat(cache): lazy re-index disk entries into LRU on pod restart

runtime/caches/lrucache.ts

@@ -58,9 +58,27 @@ function createLruCacheStorage(cacheStorageInner: CacheStorage): CacheStorage {
           assertNoOptions(options);
           const cacheKey = await requestURLSHA1(request);
           if (fileCache.has(cacheKey)) {
-            const result = cacheInner.match(cacheKey);
-            return result;
+            return cacheInner.match(cacheKey);
           }
+          // Lazy re-index: on a cold LRU (e.g. after pod restart), check if the file
+          // exists on disk. If still valid, re-index into the LRU so eviction is managed
+          // normally from this point on. If expired, delete the orphaned file and miss.
+          // TODO: add a background sweep at startup that deletes expired orphaned files
+          // that are never re-accessed — they accumulate on disk across restarts and are
+          // never evicted without this sweep.
+          const response = await cacheInner.match(cacheKey);
+          if (!response) return undefined;
+          const expires = response.headers.get("expires");
+          const length = response.headers.get("content-length");
+          if (expires && length) {
+            const ttl = Date.parse(expires) - Date.now() + STALE_TTL_PERIOD;
+            if (ttl > 0) {
+              fileCache.set(cacheKey, true, { size: parseInt(length), ttl });
+              return response;
+            }
+          }
+          // Expired or missing metadata — delete the orphaned file and treat as a miss.
+          cacheInner.delete(cacheKey).catch(() => {});
           return undefined;
         },
         put: async (

runtime/caches/mod.test.ts

@@ -137,3 +137,154 @@ Deno.test({
 });
 
 // TODO TESTAR O CENARIO ONDE O RESPONSE N TEM LENGTH
+
+// ---------------------------------------------------------------------------
+// Lazy re-index tests
+// ---------------------------------------------------------------------------
+
+const STALE_TTL_PERIOD_MS = parseInt(
+  Deno.env.get("STALE_TTL_PERIOD") ?? "30000",
+);
+
+/**
+ * Helper: build a testCacheStorage where `open` returns a *shared* map so we
+ * can simulate "disk" surviving an LRU restart.
+ */
+const sharedMapCacheStorage = (
+  map: Map<RequestInfo | URL, Response>,
+): CacheStorage => {
+  const getUrl = (request: RequestInfo | URL) =>
+    (request as Request).url ?? request.toString();
+  return {
+    delete: () => {
+      map.clear();
+      return Promise.resolve(true);
+    },
+    has: NOT_IMPLEMENTED,
+    keys: NOT_IMPLEMENTED,
+    match: NOT_IMPLEMENTED,
+    open: () =>
+      Promise.resolve({
+        add: NOT_IMPLEMENTED,
+        addAll: NOT_IMPLEMENTED,
+        delete: (request: RequestInfo | URL) =>
+          Promise.resolve(Boolean(map.delete(getUrl(request)))),
+        keys: NOT_IMPLEMENTED,
+        match: (request: RequestInfo | URL) =>
+          Promise.resolve(map.get(getUrl(request))),
+        matchAll: NOT_IMPLEMENTED,
+        put: (request: RequestInfo | URL, response: Response) => {
+          map.set(getUrl(request), response);
+          return Promise.resolve();
+        },
+      } as Cache),
+  };
+};
+
+Deno.test({
+  name: "lru_cache_lazy_reindex: valid entry is served after LRU restart",
+  sanitizeResources: false,
+  sanitizeOps: false,
+}, async () => {
+  const disk = new Map<RequestInfo | URL, Response>();
+  const storage1 = sharedMapCacheStorage(disk);
+
+  // --- first LRU lifetime: put an entry ---
+  const cache1 = await headersCache(lruCache(storage1)).open(CACHE_NAME);
+  const futureExpires = new Date(Date.now() + 60_000).toUTCString();
+  await cache1.put(
+    createRequest(100),
+    new Response("cached-body", {
+      headers: {
+        "content-length": "11",
+        expires: futureExpires,
+      },
+    }),
+  );
+
+  // --- simulate pod restart: new LRU over the *same* disk map ---
+  const storage2 = sharedMapCacheStorage(disk);
+  const cache2 = await headersCache(lruCache(storage2)).open(CACHE_NAME);
+
+  const response = await cache2.match(createRequest(100));
+  assertNotEquals(response, undefined);
+});
+
+Deno.test({
+  name: "lru_cache_lazy_reindex: truly expired entry is evicted on access",
+  sanitizeResources: false,
+  sanitizeOps: false,
+}, async () => {
+  const disk = new Map<RequestInfo | URL, Response>();
+  const storage1 = sharedMapCacheStorage(disk);
+
+  const cache1 = await headersCache(lruCache(storage1)).open(CACHE_NAME);
+  // Expired well before now, even accounting for STALE_TTL_PERIOD
+  const pastExpires = new Date(
+    Date.now() - STALE_TTL_PERIOD_MS - 60_000,
+  ).toUTCString();
+  await cache1.put(
+    createRequest(200),
+    new Response("old-body", {
+      headers: {
+        "content-length": "8",
+        expires: pastExpires,
+      },
+    }),
+  );
+
+  // --- simulate pod restart ---
+  const storage2 = sharedMapCacheStorage(disk);
+  const cache2 = await headersCache(lruCache(storage2)).open(CACHE_NAME);
+
+  const response = await cache2.match(createRequest(200));
+  assertEquals(response, undefined);
+});
+
+Deno.test({
+  name: "lru_cache_lazy_reindex: entry missing from disk is a miss",
+  sanitizeResources: false,
+  sanitizeOps: false,
+}, async () => {
+  // Empty disk — nothing was ever written
+  const disk = new Map<RequestInfo | URL, Response>();
+  const storage = sharedMapCacheStorage(disk);
+  const cache = await headersCache(lruCache(storage)).open(CACHE_NAME);
+
+  const response = await cache.match(createRequest(300));
+  assertEquals(response, undefined);
+});
+
+Deno.test({
+  name:
+    "lru_cache_lazy_reindex: re-indexed entry stays accessible on subsequent accesses",
+  sanitizeResources: false,
+  sanitizeOps: false,
+}, async () => {
+  const disk = new Map<RequestInfo | URL, Response>();
+  const storage1 = sharedMapCacheStorage(disk);
+
+  const cache1 = await headersCache(lruCache(storage1)).open(CACHE_NAME);
+  const futureExpires = new Date(Date.now() + 60_000).toUTCString();
+  await cache1.put(
+    createRequest(400),
+    new Response("repeat-body", {
+      headers: {
+        "content-length": "11",
+        expires: futureExpires,
+      },
+    }),
+  );
+
+  // --- simulate pod restart ---
+  const storage2 = sharedMapCacheStorage(disk);
+  const cache2 = await headersCache(lruCache(storage2)).open(CACHE_NAME);
+
+  // First access triggers lazy re-index
+  const first = await cache2.match(createRequest(400));
+  assertNotEquals(first, undefined);
+
+  // Second access should hit the LRU directly (no re-index needed)
+  const second = await cache2.match(createRequest(400));
+  assertNotEquals(second, undefined);
+});