in memory cache of DID lookups as well as files

hosting-service/src/index.ts

···
 import { logger } from './lib/observability';
 import { mkdirSync, existsSync } from 'fs';
 import { backfillCache } from './lib/backfill';
+import { startDomainCacheCleanup, stopDomainCacheCleanup } from './lib/db';
 
 const PORT = process.env.PORT ? parseInt(process.env.PORT) : 3001;
 const CACHE_DIR = process.env.CACHE_DIR || './cache/sites';
···
   mkdirSync(CACHE_DIR, { recursive: true });
   console.log('Created cache directory:', CACHE_DIR);
 }
+
+// Start domain cache cleanup
+startDomainCacheCleanup();
 
 // Start firehose worker with observability logger
 const firehose = new FirehoseWorker((msg, data) => {
···
 process.on('SIGINT', async () => {
   console.log('\n🛑 Shutting down...');
   firehose.stop();
+  stopDomainCacheCleanup();
   server.close();
   process.exit(0);
 });
···
 process.on('SIGTERM', async () => {
   console.log('\n🛑 Shutting down...');
   firehose.stop();
+  stopDomainCacheCleanup();
   server.close();
   process.exit(0);
 });

hosting-service/src/lib/cache.ts

···
+// In-memory LRU cache for file contents and metadata
+
+interface CacheEntry<T> {
+  value: T;
+  size: number;
+  timestamp: number;
+}
+
+interface CacheStats {
+  hits: number;
+  misses: number;
+  evictions: number;
+  currentSize: number;
+  currentCount: number;
+}
+
+export class LRUCache<T> {
+  private cache: Map<string, CacheEntry<T>>;
+  private maxSize: number;
+  private maxCount: number;
+  private currentSize: number;
+  private stats: CacheStats;
+
+  constructor(maxSize: number, maxCount: number) {
+    this.cache = new Map();
+    this.maxSize = maxSize;
+    this.maxCount = maxCount;
+    this.currentSize = 0;
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      evictions: 0,
+      currentSize: 0,
+      currentCount: 0,
+    };
+  }
+
+  get(key: string): T | null {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.stats.misses++;
+      return null;
+    }
+
+    // Move to end (most recently used)
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+
+    this.stats.hits++;
+    return entry.value;
+  }
+
+  set(key: string, value: T, size: number): void {
+    // Remove existing entry if present
+    if (this.cache.has(key)) {
+      const existing = this.cache.get(key)!;
+      this.currentSize -= existing.size;
+      this.cache.delete(key);
+    }
+
+    // Evict entries if needed
+    while (
+      (this.cache.size >= this.maxCount || this.currentSize + size > this.maxSize) &&
+      this.cache.size > 0
+    ) {
+      const firstKey = this.cache.keys().next().value;
+      if (!firstKey) break; // Should never happen, but satisfy TypeScript
+      const firstEntry = this.cache.get(firstKey);
+      if (!firstEntry) break; // Should never happen, but satisfy TypeScript
+      this.cache.delete(firstKey);
+      this.currentSize -= firstEntry.size;
+      this.stats.evictions++;
+    }
+
+    // Add new entry
+    this.cache.set(key, {
+      value,
+      size,
+      timestamp: Date.now(),
+    });
+    this.currentSize += size;
+
+    // Update stats
+    this.stats.currentSize = this.currentSize;
+    this.stats.currentCount = this.cache.size;
+  }
+
+  delete(key: string): boolean {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+
+    this.cache.delete(key);
+    this.currentSize -= entry.size;
+    this.stats.currentSize = this.currentSize;
+    this.stats.currentCount = this.cache.size;
+    return true;
+  }
+
+  // Invalidate all entries for a specific site
+  invalidateSite(did: string, rkey: string): number {
+    const prefix = `${did}:${rkey}:`;
+    let count = 0;
+
+    for (const key of Array.from(this.cache.keys())) {
+      if (key.startsWith(prefix)) {
+        this.delete(key);
+        count++;
+      }
+    }
+
+    return count;
+  }
+
+  // Get cache size
+  size(): number {
+    return this.cache.size;
+  }
+
+  clear(): void {
+    this.cache.clear();
+    this.currentSize = 0;
+    this.stats.currentSize = 0;
+    this.stats.currentCount = 0;
+  }
+
+  getStats(): CacheStats {
+    return { ...this.stats };
+  }
+
+  // Get cache hit rate
+  getHitRate(): number {
+    const total = this.stats.hits + this.stats.misses;
+    return total === 0 ? 0 : (this.stats.hits / total) * 100;
+  }
+}
+
+// File metadata cache entry
+export interface FileMetadata {
+  encoding?: 'gzip';
+  mimeType: string;
+}
+
+// Global cache instances
+const FILE_CACHE_SIZE = 100 * 1024 * 1024; // 100MB
+const FILE_CACHE_COUNT = 500;
+const METADATA_CACHE_COUNT = 2000;
+
+export const fileCache = new LRUCache<Buffer>(FILE_CACHE_SIZE, FILE_CACHE_COUNT);
+export const metadataCache = new LRUCache<FileMetadata>(1024 * 1024, METADATA_CACHE_COUNT); // 1MB for metadata
+export const rewrittenHtmlCache = new LRUCache<Buffer>(50 * 1024 * 1024, 200); // 50MB for rewritten HTML
+
+// Helper to generate cache keys
+export function getCacheKey(did: string, rkey: string, filePath: string, suffix?: string): string {
+  const base = `${did}:${rkey}:${filePath}`;
+  return suffix ? `${base}:${suffix}` : base;
+}
+
+// Invalidate all caches for a site
+export function invalidateSiteCache(did: string, rkey: string): void {
+  const fileCount = fileCache.invalidateSite(did, rkey);
+  const metaCount = metadataCache.invalidateSite(did, rkey);
+  const htmlCount = rewrittenHtmlCache.invalidateSite(did, rkey);
+
+  console.log(`[Cache] Invalidated site ${did}:${rkey} - ${fileCount} files, ${metaCount} metadata, ${htmlCount} HTML`);
+}
+
+// Get overall cache statistics
+export function getCacheStats() {
+  return {
+    files: fileCache.getStats(),
+    fileHitRate: fileCache.getHitRate(),
+    metadata: metadataCache.getStats(),
+    metadataHitRate: metadataCache.getHitRate(),
+    rewrittenHtml: rewrittenHtmlCache.getStats(),
+    rewrittenHtmlHitRate: rewrittenHtmlCache.getHitRate(),
+  };
+}

