@banou/ripple 0.0.30 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@banou/ripple",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "type": "module",
   "repository": {
     "type": "git",

package/sw.js

@@ -8,10 +8,12 @@ const live = new Map()
 /* Stamped at build time. These are the dev defaults and must never reach production: a worker whose
    BUILD never changes is never reinstalled, so the update this feature announces would never fire. */
 const MODE = "cache"    // @stamp:mode
-const BUILD = "0a822c9844cb9b01"   // @stamp:build
-const MANIFEST = [["/assets/empty-BvRk9kiK.js","e3b0c44298fc1c14"],["/assets/libtorrent-DleyqKUt.js","27516279f85831f1"],["/assets/worker-Dx1oQ7Q_.js","f43c4541e44036f4"],["/build-B7te3F-u.js","47b056c564f078c5"],["/remote-DvdN47iT.js","b0649250a9e3a079"],["/volume-normalizer-worklet.js","4021752281e110ba"]] // @stamp:manifest
+const BUILD = "dc9663766143c273"   // @stamp:build
+const MANIFEST = [["/assets/empty-BvRk9kiK.js","e3b0c44298fc1c14"],["/assets/libtorrent-DleyqKUt.js","27516279f85831f1"],["/assets/worker-kaROsro7.js","3f29b36a9bea36cc"],["/build-B7te3F-u.js","47b056c564f078c5"],["/remote-DvdN47iT.js","b0649250a9e3a079"]] // @stamp:manifest
 
 const CACHE = 'ripple-assets-' + BUILD
+/** Holds the name of the generation that activated last, so the next activation can keep it. */
+const ACTIVE = 'ripple-active'
 
 /**
  * Which requests this worker may answer from its cache, and the whole of it.
@@ -30,25 +32,49 @@ const CACHE = 'ripple-assets-' + BUILD
  * SPA fallback: 200, text/html, which the browser then runs as a module worker. Measured against
  * production, an earlier build's chunk is byte-identical to one that never existed.
  */
-const HASHED = /^\/(?:assets\/)?[A-Za-z0-9_.$-]+-[A-Za-z0-9_-]{8,}\.js$/
+const HASHED = /^\/(?:assets\/)?[A-Za-z0-9_.$-]+-[A-Za-z0-9_-]{8}\.js$/
+
+// An HTML answer for a chunk path is Cloudflare's SPA fallback for a chunk that is gone, not the chunk.
+const isScript = (response) => response.ok && (response.headers.get('content-type') || '').includes('javascript')
+
+const PRECACHE_ATTEMPTS = 3
+
+/** Resolves once every manifest chunk is stored, asking again only for the ones that failed. */
+const precache = async () => {
+  const cache = await caches.open(CACHE)
+  let missing = MANIFEST.map(([path]) => path)
+  for (let attempt = 0; attempt < PRECACHE_ATTEMPTS && missing.length > 0; attempt++) {
+    const failed = await Promise.all(missing.map(async (path) => {
+      try {
+        const response = await fetch(path)
+        if (!isScript(response)) return path
+        await cache.put(path, response)
+        return null
+      } catch {
+        return path
+      }
+    }))
+    missing = failed.filter((path) => path !== null)
+  }
+  if (missing.length > 0) throw new Error('precache incomplete: ' + missing.join(', '))
+}
 
 self.addEventListener('install', (event) => {
   // PURGE is the remote kill switch: ship src/sw.mode as `purge` and the next deploy's worker takes
   // over at once, deletes every cache, and answers nothing. It needs no cooperation from the page.
   if (MODE === 'purge') { self.skipWaiting(); return }
   /*
-   * No skipWaiting. A new worker installs and WAITS, so a page keeps the build it loaded with until
-   * somebody presses Update. That is the opposite of what this worker used to do, and it is the
-   * point: taking over immediately is what would swap the chunk set under a running engine.
+   * No skipWaiting: a new worker installs and WAITS, and the page decides when it takes over.
+   *
+   * An installed worker is what the page reads as "the update is downloaded", so with a worker
+   * already active an incomplete precache fails the install: the browser drops this worker and
+   * installs it again at its next update check, while the active one keeps serving. The first
+   * install never fails on it, because an origin with no worker at all is worse than one whose
+   * cache fills on demand.
    */
-  event.waitUntil(
-    caches.open(CACHE)
-      .then((cache) => cache.addAll(MANIFEST.map(([path]) => path)))
-      // A failed precache must not fail the install. The worker still routes and still fills the
-      // cache on demand; a rejected install would leave the origin with no worker at all, which is
-      // strictly worse than one with a cold cache.
-      .catch(() => undefined),
-  )
+  event.waitUntil(precache().catch((error) => {
+    if (self.registration.active) throw error
+  }))
 })
 
 self.addEventListener('activate', (event) => {
@@ -58,11 +84,21 @@ self.addEventListener('activate', (event) => {
       await self.clients.claim()
       return
     }
-    // every generation but this one: a hashed chunk is immutable, so old generations are only ever
-    // wasted room, never wrong answers
-    for (const key of await caches.keys()) {
-      if (key.startsWith('ripple-assets-') && key !== CACHE) await caches.delete(key)
+    /*
+     * Every generation but this one and the one active before it. A page the update gate leaves on
+     * the previous build (held by a save or a video, or framed by another page) still loads its lazy
+     * chunks, the torrent engine's included, and this worker controls it from the claim below. Older
+     * generations are only wasted room: a hashed chunk is immutable, so none of them is ever wrong.
+     * With no record yet (the first activation that keeps one) nothing is deleted.
+     */
+    const record = await caches.open(ACTIVE)
+    const previous = await (await record.match('/'))?.text()
+    if (previous !== undefined) {
+      for (const key of await caches.keys()) {
+        if (key.startsWith('ripple-assets-') && key !== CACHE && key !== previous) await caches.delete(key)
+      }
     }
+    await record.put('/', new Response(CACHE))
     await self.clients.claim()
   })())
 })
@@ -82,8 +118,8 @@ self.addEventListener('message', (event) => {
     event.source.postMessage({ type: 'pong', id: data.id })
     return
   }
-  // Pressed Update. Only a WAITING worker ever receives this, and taking over fires controllerchange
-  // in every open page, which is what reloads them all together.
+  // From a page's update gate. Only a WAITING worker ever receives this, and taking over fires
+  // controllerchange in every open page, each of which then reloads at its own safe moment.
   if (data.type === 'take-over') self.skipWaiting()
   if (data.type === 'which-build' && event.source) {
     event.source.postMessage({ type: 'build', build: BUILD, mode: MODE })
@@ -110,15 +146,14 @@ self.addEventListener('fetch', (event) => {
     const path = new URL(url).pathname
     if (new URL(url).origin === self.location.origin && HASHED.test(path)) {
       event.respondWith((async () => {
-        const cache = await caches.open(CACHE)
-        const hit = await cache.match(path)
+        // any generation: a page still on the previous build asks for that build's chunks
+        const hit = await caches.match(path)
         if (hit) return hit
         const fresh = await fetch(event.request)
         // An HTML answer here IS the bug this worker exists for: the chunk is gone and Cloudflare
         // served the SPA fallback with a 200. Never store that, or the cache would preserve the
         // failure across the very reload meant to cure it.
-        const type = fresh.headers.get('content-type') || ''
-        if (fresh.ok && type.includes('javascript')) await cache.put(path, fresh.clone())
+        if (isScript(fresh)) await (await caches.open(CACHE)).put(path, fresh.clone())
         return fresh
       })())
       return