@rsc-kit/core 0.21.2 → 0.21.3

package/dist/vite.d.ts

@@ -29,8 +29,10 @@ export interface RscKitOptions {
      * tags, responses }`; the document says its own with `info`, `servers`,
      * `security`. An api route the build stores, without middleware.
      *
-     * The page that reads it is Scalar's: `export const GET = ApiReference({
-     * url: '/openapi.json' })` from @scalar/nextjs-api-reference in a route.ts.
+     * The page that reads it is Scalar's: `renderApiReference({ config: { url:
+     * '/openapi.json' } })` from @scalar/client-side-rendering, returned as an
+     * HTML Response from a route.ts. Not @scalar/nextjs-api-reference, whose
+     * peer dependency installs all of Next.js.
      */
     openapi?: boolean | {
         path?: string;
@@ -347,6 +349,20 @@ export declare function offlineFallback(frozen: string[], results: PrerenderResu
  * browser ever renders.
  */
 export declare function bootsTheApp(file: string): boolean;
+/**
+ * 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 declare function workerVersion(precache: string[], storedDir: string | null): string;
 export declare function smallStylesheetReader(assetsDir: string, setting: "auto" | true | number): (href: string) => string | null;
 /** A server action the bundle registered: where it is and what it is called. */
 export interface KnownAction {

package/dist/vite.js

@@ -849,6 +849,43 @@ const INSTALL_FETCH_MS = 30000
 const within = (ms, promise) =>
   Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new Error('no answer in ' + ms + ' ms')), ms))])
 
+// The same limit, and the download stopped when it is reached. A race only
+// stops the waiting: the fetch it gave up on went on downloading beside
+// everything after it.
+const abortable = (ms, start) => {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), ms)
+
+  return within(ms, start(controller.signal)).finally(() => clearTimeout(timer))
+}
+
+// How many precache downloads run together. The page a visitor is looking at
+// comes first; the precache is for the next visit.
+const PRECACHE_AT_ONCE = 4
+
+// Run a task over every item, at most limit of them at a time. Resolves once
+// all have settled; a task that fails is its own business.
+const pool = (items, limit, task) =>
+  new Promise((resolve) => {
+    let next = 0
+    let running = 0
+    const launch = () => {
+      if (next >= items.length && running === 0) return resolve()
+
+      while (running < limit && next < items.length) {
+        running++
+        Promise.resolve(task(items[next++]))
+          .catch(() => {})
+          .finally(() => {
+            running--
+            launch()
+          })
+      }
+    }
+
+    launch()
+  })
+
 self.addEventListener('install', (event) => {
   // The new worker takes over rather than waiting for every tab to close.
   // Safe here because assets are content-hashed: a page already open keeps
@@ -872,13 +909,23 @@ self.addEventListener('install', (event) => {
       // lands. The browser checks /sw.js for itself, without the page's
       // javascript, so an install that cannot fail is also what rescues a
       // visitor stuck on a worker far older than this one.
+      //
+      // A few at a time and at low priority, never all at once. An install
+      // runs beside the page that triggered it - the first visit after a
+      // deploy - and a hundred and seventy files requested together queued
+      // that page's own requests behind them: on a phone, the page sat
+      // unhydrated for about forty seconds, until the precache had finished.
       .then((cache) =>
-        Promise.all(
-          (OFFLINE_URL ? [...PRECACHE, OFFLINE_URL] : PRECACHE).map((url) =>
-            within(INSTALL_FETCH_MS, cache.add(url)).catch((error) => {
-              console.warn('[rsc-kit] offline: ' + url + ' was not precached (' + (error && error.message || error) + '); it will be cached the first time it is fetched')
+        pool(OFFLINE_URL ? [...PRECACHE, OFFLINE_URL] : PRECACHE, PRECACHE_AT_ONCE, (url) =>
+          abortable(INSTALL_FETCH_MS, (signal) =>
+            fetch(url, { priority: 'low', signal }).then((response) => {
+              if (!response.ok) throw new Error('status ' + response.status)
+
+              return cache.put(url, response)
             }),
-          ),
+          ).catch((error) => {
+            console.warn('[rsc-kit] offline: ' + url + ' was not precached (' + (error && error.message || error) + '); it will be cached the first time it is fetched')
+          }),
         ).then(() => cache),
       )
       // And the payload each precached page boots from. A document alone is
@@ -1032,6 +1079,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 +1160,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 +1177,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 +1402,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 +1464,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 +6604,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) {