@rsc-kit/core 0.10.0 → 0.12.0

package/dist/vite.js

@@ -12,7 +12,7 @@
 // carry the route composition and the worker's render contract, and supplies
 // the structural config (entries, output dirs, base). @vitejs/plugin-rsc is
 // included here so it always runs before any react() layer the app adds.
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { gzipSync } from 'node:zlib';
 import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
@@ -20,6 +20,9 @@ import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import rsc from '@vitejs/plugin-rsc';
 import { loadEnv } from 'vite';
+import { REPORT_FILE, buildReport } from './buildReport.js';
+import { MANIFEST_PATH, manifestWarning, webManifest } from './webManifest.js';
+import { ASSET_BASE, appAssets, headTags } from './appAssets.js';
 import { httpHostCalls } from './hostCalls.js';
 // Resolved once per rscKit() call. One build runs in one process, so these are
 // module state rather than threaded through every helper.
@@ -58,6 +61,8 @@ let isWatch = false;
 let viewTransitions = false;
 /** Whether a service worker is generated and registered — see options. */
 let offline = false;
+let webManifestOptions = null;
+let foundAssets = { favicon: null, icons: [], appleIcon: null, openGraph: null, twitter: null };
 /** Host functions to generate stubs for — see RscKitOptions.hostActions. */
 let hostActions;
 /**
@@ -201,6 +206,20 @@ function resolvePaths(options) {
     prerenderAfterBuild = options.prerender ?? process.env.RSC_PRERENDER !== '0';
     viewTransitions = options.viewTransitions === true;
     offline = options.offline === true;
+    // One place, and it is the file. A plugin option as well would be the same
+    // thing sayable in two places, which is the problem the file was moved to
+    // solve rather than a convenience to keep beside it.
+    webManifestOptions = declaredManifest(join(sourceDir, 'app'));
+    foundAssets = appAssets(join(sourceDir, 'app'));
+    // An app that put icons where they could be found has already listed them.
+    // Writing them again in the manifest is the same set in two places, and the
+    // one that goes stale is the one nobody looks at.
+    if (webManifestOptions && !webManifestOptions.icons?.length && foundAssets.icons.length) {
+        webManifestOptions = {
+            ...webManifestOptions,
+            icons: foundAssets.icons.map((icon) => icon.href),
+        };
+    }
     hostActions = options.hostActions ?? fileHostActions(projectRoot);
 }
 function log(...args) {
@@ -547,17 +566,63 @@ function reportAllDynamic() {
  * Nothing else is touched. An action is a POST and must never be answered from
  * a cache; anything cross-origin is somebody else's to cache.
  */
