@rsc-kit/core 0.16.3 → 0.18.0

package/dist/vite.js

@@ -16,13 +16,21 @@ import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync,
 import { gzipSync } from "node:zlib";
 import { createHash } from "node:crypto";
 import { createRequire } from "node:module";
-import { dirname, join, relative, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import rsc, { getPluginApi } 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, allAppAssets, appAssets, headTags, typeOf, } from "./appAssets.js";
+import { reactCacheImports } from "./reactCache.js";
+import { clientEntries, clientScanPlugin, engineClientEntries, } from "./clientEntries.js";
+import { serverImportsOfClientPackages } from "./clientImports.js";
+import { automaticSitemap, METADATA_ROUTES, ROOT_FILES, rootFileType, } from "./metadataRoutes.js";
+import { ownHosts } from "./hostRouting.js";
+import { unrollBarrelImports } from "./barrelImports.js";
+import { serverRendererMessage, SERVER_RENDERER, ssrProxyModule, UseSsrError, } from "./useSsr.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.
@@ -30,8 +38,13 @@ let projectRoot;
 let sourceDir;
 let inlineStylesheets = "auto";
 let resolvedConfig = null;
+/** Server files importing a client library, read off the rsc graph when it is built. */
+let clientLibraryImports = [];
 /** Modules a runtime provides and no bundle should try to carry. */
 const RUNTIME_BUILTINS = ["bun", /^bun:/];
+function arrayOf(value) {
+    return value == null ? [] : Array.isArray(value) ? value : [value];
+}
 /**
  * What a client chunk is called on disk.
  *
@@ -93,11 +106,15 @@ let routeConfig;
 let prerenderAfterBuild;
 /** True during `vite build --watch`, where re-rendering every route is noise. */
 let isWatch = false;
-/** Whether navigations are wrapped in React's ViewTransition — see options. */
-let viewTransitions = false;
 /** Whether a service worker is generated and registered — see options. */
 let offline = false;
+let typecheck = true;
 let webManifestOptions = null;