hosting-service/src/lib/db.ts

···
   }
 );
 
+// Domain lookup cache with TTL
+const DOMAIN_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+interface CachedDomain<T> {
+  value: T;
+  timestamp: number;
+}
+
+const domainCache = new Map<string, CachedDomain<DomainLookup | null>>();
+const customDomainCache = new Map<string, CachedDomain<CustomDomainLookup | null>>();
+
+let cleanupInterval: NodeJS.Timeout | null = null;
+
+export function startDomainCacheCleanup() {
+  if (cleanupInterval) return;
+
+  cleanupInterval = setInterval(() => {
+    const now = Date.now();
+
+    for (const [key, entry] of domainCache.entries()) {
+      if (now - entry.timestamp > DOMAIN_CACHE_TTL) {
+        domainCache.delete(key);
+      }
+    }
+
+    for (const [key, entry] of customDomainCache.entries()) {
+      if (now - entry.timestamp > DOMAIN_CACHE_TTL) {
+        customDomainCache.delete(key);
+      }
+    }
+  }, 30 * 60 * 1000); // Run every 30 minutes
+}
+
+export function stopDomainCacheCleanup() {
+  if (cleanupInterval) {
+    clearInterval(cleanupInterval);
+    cleanupInterval = null;
+  }
+}
+
 export interface DomainLookup {
   did: string;
   rkey: string | null;
···
 export async function getWispDomain(domain: string): Promise<DomainLookup | null> {
   const key = domain.toLowerCase();
 
+  // Check cache first
+  const cached = domainCache.get(key);
+  if (cached && Date.now() - cached.timestamp < DOMAIN_CACHE_TTL) {
+    return cached.value;
+  }
+
   // Query database
   const result = await sql<DomainLookup[]>`
     SELECT did, rkey FROM domains WHERE domain = ${key} LIMIT 1
   `;
   const data = result[0] || null;
 
+  // Cache the result
+  domainCache.set(key, { value: data, timestamp: Date.now() });
+
   return data;
 }
 
 export async function getCustomDomain(domain: string): Promise<CustomDomainLookup | null> {
   const key = domain.toLowerCase();
 
+  // Check cache first
+  const cached = customDomainCache.get(key);
+  if (cached && Date.now() - cached.timestamp < DOMAIN_CACHE_TTL) {
+    return cached.value;
+  }
+
   // Query database
   const result = await sql<CustomDomainLookup[]>`
     SELECT id, domain, did, rkey, verified FROM custom_domains
···
   `;
   const data = result[0] || null;
 
+  // Cache the result
+  customDomainCache.set(key, { value: data, timestamp: Date.now() });
+
   return data;
 }
 
 export async function getCustomDomainByHash(hash: string): Promise<CustomDomainLookup | null> {
+  const key = `hash:${hash}`;
+
+  // Check cache first
+  const cached = customDomainCache.get(key);
+  if (cached && Date.now() - cached.timestamp < DOMAIN_CACHE_TTL) {
+    return cached.value;
+  }
+
   // Query database
   const result = await sql<CustomDomainLookup[]>`
     SELECT id, domain, did, rkey, verified FROM custom_domains
     WHERE id = ${hash} AND verified = true LIMIT 1
   `;
   const data = result[0] || null;
+
+  // Cache the result
+  customDomainCache.set(key, { value: data, timestamp: Date.now() });
 
   return data;
 }

hosting-service/src/lib/firehose.ts

···
 import { isRecord, validateRecord } from '../lexicon/types/place/wisp/fs'
 import { Firehose } from '@atproto/sync'
 import { IdResolver } from '@atproto/identity'
+import { invalidateSiteCache } from './cache'
 
 const CACHE_DIR = './cache/sites'
 
···
 			return
 		}
 
