@rsc-kit/core 0.21.2 → 0.21.4

package/dist/vite.js

@@ -862,12 +862,11 @@ self.addEventListener('install', (event) => {
       // worker cannot see. Added here so it is in the cache before it is
       // needed, which is the only moment it cannot be fetched.
       //
-      // One at a time rather than cache.addAll, which rejects the whole list
-      // for one failure - and a worker whose install rejects is never
+      // Each file on its own rather than cache.addAll, which rejects the whole
+      // list for one failure - and a worker whose install rejects is never
       // installed. The worker before it then stays in charge, serving its own
       // build's pages, for every visit until one install happens to succeed:
-      // a network blip, a quota, a file a deploy replaced mid-install, and a
-      // phone kept a worker from builds ago whose bugs had long been fixed.
+      // a network blip, a quota, a file a deploy replaced mid-install.
       // A file that did not arrive costs a cache entry; the update still
       // lands. The browser checks /sw.js for itself, without the page's
       // javascript, so an install that cannot fail is also what rescues a
@@ -1032,6 +1031,10 @@ const standIn = async (request) => {
 // the ?__rsc=<segments> above is the one header the answer differs on.
 const MATCH = { ignoreVary: true }
 
+// The documents being fetched to go with a payload, by url - so the payloads
+// of one page, asked for at several depths, fetch its document once.
+const documentsInFlight = new Set()
+
 self.addEventListener('fetch', (event) => {
   const request = event.request
   const url = new URL(request.url)
@@ -1109,26 +1112,14 @@ self.addEventListener('fetch', (event) => {
           const copy = response.clone()
           caches.open(CACHE).then((cache) => cache.put(keyFor(request), copy))
 
-          // A document is not enough to boot from. The client hydrates from a
-          // payload it fetches for itself, and on a first visit that request
-          // happens before this worker controls the page — so it is never
-          // cached, and a reload with no network has the markup and nothing to
-          // hydrate it with.
-          //
-          // \`X-RSC: 1\` and no segments header is exactly what a fresh boot
-          // sends, which is what makes this entry the one it finds: the server
-          // varies on those, and the Cache API matches on the same.
-          if (request.mode === 'navigate') {
-            const warm = new Request(request.url, { headers: { 'X-RSC': '1' } })
-
-            fetch(warm)
-              .then((payload) => {
-                if (mayStore(payload)) {
-                  caches.open(CACHE).then((cache) => cache.put(keyFor(warm), payload))
-                }
-              })
-              .catch(() => {})
-          }
+          // No second fetch of the page's payload here. There used to be one,
+          // for offline: a document alone does not boot. But whenever this
+          // worker handles a page load, the page's own boot request - the
+          // same url, X-RSC: 1, no segments - comes through this worker too
+          // and is cached just above. The one time it does not is a first
+          // visit, before the worker controls the page, and then it did not
+          // handle the page load either. So it was a duplicate request on
+          // every page load, at the moment the visitor was waiting.
 
           // And the other way round. Moving between pages fetches payloads and
           // never documents, so a page reached only by a link had nothing to
@@ -1138,16 +1129,20 @@ self.addEventListener('fetch', (event) => {
           // Once per url: the document is fetched only when the cache has none,
           // so this costs one extra request the first time a page is visited
           // rather than one on every navigation to it.
-          if (request.headers.get('X-RSC')) {
+          if (request.headers.get('X-RSC') && !documentsInFlight.has(request.url)) {
             const document = new Request(request.url)
 
-            caches.open(CACHE).then(async (cache) => {
-              if (await cache.match(document)) return
+            documentsInFlight.add(request.url)
+            caches
+              .open(CACHE)
+              .then(async (cache) => {
+                if (await cache.match(document)) return
 
-              const fresh = await fetch(document).catch(() => null)
+                const fresh = await fetch(document).catch(() => null)
 
-              if (fresh && mayStore(fresh)) await cache.put(document, fresh)
-            })
+                if (fresh && mayStore(fresh)) await cache.put(document, fresh)
+              })
+              .finally(() => documentsInFlight.delete(request.url))
           }
         }
 
@@ -1359,7 +1354,45 @@ export function bootsTheApp(file) {
         return true;
     return false;
 }
-function writeServiceWorker(clientDir, frozen = [], offlineUrl = null) {
+/**
+ * A service worker's version: a hash of everything it serves cache-first.
+ *
+ * It used to be the precache list alone - the hashed file names - on the
+ * reasoning that a deploy changes them. A deploy that changes a stored page
+ * and no client script does not: the list was the same, so sw.js was byte
+ * for byte the same, the browser saw no update, and the worker went on
+ * serving the previous build's page from its cache, cache-first, because "a
+ * deploy changes VERSION and sweeps this cache". Reproduced: deploy build B
+ * over A, reload, and the page is A; only the load after the background
+ * refresh shows B. So the stored pages' bytes are in it too, and a deploy
+ * that changes what the worker holds is a new worker.
+ */
+export function workerVersion(precache, storedDir) {
+    const version = createHash("sha256");
+    version.update(precache.join("\n"));
+    if (storedDir && existsSync(storedDir)) {
+        const stored = [];
+        const walkStored = (dir) => {
+            for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                const path = join(dir, entry.name);
+                if (entry.isDirectory())
+                    walkStored(path);
+                else
+                    stored.push(path);
+            }
+        };
+        walkStored(storedDir);
+        for (const path of stored.sort()) {
+            version.update("\n" + relative(storedDir, path) + "\n");
+            version.update(readFileSync(path));
+        }
+    }
+    return version.digest("hex").slice(0, 12);
+}
+function writeServiceWorker(clientDir, frozen = [], offlineUrl = null, 
+// The pages the build stored, which the worker serves cache-first. Their
+// bytes are part of what a version is - see below.
+storedDir = null) {
     if (!existsSync(clientDir))
         return;
     // Before the walk, so it lands in the precache with everything else. The
@@ -1383,12 +1416,9 @@ function writeServiceWorker(clientDir, frozen = [], offlineUrl = null) {
     };
     walk(clientDir, "");
     const precache = ["/", ...files.map((file) => `/${file}`)].sort();
-    const version = createHash("sha256")
-        .update(precache.join("\n"))
-        .digest("hex")
-        .slice(0, 12);
-    writeFileSync(join(clientDir, "sw.js"), SERVICE_WORKER(version, precache, frozen, offlineUrl, extra));
-    log(`offline: ${precache.length} files precached as rsc-kit-${version}` +
+    const versionHash = workerVersion(precache, storedDir);
+    writeFileSync(join(clientDir, "sw.js"), SERVICE_WORKER(versionHash, precache, frozen, offlineUrl, extra));
+    log(`offline: ${precache.length} files precached as rsc-kit-${versionHash}` +
         (offlineUrl ? `, falling back to ${offlineUrl}` : "") +
         (extra ? ", with app/sw.js" : ""));
 }
@@ -6526,7 +6556,7 @@ export function rscKit(options = {}) {
             if (webManifestOptions)
                 writeWebManifest(clientOut ?? publicAssetsDir, webManifestOptions);
             if (offline) {
-                writeServiceWorker(clientOut ?? publicAssetsDir, frozen, offlineFallback(frozen, results));
+                writeServiceWorker(clientOut ?? publicAssetsDir, frozen, offlineFallback(frozen, results), staticDir);
             }
         },
         configResolved(config) {