+/** The site's own hosts, from the root layout's metadataBase and rscKit({ hosts }). */
+let siteHosts = [];
+let hostsOption = [];
+let barrelImports = true;
+let identify = true;
 let foundAssets = {
     favicon: null,
     icons: [],
@@ -258,8 +275,11 @@ function resolvePaths(options) {
     // sets it, and so does a host that drives the build out of process and
     // prerenders itself afterwards with paths only it knows.
     prerenderAfterBuild = process.env.RSC_PRERENDER !== "0";
-    viewTransitions = options.viewTransitions === true;
     offline = options.offline === true;
+    typecheck = options.typecheck !== false;
+    hostsOption = options.hosts ?? [];
+    barrelImports = options.barrelImports !== false;
+    identify = options.identify !== false;
     inlineStylesheets = options.inlineStylesheets ?? "auto";
     maxActionBody = options.maxActionBody;
     // One place, and it is the file. A plugin option as well would be the same
@@ -313,7 +333,12 @@ function urlSegments(componentName) {
             continue;
         }
         if (part.startsWith("[") && part.endsWith("]")) {
-            segments.push({ type: "param", value: part.slice(1, -1) });
+            // At the top of app/ - the first segment the url has - a parameter is
+            // the host's: bound from acme.example.com, never from example.com/acme.
+            segments.push({
+                type: segments.length === 0 ? "host" : "param",
+                value: part.slice(1, -1),
+            });
             continue;
         }
         // An interception marker says which url this replaces, not what it is
@@ -385,7 +410,11 @@ function routeManifest() {
      * to whoever knows what they mean.
      */
     const middlewareIn = (absDir) => {
-        for (const file of ["route.ts", "route.tsx"]) {
+        // middleware.ts first: it is the file named for what this is. A guard
+        // the engine runs is its default export; the names a host runs are its
+        // `middleware` export, and a file may carry either or both. route.ts is
+        // read too, for the apps written before middleware.ts could.
+        for (const file of ["middleware.ts", "middleware.tsx", "route.ts", "route.tsx"]) {
             const path = join(absDir, file);
             if (!existsSync(path))
                 continue;
@@ -471,14 +500,22 @@ function routeManifest() {
     // writing the site out, and knowing which filename the client will ask for.
     return {
         version: 1,
-        build: { output, exportPath, payloadName: staticPayloads },
+        build: {
+            output,
+            exportPath,
+            payloadName: staticPayloads,
+            hosts: siteHosts,
+            identify,
+        },
         routes,
         intercepts,
-        apis: [...apiRoutes.values()].map(({ name, methods }) => ({
+        apis: [...apiRoutes.values()].map(({ name, methods, generated }) => ({
             name,
             segments: urlSegments(name),
             methods,
-            middleware: ancestors(name, "middleware"),
+            // A synthesised robots.txt or sitemap.xml runs no guard: it exists to be
+            // read by anyone, and a guard on the root would 401 the crawler.
+            middleware: generated ? [] : ancestors(name, "middleware"),
         })),
     };
 }
@@ -956,6 +993,9 @@ export function declaredManifest(appDir) {
 function copyAppAssets(clientDir) {
     if (!existsSync(clientDir))
         return;
+    for (const file of rootFiles) {
+        copyFileSync(join(sourceDir, "app", file), join(clientDir, file));
+    }
     const all = allAppAssets(foundAssets);
     if (all.length === 0)
         return;
@@ -1221,6 +1261,41 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
     // places to look for one fact.
     const manifest = engine.manifest();
     const apis = await prerenderApiRoutes(engine, manifest, writeTo(staticDir));
+    // A sitemap the build writes itself, when the app wrote none: every url
+    // it stored or was told about, minus the guarded ones. It needs the site's
+    // host, which the root layout's metadataBase is for; without one there is
+    // nothing to write and the report says so once.
+    const writesSitemap = manifest.apis?.some((api) => api.name === "app/sitemap.xml/route");
+    const hasSitemapFile = rootFiles.includes("sitemap.xml");
+    if (!writesSitemap && !hasSitemapFile) {
+        const base = rootMetadataBase(join(sourceDir, "app"));
+        if (base) {
+            const xml = automaticSitemap(results, manifest.routes, base);
+            const stored = JSON.stringify({
+                status: 200,
+                headers: [["content-type", "application/xml; charset=utf-8"]],
+                body: xml,
+                varies: false,
+            });
+            await writeTo(staticDir)("sitemap.xml.api.json", stored);
+            pending.push({
+                line: "  ○  /sitemap.xml",
+                bytes: null,
+                extra: [
+                    `     written by the build: ${xml.split("<url>").length - 1} urls; a sitemap.ts beside the root layout replaces it`,
+                ],
+            });
+        }
+        else {
+            pending.push({
+                line: "  -  /sitemap.xml",
+                bytes: null,
+                extra: [
+                    "     not written: the root layout has no metadataBase to make the urls absolute",
+                ],
+            });
+        }
+    }
     for (const api of apis) {
         pending.push({
             line: `  ${api.type === "frozen" ? "○" : "ƒ"}  ${api.url}`,
@@ -1258,6 +1333,30 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
         console.log("     Nothing checks who calls them. Fine for a public one; otherwise build it\n" +
             "     from an action client, so the check cannot be forgotten.");
     }
+    // Server files importing cache from React. Its cache() memoises on the
+    // dispatcher a render installs, so in a guard, an action, an api route or
+    // the SSR pass it calls straight through - no dedupe, no error, the helper
+    // runs twice. The difference is silent, which is why this line exists.
+    const reactCache = reactCacheImports(sourceDir);
+    if (reactCache.length > 0) {
+        console.log(`\n  \u26a0  ${reactCache.length} server ${reactCache.length === 1 ? "file imports" : "files import"} cache from 'react': ` +
+            reactCache.join(", "));
+        console.log("     React's cache() dedupes only inside a component render; in a guard, an action or\n" +
+            "     an api route it calls straight through. Import it from @rsc-kit/core/cache instead.");
+    }
+    // Server files importing a client library. Legal - a server component may
+    // render a client component from a package - but the shape that costs an
+    // afternoon is a file with no "use client" that only wraps them, so the
+    // library's internals run on the server. Said, with the packages and the
+    // importer, so the person reading can tell which it is.
+    if (clientLibraryImports.length > 0) {
+        console.log(`\n  \u2139  ${clientLibraryImports.length} server ${clientLibraryImports.length === 1 ? "file imports" : "files import"} a client library: ` +
+            clientLibraryImports
+                .map((c) => `${c.file} (${c.packages.join(", ")}${c.from ? `; imported by ${c.from}` : ""})`)
+                .join("; "));
+        console.log('     Legal for a server component. A file that only wraps client components wants "use client" -\n' +
+            "     as shadcn ships it - so the server stops at the boundary.");
+    }
     // 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) => ({
@@ -1274,7 +1373,7 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
         type: a.type,
         reason: a.reason,
         warning: a.warning ?? null,
-    })), audited));
+    })), audited, reactCache, clientLibraryImports));
     const note = notes(results);
     const counted = [...results, ...apis];
     console.log(`
@@ -1441,6 +1540,23 @@ function renderRouteTypes(manifest) {
         const target = relative(typesDir, join(sourceDir, route.component)).replace(/\\/g, "/");
         search.set(pattern, target.startsWith(".") ? target : "./" + target);
     }
+    // Section names are read from the source - section('orders', …) - the way
+    // generateStaticParams is detected, because this runs before any bundle
+    // exists. A name computed at runtime is not seen and revalidate() falls
+    // back to refusing it at the renderer, as before.
+    const regions = [
+        ...new Set([
+            ...[...components.values()]
+                .filter((c) => SECTION_FILE.test(c.absPath))
+                .flatMap((c) => [
+                ...readFileSync(c.absPath, "utf-8").matchAll(/\bsection\(\s*['"`]([^'"`]+)['"`]/g),
+            ].map((m) => m[1])),
+            ...[...components.keys()].flatMap((name) => {
+                const slot = name.split("/").find((part) => part.startsWith("@"));
+                return slot ? [slot.slice(1)] : [];
+            }),
+        ]),
+    ].sort();
     return [
         "// @generated — do not edit. Written by the RSC build from the route tree.",
         "//",
@@ -1474,6 +1590,14 @@ function renderRouteTypes(manifest) {
         // Api routes are a separate union, so Link refuses an api url and apiUrl()
         // refuses a page. Linking to an api route navigates the browser away to a
         // json document, which is the mistake worth catching.
+        // Regions: every section('name', …) the build read, and every @slot
+        // directory. This is what types revalidate().
+        "  interface RegisterRegions {",
+        regions.length > 0
+            ? "    regions:\n" +
+                regions.map((r) => "      | " + JSON.stringify(r)).join("\n")
+            : "    // No sections or slots found under the source directory.\n    regions: never",
+        "  }",
         "  interface RegisterApi {",
         apis.length > 0
             ? "    apis:\n" +
@@ -1571,6 +1695,76 @@ const components = new Map();
  * a default component.
  */
 const apiRoutes = new Map();
+/** Files beside the root layout served at the root as they are: robots.txt, a hand-written sitemap.xml, humans.txt. */
+let rootFiles = [];
+const METADATA_ROUTE_ID = "virtual:rsc-kit/metadata-route/";
+/**
+ * robots.ts, sitemap.ts, llms.ts beside the root layout, each registered as
+ * an api route at the file it stands for. The module the entry imports is
+ * synthesised (metadataRoutesPlugin): the app's default export, formatted by
+ * the engine, with the root layout's metadataBase for relative urls.
+ *
+ * Api routes, so nothing else is new: the build stores the ones that read
+ * nothing per request and names the ones that do. Without middleware, on
+ * purpose - these exist to be read by anyone, and a guard on the root would
+ * otherwise 401 the crawler asking for robots.txt.
+ */
+function registerMetadataRoutes(appDir) {
+    rootFiles = existsSync(appDir)
+        ? readdirSync(appDir)
+            .filter((name) => ROOT_FILES.test(name))
+            .sort()
+        : [];
+    for (const kind of Object.keys(METADATA_ROUTES)) {
+        const source = ["ts", "tsx", "js", "mjs"]
+            .map((ext) => join(appDir, `${kind}.${ext}`))
+            .find((file) => existsSync(file));
+        if (!source)
+            continue;
+        const { file } = METADATA_ROUTES[kind];
+        if (rootFiles.includes(file)) {
+            throw new Error(`[rsc-kit] app/${basename(source)} and app/${file} both answer /${file}. Keep one: the function, or the file as written.`);
+        }
+        const name = `app/${file}/route`;
+        if (apiRoutes.has(name)) {
+            throw new Error(`[rsc-kit] app/${basename(source)} and app/${file}/route.ts both answer /${file}. Keep one.`);
+        }
+        apiRoutes.set(name, {
+            name,
+            absPath: METADATA_ROUTE_ID + kind,
+            methods: ["GET"],
+            generated: { kind, file: source },
+        });
+    }
+}
+/** The module behind a synthesised metadata route. */
+function metadataRoutesPlugin() {
+    return {
+        name: "rsc-kit:metadata-routes",
+        resolveId(id) {
+            if (id.startsWith(METADATA_ROUTE_ID))
+                return "\0" + id;
+        },
+        load(id) {
+            if (!id.startsWith("\0" + METADATA_ROUTE_ID))
+                return;
+            const kind = id.slice(("\0" + METADATA_ROUTE_ID).length);
+            const route = [...apiRoutes.values()].find((r) => r.generated?.kind === kind);
+            if (!route?.generated)
+                return;
+            const rootLayout = components.get("app/layout")?.absPath ?? null;
+            return [
+                `import produce from ${JSON.stringify(route.generated.file)}`,
+                rootLayout
+                    ? `import * as __root from ${JSON.stringify(rootLayout)}`
+                    : "const __root = {}",
+                `import { metadataResponse } from ${JSON.stringify(join(packageDir, "metadataRoutes"))}`,
+                `export const GET = () => metadataResponse(${JSON.stringify(kind)}, produce, __root.metadata?.metadataBase ?? null)`,
+                "",
+            ].join("\n");
+        },
+    };
+}
 function register(absPath) {
     const name = componentName(absPath);
     const existing = components.get(name);
@@ -1605,10 +1799,20 @@ function registerApiRoute(absPath) {
     }
     apiRoutes.set(name, { name, absPath, methods });
 }
+/**
+ * Whether a middleware.ts is a guard the engine runs, or only names guards
+ * the host runs. The engine imports a guard's default export; a file with
+ * none - `export const middleware = ['auth']` and nothing else - has nothing
+ * to import, and registering it would make the build fail on an export that
+ * was never meant to exist.
+ */
+function isEngineGuard(absPath) {
+    return /export\s+default\b/.test(readFileSync(absPath, "utf-8"));
+}
 function discover(dir) {
     for (const base of ROUTE_FILES) {
         const p = findRouteFile(dir, base);
-        if (p)
+        if (p && (base !== "middleware" || isEngineGuard(p)))
             register(p);
     }
     // route.ts — an api endpoint, colocated with the pages it sits among. Read
@@ -1639,6 +1843,21 @@ function discover(dir) {
  * pages export only the static object, so referencing both meant that warning
  * for almost every route in an app.
  */
+/**
+ * The root layout's metadataBase, read from the source. Wanted while the
+ * manifest is built, before there is a bundle to execute - the same reason
+ * generateStaticParams is detected by reading. A `new URL('…')` or a string
+ * literal; anything computed is not seen, and rscKit({ hosts }) says it.
+ */
+function rootMetadataBase(appDir) {
+    const layout = ["layout.tsx", "layout.jsx", "layout.ts", "layout.js"]
+        .map((name) => join(appDir, name))
+        .find((file) => existsSync(file));
+    if (!layout)
+        return null;
+    const match = /metadataBase\s*:\s*(?:new\s+URL\(\s*)?["'`](https?:\/\/[^"'`]+)["'`]/.exec(readFileSync(layout, "utf-8"));
+    return match ? match[1] : null;
+}
 function metadataExports(absPath) {
     const src = readFileSync(absPath, "utf-8");
     return {
@@ -1833,7 +2052,29 @@ function installHostCallsOnce(): void {
 }
 
 `;
+/**
+ * The app's process bootstrap, if it has one: `instrumentation.ts` beside
+ * `app/`, the name Next uses so a reader arriving from there knows what it
+ * is.
+ *
+ * Two things make it a framework concern rather than an import the app
+ * adds. Module evaluation order: a page that configures a shared package at
+ * import time runs before any module the app could put first, and only the
+ * generated entry can import something before the pages. And "before the
+ * first request": an async `register()` — connecting, validating env — has
+ * to be awaited by every entry point a host or a prerender can call, which
+ * is a list the app cannot see.
+ */
+function instrumentationFile() {
+    for (const ext of ["ts", "tsx", "mts", "js", "mjs"]) {
+        const file = join(sourceDir, `instrumentation.${ext}`);
+        if (existsSync(file))
+            return file;
+    }
+    return null;
+}
 function generateEntryRsc(fallbackOrigin = "") {
+    const instrumentation = instrumentationFile();
     // The 404 page, if the app has one, and the layouts it renders inside.
     // Computed here rather than looked up at runtime: not-found is not a route,
     // so the manifest has no entry to read its chain from.
@@ -1890,12 +2131,20 @@ function generateEntryRsc(fallbackOrigin = "") {
     // from src/ in its own repo and from dist/ once published, and Vite resolves
     // either. Naming .tsx here builds fine from source and fails after publish.
     return `// GENERATED by rscKit() — do not edit.
+${
+    // First, before any page: an import's side effects run in import order,
+    // and a package configured here has to be configured before a page module
+    // that reads it at evaluation time.
+    instrumentation
+        ? `import * as __instrumentation from ${JSON.stringify(instrumentation)}`
+        : "const __instrumentation: { register?: () => unknown } = {}"}
 import { SegmentBoundary } from ${JSON.stringify(join(packageDir, "js/SegmentBoundary"))}
 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 { 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"))}
 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"))}
@@ -1907,6 +2156,9 @@ import { prerenderedBeside } from ${JSON.stringify(join(packageDir, "files"))}
 import { renderToReadableStream, decodeReply, loadServerAction } from '@vitejs/plugin-rsc/rsc'
 import { isQuery, queryCacheControl, isQueryValidationError } from ${JSON.stringify(join(packageDir, "query"))}
 import { isActionValidationError, isClientBuilt } from ${JSON.stringify(join(packageDir, "action"))}
+import { noteFallback as noteCaughtRead } from ${JSON.stringify(join(packageDir, "request"))}
+import { isOutdatedOptimizedDep, outdatedDepResponse } from ${JSON.stringify(join(packageDir, "devReload"))}
+import { sharedDepth } from ${JSON.stringify(join(packageDir, "routing"))}
 import { Suspense, createElement, Fragment } from 'react'
 import { AsyncLocalStorage } from 'node:async_hooks'
 ${imports.join("\n")}
@@ -2032,6 +2284,7 @@ export async function handleApiRoute(
   params: Record<string, string>,
   allow: string,
 ): Promise<Response> {
+  await instrumented()
   applyHost()
 
   const mod = apiRoutes[name]
@@ -2139,6 +2392,8 @@ export async function auditActions(ids: string[]): Promise<{ id: string; client:
  * that asked for everything, or the reverse.
  */
 export async function getStaticParams(component: string): Promise<Record<string, string>[] | null> {
+  await instrumented()
+
   const generate = staticParamsMap[component]
 
   if (!generate) return null
@@ -2162,6 +2417,57 @@ const HOST_GLOBAL = ${JSON.stringify(hostGlobal)}
  */
 const HOST_MIDDLEWARE_FN = '__rsc.middleware'
 
+/**
+ * instrumentation.ts's register(), once.
+ *
+ * On a long-lived server it runs at startup: the entry is evaluated when the
+ * process starts, and this begins then, so env that fails validation fails
+ * the boot rather than the first visitor, and the first request does not
+ * pay for it. On a Worker there is no startup — an isolate is created for a
+ * request, and a binding is only readable once one has arrived — so it runs
+ * at the first request of each isolate instead. Every entry point awaits it
+ * either way, which is what makes "before the first render" hold whether the
+ * caller is the built server, the dev server or the prerender.
+ *
+ * A rejection is not memoised. Env that fails validation fails the same way
+ * on every request, which is right; a database that was not up yet gets
+ * asked again rather than leaving the process permanently refusing. In
+ * production a startup failure is reported and the process exits, because a
+ * server that could not bootstrap has nothing correct to serve; the dev
+ * server stays up and reports it on the page instead.
+ */
+let __instrumented: Promise<void> | null = null
+
+function instrumented(): Promise<void> {
+  if (!__instrumented) {
+    __instrumented = Promise.resolve()
+      .then(() => __instrumentation.register?.())
+      .then(
+        () => undefined,
+        (error) => {
+          __instrumented = null
+          throw error
+        },
+      )
+  }
+
+  return __instrumented
+}
+
+// Workers name themselves; nothing else does. Where there is a process to
+// start, start now.
+const isolateRuntime = typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers'
+
+if (__instrumentation.register && !isolateRuntime) {
+  instrumented().catch((error) => {
+    console.error('[rsc-kit] instrumentation.ts register() failed:', error)
+
+    if (!import.meta.env.DEV && typeof process !== 'undefined' && typeof process.exit === 'function') {
+      process.exit(1)
+    }
+  })
+}
+
 let currentHost: HostFn | null = null
 
 export function installHostFn(fn: HostFn) {
@@ -2395,6 +2701,19 @@ function buildElement(
     )
   }
 
+  // Outermost, for a throw no error.tsx covers - including one in a layout,
+  // which the boundary inside that layout cannot see. Without it React
+  // unmounted the document on hydration: a black page with the cause nowhere
+  // near it. Only with the runtime: it is a client component, and a route
+  // shipping none has nothing to catch with.
+  if (bootstrap) {
+    element = createElement(
+      RouteErrorBoundary,
+      { fallback: DefaultRouteError as never, resetKey: pageKey || component },
+      element,
+    )
+  }
+
   // <title>/<meta> go OUTSIDE the Suspense boundaries so they reach the shell
   // immediately — inside, they would be withheld until the page's data
   // resolves, delaying the whole document on a slow page.
@@ -2548,6 +2867,40 @@ async function renderTree(
       if (bootstrap) head.push(createElement(DocumentTitle, { key: '__ts', title: String(md.title) }))
     }
     if (md.description != null) head.push(createElement('meta', { key: '__d', name: 'description', content: String(md.description) }))
+    // The name only, never the version - see the identify option.
+    if (manifest().build?.identify) head.push(createElement('meta', { key: '__g', name: 'generator', content: 'rsc-kit' }))
+
+    // robots is a string, or the object Next takes: index and follow as
+    // their no- forms, the flags by name, the limits as name:value. googleBot
+    // is the same shape for the googlebot tag. The object used to fall
+    // through to the catch-all below as "[object Object]" - which no crawler
+    // reads, on the one page that asked not to be indexed.
+    const robotsContent = (value: unknown): string => {
+      if (typeof value !== 'object' || value === null) return String(value)
+
+      const r = value as Record<string, unknown>
+      const parts: string[] = []
+
+      if (r.index != null) parts.push(r.index ? 'index' : 'noindex')
+      if (r.follow != null) parts.push(r.follow ? 'follow' : 'nofollow')
+      for (const flag of ['noarchive', 'nosnippet', 'noimageindex', 'nocache', 'notranslate', 'indexifembedded', 'nositelinkssearchbox']) {
+        if (r[flag]) parts.push(flag)
+      }
+      if (r.unavailable_after != null) parts.push('unavailable_after: ' + String(r.unavailable_after))
+      for (const limit of ['max-video-preview', 'max-image-preview', 'max-snippet']) {
+        if (r[limit] != null) parts.push(limit + ':' + String(r[limit]))
+      }
+
+      return parts.join(', ')
+    }
+
+    if (md.robots != null) {
+      head.push(createElement('meta', { key: '__r', name: 'robots', content: robotsContent(md.robots) }))
+
+      const bot = typeof md.robots === 'object' ? (md.robots as { googleBot?: unknown }).googleBot : null
+
+      if (bot != null) head.push(createElement('meta', { key: '__rg', name: 'googlebot', content: robotsContent(bot) }))
+    }
 
     // og: and its relatives are PROPERTY, not name. Facebook's scraper - and
     // Slack's, and LinkedIn's - reads only property=, so every og tag this
@@ -2653,7 +3006,7 @@ async function renderTree(
     // meta tags rather than a meta tag by that name. A key at the top level
     // still renders - the type no longer invites one, but an app written
     // against the old shape must not silently lose its tags.
-    const structured = new Set(['title', 'description', 'metadataBase', 'openGraph', 'twitter', 'icons', 'other'])
+    const structured = new Set(['title', 'description', 'robots', 'metadataBase', 'openGraph', 'twitter', 'icons', 'other'])
     const named = Object.entries(md).filter(([k]) => !structured.has(k))
     const extra = Object.entries((md.other ?? {}) as Record<string, unknown>)
 
@@ -2817,6 +3170,7 @@ async function runMiddleware(component: string, props: Record<string, unknown> =
  * throws, exactly as it does mid-render.
  */
 export async function runRouteMiddleware(component: string, props: Record<string, unknown> = {}): Promise<void> {
+  await instrumented()
   applyHost()
 
   return runMiddleware(component, props)
@@ -2832,6 +3186,7 @@ export async function handleRscStream(
   from = 0,
   pageKey = '',
 ): Promise<{ stream: ReadableStream; clientChunks: unknown; segmentDepth: number }> {
+  await instrumented()
   applyHost()
 
   // The host proposes how much the client already has; the engine decides what
@@ -2887,6 +3242,7 @@ export async function handleRscHtmlStream(
   pageKey = '',
   bootstrap = true,
 ): Promise<{ htmlStream: ReadableStream; rscPayloadPromise: Promise<string>; clientChunks: unknown }> {
+  await instrumented()
   applyHost()
   await runMiddleware(component, props)
   const flight = renderToReadableStream(
@@ -2922,6 +3278,7 @@ export async function handleRscResume(
   nonce?: string,
   pageKey = '',
 ): Promise<{ htmlStream: ReadableStream }> {
+  await instrumented()
   applyHost()
   await runMiddleware(component, props)
 
@@ -3072,6 +3429,7 @@ export async function handleQuery(
   | { status: number; message: string; errors?: Record<string, string[]> }
   | null
 > {
+  await instrumented()
   applyHost()
 
   let fn: unknown
@@ -3120,6 +3478,7 @@ export async function handleAction(
   page?: PageContext,
   takeRevalidated?: () => string[],
 ): Promise<{ stream: ReadableStream }> {
+  await instrumented()
   applyHost()
 
   // Every body arrives as bytes on its own socket frame — an upload because it
@@ -3212,6 +3571,8 @@ export async function resolveMetadata(
   props: Record<string, unknown> = {},
   layouts: LayoutEntry[] = [],
 ): Promise<Record<string, unknown> | null> {
+  await instrumented()
+
   const pageEntry = metadataMap[component]
   const page: Record<string, unknown> = pageEntry
     ? (pageEntry.generate
@@ -3281,6 +3642,7 @@ export async function handleRsc(
   bootstrap = true,
   canReachHost = true,
 ): Promise<{ body: string; rscPayload: string; clientChunks: unknown; usedDynamicApis: boolean; dynamicBecause: string[]; clientComponents: string[]; serverReferences: boolean }> {
+  await instrumented()
   applyHost()
 
   // A build renders this with no host installed, so every rpc() has to suspend
@@ -3394,6 +3756,7 @@ export async function handleRscRevalidate(
   target: string,
   page: PageContext,
 ): Promise<{ rscPayload: string }> {
+  await instrumented()
   applyHost()
 
   const flight = renderToReadableStream(await renderRevalidated(target, page))
@@ -3410,6 +3773,7 @@ export async function handleRscPayload(
   from = 0,
   pageKey = '',
 ): Promise<{ rscPayload: string }> {
+  await instrumented()
   applyHost()
 
   const flight = renderToReadableStream(
@@ -3477,6 +3841,7 @@ export async function handleRscPprShell(
   // and make every guarded route dynamic for the wrong reason.
   let usedDynamicApis = false
 
+  await instrumented()
   applyHost()
 
   const probe = (..._args: unknown[]) => {
@@ -3506,12 +3871,22 @@ export async function handleRscPprShell(
   // page, stored, with the build reporting success.
   let renderFailure: string | undefined
 
-  const noteFailure = (e: unknown): string | undefined => {
+  const noteFailure = (e: unknown, info?: { componentStack?: string }): string | undefined => {
     const digest = redirectDigest(e)
 
     // A redirect is a classification here, not a failure.
     if (digest) return digest
 
+    // A read the server could not answer, caught at a boundary: the fallback
+    // there is what gets stored. Noted with its component so the build can
+    // say so on the route's line; the digest goes into the document for the
+    // browser to recognise.
+    if ((e as { digest?: string } | null)?.digest === 'rsc-kit:search-params-fallback') {
+      const where = /at ([A-Z][\\w$]*)/.exec(info?.componentStack ?? '')?.[1]
+      noteCaughtRead('useSearchParams()' + (where ? ' in ' + where : ''))
+      return 'rsc-kit:search-params-fallback'
+    }
+
     // Every probe ends by aborting, so React reports that abort. Asked of the
     // signal rather than matched against the message: a string test would be a
     // guess about wording, and would quietly stop working when React changed it.
@@ -3624,6 +3999,29 @@ ${fallbackOrigin ? FALLBACK_CONSTS.replace("__ORIGIN__", JSON.stringify(fallback
 let devHandler: ((request: Request) => Promise<Response | null>) | null = null
 
 export default async function handler(request: Request): Promise<Response> {
+  try {
+    return await serve(request)
+  } catch (error) {
+    // Vite re-optimised a server pre-bundle under this render. The condition
+    // is over already; the page is asked to load again.
+    if (import.meta.env.DEV && isOutdatedOptimizedDep(error)) return outdatedDepResponse(request)
+
+    throw error
+  }
+}
+
+async function serve(request: Request): Promise<Response> {
+  // The startup plugin's probe. Nitro loads this module at the first request
+  // rather than when the server starts, so a plugin that runs at startup
+  // sends one request to load it; the module's evaluation began register(),
+  // and this waits for it so a failure is reported as the startup failure it
+  // is. No page is rendered and nothing is disclosed.
+  if (request.headers.get('x-rsc-kit-startup') !== null) {
+    await instrumented()
+
+    return new Response(null, { status: 204 })
+  }
+
   installHostCallsOnce()
 
   devHandler ??= createRscHandler({
@@ -3647,7 +4045,7 @@ export default async function handler(request: Request): Promise<Response> {
 ${NITRO_HANDLER_OPTIONS}${NITRO_PRERENDERED}    maxActionBody: ${maxActionBody === undefined ? "undefined" : String(maxActionBody)},
   })
 
-${fallbackOrigin ? FALLBACK_BODY : "  return (await devHandler(request)) ?? (await notFound())\n"}}
+${fallbackOrigin ? FALLBACK_BODY : "  return (await devHandler(request)) ?? (await notFound(request))\n"}}
 
 /**
  * The page for a url nothing answers.
@@ -3658,9 +4056,42 @@ ${fallbackOrigin ? FALLBACK_BODY : "  return (await devHandler(request)) ?? (awa
  *
  * Without a not-found.tsx this is the string it always was.
  */
-async function notFound(): Promise<Response> {
+async function notFound(request: Request): Promise<Response> {
   ${notFoundComponent
         ? `
+  // A navigation, not a document: answer with the not-found tree as a
+  // payload, at the depth the client already holds, so the router renders
+  // it in place - the layout stays, the url changes, nothing reloads. The
+  // status is still 404; a payload is a payload whatever it says.
+  if (request.headers.get('X-RSC')) {
+    try {
+      const chain = ${JSON.stringify(notFoundLayouts)}
+      const from = sharedDepth(request.headers.get('X-RSC-Segments'), chain)
+      const { rscPayload } = await handleRscPayload(
+        ${JSON.stringify(notFoundComponent)},
+        {},
+        ${JSON.stringify(notFoundLayouts.map((component) => ({ component, props: {} })))},
+        [],
+        {},
+        from,
+        '/404',
+      )
+
+      return new Response(rscPayload, {
+        status: 404,
+        headers: {
+          'Content-Type': 'text/x-component; charset=utf-8',
+          'X-RSC-Segment-Depth': String(from),
+          'X-RSC-Layouts': chain.join(','),
+          'Cache-Control': 'no-store',
+          Vary: 'X-RSC',
+        },
+      })
+    } catch {
+      // Fall through to the document answer below.
+    }
+  }
+
   try {
     const { htmlStream } = await handleRscHtmlStream(
       ${JSON.stringify(notFoundComponent)},
@@ -3689,11 +4120,15 @@ async function notFound(): Promise<Response> {
 }
 function generateEntrySsr() {
     const devUrls = join(packageDir, "devUrls");
+    const request = join(packageDir, "request");
+    const fallbackReport = join(packageDir, "js/fallbackReport");
     return `// GENERATED by rscKit() — do not edit.
 import { createFromReadableStream } from '@vitejs/plugin-rsc/ssr'
 import { renderToReadableStream, resume } from 'react-dom/server.edge'
 import { prerender } from 'react-dom/static.edge'
 import { rewriteViteDevUrlStream } from ${JSON.stringify(devUrls)}
+import { noteFallback } from ${JSON.stringify(request)}
+import { cancelledByConsumer, caughtByLoading } from ${JSON.stringify(fallbackReport)}
 
 // 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
@@ -3724,12 +4159,28 @@ export async function handleSsr(
     // The query-string fallback is the designed path for a stored page, and
     // its digest is what lets the client tell it from a fault on hydration;
     // returned here so React writes it into the document.
-    onError: onError ?? ((error: unknown) => {
+    onError: onError ?? ((error: unknown, info?: { componentStack?: string }) => {
+      // The consumer cancelled - a browser that left mid-stream, a prefetch
+      // abandoned. React reports it as an error; the page had none.
+      if (cancelledByConsumer(error)) return
       const digest = (error as { digest?: string } | null)?.digest
       if (digest === 'rsc-kit:search-params-fallback') {
-        // One line, not a stack: the line is the dev server saying which
-        // boundary the build will want.
-        console.error('[rsc-kit] ' + String((error as Error).message))
+        // The component is the first frame of React's stack. Noted on the
+        // request so the build attaches it to the route; printed as one line,
+        // not a stack, so the dev server says which boundary the build wants.
+        const where = /at ([A-Z][\\w$]*)/.exec(info?.componentStack ?? '')?.[1]
+        noteFallback('useSearchParams()' + (where ? ' in ' + where : ''))
+        // Under a boundary the developer wrote, nothing to say. With nothing
+        // closer than a loading.tsx, one line: the whole segment is the
+        // fallback until the query arrives.
+        if (caughtByLoading(info?.componentStack)) {
+          console.error(
+            '[rsc-kit] ' + (where ? where + ': ' : '') +
+            'useSearchParams() was read on the server with nothing closer than a loading.tsx, so the whole ' +
+            'segment shows that fallback until the query arrives. A <Suspense> around the component that reads ' +
+            'keeps the rest of the page painted.',
+          )
+        }
         return digest
       }
       console.error('[rsc-kit:ssr]', error)
@@ -3769,8 +4220,14 @@ export async function handleSsrPrerender(
     bootstrapScriptContent,
     nonce: options.nonce,
     signal: options.signal,
-    // Aborting is how this ends, so React's report of it is not news.
-    onError: () => {},
+    // Aborting is how this ends, so React's report of it is not news. A read
+    // caught at a boundary is: the build attaches it to the route.
+    onError: (error: unknown, info?: { componentStack?: string }) => {
+      if ((error as { digest?: string } | null)?.digest !== 'rsc-kit:search-params-fallback') return
+      const where = /at ([A-Z][\\w$]*)/.exec(info?.componentStack ?? '')?.[1]
+      noteFallback('useSearchParams()' + (where ? ' in ' + where : ''))
+      return 'rsc-kit:search-params-fallback'
+    },
   })
 
   return {
@@ -4062,16 +4519,307 @@ function extendableClientReferences() {
         },
     };
 }
+/**
+ * The worker the dev server serves at /sw.js: it removes the one a production
+ * run left on this origin, and the caches with it, then reloads each page it
+ * was controlling so they load uncontrolled. Nothing else runs in development.
+ */
+export const DEV_WORKER = `self.addEventListener('install', () => self.skipWaiting())
+self.addEventListener('activate', (event) => {
+  event.waitUntil((async () => {
+    const keys = await caches.keys()
+    await Promise.all(keys.filter((k) => k.startsWith('rsc-kit-')).map((k) => caches.delete(k)))
+    await self.clients.claim()
+    const pages = await self.clients.matchAll({ type: 'window' })
+    await self.registration.unregister()
+    for (const page of pages) page.navigate(page.url).catch(() => {})
+  })())
+})
+`;
+/**
+ * Named imports from a barrel package, unrolled on the server environments.
+ *
+ * The browser gets lucide pre-bundled; the server environments do not, so
+ * `import { ArrowRight } from 'lucide-react'` loaded and transformed every
+ * icon module - 3,700 transforms, twenty-five seconds before the first
+ * document, for thirteen icons. See barrelImports. Development only: a
+ * build tree-shakes the barrel itself.
+ */
+function barrelImportsPlugin() {
+    const entries = new Map();
+    return {
+        name: "rsc-kit:barrel-imports",
+        apply: () => barrelImports && process.env.NODE_ENV !== "production",
+        enforce: "pre",
+        applyToEnvironment: (environment) => environment.name === "rsc" || environment.name === "ssr",
+        async transform(code, id) {
+            if (id.includes("/node_modules/") ||
+                !/\.[cm]?[jt]sx?$/.test(id.split("?")[0]))
+                return;
+            if (!code.includes("from"))
+                return;
+            const pending = [];
+            const wanted = new Set();
+            for (const m of code.matchAll(/import\s*(?:type\s+)?\{[^}]*\}\s*from\s*['"]([^'"./][^'"]*)['"]/g)) {
+                wanted.add(m[1]);
+            }
+            for (const specifier of wanted) {
+                if (entries.has(specifier))
+                    continue;
+                pending.push(this.resolve(specifier, id).then((resolved) => {
+                    entries.set(specifier, resolved && !resolved.external ? resolved.id.split("?")[0] : null);
+                }));
+            }
+            await Promise.all(pending);
+            const out = unrollBarrelImports(code, (specifier) => entries.get(specifier) ?? null);
+            return out === null ? undefined : { code: out, map: null };
+        },
+    };
+}
+/**
+ * "use ssr" modules, rewritten for the server-components environment into
+ * proxies that call the real module in the ssr environment. See useSsr.ts.
+ *
+ * Before every other transform, so the cross-environment import this emits
+ * is still ahead of plugin-rsc's handling of it - and so the module's own
+ * imports, react-dom/server among them, are never resolved here at all.
+ */
+function useSsrModules() {
+    return {
+        name: "rsc-kit:use-ssr",
+        enforce: "pre",
+        applyToEnvironment: (environment) => environment.name === "rsc",
+        transform(code, id) {
+            if (!code.includes("use ssr"))
+                return;
+            try {
+                const proxy = ssrProxyModule(code, id);
+                return proxy === null ? undefined : { code: proxy, map: null };
+            }
+            catch (error) {
+                if (error instanceof UseSsrError)
+                    this.error(error.message);
+                throw error;
+            }
+        },
+    };
+}
+/**
+ * react-dom/server, imported where server components render, becomes a
+ * module that throws the fix instead of React's refusal - naming the app
+ * file that imported it (through @react-email/render, say) and the
+ * directive that moves it. The build says the same once, as a warning.
+ */
+const RENDERER_STUB = "\0rsc-kit:react-dom-server?from=";
+function serverRendererInRsc() {
+    const warned = new Set();
+    const appImporter = (ctx, importer) => {
+        let current = importer;
+        for (let hop = 0; current && hop < 12; hop++) {
+            if (!current.includes("/node_modules/"))
+                return relative(process.cwd(), current.split("?")[0]);
+            const next = ctx.environment.mode === "build"
+                ? ctx.getModuleInfo(current)?.importers[0]
+                : (ctx.environment.moduleGraph
+                    ?.getModuleById(current)
+                    ?.importers.values()
+                    .next().value?.id ?? undefined);
+            if (!next)
+                break;
+            current = next;
+        }
+        return importer ? relative(process.cwd(), importer.split("?")[0]) : null;
+    };
+    return {
+        name: "rsc-kit:server-renderer",
+        applyToEnvironment: (environment) => environment.name === "rsc",
+        resolveId(source, importer) {
+            if (!SERVER_RENDERER.test(source))
+                return;
+            return RENDERER_STUB + encodeURIComponent(importer ?? "");
+        },
+        load(id) {
+            if (!id.startsWith(RENDERER_STUB))
+                return;
+            const importer = decodeURIComponent(id.slice(RENDERER_STUB.length)) || null;
+            const message = serverRendererMessage(appImporter(this, importer));
+            if (this.environment.mode === "build" && !warned.has(message)) {
+                warned.add(message);
+                this.warn(message);
+            }
+            return `throw new Error(${JSON.stringify(message)});\n`;
+        },
+    };
+}
+/**
+ * `tsc --noEmit` on the project's own tsconfig, the way `check` runs it.
+ *
+ * Through package.json rather than a subpath: TypeScript's exports map does
+ * not expose bin/tsc, and the bin field is where the name lives. Its output
+ * is the message, because that is what the developer would have read.
+ */
+export function typecheckProject(root) {
+    const tsconfig = join(root, "tsconfig.json");
+    if (!existsSync(tsconfig))
+        return { ran: false, because: "no tsconfig" };
+    let tsc;
+    try {
+        const fromApp = createRequire(join(root, "package.json"));
+        const manifest = fromApp.resolve("typescript/package.json");
+        const bin = fromApp(manifest)
+            .bin;
+        const relative = typeof bin === "string" ? bin : bin?.tsc;
+        if (!relative)
+            return { ran: false, because: "no typescript" };
+        tsc = join(dirname(manifest), relative);
+    }
+    catch {
+        return { ran: false, because: "no typescript" };
+    }
+    const started = Date.now();
+    const script = /\.[cm]?js$/.test(tsc) || !/\.\w+$/.test(tsc);
+    const result = spawnSync(script ? process.execPath : tsc, 
+    // Plain lines, not coloured ones: they go into a build error, and the
+    // test that reads them is a reader too.
+    [...(script ? [tsc] : []), "--noEmit", "--pretty", "false", "-p", tsconfig], { cwd: root, encoding: "utf-8", maxBuffer: 64 * 1024 * 1024 });
+    if (result.status === 0)
+        return { ran: true, ok: true, seconds: (Date.now() - started) / 1000 };
+    return {
+        ran: true,
+        ok: false,
+        output: `${result.stdout ?? ""}${result.stderr ?? ""}`.trim(),
+    };
+}
+/**
+ * The project's typecheck, as part of the build.
+ *
+ * Runs once, in the first environment to start, after the route types have
+ * been written by the config hook - so a link to a route that does not exist
+ * is an error here and not a 404 found after deploying. Skipped where the
+ * project is not doing this checking at all: no tsconfig.json, or no
+ * typescript to run.
+ */
+function typecheckPlugin() {
+    let ran = false;
+    return {
+        name: "rsc-kit:typecheck",
+        apply: "build",
+        buildStart() {
+            if (ran || !typecheck || isWatch)
+                return;
+            ran = true;
+            const outcome = typecheckProject(projectRoot);
+            if (!outcome.ran)
+                return;
+            if (outcome.ok) {
+                log(`typecheck: ok (${outcome.seconds.toFixed(1)}s)`);
+                return;
+            }
+            throw new Error("[rsc-kit] The typecheck failed, so the build stops here.\n\n" +
+                outcome.output +
+                "\n\nrscKit({ typecheck: false }) builds without it.");
+        },
+    };
+}
+/**
+ * Which server files import a client library, read off the rsc environment's
+ * module graph once it is built. plugin-rsc classifies the client packages
+ * (every package with react among its peers) and excludes them from the
+ * server optimizers; that list is the one used here, minus this package -
+ * a server component importing Link is the norm - and plugin-rsc's own.
+ */
+function clientImportsAudit() {
+    return {
+        name: "rsc-kit:client-imports",
+        apply: "build",
+        applyToEnvironment: (environment) => environment.name === "rsc",
+        buildEnd() {
+            const excluded = resolvedConfig?.environments?.rsc?.optimizeDeps?.exclude ?? [];
+            const clientPackages = excluded.filter((name) => !name.startsWith("@vitejs/plugin-rsc"));
+            if (clientPackages.length === 0)
+                return;
+            clientLibraryImports = serverImportsOfClientPackages({
+                moduleIds: () => this.getModuleIds(),
+                importedIds: (id) => this.getModuleInfo(id)?.importedIds ?? [],
+                importers: (id) => this.getModuleInfo(id)?.importers ?? [],
+            }, {
+                sourceDir,
+                clientPackages,
+                ignore: [PACKAGE_NAME, "server-only", "client-only"],
+            });
+        },
+    };
+}
+/**
+ * A Nitro runtime plugin, so instrumentation.ts runs when the server starts.
+ *
+ * Nitro loads the rsc service at the first request, not at startup - so
+ * without this, register() would run when the first visitor arrived, and a
+ * bad environment would take down a server that had already reported itself
+ * up. The plugin runs at app init and sends the service one request, which
+ * loads the module; loading it begins register(), and the request waits for
+ * it. Not on a Worker: there is no startup, and the first request is the
+ * first chance to read a binding.
+ */
+const STARTUP_PLUGIN = `import { viteServices } from "#nitro/virtual/vite-services"
+
+export default function rscKitStartup() {
+  if (typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers') return
+
+  // The ssr service is the one Nitro's renderer asks; its fetch imports the
+  // rsc entry and hands the request on. The rsc service's own export is the
+  // handler function, not a { fetch }, so it cannot be probed directly.
+  const ssr = viteServices.ssr
+  if (!ssr) return
+
+  // Two ways to fail, one outcome. register() rejecting is reported by the
+  // module itself. instrumentation.ts throwing at import - an env schema
+  // refusing - means the module never evaluated, so nothing in it can
+  // report; the load rejects here instead. Either way a server that could
+  // not bootstrap has nothing correct to serve, and says so and stops
+  // rather than reporting itself up.
+  ssr
+    .fetch(new Request('http://rsc-kit.internal/_rsc/startup', { headers: { 'x-rsc-kit-startup': '1' } }))
+    .then((response) => {
+      if (!response.ok) throw new Error('the startup probe answered ' + response.status)
+    })
+    .catch((error) => {
+      console.error('[rsc-kit] instrumentation.ts failed at startup:', error)
+
+      if (typeof process !== 'undefined' && typeof process.exit === 'function') process.exit(1)
+    })
+}
+`;
 export function rscKit(options = {}) {
     resolvePaths(options);
     const routesPlugin = {
         name: "rsc-kit",
+        // A Nitro module, which Nitro's Vite plugin collects from any plugin
+        // that carries one. Only for a built server: the dev server evaluates
+        // the entry through Vite's runner when it is first asked for, and there
+        // is no earlier moment to offer.
+        nitro: {
+            name: "rsc-kit",
+            setup(nitro) {
+                if (nitro.options.dev || !instrumentationFile())
+                    return;
+                nitro.options.virtual ??= {};
+                nitro.options.virtual["#rsc-kit/startup"] = STARTUP_PLUGIN;
+                nitro.options.plugins = [...(nitro.options.plugins ?? []), "#rsc-kit/startup"];
+            },
+        },
         config(_config, env) {
             if (!existsSync(appDir)) {
                 throw new Error(`[rsc-kit] No app directory at ${appDir} — nothing to build.`);
             }
+            // Both maps, not one: the config hook runs again when the config
+            // changes under a dev server, and a route.ts or a synthesised
+            // robots.txt left over from the previous run read as a duplicate.
             components.clear();
+            apiRoutes.clear();
             discover(appDir);
+            registerMetadataRoutes(appDir);
+            siteHosts = ownHosts(rootMetadataBase(appDir), hostsOption);
             // Silent when it worked. The names were printed on every dev start and
             // every build — thirty of them for a middling app, above the output that
             // actually says something, and the build's classification table lists
@@ -4160,9 +4908,6 @@ export function rscKit(options = {}) {
                  */
                 define: {
                     "process.env.NODE_ENV": JSON.stringify(env.mode === "development" ? "development" : "production"),
-                    // A constant, so the boundary and its import fall out of the bundle
-                    // entirely when this is off rather than shipping a branch nobody takes.
-                    __RSC_VIEW_TRANSITIONS__: JSON.stringify(viewTransitions),
                     __RSC_OFFLINE__: JSON.stringify(offline),
                 },
                 /*
@@ -4187,6 +4932,36 @@ export function rscKit(options = {}) {
                  */
                 optimizeDeps: {
                     exclude: [PACKAGE_NAME, ...(_config.optimizeDeps?.exclude ?? [])],
+                    // Every "use client" file, so the browser's dependencies are all
+                    // found at startup. The client entry reaches only the engine and
+                    // React; the app's client components arrive through payloads, page
+                    // by page, and a dependency first seen on the third page visited
+                    // re-optimised every pre-bundle under a running page - two Reacts,
+                    // a blank document, then Vite's own reload. See clientEntries.
+                    // Naming entries replaces the input, so the browser entry is named
+                    // too, or the engine and React would be the ones left out.
+                    entries: [
+                        ...(Array.isArray(_config.optimizeDeps?.entries)
+                            ? _config.optimizeDeps.entries
+                            : _config.optimizeDeps?.entries
+                                ? [_config.optimizeDeps.entries]
+                                : []),
+                        // Entries are globs: a route group's parentheses, or a bracket
+                        // in a dynamic segment, would otherwise read as pattern syntax
+                        // and match nothing - and the scanner would crawl nothing, quietly.
+                        ...[
+                            join(genDir, "entry.browser.tsx"),
+                            ...engineClientEntries(),
+                            ...clientEntries(sourceDir),
+                        ].map((file) => file.replace(/[()[\]{}*?!+@]/g, "\\$&")),
+                    ],
+                    rolldownOptions: {
+                        ...(_config.optimizeDeps?.rolldownOptions ?? {}),
+                        plugins: [
+                            clientScanPlugin(),
+                            ...arrayOf(_config.optimizeDeps?.rolldownOptions?.plugins),
+                        ],
+                    },
                 },
                 // Public URL for browser-facing client assets, and a BUILD concern
                 // only: it says where the built files will be served from.
@@ -4279,6 +5054,28 @@ export function rscKit(options = {}) {
             // and the console a 404 for a file that is right there.
             server.middlewares.use((req, res, next) => {
                 const url = (req.url ?? "").split("?")[0];
+                // A worker registered by a production run on this origin - `bun run
+                // start` on the port the dev server uses next - outlives that run and
+                // answers the dev server's documents from its cache: a stored page is
+                // cache-first, so a refresh brings back yesterday's document with
+                // yesterday's module hashes, and a 504 for each. The browser fetches
+                // /sw.js again on every navigation to look for an update; in
+                // development that fetch gets a worker whose only job is to remove
+                // itself, its caches, and reload the pages it controlled.
+                // robots.txt, a hand-written sitemap.xml, humans.txt: beside the root
+                // layout, served at the root. The build copies them beside the client
+                // output; here they are read from app/.
+                if (url.startsWith("/") && rootFiles.includes(url.slice(1))) {
+                    res.setHeader("Content-Type", rootFileType(url.slice(1)));
+                    res.end(readFileSync(join(sourceDir, "app", url.slice(1))));
+                    return;
+                }
+                if (url === "/sw.js") {
+                    res.setHeader("Content-Type", "text/javascript");
+                    res.setHeader("Cache-Control", "no-store");
+                    res.end(DEV_WORKER);
+                    return;
+                }
                 if (webManifestOptions && url === MANIFEST_PATH) {
                     res.setHeader("Content-Type", "application/manifest+json");
                     res.end(webManifest(webManifestOptions));
@@ -4506,7 +5303,13 @@ export function rscKit(options = {}) {
             clientChunks: (meta) => meta.normalizedId,
             ...actionEncryptionKey(),
         }),
+        barrelImportsPlugin(),
+        useSsrModules(),
+        serverRendererInRsc(),
+        metadataRoutesPlugin(),
         extendableClientReferences(),
+        typecheckPlugin(),
+        clientImportsAudit(),
         routesPlugin,
     ];
 }