Remove maxSize option in favor of maxEntries + maxEntrySize

The combination of maxEntries and maxEntrySize provides a guaranteed
upper bound (maxEntries × maxEntrySize) without the complexity of
tracking aggregate cache size. This simplifies the implementation
by removing stats tracking in IndexedDB.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: rosa

src/offline/cache_registry.js

@@ -66,20 +66,6 @@ class CacheRegistryDatabase {
     return this.#performOperation(STORE_NAME, countOp, "readonly")
   }
 
-  getTotalSize(cacheName) {
-    const sumOp = (store) => {
-      const index = store.index("cacheNameAndTimestamp")
-      const range = IDBKeyRange.bound(
-        [cacheName, 0],
-        [cacheName, Infinity]
-      )
-      const cursorRequest = index.openCursor(range)
-
-      return this.#sumSizesFromCursor(cursorRequest)
-    }
-    return this.#performOperation(STORE_NAME, sumOp, "readonly")
-  }
-
   getOldestEntries(cacheName, limit) {
     const getOldestOp = (store) => {
       const index = store.index("cacheNameAndTimestamp")
@@ -94,20 +80,6 @@ class CacheRegistryDatabase {
     return this.#performOperation(STORE_NAME, getOldestOp, "readonly")
   }
 
-  getEntriesForSizeReduction(cacheName, targetReduction) {
-    const getEntriesOp = (store) => {
-      const index = store.index("cacheNameAndTimestamp")
-      const range = IDBKeyRange.bound(
-        [cacheName, 0],
-        [cacheName, Infinity]
-      )
-      const cursorRequest = index.openCursor(range)
-
-      return this.#getEntriesUntilSizeReached(cursorRequest, targetReduction)
-    }
-    return this.#performOperation(STORE_NAME, getEntriesOp, "readonly")
-  }
-
   delete(key) {
     const deleteOp = (store) => this.#requestToPromise(store.delete(key))
     return this.#performOperation(STORE_NAME, deleteOp, "readwrite")
@@ -173,44 +145,6 @@ class CacheRegistryDatabase {
       request.onerror = () => reject(request.error)
     })
   }
-
-  #sumSizesFromCursor(request) {
-    return new Promise((resolve, reject) => {
-      let total = 0
-
-      request.onsuccess = (event) => {
-        const cursor = event.target.result
-        if (cursor) {
-          total += cursor.value.size ?? 0
-          cursor.continue()
-        } else {
-          resolve(total)
-        }
-      }
-
-      request.onerror = () => reject(request.error)
-    })
-  }
-
-  #getEntriesUntilSizeReached(request, targetSize) {
-    return new Promise((resolve, reject) => {
-      const results = []
-      let accumulated = 0
-
-      request.onsuccess = (event) => {
-        const cursor = event.target.result
-        if (cursor && accumulated < targetSize) {
-          results.push(cursor.value)
-          accumulated += cursor.value.size ?? 0
-          cursor.continue()
-        } else {
-          resolve(results)
-        }
-      }
-
-      request.onerror = () => reject(request.error)
-    })
-  }
 }
 
 let cacheRegistryDatabase = null
@@ -252,18 +186,10 @@ export class CacheRegistry {
     return this.database.getEntryCount(this.cacheName)
   }
 
-  getTotalSize() {
-    return this.database.getTotalSize(this.cacheName)
-  }
-
   getOldestEntries(limit) {
     return this.database.getOldestEntries(this.cacheName, limit)
   }
 
-  getEntriesForSizeReduction(targetReduction) {
-    return this.database.getEntriesForSizeReduction(this.cacheName, targetReduction)
-  }
-
   delete(key) {
     return this.database.delete(key)
   }

src/offline/cache_trimmer.js

@@ -26,23 +26,18 @@ export class CacheTrimmer {
   }
 
   #shouldTrim() {