-export const SERVICE_WORKER = (version, precache) => `// GENERATED by rscKit() — do not edit.
+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
 const PRECACHE = ${JSON.stringify(precache, null, 2)}
 
+// The urls the build stored whole. Their answer cannot change until the next
+// deploy, and a deploy changes VERSION and sweeps this cache — so for these,
+// and only these, the cache is the better source and the network is the
+// fallback rather than the other way round.
+//
+// Everything else stays network-first. A page that reads the request has a
+// right answer that depends on the request, and serving yesterday's from a
+// cache would be wrong in a way the visitor cannot see.
+const FROZEN = new Set(${JSON.stringify(frozen)})
+
+// The page to show when a navigation cannot be answered at all.
+//
+// An ordinary route at /offline, stored at build time like any other — nothing
+// special about the file, only about when it is served. Null when the app has
+// none, and then a navigation with nothing cached fails as it always did.
+//
+// Deliberately NOT the cached root. That was tried: the document IS the page
+// here, so the visitor got the home page's markup under the address they asked
+// for and it did not hydrate — a wrong page pretending to be the right one.
+// This one is about being offline whatever url it appears under, so it is the
+// only page that can honestly stand in for another.
+const OFFLINE_URL = ${JSON.stringify(offlineUrl)}
+${swExtra
+    ? `
+// The app's own worker code — push, notification clicks, background sync.
+//
+// importScripts rather than a bundled import, because this file is evaluated
+// in a worker scope by the browser rather than built: whatever the app wrote is
+// run as it was written, in the same global, so its listeners sit beside the
+// ones below.
+//
+// First, so an app handler for an event this file does not handle is registered
+// before anything here can call respondWith on it.
+self.importScripts(${JSON.stringify(swExtra)})
+`
+    : ''}
+
 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
   // asking for the names it was built with, and those are still cached under
   // their own version until this activates and sweeps.
-  event.waitUntil(caches.open(CACHE).then((cache) => cache.addAll(PRECACHE)).then(() => self.skipWaiting()))
+  event.waitUntil(
+    caches
+      .open(CACHE)
+      // The offline page is fetched rather than copied from the build output:
+      // it is served by the host out of the prerendered directory, which this
+      // worker cannot see. Added here so it is in the cache before it is
+      // needed, which is the only moment it cannot be fetched.
+      .then((cache) => cache.addAll(OFFLINE_URL ? [...PRECACHE, OFFLINE_URL] : PRECACHE))
+      .then(() => self.skipWaiting()),
+  )
 })
 
 self.addEventListener('activate', (event) => {
@@ -565,10 +630,24 @@ self.addEventListener('activate', (event) => {
     caches
       .keys()
       .then((keys) => Promise.all(keys.filter((k) => k.startsWith('rsc-kit-') && k !== CACHE).map((k) => caches.delete(k))))
-      .then(() => self.clients.claim()),
+      .then(() => self.clients.claim())
+      .then(() => tellTheOpenPages()),
   )
 })
 
+// A page open right now is running the previous build's javascript, and the
+// chunks it has not loaded yet were just swept. It cannot fix that by itself —
+// only a reload gets the new ones — so it is told, and the app decides what to
+// say about it.
+//
+// After the sweep rather than before, so a page acting on this immediately
+// reloads into the new version rather than racing the deletion.
+async function tellTheOpenPages() {
+  const open = await self.clients.matchAll({ type: 'window' })
+
+  for (const page of open) page.postMessage({ type: 'rsc-kit:updated', version: VERSION })
+}
+
 const immutable = (url) => url.pathname.startsWith('/assets/') || /-[A-Za-z0-9_-]{8,}\\.[a-z]+$/.test(url.pathname)
 
 // Whether a response may be kept at all.
@@ -622,6 +701,40 @@ self.addEventListener('fetch', (event) => {
     return
   }
 
+  // A stored page, asked for without a query string. Cache first, and refresh
+  // in the background so the next visit has the new one even if this worker
+  // never updates.
+  //
+  // The query matters for the same reason it matters to a stored api route:
+  // the build answered the bare url, and a page reading ?q= answers
+  // differently for every value of it.
+  if (FROZEN.has(url.pathname.replace(/\\/+$/, '') || '/') && !url.search) {
+    event.respondWith(
+      caches.match(keyFor(request)).then((hit) => {
+        const fresh = fetch(request)
+          .then((response) => {
+            if (mayStore(response)) {
+              const copy = response.clone()
+              caches.open(CACHE).then((cache) => cache.put(keyFor(request), copy))
+            }
+
+            return response
+          })
+          .catch((error) => {
+            if (hit) return hit
+
+            throw error
+          })
+
+        // 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.
+        return hit ?? fresh
+      }),
+    )
+
+    return
+  }
+
   event.respondWith(
     fetch(request)
       .then((response) => {
@@ -678,12 +791,25 @@ self.addEventListener('fetch', (event) => {
 
         if (hit) return hit
 
-        // Nothing cached for this url and no network to ask. Falling back to
-        // the cached root was worse than failing: the document IS the page
-        // here, so the visitor got the home page's markup under the address
-        // they asked for, and it did not hydrate — a wrong page pretending to
-        // be the right one. Letting it fail says what is true, and a page
-        // already open is unaffected.
+        // Nothing cached for this url and no network to ask.
+        //
+        // Falling back to the cached ROOT was worse than failing: the document
+        // IS the page here, so the visitor got the home page's markup under the
+        // address they asked for, and it did not hydrate — a wrong page
+        // pretending to be the right one.
+        //
+        // An offline page is different, and is the one page that can honestly
+        // stand in for another: it is about being offline, not about the url it
+        // appears under. Navigations only — a payload request answered with a
+        // document would be decoded as one and throw.
+        if (OFFLINE_URL && request.mode === 'navigate') {
+          const page = await caches.match(OFFLINE_URL)
+
+          if (page) return page
+        }
+
+        // Letting it fail says what is true, and a page already open is
+        // unaffected.
         return Response.error()
       }),
   )
@@ -698,9 +824,150 @@ self.addEventListener('fetch', (event) => {
  * and a build that changed anything produces a different one — which is the
  * whole of cache invalidation, without asking anyone to set a variable.
  */
-function writeServiceWorker(clientDir) {
+/**
+ * Write the web app manifest into the client output, beside the assets.
+ *
+ * Into the same directory the browser is served from, because that is where a
+ * relative icon path resolves — a manifest served from somewhere else resolves
+ * its icons somewhere else too, and the failure is a browser that quietly does
+ * not offer to install.
+ */
+/**
+ * The manifest an app declared beside its routes.
+ *
+ * `src/app/manifest.ts`, default-exporting the object — the same shape every
+ * other thing about a route tree takes here, and the reason this is a file
+ * rather than a `vite.config.ts` key. A manifest is not build configuration
+ * any more than a page is; it is one more thing the app declares about itself,
+ * and it belongs where the app is.
+ *
+ * Evaluated with the TypeScript stripped rather than imported: this runs while
+ * the plugin is being constructed, long before there is a module graph to pull
+ * it through, and importing an app module here would drag its imports in with
+ * it. The file is a literal object by contract, which is all that has to parse.
+ */
+export function declaredManifest(appDir) {
+    for (const extension of ['ts', 'tsx', 'js', 'mjs']) {
+        const file = join(appDir, `manifest.${extension}`);
+        if (!existsSync(file))
+            continue;
+        const source = readFileSync(file, 'utf-8');
+        // The object literal after `export default`, with a `satisfies` or `as`
+        // annotation tolerated after it — which is how anyone who wants the type
+        // checked will actually write the file, and getting that wrong would refuse
+        // the recommended spelling.
+        //
+        // A manifest that is not a literal — computed, imported from elsewhere — is
+        // refused loudly rather than silently ignored, because the failure would
+        // otherwise be an app that is simply not installable with nothing said.
+        const match = /export\s+default\s+(\{[\s\S]*\})(?:\s+(?:satisfies|as)\s+[\w.<>\[\]| ]+)?\s*;?\s*$/.exec(source.trim());
+        if (!match) {
+            throw new Error(`[rsc-kit] app/manifest.${extension} must default-export an object literal.\n` +
+                'It is read at build time, before there is a module graph to evaluate it in, so it ' +
+                'cannot be computed or imported from elsewhere.');
+        }
+        try {
+            // Function rather than JSON.parse: the file is TypeScript source with
+            // unquoted keys, trailing commas and comments in it, none of which JSON
+            // accepts and all of which are ordinary in a file a person edits.
+            return new Function(`return (${match[1]})`)();
+        }
+        catch (error) {
+            throw new Error(`[rsc-kit] Could not read app/manifest.${extension}: ${error.message}`);
+        }
+    }
+    return null;
+}
+/**
+ * Copy the icons and share images into the client output.
+ *
+ * They live in `app/` so the build can read them - an icon's filename decides
+ * what goes in the manifest - but a browser has to be able to fetch them, and
+ * nothing serves `app/`. Copied rather than symlinked: the output is what gets
+ * deployed, and a link into a source tree that is not deployed points nowhere.
+ */
+function copyAppAssets(clientDir) {
+    if (!existsSync(clientDir))
+        return;
+    const all = [
+        ...(foundAssets.favicon ? [foundAssets.favicon] : []),
+        ...foundAssets.icons,
+        ...(foundAssets.appleIcon ? [foundAssets.appleIcon] : []),
+        ...(foundAssets.openGraph ? [foundAssets.openGraph] : []),
+        ...(foundAssets.twitter ? [foundAssets.twitter] : []),
+    ];
+    if (all.length === 0)
+        return;
+    for (const asset of all) {
+        const to = join(clientDir, asset.href.slice(1));
+        mkdirSync(dirname(to), { recursive: true });
+        copyFileSync(join(sourceDir, 'app', asset.file), to);
+    }
+    log(`icons: ${all.length} copied from app/`);
+}
+function writeWebManifest(clientDir, options) {
     if (!existsSync(clientDir))
         return;
+    writeFileSync(join(clientDir, MANIFEST_PATH.slice(1)), webManifest(options));
+    const warning = manifestWarning(options);
+    if (warning)
+        log(warning);
+    else
+        log(`manifest: ${options.name} is installable`);
+}
+/**
+ * The url a navigation falls back to when nothing else can answer it.
+ *
+ * An ordinary route at /offline, and it has to be one the build STORED — a
+ * page that renders per request cannot be served when there is no request to
+ * be made. So a dynamic /offline is refused as a fallback rather than
+ * precached and found wanting at the one moment it matters, and the build says
+ * which read did it.
+ */
+function offlineFallback(frozen, results) {
+    const found = results.find((r) => r.url === '/offline');
+    if (!found)
+        return null;
+    if (!frozen.includes('/offline')) {
+        // The reason already reads "dynamic — called cookies()", and this sentence
+        // has said "not stored" by the time it gets there, so the prefix would say
+        // it twice with a dash in the middle of both.
+        const why = found.reason?.replace(/^dynamic — /, '') ?? null;
+        log('offline: /offline cannot be the fallback' +
+            (why ? `, because it ${why}` : '') +
+            '. A fallback has to be servable with no network at all.');
+        return null;
+    }
+    return '/offline';
+}
+/**
+ * The app's own service worker code, if it wrote any.
+ *
+ * `src/app/sw.js`, copied next to the generated worker and imported by it. Plain
+ * javascript rather than TypeScript, and that is not an oversight: it is
+ * evaluated by the browser in a worker scope with no build step in front of it,
+ * so what is written is what runs. Calling it .js says so.
+ *
+ * This is the only way to add an event this package does not handle — push,
+ * notificationclick, sync — without giving up everything the generated worker
+ * does. There is no option for it because there is nothing to configure: the
+ * file is there or it is not.
+ */
+function copyServiceWorkerExtra(clientDir) {
+    const source = join(sourceDir, 'app', 'sw.js');
+    if (!existsSync(source))
+        return null;
+    copyFileSync(source, join(clientDir, 'sw-app.js'));
+    return '/sw-app.js';
+}
+function writeServiceWorker(clientDir, frozen = [], offlineUrl = null) {
+    if (!existsSync(clientDir))
+        return;
+    // Before the walk, so it lands in the precache with everything else. The
+    // worker importScripts it while evaluating, which is the one moment it cannot
+    // go to the network for it — a worker whose import fails does not start, and
+    // then nothing is cached at all.
+    const extra = copyServiceWorkerExtra(clientDir);
     const files = [];
     const walk = (dir, prefix) => {
         for (const entry of readdirSync(dir, { withFileTypes: true })) {
@@ -718,8 +985,10 @@ function writeServiceWorker(clientDir) {
     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));
-    log(`offline: ${precache.length} files precached as rsc-kit-${version}`);
+    writeFileSync(join(clientDir, 'sw.js'), SERVICE_WORKER(version, precache, frozen, offlineUrl, extra));
+    log(`offline: ${precache.length} files precached as rsc-kit-${version}` +
+        (offlineUrl ? `, falling back to ${offlineUrl}` : '') +
+        (extra ? ', with app/sw.js' : ''));
 }
 /**
  * The rsc bundle the build just wrote, whatever it decided to call it.
@@ -768,6 +1037,7 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir) {
     // Weighed from the page the prerenderer just wrote, so the column is what
     // that page actually loads rather than a total every route is charged for.
     const weigh = weighClientJs(assetsDir);
+    const sized = new Map();
     const pending = [];
     const results = await prerender({
         engine,
@@ -779,9 +1049,12 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir) {
             const file = [`${key}.html`, `${key}.ppr.html`]
                 .map((name) => join(staticDir, name))
                 .find((path) => existsSync(path));
+            const bytes = file ? weigh(readFileSync(file, 'utf-8')) : null;
+            if (bytes !== null)
+                sized.set(r.url, bytes);
             pending.push({
                 line: `  ${mark[r.type] ?? ' '}  ${r.url}`,
-                bytes: file ? weigh(readFileSync(file, 'utf-8')) : null,
+                bytes,
                 extra: [
                     ...(r.reason ? [`     ${r.reason}`] : []),
                     ...(r.warning ? [`     ⚠  ${r.warning}`] : []),
@@ -793,7 +1066,8 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir) {
     // either answered or could not, which is the same question the table above
     // is already answering — a second list under its own heading would be two
     // places to look for one fact.
-    const apis = await prerenderApiRoutes(engine, engine.manifest(), writeTo(staticDir));
+    const manifest = engine.manifest();
+    const apis = await prerenderApiRoutes(engine, manifest, writeTo(staticDir));
     for (const api of apis) {
         pending.push({
             line: `  ${api.type === 'frozen' ? '○' : 'ƒ'}  ${api.url}`,
@@ -811,6 +1085,16 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir) {
             console.log(line);
     }
     const count = (type) => results.filter((r) => r.type === type).length;
+    // Written from the rows that were just printed rather than recomputed: the
+    // report and the terminal must not be able to disagree about what happened.
+    writeFileSync(join(outDir, REPORT_FILE), buildReport(results.map((r) => ({
+        url: r.url,
+        component: r.component,
+        type: r.type,
+        reason: r.reason,
+        warning: r.warning ?? null,
+        clientJs: sized.get(r.url) ?? null,
+    })), apis.map((a) => ({ url: a.url, name: a.name, type: a.type, reason: a.reason }))));
     const note = notes(results);
     const counted = [...results, ...apis];
     console.log(`