+		// Invalidate in-memory caches before updating
+		invalidateSiteCache(did, site)
+
 		// Cache the record with verified CID (uses atomic swap internally)
 		// All instances cache locally for edge serving
 		await downloadAndCacheSite(
···
 			})
 		}
 
-		// Delete cache
+		// Invalidate in-memory caches
+		invalidateSiteCache(did, site)
+
+		// Delete disk cache
 		this.deleteCache(did, site)
 
 		this.log('Successfully processed delete', { did, site })

hosting-service/src/server.ts

···
 import { getWispDomain, getCustomDomain, getCustomDomainByHash } from './lib/db';
 import { resolveDid, getPdsForDid, fetchSiteRecord, downloadAndCacheSite, getCachedFilePath, isCached, sanitizePath, shouldCompressMimeType } from './lib/utils';
 import { rewriteHtmlPaths, isHtmlContent } from './lib/html-rewriter';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync } from 'fs';
+import { readFile, access } from 'fs/promises';
 import { lookup } from 'mime-types';
 import { logger, observabilityMiddleware, observabilityErrorHandler, logCollector, errorTracker, metricsCollector } from './lib/observability';
+import { fileCache, metadataCache, rewrittenHtmlCache, getCacheKey, type FileMetadata } from './lib/cache';
 
 const BASE_HOST = process.env.BASE_HOST || 'wisp.place';
 
···
   return validRkeyPattern.test(rkey);
 }
 
+/**
+ * Async file existence check
+ */
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // Helper to serve files from cache
 async function serveFromCache(did: string, rkey: string, filePath: string) {
   // Default to index.html if path is empty or ends with /
···
     requestPath += 'index.html';
   }
 
+  const cacheKey = getCacheKey(did, rkey, requestPath);
   const cachedFile = getCachedFilePath(did, rkey, requestPath);
 