-    const { maxAge, maxEntries, maxSize } = this.options
-    return (maxAge && maxAge > 0) ||
-           (maxEntries && maxEntries > 0) ||
-           (maxSize && maxSize > 0)
+    const { maxAge, maxEntries } = this.options
+    return (maxAge && maxAge > 0) || (maxEntries && maxEntries > 0)
   }
 
   async deleteEntries() {
-    // Order: age first → count → size (each reduces the set for subsequent operations)
+    // Order: age first, then count (age reduces the set for count trimming)
     if (this.options.maxAge) {
       await this.deleteEntriesByAge()
     }
     if (this.options.maxEntries) {
       await this.deleteEntriesByCount()
     }
-    if (this.options.maxSize) {
-      await this.deleteEntriesBySize()
-    }
   }
 
   async deleteEntriesByAge() {
@@ -79,25 +74,6 @@ export class CacheTrimmer {
     console.debug(`Successfully trimmed ${entriesToDelete.length} entries from cache "${this.cacheName}"`)
   }
 
-  async deleteEntriesBySize() {
-    const currentSize = await this.cacheRegistry.getTotalSize()
-    const excess = currentSize - this.options.maxSize
-
-    if (excess <= 0) {
-      return
-    }
-
-    const entriesToDelete = await this.cacheRegistry.getEntriesForSizeReduction(excess)
-
-    if (entriesToDelete.length === 0) {
-      return
-    }
-
-    console.debug(`Trimming ${entriesToDelete.length} entries (size limit) from cache "${this.cacheName}"`)
-    await this.#deleteEntryList(entriesToDelete)
-    console.debug(`Successfully trimmed ${entriesToDelete.length} entries from cache "${this.cacheName}"`)
-  }
-
   async #deleteEntryList(entries) {
     const cache = await caches.open(this.cacheName)
 

src/offline/handlers/handler.js

@@ -3,14 +3,14 @@ import { CacheTrimmer } from "../cache_trimmer"
 import { buildPartialResponse } from "../range_request"
 
 export class Handler {
-  constructor({ cacheName, networkTimeout, maxAge, maxEntries, maxSize, maxEntrySize, fetchOptions }) {
+  constructor({ cacheName, networkTimeout, maxAge, maxEntries, maxEntrySize, fetchOptions }) {
     this.cacheName = cacheName
     this.networkTimeout = networkTimeout
     this.fetchOptions = fetchOptions || {}
     this.maxEntrySize = maxEntrySize
 
     this.cacheRegistry = new CacheRegistry(cacheName)
-    this.cacheTrimmer = new CacheTrimmer(cacheName, this.cacheRegistry, { maxAge, maxEntries, maxSize })
+    this.cacheTrimmer = new CacheTrimmer(cacheName, this.cacheRegistry, { maxAge, maxEntries })
   }
 
   async handle(request) {

src/tests/fixtures/service_workers/max_size.js

@@ -424,35 +424,6 @@ test("trims oldest entries when maxEntries is exceeded", async ({ page }) => {
   await assertCachedContent(page, "test-max-entries", urls[4], contents[4])
 })
 
-test("trims oldest entries when maxSize is exceeded", async ({ page }) => {
-  await registerServiceWorker(page, "/src/tests/fixtures/service_workers/max_size.js")
-  await waitForServiceWorkerToControl(page)
-
-  // Cache multiple URLs - each response is ~60-70 bytes, maxSize is 150 bytes
-  const urls = [
-    "/__turbo/dynamic.txt?id=1",
-    "/__turbo/dynamic.txt?id=2",
-    "/__turbo/dynamic.txt?id=3"
-  ]
-
-  const contents = []
-  for (const url of urls) {
-    contents.push(await fetchContent(page, url))
-    // Wait between requests to ensure distinct timestamps
-    await page.waitForTimeout(100)
-  }
-
-  // Wait for trimming to complete
-  await page.waitForTimeout(300)
-
-  // With maxSize: 150 and ~70 byte responses, only ~2 should fit
-  // The oldest entry should be removed
-  await assertNotCached(page, "test-max-size", urls[0])
-
-  // At least the newest entry should remain
-  await assertCachedContent(page, "test-max-size", urls[2], contents[2])
-})
-
 test("rejects entries exceeding maxEntrySize", async ({ page }) => {
   await registerServiceWorker(page, "/src/tests/fixtures/service_workers/max_entry_size.js")
   await waitForServiceWorkerToControl(page)