@@ -824,6 +1108,28 @@ ${legend(counted)}
     }
     if (output === 'export')
         await exportAfterPrerender(results, staticDir, assetsDir);
+    // The urls whose answer cannot change until the next build. The service
+    // worker serves these from its cache first rather than asking the network
+    // and falling back — see writeServiceWorker.
+    //
+    // Two narrowings beyond "frozen", and neither is redundant even though the
+    // worker would survive without them. A guarded route IS frozen — the guard
+    // is a serving decision, not a build one — but its response is per visitor
+    // and must never be read from a cache that has no notion of who asked. A
+    // redirect is stored as a destination rather than a page, so there is no
+    // document to serve from a cache at all.
+    //
+    // Both are already refused downstream: a guarded response carries no-store
+    // and a 3xx is not `ok`. Saying it here as well means the list means what it
+    // says, rather than being a wider list that happens to be filtered later.
+    const guarded = new Set(manifest.routes.filter((r) => r.middleware?.length).map((r) => r.component));
+    return {
+        frozen: results
+            .filter((r) => r.type === 'frozen' && !guarded.has(r.component))
+            .filter((r) => existsSync(join(staticDir, pathKeyOf(r.url) + '.html')))
+            .map((r) => r.url),
+        results,
+    };
 }
 /**
  * Weighs the javascript one stored page makes the browser download.
@@ -1357,6 +1663,7 @@ import { PathnameProvider } from ${JSON.stringify(join(packageDir, "js/PathnameP
 import { searchParams as requestSearchParams } from ${JSON.stringify(join(packageDir, "request"))}
 import { parseParams, parseSearchParams, parseBody, isSearchParamsError, isBodyError } from ${JSON.stringify(join(packageDir, "routeSchema"))}
 import { notFoundDigest, isNotFoundSignal } from ${JSON.stringify(join(packageDir, "notFound"))}
+import { noteRequestRead } from ${JSON.stringify(join(packageDir, "request"))}
 import { redirectDigest } from ${JSON.stringify(join(packageDir, "redirectDigest"))}
 import { createRscHandler } from ${JSON.stringify(join(packageDir, "host"))}
 import { httpHostCalls } from ${JSON.stringify(join(packageDir, 'hostCalls'))}
@@ -1381,6 +1688,20 @@ ${mapEntries.join('\n')}
  * Empty for a page that exported none, which is the common case — the lookup
  * below then hands the url through untouched and costs a property read.
  */