-  if (existsSync(cachedFile)) {
-    const content = readFileSync(cachedFile);
+  // Check in-memory cache first
+  let content = fileCache.get(cacheKey);
+  let meta = metadataCache.get(cacheKey);
+
+  if (!content && await fileExists(cachedFile)) {
+    // Read from disk and cache
+    content = await readFile(cachedFile);
+    fileCache.set(cacheKey, content, content.length);
+
     const metaFile = `${cachedFile}.meta`;
+    if (await fileExists(metaFile)) {
+      const metaJson = await readFile(metaFile, 'utf-8');
+      meta = JSON.parse(metaJson);
+      metadataCache.set(cacheKey, meta!, JSON.stringify(meta).length);
+    }
+  }
 
-    console.log(`[DEBUG SERVE] ${requestPath}: file size=${content.length} bytes, metaFile exists=${existsSync(metaFile)}`);
+  if (content) {
+    // Build headers with caching
+    const headers: Record<string, string> = {};
 
-    // Check if file has compression metadata
-    if (existsSync(metaFile)) {
-      const meta = JSON.parse(readFileSync(metaFile, 'utf-8'));
-      console.log(`[DEBUG SERVE] ${requestPath}: meta=${JSON.stringify(meta)}`);
-      
-      // Check actual content for gzip magic bytes
-      if (content.length >= 2) {
-        const hasGzipMagic = content[0] === 0x1f && content[1] === 0x8b;
-        console.log(`[DEBUG SERVE] ${requestPath}: has gzip magic bytes=${hasGzipMagic}`);
-      }
-      
-      if (meta.encoding === 'gzip' && meta.mimeType) {
-        // Use shared function to determine if this should be served compressed
-        const shouldServeCompressed = shouldCompressMimeType(meta.mimeType);
-        
-        if (!shouldServeCompressed) {
-          // This shouldn't happen if caching is working correctly, but handle it gracefully
-          console.log(`[DEBUG SERVE] ${requestPath}: decompressing file that shouldn't be compressed (${meta.mimeType})`);
-          const { gunzipSync } = await import('zlib');
-          const decompressed = gunzipSync(content);
-          console.log(`[DEBUG SERVE] ${requestPath}: decompressed from ${content.length} to ${decompressed.length} bytes`);
-          return new Response(decompressed, {
-            headers: {
-              'Content-Type': meta.mimeType,
-            },
-          });
-        }
-        
-        // Serve gzipped content with proper headers (for HTML, CSS, JS, etc.)
-        console.log(`[DEBUG SERVE] ${requestPath}: serving as gzipped with Content-Encoding header`);
-        return new Response(content, {
-          headers: {
-            'Content-Type': meta.mimeType,
-            'Content-Encoding': 'gzip',
-          },
-        });
+    if (meta && meta.encoding === 'gzip' && meta.mimeType) {
+      const shouldServeCompressed = shouldCompressMimeType(meta.mimeType);
+
+      if (!shouldServeCompressed) {
+        const { gunzipSync } = await import('zlib');
+        const decompressed = gunzipSync(content);
+        headers['Content-Type'] = meta.mimeType;
+        headers['Cache-Control'] = 'public, max-age=31536000, immutable';
+        return new Response(decompressed, { headers });
       }
+
+      headers['Content-Type'] = meta.mimeType;
+      headers['Content-Encoding'] = 'gzip';
+      headers['Cache-Control'] = meta.mimeType.startsWith('text/html')
+        ? 'public, max-age=300'
+        : 'public, max-age=31536000, immutable';
+      return new Response(content, { headers });
     }
 
-    // Serve non-compressed files normally
+    // Non-compressed files
     const mimeType = lookup(cachedFile) || 'application/octet-stream';
-    return new Response(content, {
-      headers: {
-        'Content-Type': mimeType,
-      },
-    });
+    headers['Content-Type'] = mimeType;
+    headers['Cache-Control'] = mimeType.startsWith('text/html')
+      ? 'public, max-age=300'
+      : 'public, max-age=31536000, immutable';
+    return new Response(content, { headers });
   }
 
   // Try index.html for directory-like paths
   if (!requestPath.includes('.')) {
-    const indexFile = getCachedFilePath(did, rkey, `${requestPath}/index.html`);
-    if (existsSync(indexFile)) {
-      const content = readFileSync(indexFile);
-      const metaFile = `${indexFile}.meta`;
+    const indexPath = `${requestPath}/index.html`;
+    const indexCacheKey = getCacheKey(did, rkey, indexPath);
+    const indexFile = getCachedFilePath(did, rkey, indexPath);
 
-      // Check if file has compression metadata
-      if (existsSync(metaFile)) {
-        const meta = JSON.parse(readFileSync(metaFile, 'utf-8'));
-        if (meta.encoding === 'gzip' && meta.mimeType) {
-          return new Response(content, {
-            headers: {
-              'Content-Type': meta.mimeType,
-              'Content-Encoding': 'gzip',
-            },
-          });
-        }
+    let indexContent = fileCache.get(indexCacheKey);
+    let indexMeta = metadataCache.get(indexCacheKey);
+
+    if (!indexContent && await fileExists(indexFile)) {
+      indexContent = await readFile(indexFile);
+      fileCache.set(indexCacheKey, indexContent, indexContent.length);
+
+      const indexMetaFile = `${indexFile}.meta`;
+      if (await fileExists(indexMetaFile)) {
+        const metaJson = await readFile(indexMetaFile, 'utf-8');
+        indexMeta = JSON.parse(metaJson);
+        metadataCache.set(indexCacheKey, indexMeta!, JSON.stringify(indexMeta).length);
+      }
+    }
+
+    if (indexContent) {
+      const headers: Record<string, string> = {
+        'Content-Type': 'text/html; charset=utf-8',
+        'Cache-Control': 'public, max-age=300',
+      };
+
+      if (indexMeta && indexMeta.encoding === 'gzip') {
+        headers['Content-Encoding'] = 'gzip';
       }
 
-      return new Response(content, {
-        headers: {
-          'Content-Type': 'text/html; charset=utf-8',
-        },
-      });
+      return new Response(indexContent, { headers });
     }
   }
 
···
     requestPath += 'index.html';
   }
 
+  const cacheKey = getCacheKey(did, rkey, requestPath);
   const cachedFile = getCachedFilePath(did, rkey, requestPath);
 
-  if (existsSync(cachedFile)) {
+  // Check for rewritten HTML in cache first (if it's HTML)
+  const mimeTypeGuess = lookup(requestPath) || 'application/octet-stream';
+  if (isHtmlContent(requestPath, mimeTypeGuess)) {
+    const rewrittenKey = getCacheKey(did, rkey, requestPath, `rewritten:${basePath}`);
+    const rewrittenContent = rewrittenHtmlCache.get(rewrittenKey);
+    if (rewrittenContent) {
+      return new Response(rewrittenContent, {
+        headers: {
+          'Content-Type': 'text/html; charset=utf-8',
+          'Content-Encoding': 'gzip',
+          'Cache-Control': 'public, max-age=300',
+        },
+      });
+    }
+  }
+
+  // Check in-memory file cache
+  let content = fileCache.get(cacheKey);
+  let meta = metadataCache.get(cacheKey);
+
+  if (!content && await fileExists(cachedFile)) {
+    // Read from disk and cache
+    content = await readFile(cachedFile);
+    fileCache.set(cacheKey, content, content.length);
+
     const metaFile = `${cachedFile}.meta`;
-    let mimeType = lookup(cachedFile) || 'application/octet-stream';
-    let isGzipped = false;
+    if (await fileExists(metaFile)) {
+      const metaJson = await readFile(metaFile, 'utf-8');
+      meta = JSON.parse(metaJson);
+      metadataCache.set(cacheKey, meta!, JSON.stringify(meta).length);
+    }
+  }
 
-    // Check if file has compression metadata
-    if (existsSync(metaFile)) {
-      const meta = JSON.parse(readFileSync(metaFile, 'utf-8'));
-      if (meta.encoding === 'gzip' && meta.mimeType) {
-        mimeType = meta.mimeType;
-        isGzipped = true;
-      }
-    }
+  if (content) {
+    const mimeType = meta?.mimeType || lookup(cachedFile) || 'application/octet-stream';
+    const isGzipped = meta?.encoding === 'gzip';
 
     // Check if this is HTML content that needs rewriting
-    // We decompress, rewrite paths, then recompress for efficient delivery
     if (isHtmlContent(requestPath, mimeType)) {
-      let content: string;
+      let htmlContent: string;
       if (isGzipped) {
         const { gunzipSync } = await import('zlib');
-        const compressed = readFileSync(cachedFile);
-        content = gunzipSync(compressed).toString('utf-8');
+        htmlContent = gunzipSync(content).toString('utf-8');
       } else {
-        content = readFileSync(cachedFile, 'utf-8');
+        htmlContent = content.toString('utf-8');
       }
-      const rewritten = rewriteHtmlPaths(content, basePath, requestPath);
-      
-      // Recompress the HTML for efficient delivery
+      const rewritten = rewriteHtmlPaths(htmlContent, basePath, requestPath);
+
+      // Recompress and cache the rewritten HTML
       const { gzipSync } = await import('zlib');
       const recompressed = gzipSync(Buffer.from(rewritten, 'utf-8'));
-      
+
+      const rewrittenKey = getCacheKey(did, rkey, requestPath, `rewritten:${basePath}`);
+      rewrittenHtmlCache.set(rewrittenKey, recompressed, recompressed.length);
+
       return new Response(recompressed, {
         headers: {
           'Content-Type': 'text/html; charset=utf-8',
           'Content-Encoding': 'gzip',
+          'Cache-Control': 'public, max-age=300',
         },
       });
     }
 
-    // Non-HTML files: serve gzipped content as-is with proper headers
-    const content = readFileSync(cachedFile);
+    // Non-HTML files: serve as-is
+    const headers: Record<string, string> = {
+      'Content-Type': mimeType,
+      'Cache-Control': 'public, max-age=31536000, immutable',
+    };
+
     if (isGzipped) {
-      // Use shared function to determine if this should be served compressed
       const shouldServeCompressed = shouldCompressMimeType(mimeType);
-      
       if (!shouldServeCompressed) {
-        // This shouldn't happen if caching is working correctly, but handle it gracefully
         const { gunzipSync } = await import('zlib');
         const decompressed = gunzipSync(content);
-        return new Response(decompressed, {
-          headers: {
-            'Content-Type': mimeType,
-          },
-        });
+        return new Response(decompressed, { headers });
       }
-      
-      return new Response(content, {
+      headers['Content-Encoding'] = 'gzip';
+    }
+
+    return new Response(content, { headers });
+  }
+
+  // Try index.html for directory-like paths
+  if (!requestPath.includes('.')) {
+    const indexPath = `${requestPath}/index.html`;
+    const indexCacheKey = getCacheKey(did, rkey, indexPath);
+    const indexFile = getCachedFilePath(did, rkey, indexPath);
+
+    // Check for rewritten index.html in cache
+    const rewrittenKey = getCacheKey(did, rkey, indexPath, `rewritten:${basePath}`);
+    const rewrittenContent = rewrittenHtmlCache.get(rewrittenKey);
+    if (rewrittenContent) {
+      return new Response(rewrittenContent, {
         headers: {
-          'Content-Type': mimeType,
+          'Content-Type': 'text/html; charset=utf-8',
           'Content-Encoding': 'gzip',
+          'Cache-Control': 'public, max-age=300',
         },
       });
     }
-    return new Response(content, {
-      headers: {
-        'Content-Type': mimeType,
-      },
-    });
-  }
 
-  // Try index.html for directory-like paths
-  if (!requestPath.includes('.')) {
-    const indexFile = getCachedFilePath(did, rkey, `${requestPath}/index.html`);
-    if (existsSync(indexFile)) {
-      const metaFile = `${indexFile}.meta`;
-      let isGzipped = false;
+    let indexContent = fileCache.get(indexCacheKey);
+    let indexMeta = metadataCache.get(indexCacheKey);
 
-      if (existsSync(metaFile)) {
-        const meta = JSON.parse(readFileSync(metaFile, 'utf-8'));
-        if (meta.encoding === 'gzip') {
-          isGzipped = true;
-        }
+    if (!indexContent && await fileExists(indexFile)) {
+      indexContent = await readFile(indexFile);
+      fileCache.set(indexCacheKey, indexContent, indexContent.length);
+
+      const indexMetaFile = `${indexFile}.meta`;
+      if (await fileExists(indexMetaFile)) {
+        const metaJson = await readFile(indexMetaFile, 'utf-8');
+        indexMeta = JSON.parse(metaJson);
+        metadataCache.set(indexCacheKey, indexMeta!, JSON.stringify(indexMeta).length);
       }
+    }
 
-      // HTML needs path rewriting, decompress, rewrite, then recompress
-      let content: string;
+    if (indexContent) {
+      const isGzipped = indexMeta?.encoding === 'gzip';
+
+      let htmlContent: string;
       if (isGzipped) {
         const { gunzipSync } = await import('zlib');
-        const compressed = readFileSync(indexFile);
-        content = gunzipSync(compressed).toString('utf-8');
+        htmlContent = gunzipSync(indexContent).toString('utf-8');
       } else {
-        content = readFileSync(indexFile, 'utf-8');
+        htmlContent = indexContent.toString('utf-8');
       }
-      const indexPath = `${requestPath}/index.html`;
-      const rewritten = rewriteHtmlPaths(content, basePath, indexPath);
-      
-      // Recompress the HTML for efficient delivery
+      const rewritten = rewriteHtmlPaths(htmlContent, basePath, indexPath);
+
       const { gzipSync } = await import('zlib');
       const recompressed = gzipSync(Buffer.from(rewritten, 'utf-8'));
-      
+
+      rewrittenHtmlCache.set(rewrittenKey, recompressed, recompressed.length);
+
       return new Response(recompressed, {
         headers: {
           'Content-Type': 'text/html; charset=utf-8',
           'Content-Encoding': 'gzip',
+          'Cache-Control': 'public, max-age=300',
         },
       });
     }
···
   const timeWindow = query.timeWindow ? parseInt(query.timeWindow as string) : 3600000;
   const stats = metricsCollector.getStats('hosting-service', timeWindow);
   return c.json({ stats, timeWindow });
+});
+
+app.get('/__internal__/observability/cache', async (c) => {
+  const { getCacheStats } = await import('./lib/cache');
+  const stats = getCacheStats();
+  return c.json({ cache: stats });
 });
 
 export default app;