@rsc-kit/core 0.20.3 → 0.20.5

package/dist/vite.js

@@ -756,6 +756,14 @@ function reportAllDynamic() {
 export const SERVICE_WORKER = (version, precache, frozen = [], offlineUrl = null, swExtra = null) => `// GENERATED by rscKit() — do not edit.
 const VERSION = ${JSON.stringify(version)}
 const CACHE = 'rsc-kit-' + VERSION
+
+// This worker's own cache, and only that. \`caches.match()\` searches every
+// cache on the origin - the previous worker's included, until this one's
+// activation sweeps it - and answered a payload request for the page with
+// the previous build's payload: client references this build does not
+// have, and the page reloaded to recover. A document, a payload, a page
+// this worker did not cache is not served from a cache it did not fill.
+const own = (key, options) => caches.open(CACHE).then((cache) => cache.match(key, options))
 const PRECACHE = ${JSON.stringify(precache, null, 2)}
 
 // The urls the build stored whole. Their answer cannot change until the next
@@ -869,6 +877,39 @@ async function tellTheOpenPages() {
 
 const immutable = (url) => url.pathname.startsWith('/assets/') || /-[A-Za-z0-9_-]{8,}\\.[a-z]+$/.test(url.pathname)
 
+// The build the server is on, as a page reported it: a page told 409 - its
+// build is not the server's - says so here before it loads the document,
+// and answers with the same to say it has been heard. Until this worker is
+// replaced, a stored document from any other build is served from the
+// network rather than the cache. Without this a phone lived in a loop for
+// as long as the new worker took to install: the old worker served the old
+// document from cache, the old client was told 409 on its first tap, loaded
+// the document - the old one again - and so on, once per url, a document
+// load per tap, for the tens of seconds a phone spends precaching.
+let serverBuild = null
+
+self.addEventListener('message', (event) => {
+  const data = event.data
+
+  if (data && data.type === 'rsc-kit:server-build' && typeof data.version === 'string') {
+    serverBuild = data.version
+
+    if (event.ports && event.ports[0]) event.ports[0].postMessage({ type: 'rsc-kit:server-build', version: serverBuild })
+  }
+})
+
+// Whether a cached document may be the previous build's: the server has
+// been reported on another build than the copy carries, or a newer worker
+// is installing or waiting behind this one.
+const maybeStale = (hit) => {
+  if (!hit) return false
+  if (self.registration && (self.registration.installing || self.registration.waiting)) return true
+
+  const built = hit.headers.get('X-RSC-Version')
+
+  return serverBuild !== null && built !== null && built !== serverBuild
+}
+
 // Whether a response may be kept at all.
 //
 // \`no-store\` is not advice here, it is the answer. A query defaults to
@@ -905,11 +946,11 @@ const keyFor = (request) => {
 const standIn = async (request) => {
   if (!OFFLINE_URL) return null
 
-  if (request.mode === 'navigate') return (await caches.match(OFFLINE_URL)) ?? null
+  if (request.mode === 'navigate') return (await own(OFFLINE_URL)) ?? null
 
   if (request.headers.get('X-RSC') && !request.headers.get('X-RSC-Segments')) {
     return (
-      (await caches.match(
+      (await own(
         keyFor(new Request(new URL(OFFLINE_URL, self.location.origin), { headers: { 'X-RSC': '1' } })),
         MATCH,
       )) ?? null
@@ -960,7 +1001,7 @@ self.addEventListener('fetch', (event) => {
   // differently for every value of it.
   if (FROZEN.has(url.pathname.replace(/\\/+$/, '') || '/') && !url.search) {
     event.respondWith(
-      caches.match(keyFor(request), MATCH).then((hit) => {
+      own(keyFor(request), MATCH).then((hit) => {
         const fresh = fetch(request)
           .then((response) => {
             if (mayStore(response)) {
@@ -984,7 +1025,11 @@ self.addEventListener('fetch', (event) => {
           })
 
         // Not awaited when there is a hit: the point is that the visitor does
-        // not wait for the network for a page that cannot have changed.
+        // not wait for the network for a page that cannot have changed - and
+        // a deploy is how it changes, so a copy that may be the previous
+        // build's waits for the network, with the copy as the fallback.
+        if (maybeStale(hit)) return fresh.catch(() => hit)
+
         return hit ?? fresh
       }),
     )
@@ -1044,7 +1089,7 @@ self.addEventListener('fetch', (event) => {
         return response
       })
       .catch(async () => {
-        const hit = await caches.match(keyFor(request), MATCH)
+        const hit = await own(keyFor(request), MATCH)
 
         if (hit) return hit
 
@@ -2393,6 +2438,7 @@ import { LoadingBoundary } from ${JSON.stringify(join(packageDir, "js/LoadingBou
 import { DocumentTitle } from ${JSON.stringify(join(packageDir, "js/DocumentTitle"))}
 import { SlotBoundary } from ${JSON.stringify(join(packageDir, "js/SlotBoundary"))}
 import { RouteErrorBoundary } from ${JSON.stringify(join(packageDir, "js/RouteErrorBoundary"))}
+import __rsc_assets from 'virtual:vite-rsc/assets-manifest'
 import { sectionComponent } from ${JSON.stringify(join(packageDir, "js/section"))}
 import { PathnameProvider } from ${JSON.stringify(join(packageDir, "js/PathnameProvider"))}
 import { DefaultRouteError } from ${JSON.stringify(join(packageDir, "js/DefaultRouteError"))}
@@ -2659,14 +2705,48 @@ export function manifest(): any {
   return ${JSON.stringify(routeManifest())}
 }
 
+/**
+ * The stylesheet and the client entry every document of this build links,
+ * from the build's own manifest, for the host's Link header - a CDN sends
+ * it ahead as 103 Early Hints. The root layout's stylesheet is the one the
+ * document carries; the entry's own is usually empty, and either way both
+ * are named. See earlyHints.ts.
+ */
+export function criticalAssets(): { styles: string[]; modules: string[]; fonts: string[] } {
+  // Nothing to send ahead in development: the entry is Vite's own url, and
+  // there is no CDN in front to hint.
+  if (import.meta.env.DEV) return { styles: [], modules: [], fonts: [] }
+
+  const manifest = __rsc_assets as {
+    clientEntryUrl?: string
+    clientEntryDeps?: { css?: string[] }
+    serverResources?: Record<string, { css?: string[] }>
+  }
+  const styles = new Set<string>(manifest.clientEntryDeps?.css ?? [])
+
+  const rootLayouts = ['app/layout.tsx', 'app/layout.jsx', 'app/layout.ts', 'app/layout.js']
+
+  for (const [file, resources] of Object.entries(manifest.serverResources ?? {})) {
+    if (rootLayouts.some((name) => file === name || file.endsWith('/' + name))) {
+      for (const href of resources.css ?? []) styles.add(href)
+    }
+  }
+
+  return {
+    styles: [...styles],
+    modules: manifest.clientEntryUrl ? [manifest.clientEntryUrl] : [],
+    fonts: [],
+  }
+}
+
 let cachedBuildId: string | null = null
 
 /**
  * What this build's client is, as a short id.
  *
- * Derived from the bootstrap script the document ships - the hashed name of
- * the browser entry, which changes with the client references and chunks
- * it maps - so two builds whose browsers would disagree never share one.
+ * Derived from the bootstrap script the document ships and the assets
+ * manifest behind it - the entry, every client reference and the chunks
+ * each loads - so two builds whose browsers would disagree never share one.
  * The host puts it on every answer and compares it against what a client
  * says it is running; a mismatch on a payload request is a 409, and the
  * client loads the document instead. Read once, on demand, because the
@@ -2675,7 +2755,13 @@ let cachedBuildId: string | null = null
 export async function buildId(): Promise<string> {
   if (cachedBuildId !== null) return cachedBuildId
 
-  const content: string = await (import.meta as any).viteRsc.loadBootstrapScriptContent('index')
+  // The bootstrap script names the entry; the assets manifest names every
+  // client reference and the chunks each loads. A client component added
+  // to a layout changes the manifest and not always the entry - the
+  // reference map is its own chunk - and that is exactly the change an old
+  // client cannot survive, so the id covers both.
+  const content: string =
+    (await (import.meta as any).viteRsc.loadBootstrapScriptContent('index')) + JSON.stringify(__rsc_assets)
   let hash = 2166136261
 
   for (let i = 0; i < content.length; i++) {
@@ -4475,6 +4561,7 @@ async function serve(request: Request): Promise<Response> {
       resolveMetadata,
       runRouteMiddleware,
       buildId,
+      criticalAssets,
     } as never,
 ${NITRO_HANDLER_OPTIONS}${NITRO_PRERENDERED}    maxActionBody: ${maxActionBody === undefined ? "undefined" : String(maxActionBody)},
   })
@@ -4558,6 +4645,7 @@ function generateEntrySsr() {
     const fallbackReport = join(packageDir, "js/fallbackReport");
     const redirectDigestModule = join(packageDir, "redirectDigest");
     const notFoundModule = join(packageDir, "notFound");
+    const earlyClicks = join(packageDir, "js/earlyClicks");
     return `// GENERATED by rscKit() — do not edit.
 import { createFromReadableStream } from '@vitejs/plugin-rsc/ssr'
 import { renderToReadableStream, resume } from 'react-dom/server.edge'
@@ -4567,6 +4655,7 @@ import { noteFallback } from ${JSON.stringify(request)}
 import { cancelledByConsumer, caughtByLoading } from ${JSON.stringify(fallbackReport)}
 import { parseRedirectDigest } from ${JSON.stringify(redirectDigestModule)}
 import { isNotFoundDigest } from ${JSON.stringify(notFoundModule)}
+import { EARLY_CLICKS } from ${JSON.stringify(earlyClicks)}
 
 // Set only by the dev server. @vitejs/plugin-rsc emits its bootstrap and CSS
 // links root-relative in dev, which would send the browser to the host for
@@ -4585,8 +4674,11 @@ export async function handleSsr(
   // Without the bootstrap the page ships no client runtime at all: no React,
   // no Flight client, no router. HTML only. A page with nothing interactive on
   // it has no use for 70kB of hydration.
+  // The click listener first, then the runtime's import: a tap in the
+  // seconds before the runtime hydrates is held for it rather than given
+  // to the browser as a document load. See earlyClicks.ts.
   const bootstrapScriptContent = bootstrap
-    ? await (import.meta as any).viteRsc.loadBootstrapScriptContent('index')
+    ? EARLY_CLICKS + (await (import.meta as any).viteRsc.loadBootstrapScriptContent('index'))
     : undefined
 
   // Without an onError handler React rejects each abortable task on its own,
@@ -4628,7 +4720,7 @@ export async function handleSsrPrerender(
   const bootstrapScriptContent =
     options.bootstrap === false
       ? undefined
-      : await (import.meta as any).viteRsc.loadBootstrapScriptContent('index')
+      : EARLY_CLICKS + (await (import.meta as any).viteRsc.loadBootstrapScriptContent('index'))
 
   const { prelude, postponed } = await prerender(root as any, {
     bootstrapScriptContent,
@@ -5458,6 +5550,16 @@ export function rscKit(options = {}) {
                 if (typeof nitro.options.compressPublicAssets !== "object")
                     nitro.options.compressPublicAssets = true;
                 nitro.options.virtual ??= {};
+                // The worker script is never cached by heuristics. It was served
+                // with no Cache-Control at all, and a browser keeps such a file for a
+                // tenth of its age: a deploy's new worker then installs the previous
+                // deploy's list against the new server, every file 404s, and the
+                // install fails - leaving the old worker in charge, serving the old
+                // documents, for as long as the browser holds the script.
+                nitro.options.routeRules = {
+                    ...(nitro.options.routeRules ?? {}),
+                    "/sw.js": { ...(nitro.options.routeRules?.["/sw.js"] ?? {}), headers: { "cache-control": "no-cache", ...(nitro.options.routeRules?.["/sw.js"]?.headers ?? {}) } },
+                };
                 // The names of functions survive Nitro's bundle. The pages were
                 // prerendered against Vite's own server bundles, where a dependency
                 // is loaded from node_modules under the names it was written with;