+/**
+ * The manifest to link from every page, or null when the app declared none.
+ *
+ * A literal rather than a define: defines are configured per environment and
+ * this is read while rendering, in the rsc one. Generated in, so an app with
+ * no manifest carries the word null and no branch worth taking.
+ */
+/** Head tags for the icons and share images found in app/. */
+const APP_HEAD: { tag: any; props: Record<string, string> }[] = ${JSON.stringify(headTags(foundAssets))}
+
+const WEB_MANIFEST: { href: string; themeColor?: string } | null = ${JSON.stringify(webManifestOptions
+        ? { href: MANIFEST_PATH, ...(webManifestOptions.themeColor ? { themeColor: webManifestOptions.themeColor } : {}) }
+        : null)}
+
 const urlSchemas: Record<string, { params?: any; searchParams?: any }> = {
 ${schemaEntries.join('\n')}
 }
@@ -1401,6 +1722,33 @@ ${apiEntries.join('\n')}
  * without a body. Answering 405 instead breaks link checkers and anything that
  * probes before it fetches.
  */
+/**
+ * A promise that does not start until something awaits it.
+ *
+ * A thenable rather than a promise for the reason pageSearchParams is one:
+ * every handler is handed all three of these whether it reads them or not, and
+ * a real promise would run the work - and record the read - for every route on
+ * every request.
+ */
+function lazily<T>(start: () => Promise<T>): Promise<T> {
+  let pending: Promise<T> | null = null
+
+  const begin = (): Promise<T> => {
+    if (!pending) {
+      pending = start()
+      pending.catch(() => {})
+    }
+
+    return pending
+  }
+
+  return {
+    then: (ok, fail) => begin().then(ok, fail),
+    catch: (fail) => begin().catch(fail),
+    finally: (done) => begin().finally(done),
+  } as Promise<T>
+}
+
 /** Whether a method may carry a body worth reading. */
 function hasBody(method: string): boolean {
   return method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'DELETE'
@@ -1454,26 +1802,39 @@ export async function handleApiRoute(
     return new Response('Method not allowed', { status: 405, headers: { Allow: allow } })
   }
 
-  // Schemas are optional, per route and per kind. A route that exported none
-  // reaches the handler with exactly what it always did — the raw params, the
-  // URLSearchParams, and a body nobody has read — so nothing written before
-  // this existed changes behaviour.
-  let input
+  // Awaited by the handler, not before it - the same shape a page's props have,
+  // and for more than symmetry. A route that never awaits its query string
+  // provably does not vary by it, so the build can store one answer and the
+  // host can serve it for any query at all. Resolved eagerly here, that fact
+  // is unknowable and every ?utm_source= misses the stored answer.
+  //
+  // Schemas stay optional per route and per kind. A route that exported none
+  // gets the raw params, the URLSearchParams, and a body nobody has read.
+  const input = {
+    params: lazily(() => parseParams(mod.params, params)),
+    searchParams: lazily(() => {
+      // Declaring a schema is itself a statement that the query matters, so a
+      // route with one is treated as varying by it whether or not the handler
+      // reaches for the value.
+      noteRequestRead('searchParams')
+
+      return parseSearchParams(mod.searchParams, new URL(request.url).searchParams)
+    }),
+    body: hasBody(method) ? lazily(() => parseBody(mod.body, request)) : undefined,
+  }
+
+  if (mod.searchParams) noteRequestRead('searchParams')
+
+  let answer
   try {
-    input = {
-      params: await parseParams(mod.params, params),
-      searchParams: await parseSearchParams(
-        mod.searchParams,
-        new URL(request.url).searchParams,
-      ),
-      body: hasBody(method) ? await parseBody(mod.body, request) : undefined,
-    }
+    answer = await handler(request, input)
   } catch (error) {
+    // A refusal raised by one of the thenables above surfaces here, because the
+    // handler awaited it and did not catch it. Anything else is the route's own
+    // failure and is left to the caller.
     return refusedInput(error)
   }
 
-  const answer = await handler(request, input)
-
   // A HEAD answered by GET must not carry a body.
   if (method === 'HEAD' && answer instanceof Response) {
     return new Response(null, { status: answer.status, headers: answer.headers })
@@ -1868,6 +2229,27 @@ async function renderTree(
   const md = await resolveMetadata(component, props, layouts)
   const head: unknown[] = []
 
+  // Rendered into the tree rather than written into the app's layout: React
+  // hoists a link and a meta into <head> from anywhere, so this works for an
+  // app that already has a layout and never asks anyone to edit one. The
+  // engine knows the manifest exists; the app should not have to.
+  // Icons and share images the build found in app/. Rendered here so React
+  // hoists them into <head>, the same way the manifest link is — an app never
+  // edits its layout to get a favicon.
+  for (const [i, tag] of APP_HEAD.entries()) {
+    head.push(createElement(tag.tag, { key: '__a' + i, ...tag.props }))
+  }
+
+  if (WEB_MANIFEST) {
+    head.push(createElement('link', { key: '__mf', rel: 'manifest', href: WEB_MANIFEST.href }))
+
+    if (WEB_MANIFEST.themeColor) {
+      head.push(
+        createElement('meta', { key: '__tc', name: 'theme-color', content: WEB_MANIFEST.themeColor }),
+      )
+    }
+  }
+
   if (md) {
     if (md.title != null) {
       // The element is what a server render puts in <head>, and what a route
@@ -3517,9 +3899,17 @@ export function rscKit(options = {}) {
             const staticDir = clientOut
                 ? join(dirname(clientOut), 'server', NITRO_STATIC_DIR)
                 : join(outDir, NITRO_STATIC_DIR);
-            await prerenderAfterBundles(bundle, staticDir, clientOut ?? publicAssetsDir);
-            if (offline)
-                writeServiceWorker(clientOut ?? publicAssetsDir);
+            const { frozen, results } = await prerenderAfterBundles(bundle, staticDir, clientOut ?? publicAssetsDir);
+            // Manifest first. The service worker precaches whatever it finds in this
+            // directory, so writing it afterwards leaves it out of the list — and an
+            // installed app whose manifest is the one file that needs the network is
+            // the wrong way round.
+            copyAppAssets(clientOut ?? publicAssetsDir);
+            if (webManifestOptions)
+                writeWebManifest(clientOut ?? publicAssetsDir, webManifestOptions);
+            if (offline) {
+                writeServiceWorker(clientOut ?? publicAssetsDir, frozen, offlineFallback(frozen, results));
+            }
         },
         configResolved(config) {
             isWatch = config.build?.watch != null;