@rsc-kit/core 0.16.0 → 0.16.2

package/dist/vite.js

@@ -12,22 +12,58 @@
 // 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 { 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';
-import { 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, appAssets, headTags } from './appAssets.js';
-import { httpHostCalls } from './hostCalls.js';
+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";
+import { 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, 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.
 let projectRoot;
 let sourceDir;
+let inlineStylesheets = "auto";
+let resolvedConfig = null;
+/** Modules a runtime provides and no bundle should try to carry. */
+const RUNTIME_BUILTINS = ["bun", /^bun:/];
+/**
+ * What a client chunk is called on disk.
+ *
+ * A "use server" module reaches the browser as a proxy - one stub per export
+ * that calls the action by id - and the proxy keeps the file's identity, so
+ * the bundler can name a chunk after it. When shared client code is merged
+ * into that chunk the output has a file called `auth-actions-…js` in
+ * public/assets: fifty kilobytes of UI components with the name of the
+ * server file, which reads as a leak to anyone who looks. Nothing leaked -
+ * the proxy holds ids, never bodies - but a name that says otherwise is a
+ * bug. Such a chunk is called what it is.
+ */
+function clientChunkFileName(chunk) {
+    const table = resolvedConfig
+        ? getPluginApi(resolvedConfig)?.manager?.serverReferences?.metaMap
+        : undefined;
+    if (table && table.size > 0) {
+        const bare = (id) => {
+            const file = id.split("?")[0].split("/").pop() ?? "";
+            return file.replace(/\.[^.]+$/, "");
+        };
+        const serverModules = new Set([...table.keys()].map(bare));
+        const namedAfterServerModule = (chunk.facadeModuleId !== null &&
+            serverModules.has(bare(chunk.facadeModuleId))) ||
+            (serverModules.has(chunk.name) &&
+                chunk.moduleIds.some((id) => bare(id) === chunk.name));
+        if (namedAfterServerModule)
+            return "assets/client-[hash].js";
+    }
+    return "assets/[name]-[hash].js";
+}
+let maxActionBody;
 let outDir;
 let appDir;
 let genDir;
@@ -62,7 +98,13 @@ 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 };
+let foundAssets = {
+    favicon: null,
+    icons: [],
+    appleIcon: null,
+    openGraph: null,
+    twitter: null,
+};
 /** Host functions to generate stubs for — see RscKitOptions.hostActions. */
 let hostActions;
 /**
@@ -77,11 +119,11 @@ let hostActions;
 /** This package's name, for excluding it from dep optimization. */
 const PACKAGE_NAME = (() => {
     try {
-        const manifest = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf-8'));
-        return manifest.name ?? '@rsc-kit/core';
+        const manifest = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf-8"));
+        return manifest.name ?? "@rsc-kit/core";
     }
     catch {
-        return '@rsc-kit/core';
+        return "@rsc-kit/core";
     }
 })();
 function thisDir() {
@@ -96,7 +138,7 @@ function envRouteConfig() {
     return { file, dynamicPattern: new RegExp(pattern) };
 }
 /** The file a backend writes its action names into. */
-const HOST_ACTIONS_FILE = 'rsc-host-actions.json';
+const HOST_ACTIONS_FILE = "rsc-host-actions.json";
 /**
  * Host actions, read from a file the backend wrote.
  *
@@ -117,8 +159,10 @@ function fileHostActions(root) {
     if (!existsSync(path))
         return {};
     try {
-        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
-        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (parsed === null ||
+            typeof parsed !== "object" ||
+            Array.isArray(parsed)) {
             throw new Error('expected an object of { jsName: "Class.method" }');
         }
         return parsed;
@@ -143,23 +187,23 @@ function fileHostActions(root) {
 function aliasEntries() {
     if (!packageAlias)
         return [];
-    if (existsSync(join(projectRoot, 'node_modules', packageAlias)))
+    if (existsSync(join(projectRoot, "node_modules", packageAlias)))
         return [];
     return [
         {
-            find: new RegExp('^' + packageAlias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '/(.*)$'),
-            replacement: join(packageDir, 'js') + '/$1',
+            find: new RegExp("^" + packageAlias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "/(.*)$"),
+            replacement: join(packageDir, "js") + "/$1",
         },
     ];
 }
 function resolvePaths(options) {
     projectRoot = resolve(options.projectRoot || process.env.RSC_PROJECT_ROOT || process.cwd());
-    sourceDir = resolve(options.sourceDir || process.env.RSC_SOURCE_DIR || join(projectRoot, 'src'));
-    outDir = resolve(options.outDir || process.env.RSC_OUT_DIR || join(projectRoot, '.rsc'));
-    appDir = join(sourceDir, 'app');
+    sourceDir = resolve(options.sourceDir || process.env.RSC_SOURCE_DIR || join(projectRoot, "src"));
+    outDir = resolve(options.outDir || process.env.RSC_OUT_DIR || join(projectRoot, ".rsc"));
+    appDir = join(sourceDir, "app");
     // Generated entries live under the (in-project) out dir so module resolution
     // can walk up to the project's node_modules (@vitejs/plugin-rsc, react, ...).
-    genDir = join(outDir, '.gen');
+    genDir = join(outDir, ".gen");
     // Not a migration guard — those are not worth carrying in a pre-release.
     // This is the silent-failure guard the rest of this file is written to be.
     //
@@ -171,31 +215,35 @@ function resolvePaths(options) {
     //
     // There is deliberately no check for `nitro`. It is gone from the type, and
     // a config still passing `nitro: true` is asking for exactly what it gets.
-    const removed = ['assetsDir', 'assetsUrl'].filter((key) => options[key] !== undefined);
+    const removed = ["assetsDir", "assetsUrl"].filter((key) => options[key] !== undefined);
     if (removed.length > 0) {
-        throw new Error(`[rsc-kit] ${removed.join(' and ')} ${removed.length === 1 ? 'is' : 'are'} no longer an option.\n\n` +
-            'Nitro publishes the browser assets to .output/public and serves them from its own\n' +
-            'root, so there is no prefix to set. That directory is the deployment — point nginx\n' +
-            'or a CDN at it if something other than the app should serve them.');
+        throw new Error(`[rsc-kit] ${removed.join(" and ")} ${removed.length === 1 ? "is" : "are"} no longer an option.\n\n` +
+            "Nitro publishes the browser assets to .output/public and serves them from its own\n" +
+            "root, so there is no prefix to set. That directory is the deployment — point nginx\n" +
+            "or a CDN at it if something other than the app should serve them.");
     }
     // Vite's own default. Nitro overrides it with .output/public, which is why
     // there is nothing here to configure.
-    publicAssetsDir = resolve(join(projectRoot, 'dist/client'));
-    typesDir = join(projectRoot, '.rsc-kit');
-    hotFile = options.hotFile || process.env.RSC_HOT_FILE || '';
+    publicAssetsDir = resolve(join(projectRoot, "dist/client"));
+    typesDir = join(projectRoot, ".rsc-kit");
+    hotFile = options.hotFile || process.env.RSC_HOT_FILE || "";
     hostCallOptions = options.hostCall;
     packageDir = resolve(options.packageDir || process.env.RSC_PACKAGE_DIR || thisDir());
-    hostGlobal = options.hostGlobal || process.env.RSC_HOST_GLOBAL || 'rpc';
-    interceptManifestFile = resolve(options.interceptManifestFile || process.env.RSC_INTERCEPT_MANIFEST || join(outDir, 'intercept-manifest.json'));
+    hostGlobal = options.hostGlobal || process.env.RSC_HOST_GLOBAL || "rpc";
+    interceptManifestFile = resolve(options.interceptManifestFile ||
+        process.env.RSC_INTERCEPT_MANIFEST ||
+        join(outDir, "intercept-manifest.json"));
     packageAlias = options.packageAlias || process.env.RSC_PACKAGE_ALIAS || null;
-    devOrigin = options.devOrigin || process.env.RSC_DEV_ORIGIN || '';
-    output = options.output || process.env.RSC_OUTPUT || 'server';
-    exportPath = options.exportPath || process.env.RSC_EXPORT_PATH || 'dist';
+    devOrigin = options.devOrigin || process.env.RSC_DEV_ORIGIN || "";
+    output = options.output || process.env.RSC_OUTPUT || "server";
+    exportPath = options.exportPath || process.env.RSC_EXPORT_PATH || "dist";
     // An export decides this for itself: the client has to ask for payloads by
     // url because there is no server to read a header, and the name it asks for
     // is the one the export writes.
     staticPayloads =
-        options.staticPayloads || process.env.RSC_STATIC_PAYLOADS || (output === 'export' ? 'index.rsc' : '');
+        options.staticPayloads ||
+            process.env.RSC_STATIC_PAYLOADS ||
+            (output === "export" ? "index.rsc" : "");
     // No default: which file marks a route dynamic is the host's convention, and
     // guessing one here would bake a particular backend into a generic plugin.
     // The env pair exists so a host driving the build out of process can pass it
@@ -203,18 +251,28 @@ function resolvePaths(options) {
     routeConfig = options.routeConfig ?? envRouteConfig();
     // A host driving the build out of process cannot pass an option, and may
     // prerender itself afterwards with paths only it knows.
-    prerenderAfterBuild = options.prerender ?? process.env.RSC_PRERENDER !== '0';
+    // No public switch. A page that must not be frozen says so with
+    // `await connection()`, and the build names every page that could not be
+    // rendered - the same model Next has with cache components, where the
+    // only opt-out is per page. RSC_PRERENDER=0 remains, internal: watch mode
+    // 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;
+    inlineStylesheets = options.inlineStylesheets ?? "auto";
+    maxActionBody = options.maxActionBody;
     // 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'));
+    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) {
+    if (webManifestOptions &&
+        !webManifestOptions.icons?.length &&
+        foundAssets.icons.length) {
         webManifestOptions = {
             ...webManifestOptions,
             icons: foundAssets.icons.map((icon) => icon.href),
@@ -223,7 +281,7 @@ function resolvePaths(options) {
     hostActions = options.hostActions ?? fileHostActions(projectRoot);
 }
 function log(...args) {
-    console.error('[rsc-kit]', ...args);
+    console.error("[rsc-kit]", ...args);
 }
 // ── The route manifest ───────────────────────────────────────────────────────
 /**
@@ -241,37 +299,37 @@ function log(...args) {
  */
 /** `[...path]` → catchAll, `[id]` → param, `(group)` → nothing at all. */
 function urlSegments(componentName) {
-    const parts = componentName.split('/').slice(1, -1);
+    const parts = componentName.split("/").slice(1, -1);
     const segments = [];
     for (const part of parts) {
         // A route group organises files without appearing in the url.
-        if (part.startsWith('(') && part.endsWith(')'))
+        if (part.startsWith("(") && part.endsWith(")"))
             continue;
         // A slot directory is not part of its page's url either.
-        if (part.startsWith('@'))
+        if (part.startsWith("@"))
             continue;
-        if (part.startsWith('[...') && part.endsWith(']')) {
-            segments.push({ type: 'catchAll', value: part.slice(4, -1) });
+        if (part.startsWith("[...") && part.endsWith("]")) {
+            segments.push({ type: "catchAll", value: part.slice(4, -1) });
             continue;
         }
-        if (part.startsWith('[') && part.endsWith(']')) {
-            segments.push({ type: 'param', value: part.slice(1, -1) });
+        if (part.startsWith("[") && part.endsWith("]")) {
+            segments.push({ type: "param", value: part.slice(1, -1) });
             continue;
         }
         // An interception marker says which url this replaces, not what it is
         // called: (.)photo intercepts the sibling /photo. Left in place the
         // manifest would claim a route at /(.)photo, which nothing can navigate to.
-        segments.push({ type: 'static', value: part.replace(/^\(\.{1,3}\)/, '') });
+        segments.push({ type: "static", value: part.replace(/^\(\.{1,3}\)/, "") });
     }
     return segments;
 }
 /** Whether a component sits under an interception marker: (.) (..) (...) */
 function isIntercept(componentName) {
-    return componentName.split('/').some((part) => /^\(\.{1,3}\)/.test(part));
+    return componentName.split("/").some((part) => /^\(\.{1,3}\)/.test(part));
 }
 /** The slot directory a component lives under, if any. */
 function slotOf(componentName) {
-    const part = componentName.split('/').find((p) => p.startsWith('@'));
+    const part = componentName.split("/").find((p) => p.startsWith("@"));
     return part ? part.slice(1) : null;
 }
 /**
@@ -282,15 +340,17 @@ function slotOf(componentName) {
  */
 function routeManifest() {
     const names = [...components.keys()];
-    const dirOf = (name) => name.split('/').slice(0, -1).join('/');
+    const dirOf = (name) => name.split("/").slice(0, -1).join("/");
     // By path, not by string: 'app/slow3' begins with 'app/slow' as text and is
     // not inside it, which would hand /slow3 the loading state of /slow.
-    const isUnder = (dir, ancestor) => dir === ancestor || dir.startsWith(ancestor + '/');
+    const isUnder = (dir, ancestor) => dir === ancestor || dir.startsWith(ancestor + "/");
     const ancestors = (name, base) => names
-        .filter((n) => n.endsWith('/' + base) && !isIntercept(n) && isUnder(dirOf(name), dirOf(n)))
+        .filter((n) => n.endsWith("/" + base) &&
+        !isIntercept(n) &&
+        isUnder(dirOf(name), dirOf(n)))
         .sort((a, b) => a.length - b.length);
     /** Project-root-relative, posix — the same string on every machine. */
-    const fromRoot = (abs) => relative(projectRoot, abs).replace(/\\/g, '/');
+    const fromRoot = (abs) => relative(projectRoot, abs).replace(/\\/g, "/");
     /** The host's config file in a directory, if the host named one and it exists. */
     const configIn = (absDir) => {
         if (!routeConfig)
@@ -301,9 +361,9 @@ function routeManifest() {
     /** Ancestor configs, outermost first, excluding the page's own directory. */
     const ancestorConfigs = (dir) => {
         const found = [];
-        const parts = dir.split('/').slice(0, -1);
+        const parts = dir.split("/").slice(0, -1);
         while (parts.length > 0) {
-            const path = configIn(join(sourceDir, parts.join('/')));
+            const path = configIn(join(sourceDir, parts.join("/")));
             if (path)
                 found.unshift(path);
             parts.pop();
@@ -325,11 +385,11 @@ function routeManifest() {
      * to whoever knows what they mean.
      */
     const middlewareIn = (absDir) => {
-        for (const file of ['route.ts', 'route.tsx']) {
+        for (const file of ["route.ts", "route.tsx"]) {
             const path = join(absDir, file);
             if (!existsSync(path))
                 continue;
-            const match = readFileSync(path, 'utf-8').match(/export\s+const\s+middleware\s*(?::[^=]+)?=\s*\[([^\]]*)\]/);
+            const match = readFileSync(path, "utf-8").match(/export\s+const\s+middleware\s*(?::[^=]+)?=\s*\[([^\]]*)\]/);
             if (!match)
                 continue;
             // Each quoted literal, rather than splitting the list on commas: a
@@ -351,7 +411,7 @@ function routeManifest() {
      * outermost point it was asked for.
      */
     const hostMiddleware = (dir) => {
-        const parts = dir.split('/').filter(Boolean);
+        const parts = dir.split("/").filter(Boolean);
         const found = [];
         for (let depth = 0; depth <= parts.length; depth++) {
             for (const name of middlewareIn(join(sourceDir, ...parts.slice(0, depth)))) {
@@ -364,40 +424,47 @@ function routeManifest() {
     const routes = [];
     const intercepts = [];
     for (const name of names) {
-        if (name.endsWith('/page') && isIntercept(name)) {
+        if (name.endsWith("/page") && isIntercept(name)) {
             const slot = slotOf(name);
             if (slot) {
-                const marker = name.split('/').find((p) => /^\(\.{1,3}\)/.test(p))?.match(/^\(\.{1,3}\)/)?.[0] ?? '(.)';
-                intercepts.push({ component: name, slot, segments: urlSegments(name), marker });
+                const marker = name
+                    .split("/")
+                    .find((p) => /^\(\.{1,3}\)/.test(p))
+                    ?.match(/^\(\.{1,3}\)/)?.[0] ?? "(.)";
+                intercepts.push({
+                    component: name,
+                    slot,
+                    segments: urlSegments(name),
+                    marker,
+                });
             }
             continue;
         }
-        if (!name.endsWith('/page') || slotOf(name))
+        if (!name.endsWith("/page") || slotOf(name))
             continue;
         const slots = {};
         for (const candidate of names) {
             const slot = slotOf(candidate);
             // A slot belongs to the layout in the directory that declares it, so it
             // applies to a page only if that directory is on the page's path.
-            if (!slot || isIntercept(candidate) || !candidate.endsWith('/default'))
+            if (!slot || isIntercept(candidate) || !candidate.endsWith("/default"))
                 continue;
-            if (isUnder(dirOf(name), candidate.split('/@')[0]))
+            if (isUnder(dirOf(name), candidate.split("/@")[0]))
                 slots[slot] = candidate;
         }
         routes.push({
             component: name,
             segments: urlSegments(name),
-            layouts: ancestors(name, 'layout').map((n) => n),
-            loadings: ancestors(name, 'loading').map((n) => n),
-            errors: ancestors(name, 'error'),
-            middleware: ancestors(name, 'middleware').map((n) => n),
+            layouts: ancestors(name, "layout").map((n) => n),
+            loadings: ancestors(name, "loading").map((n) => n),
+            errors: ancestors(name, "error"),
+            middleware: ancestors(name, "middleware").map((n) => n),
             slots,
-            sections: names.filter((n) => SECTION_FILE.test(n + '.tsx') && dirOf(n) === dirOf(name)),
+            sections: names.filter((n) => SECTION_FILE.test(n + ".tsx") && dirOf(n) === dirOf(name)),
             config: configIn(join(sourceDir, dirOf(name))),
             hostMiddleware: hostMiddleware(dirOf(name)),
             ancestorConfigs: ancestorConfigs(dirOf(name)),
             staticParams: hasStaticParams(components.get(name).absPath),
-            clientJs: shipsClientJs(components.get(name).absPath),
         });
     }
     // What the build decided, for a host that has to act on it afterwards —
@@ -411,7 +478,7 @@ function routeManifest() {
             name,
             segments: urlSegments(name),
             methods,
-            middleware: ancestors(name, 'middleware'),
+            middleware: ancestors(name, "middleware"),
         })),
     };
 }
@@ -431,17 +498,17 @@ function routeManifest() {
  * a line of output; silent costs the types.
  */
 function warnIfTypesUnreachable() {
-    const config = join(projectRoot, 'tsconfig.json');
+    const config = join(projectRoot, "tsconfig.json");
     if (!existsSync(config))
         return;
     try {
         // Comments are legal in a tsconfig and JSON.parse does not take them.
-        const text = readFileSync(config, 'utf-8').replace(/\/\*[\s\S]*?\*\/|(^|\s)\/\/.*$/gm, '$1');
+        const text = readFileSync(config, "utf-8").replace(/\/\*[\s\S]*?\*\/|(^|\s)\/\/.*$/gm, "$1");
         const include = JSON.parse(text).include;
         if (!Array.isArray(include))
             return;
-        const covers = (what) => include.some((entry) => typeof entry === 'string' && entry.includes(what));
-        if (!covers('.rsc-kit')) {
+        const covers = (what) => include.some((entry) => typeof entry === "string" && entry.includes(what));
+        if (!covers(".rsc-kit")) {
             log(`tsconfig.json does not include .rsc-kit, where the generated types are written.\n` +
                 `  Add ".rsc-kit/**/*" to "include", or typed routes and rpc() fall back to string.`);
         }
@@ -478,17 +545,17 @@ function writeHostBindings(manifest) {
     // The global is installed at runtime, so nothing in app source declares it
     // and a typecheck cannot see it. Written whether or not there are actions:
     // server components call it directly too.
-    writeFileSync(join(typesDir, 'rsc-env.d.ts'), renderHostGlobalTypes());
+    writeFileSync(join(typesDir, "rsc-env.d.ts"), renderHostGlobalTypes());
     // The urls this build found, so a link to a page that does not exist fails
     // the typecheck instead of the browser.
-    writeFileSync(join(typesDir, 'rsc-routes.d.ts'), renderRouteTypes(manifest));
+    writeFileSync(join(typesDir, "rsc-routes.d.ts"), renderRouteTypes(manifest));
     // The bundle the host imports is generated, so nothing declares it. Written
     // here rather than left to the app: every app needs the identical file, and
     // an app-authored one goes stale — the first version named only RscEngine,
     // which typechecks a server and fails a prerender script.
-    writeFileSync(join(typesDir, 'rsc-engine.d.ts'), ENGINE_TYPES);
+    writeFileSync(join(typesDir, "rsc-engine.d.ts"), ENGINE_TYPES);
     warnIfTypesUnreachable();
-    const target = join(sourceDir, 'server-actions.generated.ts');
+    const target = join(sourceDir, "server-actions.generated.ts");
     // A host with no functions of its own leaves no file behind: kept, its
     // stubs would go on naming targets the host has stopped answering for.
     if (Object.keys(hostActions).length === 0) {
@@ -537,8 +604,8 @@ function reportAllDynamic() {
         // The pattern rather than a url: nothing was rendered, so there are no
         // params and inventing one would name a page that may not exist.
         const path = route.segments
-            .map((segment) => (segment.type === 'static' ? segment.value : `[${segment.value}]`))
-            .join('/');
+            .map((segment) => segment.type === "static" ? segment.value : `[${segment.value}]`)
+            .join("/");
         console.log(`  \u0192  /${path}`);
     }
     console.log(`
@@ -606,7 +673,7 @@ ${swExtra
 // 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.
@@ -847,11 +914,11 @@ self.addEventListener('fetch', (event) => {
  * 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']) {
+    for (const extension of ["ts", "tsx", "js", "mjs"]) {
         const file = join(appDir, `manifest.${extension}`);
         if (!existsSync(file))
             continue;
-        const source = readFileSync(file, 'utf-8');
+        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
@@ -863,8 +930,8 @@ export function declaredManifest(appDir) {
         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.');
+                "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
@@ -901,7 +968,7 @@ function copyAppAssets(clientDir) {
     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);
+        copyFileSync(join(sourceDir, "app", asset.file), to);
     }
     log(`icons: ${all.length} copied from app/`);
 }
@@ -925,20 +992,20 @@ function writeWebManifest(clientDir, options) {
  * which read did it.
  */
 function offlineFallback(frozen, results) {
-    const found = results.find((r) => r.url === '/offline');
+    const found = results.find((r) => r.url === "/offline");
     if (!found)
         return null;
-    if (!frozen.includes('/offline')) {
+    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.');
+        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';
+    return "/offline";
 }
 /**
  * The app's own service worker code, if it wrote any.
@@ -954,11 +1021,11 @@ function offlineFallback(frozen, results) {
  * file is there or it is not.
  */
 function copyServiceWorkerExtra(clientDir) {
-    const source = join(sourceDir, 'app', 'sw.js');
+    const source = join(sourceDir, "app", "sw.js");
     if (!existsSync(source))
         return null;
-    copyFileSync(source, join(clientDir, 'sw-app.js'));
-    return '/sw-app.js';
+    copyFileSync(source, join(clientDir, "sw-app.js"));
+    return "/sw-app.js";
 }
 function writeServiceWorker(clientDir, frozen = [], offlineUrl = null) {
     if (!existsSync(clientDir))
@@ -973,7 +1040,7 @@ function writeServiceWorker(clientDir, frozen = [], offlineUrl = null) {
         for (const entry of readdirSync(dir, { withFileTypes: true })) {
             // Not itself, and not a map: a debugger asks for those, a visitor does
             // not, and precaching them doubles what an install costs.
-            if (entry.name === 'sw.js' || entry.name.endsWith('.map'))
+            if (entry.name === "sw.js" || entry.name.endsWith(".map"))
                 continue;
             const path = join(dir, entry.name);
             if (entry.isDirectory())
@@ -982,13 +1049,16 @@ function writeServiceWorker(clientDir, frozen = [], offlineUrl = null) {
                 files.push(`${prefix}${entry.name}`);
         }
     };
-    walk(clientDir, '');
-    const precache = ['/', ...files.map((file) => `/${file}`)].sort();
-    const version = createHash('sha256').update(precache.join('\n')).digest('hex').slice(0, 12);
-    writeFileSync(join(clientDir, 'sw.js'), SERVICE_WORKER(version, precache, frozen, offlineUrl, extra));
+    walk(clientDir, "");
+    const precache = ["/", ...files.map((file) => `/${file}`)].sort();
+    const version = createHash("sha256")
+        .update(precache.join("\n"))
+        .digest("hex")
+        .slice(0, 12);
+    writeFileSync(join(clientDir, "sw.js"), SERVICE_WORKER(version, precache, frozen, offlineUrl, extra));
     log(`offline: ${precache.length} files precached as rsc-kit-${version}` +
-        (offlineUrl ? `, falling back to ${offlineUrl}` : '') +
-        (extra ? ', with app/sw.js' : ''));
+        (offlineUrl ? `, falling back to ${offlineUrl}` : "") +
+        (extra ? ", with app/sw.js" : ""));
 }
 /**
  * The rsc bundle the build just wrote, whatever it decided to call it.
@@ -1002,7 +1072,7 @@ function writeServiceWorker(clientDir, frozen = [], offlineUrl = null) {
  * prints.
  */
 function resolveRscBundle(dir) {
-    for (const name of ['index.js', 'index.mjs']) {
+    for (const name of ["index.js", "index.mjs"]) {
         const candidate = join(dir, name);
         if (existsSync(candidate))
             return candidate;
@@ -1022,9 +1092,9 @@ function knownActionsOf(config, root) {
         return [];
     const out = [];
     for (const meta of metaMap.values()) {
-        if (meta.importId.includes('/node_modules/'))
+        if (meta.importId.includes("/node_modules/"))
             continue;
-        const file = relative(root, meta.importId.split('?')[0] ?? meta.importId);
+        const file = relative(root, meta.importId.split("?")[0] ?? meta.importId);
         for (const name of meta.exportNames) {
             out.push({ id: `${meta.referenceKey}#${name}`, name, file });
         }
@@ -1032,12 +1102,42 @@ function knownActionsOf(config, root) {
     return out;
 }
 async function auditActions(engine, known) {
-    const audit = engine
-        .auditActions;
+    const audit = engine.auditActions;
     if (!audit || known.length === 0)
         return [];
     const byId = new Map(known.map((k) => [k.id, k]));
-    return (await audit(known.map((k) => k.id))).map((a) => ({ ...byId.get(a.id), client: a.client, query: a.query }));
+    return (await audit(known.map((k) => k.id))).map((a) => ({
+        ...byId.get(a.id),
+        client: a.client,
+        query: a.query,
+    }));
+}
+/**
+ * Inlined into a page with no runtime when it is at most this big on the
+ * wire. The point is the round trip, not the bytes: a stylesheet that
+ * compresses to a few KB costs a whole trip before anything paints, while a
+ * large one is better fetched once and cached across pages. Measured
+ * gzipped, because that is what travels - a sheet of @font-face
+ * declarations is long and compresses to almost nothing.
+ */
+const INLINE_STYLESHEET_LIMIT = 10 * 1024;
+export function smallStylesheetReader(assetsDir, setting) {
+    const limit = setting === true
+        ? Infinity
+        : setting === "auto"
+            ? INLINE_STYLESHEET_LIMIT
+            : setting;
+    return (href) => {
+        if (!href.startsWith("/") || href.includes(".."))
+            return null;
+        try {
+            const css = readFileSync(join(assetsDir, href), "utf-8");
+            return gzipSync(css).length > limit ? null : css;
+        }
+        catch {
+            return null;
+        }
+    };
 }
 async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions = []) {
     // A missing bundle used to be a silent `return`, and under Nitro it was the
@@ -1048,21 +1148,25 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
     // visitor. The caller resolves the path from the environment now, so this is
     // back to being the impossible case it reads as.
     if (!bundle) {
-        throw new Error('[rsc-kit] The build produced no rsc bundle to prerender from.\n' +
-            'Prerendering renders the app, so it needs the bundle the build just wrote. ' +
-            'Build with prerender: false to render every page on demand instead.');
+        throw new Error("[rsc-kit] The build produced no rsc bundle to prerender from.\n" +
+            "Prerendering renders the app, so it needs the bundle the build just wrote.");
     }
-    const [{ prerender, NotPrerenderable, summary, legend, notes, clientJsSize, pathKey: pathKeyOf }, { writeTo }, { prerenderApiRoutes },] = await Promise.all([
-        import('./prerender.js'),
-        import('./files.js'),
-        import('./apiPrerender.js'),
+    const [{ prerender, NotPrerenderable, summary, legend, notes, clientJsSize, pathKey: pathKeyOf, }, { writeTo }, { prerenderApiRoutes },] = await Promise.all([
+        import("./prerender.js"),
+        import("./files.js"),
+        import("./apiPrerender.js"),
     ]);
     // Cleared first: a route that changes classification between builds
     // otherwise leaves its old shell on disk and the host goes on serving it.
     // Nothing warns — the page loads, with content from the previous build.
     rmSync(staticDir, { recursive: true, force: true });
     const engine = (await import(pathToFileURL(bundle).href));
-    const mark = { frozen: '○', shell: '◐', blocked: '✗', error: '✗' };
+    const mark = {
+        frozen: "○",
+        shell: "◐",
+        blocked: "✗",
+        error: "✗",
+    };
     let failed = 0;
     // 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.
@@ -1085,19 +1189,22 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
             engine,
             write: writeTo(staticDir),
             serviceWorker: offline,
+            stylesheet: inlineStylesheets === false
+                ? undefined
+                : smallStylesheetReader(assetsDir, inlineStylesheets),
             onResult: (r) => {
                 collected.push(r);
-                if (r.type === 'error' || r.type === 'blocked')
+                if (r.type === "error" || r.type === "blocked")
                     failed++;
                 const key = pathKeyOf(r.url);
                 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;
+                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}`,
+                    line: `  ${mark[r.type] ?? " "}  ${r.url}`,
                     bytes,
                     extra: [
                         ...(r.reason ? [`     ${r.reason}`] : []),
@@ -1122,16 +1229,19 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
     const apis = await prerenderApiRoutes(engine, manifest, writeTo(staticDir));
     for (const api of apis) {
         pending.push({
-            line: `  ${api.type === 'frozen' ? '○' : 'ƒ'}  ${api.url}`,
+            line: `  ${api.type === "frozen" ? "○" : "ƒ"}  ${api.url}`,
             bytes: null,
-            extra: api.reason ? [`     ${api.reason}`] : [],
+            extra: [
+                ...(api.reason ? [`     ${api.reason}`] : []),
+                ...(api.warning ? [`     ⚠  ${api.warning}`] : []),
+            ],
         });
     }
     // Printed together rather than as each route lands, because a column has to
     // line up and the widest url is not known until the last one is in.
     const column = Math.max(...pending.map((p) => p.line.length)) + 2;
     for (const row of pending) {
-        const size = row.bytes === null ? '' : clientJsSize(row.bytes);
+        const size = row.bytes === null ? "" : clientJsSize(row.bytes);
         console.log(size ? row.line.padEnd(column) + size : row.line);
         for (const line of row.extra)
             console.log(line);
@@ -1147,10 +1257,12 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
         const byFile = new Map();
         for (const a of bare)
             byFile.set(a.file, [...(byFile.get(a.file) ?? []), a.name]);
-        console.log(`\n  \u26a0  ${bare.length} ${bare.length === 1 ? 'action runs' : 'actions run'} no middleware: ` +
-            [...byFile].map(([file, names]) => `${names.join(', ')} (${file})`).join('; '));
-        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.');
+        console.log(`\n  \u26a0  ${bare.length} ${bare.length === 1 ? "action runs" : "actions run"} no middleware: ` +
+            [...byFile]
+                .map(([file, names]) => `${names.join(", ")} (${file})`)
+                .join("; "));
+        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.");
     }
     // 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.
@@ -1162,22 +1274,29 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
         warning: r.warning ?? null,
         note: r.note ?? null,
         clientJs: sized.get(r.url) ?? null,
-    })), apis.map((a) => ({ url: a.url, name: a.name, type: a.type, reason: a.reason })), audited));
+    })), apis.map((a) => ({
+        url: a.url,
+        name: a.name,
+        type: a.type,
+        reason: a.reason,
+        warning: a.warning ?? null,
+    })), audited));
     const note = notes(results);
     const counted = [...results, ...apis];
     console.log(`
 ${legend(counted)}
 
-  ${summary(counted)}${note ? `\n\n${note}` : ''}`);
+  ${summary(counted)}${note ? `\n\n${note}` : ""}`);
     // The table and the report are on disk. Now the refusal, in its own words.
     if (refusal)
         throw new Error(refusal.message);
     if (failed > 0) {
-        throw new Error(`[rsc-kit] ${failed} route${failed === 1 ? '' : 's'} failed to render.\n` +
-            'Prerendering runs your app: whatever those pages need at render time has to be\n' +
-            'reachable from the build. Fix them, or build with prerender: false and render on demand.');
+        throw new Error(`[rsc-kit] ${failed} route${failed === 1 ? "" : "s"} failed to render.\n` +
+            "Prerendering runs your app: whatever those pages need at render time has to be\n" +
+            "reachable from the build. Give it that, or mark the read with `await connection()`\n" +
+            "so the page renders per request and the rest of it is still stored.");
     }
-    if (output === 'export')
+    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
@@ -1196,8 +1315,8 @@ ${legend(counted)}
     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')))
+            .filter((r) => r.type === "frozen" && !guarded.has(r.component))
+            .filter((r) => existsSync(join(staticDir, pathKeyOf(r.url) + ".html")))
             .map((r) => r.url),
         results,
     };
@@ -1224,7 +1343,9 @@ function weighClientJs(assetsDir) {
         if (cached !== undefined)
             return cached;
         const file = join(assetsDir, asset);
-        const bytes = existsSync(file) ? gzipSync(readFileSync(file)).byteLength : 0;
+        const bytes = existsSync(file)
+            ? gzipSync(readFileSync(file)).byteLength
+            : 0;
         weighed.set(asset, bytes);
         return bytes;
     };
@@ -1234,10 +1355,10 @@ function weighClientJs(assetsDir) {
         const named = new Set();
         // Split rather than matched: /assets/name.js is the only shape written, and
         // a regex over a whole document is the slower half of this function.
-        for (const piece of html.split('/assets/').slice(1)) {
+        for (const piece of html.split("/assets/").slice(1)) {
             const name = piece.split(/["'\s)]/)[0];
-            if (name.endsWith('.js'))
-                named.add('assets/' + name);
+            if (name.endsWith(".js"))
+                named.add("assets/" + name);
         }
         let total = 0;
         for (const asset of named)
@@ -1261,22 +1382,19 @@ function weighClientJs(assetsDir) {
  * page that loads and then stays empty forever.
  */
 async function exportAfterPrerender(results, staticDir, assetsDir) {
-    const [{ exportSite, NotExportable }, { writeTo, prerenderedFrom, copyAssets }] = await Promise.all([
-        import('./export.js'),
-        import('./files.js'),
-    ]);
+    const [{ exportSite, NotExportable }, { writeTo, prerenderedFrom, copyAssets },] = await Promise.all([import("./export.js"), import("./files.js")]);
     try {
         const { pages, refused } = await exportSite({
             results,
             read: prerenderedFrom(staticDir),
             write: writeTo(exportPath),
             manifest: routeManifest(),
-            assets: copyAssets(join(assetsDir, 'assets'), exportPath, '/assets/'),
-            force: process.env.RSC_EXPORT_FORCE === '1',
+            assets: copyAssets(join(assetsDir, "assets"), exportPath, "/assets/"),
+            force: process.env.RSC_EXPORT_FORCE === "1",
         });
-        console.log(`\n  Exported ${pages} page${pages === 1 ? '' : 's'} to ${relative(projectRoot, exportPath)}`);
+        console.log(`\n  Exported ${pages} page${pages === 1 ? "" : "s"} to ${relative(projectRoot, exportPath)}`);
         if (refused.length > 0) {
-            console.log(`  Left out ${refused.length}: ${refused.map((r) => r.url).join(', ')}`);
+            console.log(`  Left out ${refused.length}: ${refused.map((r) => r.url).join(", ")}`);
         }
     }
     catch (error) {
@@ -1288,15 +1406,15 @@ async function exportAfterPrerender(results, staticDir, assetsDir) {
 /** `/posts/[slug]` — the pattern, in the shape the app writes its links in. */
 function patternOf(segments) {
     if (segments.length === 0)
-        return '/';
-    return ('/' +
+        return "/";
+    return ("/" +
         segments
-            .map((segment) => segment.type === 'static'
+            .map((segment) => segment.type === "static"
             ? segment.value
-            : segment.type === 'catchAll'
+            : segment.type === "catchAll"
                 ? `[...${segment.value}]`
                 : `[${segment.value}]`)
-            .join('/'));
+            .join("/"));
 }
 /**
  * The app's routes as a union, for `@rsc-kit/core/routes` to derive from.
@@ -1310,8 +1428,12 @@ function patternOf(segments) {
  * the union twice and imply you could link to a modal.
  */
 function renderRouteTypes(manifest) {
-    const patterns = [...new Set(manifest.routes.map((route) => patternOf(route.segments)))].sort();
-    const apis = [...new Set((manifest.apis ?? []).map((route) => patternOf(route.segments)))].sort();
+    const patterns = [
+        ...new Set(manifest.routes.map((route) => patternOf(route.segments))),
+    ].sort();
+    const apis = [
+        ...new Set((manifest.apis ?? []).map((route) => patternOf(route.segments))),
+    ].sort();
     // Each pattern to the page module that answers it, as a type-only import
     // from the generated file's own directory. SearchExportOf reads the page's
     // `searchParams` export, or undefined when there is none, so nothing here
@@ -1322,82 +1444,114 @@ function renderRouteTypes(manifest) {
         const pattern = patternOf(route.segments);
         if (search.has(pattern))
             continue;
-        const target = relative(typesDir, join(sourceDir, route.component)).replace(/\\/g, '/');
-        search.set(pattern, target.startsWith('.') ? target : './' + target);
+        const target = relative(typesDir, join(sourceDir, route.component)).replace(/\\/g, "/");
+        search.set(pattern, target.startsWith(".") ? target : "./" + target);
     }
     return [
-        '// @generated — do not edit. Written by the RSC build from the route tree.',
-        '//',
-        '// Turns Link, navigate() and route() into typed apis: an href that no route',
-        '// answers stops compiling. Delete this file and they fall back to `string`,',
-        '// which is what a project that has not built yet gets.',
-        '',
-        '// `export {}` is load-bearing: in a file with no import or export,',
-        '// `declare module` *replaces* the real module rather than augmenting it,',
-        '// and Href and route() vanish from it with no error to explain why.',
-        'export {}',
-        '',
+        "// @generated — do not edit. Written by the RSC build from the route tree.",
+        "//",
+        "// Turns Link, navigate() and route() into typed apis: an href that no route",
+        "// answers stops compiling. Delete this file and they fall back to `string`,",
+        "// which is what a project that has not built yet gets.",
+        "",
+        "// `export {}` is load-bearing: in a file with no import or export,",
+        "// `declare module` *replaces* the real module rather than augmenting it,",
+        "// and Href and route() vanish from it with no error to explain why.",
+        "export {}",
+        "",
         "declare module '@rsc-kit/core/routes' {",
-        '  interface Register {',
+        "  interface Register {",
         patterns.length > 0
-            ? '    routes:\n' + patterns.map((p) => '      | ' + JSON.stringify(p)).join('\n')
-            : '    // No routes found under the source directory.\n    routes: never',
+            ? "    routes:\n" +
+                patterns.map((p) => "      | " + JSON.stringify(p)).join("\n")
+            : "    // No routes found under the source directory.\n    routes: never",
         // The searchParams schema each page exports, read off the module's type.
         // This is what types Link's `search` prop and href() per route.
-        '    search: {',
-        ...[...search].sort().map(([pattern, target]) => '      ' + JSON.stringify(pattern) + ': SearchExportOf<typeof import(' + JSON.stringify(target) + ')>'),
-        '    }',
-        '  }',
+        "    search: {",
+        ...[...search]
+            .sort()
+            .map(([pattern, target]) => "      " +
+            JSON.stringify(pattern) +
+            ": SearchExportOf<typeof import(" +
+            JSON.stringify(target) +
+            ")>"),
+        "    }",
+        "  }",
         // 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.
-        '  interface RegisterApi {',
+        "  interface RegisterApi {",
         apis.length > 0
-            ? '    apis:\n' + apis.map((p) => '      | ' + JSON.stringify(p)).join('\n')
-            : '    // No route.ts files found under the source directory.\n    apis: never',
-        '  }',
-        '}',
-        '',
-    ].join('\n');
+            ? "    apis:\n" +
+                apis.map((p) => "      | " + JSON.stringify(p)).join("\n")
+            : "    // No route.ts files found under the source directory.\n    apis: never",
+        "  }",
+        "}",
+        "",
+    ].join("\n");
 }
 /** The "use server" module exposing each host function as a plain async call. */
 function renderHostActions() {
     const lines = [
         '"use server";',
-        '// @generated — do not edit. Written by the RSC build from the host action map.',
-        '',
+        "// @generated — do not edit. Written by the RSC build from the host action map.",
+        "",
     ];
     for (const [name, target] of Object.entries(hostActions)) {
-        lines.push('export async function ' + name + '(...args: unknown[]) {');
-        lines.push('  return await (globalThis as any).' + hostGlobal + '(' + JSON.stringify(target) + ', ...args);');
-        lines.push('}');
-        lines.push('');
+        lines.push("export async function " + name + "(...args: unknown[]) {");
+        lines.push("  return await (globalThis as any)." +
+            hostGlobal +
+            "(" +
+            JSON.stringify(target) +
+            ", ...args);");
+        lines.push("}");
+        lines.push("");
     }
-    return lines.join('\n');
+    return lines.join("\n");
 }
 /** Ambient declaration for the host global, written beside the app's source. */
 function renderHostGlobalTypes() {
     return [
-        '// @generated — do not edit.',
-        '//',
-        '// ' + hostGlobal + '() is installed on globalThis by the RSC worker, so it has no',
-        '// import to resolve. This declares it for the typechecker; run',
-        '// `tsc --noEmit` to catch calls to a host global that no longer exists.',
-        '//',
-        '// Deliberately not a module — no import/export — so the declaration is',
-        '// global to the project without every file having to reference it.',
-        '',
-        'declare function ' + hostGlobal + '<T = unknown>(name: string, ...args: unknown[]): Promise<T>;',
-        '',
-    ].join('\n');
+        "// @generated — do not edit.",
+        "//",
+        "// " +
+            hostGlobal +
+            "() is installed on globalThis by the RSC worker, so it has no",
+        "// import to resolve. This declares it for the typechecker; run",
+        "// `tsc --noEmit` to catch calls to a host global that no longer exists.",
+        "//",
+        "// Deliberately not a module — no import/export — so the declaration is",
+        "// global to the project without every file having to reference it.",
+        "",
+        "declare function " +
+            hostGlobal +
+            "<T = unknown>(name: string, ...args: unknown[]): Promise<T>;",
+        "",
+    ].join("\n");
 }
 // ── Discovery ────────────────────────────────────────────────────────────────
-const ROUTE_FILES = ['page', 'layout', 'loading', 'error', 'not-found', 'default', 'middleware'];
+const ROUTE_FILES = [
+    "page",
+    "layout",
+    "loading",
+    "error",
+    "not-found",
+    "default",
+    "middleware",
+];
 /** The methods a route.ts may export. HEAD and OPTIONS are answered for you. */
-const API_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'];
+const API_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "HEAD",
+    "OPTIONS",
+];
 /** `orders.section.tsx` — a region of a page that can be refreshed by name. */
 const SECTION_FILE = /\.section\.(tsx|jsx|ts|js)$/;
-const EXTS = ['tsx', 'jsx', 'ts', 'js'];
+const EXTS = ["tsx", "jsx", "ts", "js"];
 function findRouteFile(dir, base) {
     for (const ext of EXTS) {
         const p = join(dir, `${base}.${ext}`);
@@ -1407,11 +1561,11 @@ function findRouteFile(dir, base) {
     return null;
 }
 function componentName(absPath) {
-    const rel = relative(sourceDir, absPath).replace(/\\/g, '/');
-    return rel.replace(/\.(tsx|jsx|ts|js)$/, '');
+    const rel = relative(sourceDir, absPath).replace(/\\/g, "/");
+    return rel.replace(/\.(tsx|jsx|ts|js)$/, "");
 }
 function toAlias(name) {
-    return '_c_' + name.replace(/[^a-zA-Z0-9]/g, '_');
+    return "_c_" + name.replace(/[^a-zA-Z0-9]/g, "_");
 }
 const components = new Map();
 /**
@@ -1442,8 +1596,8 @@ function register(absPath) {
  */
 function registerApiRoute(absPath) {
     const name = componentName(absPath);
-    const source = readFileSync(absPath, 'utf-8');
-    const methods = API_METHODS.filter((method) => new RegExp(`^\\s*export\\s+(?:async\\s+function|function|const|let|var)\\s+${method}\\b`, 'm').test(source));
+    const source = readFileSync(absPath, "utf-8");
+    const methods = API_METHODS.filter((method) => new RegExp(`^\\s*export\\s+(?:async\\s+function|function|const|let|var)\\s+${method}\\b`, "m").test(source));
     if (methods.length === 0) {
         // `route.ts` is also where a host declares the guards for everything below
         // it — the file predates api routes and is still read that way. One that
@@ -1453,7 +1607,7 @@ function registerApiRoute(absPath) {
             return;
         throw new Error(`[rsc-kit] ${relative(projectRoot, absPath)} exports no request methods.\n` +
             `  Export one named for the method it answers — export function GET(request: Request) — ` +
-            `or delete the file. One of: ${API_METHODS.join(', ')}.`);
+            `or delete the file. One of: ${API_METHODS.join(", ")}.`);
     }
     apiRoutes.set(name, { name, absPath, methods });
 }
@@ -1466,7 +1620,7 @@ function discover(dir) {
     // route.ts — an api endpoint, colocated with the pages it sits among. Read
     // for its method exports here rather than at request time, so a route that
     // exports nothing callable is a build error instead of a 404 nobody explains.
-    const api = findRouteFile(dir, 'route');
+    const api = findRouteFile(dir, "route");
     if (api)
         registerApiRoute(api);
     // Named regions. Registered like any other component so the generated entry
@@ -1492,25 +1646,12 @@ function discover(dir) {
  * for almost every route in an app.
  */
 function metadataExports(absPath) {
-    const src = readFileSync(absPath, 'utf-8');
+    const src = readFileSync(absPath, "utf-8");
     return {
         static: /export\s+const\s+metadata\b/.test(src),
         generate: /export\s+(async\s+)?function\s+generateMetadata\b/.test(src),
     };
 }
-/**
- * Whether a route ships the client runtime at all.
- *
- * Opting out buys back everything React costs on a page that has nothing to
- * hydrate — react-dom alone is most of it. Declared rather than inferred: a
- * page with no client components today may gain one tomorrow, and the build
- * refusing that is the point.
- */
-function shipsClientJs(absPath) {
-    const src = readFileSync(absPath, 'utf-8');
-    const declared = /export\s+const\s+clientJs\s*(:[^=]+)?=\s*(true|false)/.exec(src);
-    return declared ? declared[2] === 'true' : 'auto';
-}
 /**
  * Which urls exist for a parameterised route.
  *
@@ -1521,7 +1662,7 @@ function shipsClientJs(absPath) {
  * inferred because there is nothing to infer it from.
  */
 function hasStaticParams(absPath) {
-    const src = readFileSync(absPath, 'utf-8');
+    const src = readFileSync(absPath, "utf-8");
     return /export\s+((async\s+)?function\s+generateStaticParams|const\s+generateStaticParams)/.test(src);
 }
 /**
@@ -1537,7 +1678,7 @@ function hasStaticParams(absPath) {
  * import for something that can never validate.
  */
 function urlSchemaExports(absPath) {
-    const src = readFileSync(absPath, 'utf-8');
+    const src = readFileSync(absPath, "utf-8");
     return {
         params: /export\s+const\s+params\s*[=:]/.test(src),
         searchParams: /export\s+const\s+searchParams\s*[=:]/.test(src),
@@ -1659,7 +1800,7 @@ const FALLBACK_BODY = `  const answer = await devHandler(request)
  * the failure is silent: the server finds no directory, decides nothing was
  * frozen, and renders every page live exactly as it did before.
  */
-const NITRO_STATIC_DIR = 'rsc-static';
+const NITRO_STATIC_DIR = "rsc-static";
 /**
  * Serve what the build froze.
  *
@@ -1698,15 +1839,15 @@ function installHostCallsOnce(): void {
 }
 
 `;
-function generateEntryRsc(fallbackOrigin = '') {
+function generateEntryRsc(fallbackOrigin = "") {
     // 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.
-    const notFoundComponent = [...components.keys()].find((name) => name.endsWith('/not-found'));
+    const notFoundComponent = [...components.keys()].find((name) => name.endsWith("/not-found"));
     const notFoundLayouts = notFoundComponent
         ? [...components.keys()]
-            .filter((name) => name.endsWith('/layout') &&
-            notFoundComponent.startsWith(name.slice(0, -'layout'.length)))
+            .filter((name) => name.endsWith("/layout") &&
+            notFoundComponent.startsWith(name.slice(0, -"layout".length)))
             .sort((a, b) => a.length - b.length)
         : [];
     const imports = [];
@@ -1731,7 +1872,7 @@ function generateEntryRsc(fallbackOrigin = '') {
                 meta.static ? `static: ${c.alias}_meta.metadata` : null,
                 meta.generate ? `generate: ${c.alias}_meta.generateMetadata` : null,
             ].filter(Boolean);
-            metaEntries.push(`  ${JSON.stringify(c.name)}: { ${fields.join(', ')} },`);
+            metaEntries.push(`  ${JSON.stringify(c.name)}: { ${fields.join(", ")} },`);
         }
         if (hasStaticParams(c.absPath)) {
             // The namespace import may already be in place for metadata; a second
@@ -1744,9 +1885,11 @@ function generateEntryRsc(fallbackOrigin = '') {
             imports.push(`import * as ${c.alias}_schema from ${JSON.stringify(c.absPath)}`);
             const fields = [
                 urlSchemas.params ? `params: ${c.alias}_schema.params` : null,
-                urlSchemas.searchParams ? `searchParams: ${c.alias}_schema.searchParams` : null,
+                urlSchemas.searchParams
+                    ? `searchParams: ${c.alias}_schema.searchParams`
+                    : null,
             ].filter(Boolean);
-            schemaEntries.push(`  ${JSON.stringify(c.name)}: { ${fields.join(', ')} },`);
+            schemaEntries.push(`  ${JSON.stringify(c.name)}: { ${fields.join(", ")} },`);
         }
     }
     // The engine's own modules are named without an extension: this plugin runs
@@ -1765,21 +1908,21 @@ import { notFoundDigest, isNotFoundSignal } from ${JSON.stringify(join(packageDi
 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'))}
-import { prerenderedBeside } from ${JSON.stringify(join(packageDir, 'files'))}
+import { httpHostCalls } from ${JSON.stringify(join(packageDir, "hostCalls"))}
+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 { isQuery, queryCacheControl, isQueryValidationError } from ${JSON.stringify(join(packageDir, "query"))}
+import { isActionValidationError, isClientBuilt } from ${JSON.stringify(join(packageDir, "action"))}
 import { Suspense, createElement, Fragment } from 'react'
 import { AsyncLocalStorage } from 'node:async_hooks'
-${imports.join('\n')}
+${imports.join("\n")}
 
 type HostFn = (name: string, ...args: unknown[]) => Promise<unknown>
 type LayoutEntry = { component: string; props?: Record<string, unknown> }
 type SlotOverride = { component: string; props?: Record<string, unknown> }
 
 const components: Record<string, any> = {
-${mapEntries.join('\n')}
+${mapEntries.join("\n")}
 }
 
 /**
@@ -1799,16 +1942,21 @@ ${mapEntries.join('\n')}
 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 } : {}) }
+        ? {
+            href: MANIFEST_PATH,
+            ...(webManifestOptions.themeColor
+                ? { themeColor: webManifestOptions.themeColor }
+                : {}),
+        }
         : null)}
 
 const urlSchemas: Record<string, { params?: any; searchParams?: any }> = {
-${schemaEntries.join('\n')}
+${schemaEntries.join("\n")}
 }
 
 /** route.ts modules, by the name the manifest matched. */
 const apiRoutes: Record<string, any> = {
-${apiEntries.join('\n')}
+${apiEntries.join("\n")}
 }
 
 /**
@@ -1944,11 +2092,11 @@ export async function handleApiRoute(
 }
 
 const metadataMap: Record<string, { static?: any; generate?: (p: any) => any }> = {
-${metaEntries.join('\n')}
+${metaEntries.join("\n")}
 }
 
 const staticParamsMap: Record<string, () => any> = {
-${paramEntries.join('\n')}
+${paramEntries.join("\n")}
 }
 
 /**
@@ -3478,7 +3626,7 @@ export async function handleRscPprShell(
  * server rendering live pages it had already frozen. The gate is the mode, not
  * the file.
  */
-${fallbackOrigin ? FALLBACK_CONSTS.replace('__ORIGIN__', JSON.stringify(fallbackOrigin)) : ''}${NITRO_HOST_CALLS}
+${fallbackOrigin ? FALLBACK_CONSTS.replace("__ORIGIN__", JSON.stringify(fallbackOrigin)) : ""}${NITRO_HOST_CALLS}
 let devHandler: ((request: Request) => Promise<Response | null>) | null = null
 
 export default async function handler(request: Request): Promise<Response> {
@@ -3502,7 +3650,8 @@ export default async function handler(request: Request): Promise<Response> {
       resolveMetadata,
       runRouteMiddleware,
     } as never,
-${NITRO_HANDLER_OPTIONS}${NITRO_PRERENDERED}  })
+${NITRO_HANDLER_OPTIONS}${NITRO_PRERENDERED}    maxActionBody: ${maxActionBody === undefined ? "undefined" : String(maxActionBody)},
+  })
 
 ${fallbackOrigin ? FALLBACK_BODY : "  return (await devHandler(request)) ?? (await notFound())\n"}}
 
@@ -3516,7 +3665,8 @@ ${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> {
-  ${notFoundComponent ? `
+  ${notFoundComponent
+        ? `
   try {
     const { htmlStream } = await handleRscHtmlStream(
       ${JSON.stringify(notFoundComponent)},
@@ -3537,13 +3687,14 @@ async function notFound(): Promise<Response> {
     // A 404 page that throws is still a 404. Falling back rather than
     // answering 500 keeps the status honest about what happened.
   }
-  ` : ''}
+  `
+        : ""}
   return new Response('Not found', { status: 404 })
 }
 `;
 }
 function generateEntrySsr() {
-    const devUrls = join(packageDir, 'devUrls');
+    const devUrls = join(packageDir, "devUrls");
     return `// GENERATED by rscKit() — do not edit.
 import { createFromReadableStream } from '@vitejs/plugin-rsc/ssr'
 import { renderToReadableStream, resume } from 'react-dom/server.edge'
@@ -3670,7 +3821,7 @@ export default {
 }
 `;
 function generateEntryBrowser() {
-    const clientBootstrap = join(packageDir, 'js/createViteRscApp');
+    const clientBootstrap = join(packageDir, "js/createViteRscApp");
     // Only for an exported build, and only what the client needs to work out how
     // much of a page to ask for: a file server sends no headers, so without this
     // every navigation takes the whole document and replaces the root. Inlined
@@ -3678,9 +3829,12 @@ function generateEntryBrowser() {
     // a server answers this, and shipping a route table to every browser for
     // nothing is a page-weight cost with no benefit.
     const routesForClient = staticPayloads
-        ? routeManifest().routes.map((route) => ({ segments: route.segments, layouts: route.layouts }))
+        ? routeManifest().routes.map((route) => ({
+            segments: route.segments,
+            layouts: route.layouts,
+        }))
         : null;
-    const refreshModule = join(packageDir, 'js/navigate');
+    const refreshModule = join(packageDir, "js/navigate");
     return `// GENERATED by rscKit() — do not edit.
 import { createViteRscApp } from ${JSON.stringify(clientBootstrap)}
 import { refresh } from ${JSON.stringify(refreshModule)}
@@ -3726,7 +3880,7 @@ if ('serviceWorker' in navigator && import.meta.env.PROD) {
   })
 }
 `
-        : ''}`;
+        : ""}`;
 }
 /**
  * Intercepted URL patterns, published by the host before the build.
@@ -3748,10 +3902,10 @@ if ('serviceWorker' in navigator && import.meta.env.PROD) {
 function interceptManifest() {
     return routeManifest().intercepts.map((entry) => ({
         // The client writes [id] where a Laravel route writes {id}.
-        urlPattern: '/' +
+        urlPattern: "/" +
             entry.segments
-                .map((seg) => (seg.type === 'static' ? seg.value : '[' + seg.value + ']'))
-                .join('/'),
+                .map((seg) => seg.type === "static" ? seg.value : "[" + seg.value + "]")
+                .join("/"),
         slot: entry.slot,
     }));
 }
@@ -3772,9 +3926,9 @@ function defaultExportBody(source) {
     const start = match.index + match[0].length - 1;
     for (let i = start; i < source.length; i++) {
         const ch = source[i];
-        if (ch === '{')
+        if (ch === "{")
             depth++;
-        else if (ch === '}' && --depth === 0)
+        else if (ch === "}" && --depth === 0)
             return source.slice(start, i + 1);
     }
     return null;
@@ -3797,7 +3951,7 @@ function pageBlocksOnHostCall(source) {
     const body = defaultExportBody(source);
     // Matches `await rpc(`, and the explicitly-qualified forms a typed codebase
     // may use: `await globalThis.rpc(` / `await (globalThis as any).rpc(`.
-    const qualifier = '(?:\\(\\s*globalThis[^)]*\\)\\s*\\.\\s*|globalThis\\s*\\.\\s*)?';
+    const qualifier = "(?:\\(\\s*globalThis[^)]*\\)\\s*\\.\\s*|globalThis\\s*\\.\\s*)?";
     const awaited = new RegExp(`\\bawait\\s+${qualifier}${hostGlobal}\\s*[<(]`);
     return body !== null && awaited.test(body);
 }
@@ -3805,7 +3959,7 @@ function pageBlocksOnHostCall(source) {
 function hasLoadingInChain(pageDir) {
     let dir = pageDir;
     while (dir.startsWith(appDir)) {
-        if (findRouteFile(dir, 'loading'))
+        if (findRouteFile(dir, "loading"))
             return true;
         if (dir === appDir)
             break;
@@ -3832,9 +3986,9 @@ function hasLoadingInChain(pageDir) {
 function validateErrorBoundaries() {
     const wrong = [];
     for (const c of components.values()) {
-        if (!c.name.endsWith('/error'))
+        if (!c.name.endsWith("/error"))
             continue;
-        const source = readFileSync(c.absPath, 'utf-8');
+        const source = readFileSync(c.absPath, "utf-8");
         if (!/^\s*['"]use client['"]/m.test(source)) {
             wrong.push(`  ${relative(projectRoot, c.absPath)}`);
         }
@@ -3844,17 +3998,20 @@ function validateErrorBoundaries() {
 function validateLoadingBoundaries() {
     const errors = [];
     for (const c of components.values()) {
-        if (!c.name.endsWith('/page') && c.name !== 'app/page')
+        if (!c.name.endsWith("/page") && c.name !== "app/page")
             continue;
         const pageDir = dirname(c.absPath);
-        const source = readFileSync(c.absPath, 'utf-8');
+        const source = readFileSync(c.absPath, "utf-8");
         let reason = null;
         if (pageBlocksOnHostCall(source)) {
             reason = `its default export awaits ${hostGlobal}()`;
         }
         else {
             const configPath = routeConfig ? join(pageDir, routeConfig.file) : null;
-            if (routeConfig && configPath && existsSync(configPath) && routeConfig.dynamicPattern.test(readFileSync(configPath, 'utf-8'))) {
+            if (routeConfig &&
+                configPath &&
+                existsSync(configPath) &&
+                routeConfig.dynamicPattern.test(readFileSync(configPath, "utf-8"))) {
                 reason = `${routeConfig.file} resolves props dynamically`;
             }
         }
@@ -3867,10 +4024,42 @@ function validateLoadingBoundaries() {
 // ── Plugin ───────────────────────────────────────────────────────────────────
 /** Names of plugins that transform JSX and must run after rsc() has split it. */
 const JSX_PLUGIN_PATTERN = /react|babel|oxc/i;
+/**
+ * The server-side stand-in for a client export, made extendable.
+ *
+ * In the rsc environment plugin-rsc replaces every export of a "use client"
+ * module with a stub that throws when called. It emits the stub as an arrow
+ * function, and an arrow function has no prototype, so a server module that
+ * does `class NullStore extends ReactStore` - base-ui does, with only the
+ * base class marked "use client" - dies at the class declaration with
+ * "The superclass is not a constructor", on a line nobody wrote, whenever a
+ * server component imports the library directly. Next.js allows that import;
+ * React's own client references are proxies over a real function.
+ *
+ * A `function` stub has a prototype, so the declaration succeeds, and the
+ * stub still throws - now from `super()`, with its own message - if the
+ * class is ever constructed on the server.
+ */
+const CLIENT_STUB = /registerClientReference\(\s*\(\) => \{ throw new Error\("Unexpectedly client reference export '"/g;
+function extendableClientReferences() {
+    return {
+        name: "rsc-kit:extendable-client-references",
+        enforce: "post",
+        applyToEnvironment: (environment) => environment.name === "rsc",
+        transform(code) {
+            if (!code.includes("Unexpectedly client reference export"))
+                return;
+            return {
+                code: code.replace(CLIENT_STUB, 'registerClientReference(function () { throw new Error("Unexpectedly client reference export \'"'),
+                map: null,
+            };
+        },
+    };
+}
 export function rscKit(options = {}) {
     resolvePaths(options);
     const routesPlugin = {
-        name: 'rsc-kit',
+        name: "rsc-kit",
         config(_config, env) {
             if (!existsSync(appDir)) {
                 throw new Error(`[rsc-kit] No app directory at ${appDir} — nothing to build.`);
@@ -3889,24 +4078,24 @@ export function rscKit(options = {}) {
             // editing is a state to pass through, not to be thrown out of.
             if (components.size === 0) {
                 const message = `No routes under ${appDir}. A directory with a page.tsx in it is a route; ` +
-                    'without one there is nothing to serve.';
-                if (env.command === 'build')
+                    "without one there is nothing to serve.";
+                if (env.command === "build")
                     throw new Error(`[rsc-kit] ${message}`);
                 log(message);
             }
             const notClient = validateErrorBoundaries();
             if (notClient.length) {
-                throw new Error('[rsc-kit] An error.tsx must be a client component.\n\n' +
-                    notClient.join('\n') +
+                throw new Error("[rsc-kit] An error.tsx must be a client component.\n\n" +
+                    notClient.join("\n") +
                     "\n\nAdd 'use client' at the top. It is rendered inside an error boundary and is\n" +
-                    'handed a reset() callback to call, neither of which a server component can do.');
+                    "handed a reset() callback to call, neither of which a server component can do.");
             }
             const loadingErrors = validateLoadingBoundaries();
             if (loadingErrors.length) {
-                throw new Error('[rsc-kit] A page that blocks before it can paint needs a loading.tsx boundary.\n\n' +
-                    loadingErrors.join('\n') +
-                    '\n\nAdd loading.tsx in the page directory (or a parent), or move the slow work\n' +
-                    'into a child component wrapped in its own <Suspense> so the page can paint.');
+                throw new Error("[rsc-kit] A page that blocks before it can paint needs a loading.tsx boundary.\n\n" +
+                    loadingErrors.join("\n") +
+                    "\n\nAdd loading.tsx in the page directory (or a parent), or move the slow work\n" +
+                    "into a child component wrapped in its own <Suspense> so the page can paint.");
             }
             // Before the entries, because the app's own source imports these and the
             // module graph is walked as soon as this hook returns.
@@ -3919,7 +4108,7 @@ export function rscKit(options = {}) {
             // host calls resolve their endpoint, from the app's own .env, so the two
             // cannot end up pointing at different backends. Development only: a
             // build's server.ts decides this for itself.
-            const backendEnv = loadEnv(env.mode, projectRoot, '');
+            const backendEnv = loadEnv(env.mode, projectRoot, "");
             // Only a backend this server could actually call. The shared secret is
             // what makes one a backend rather than a url that happens to be in the
             // environment — APP_URL is not a Laravel-only name, and a JavaScript
@@ -3931,16 +4120,19 @@ export function rscKit(options = {}) {
             // the address down means it.
             const backendSecret = hostCallOptions?.secret ?? backendEnv.RSC_HOST_CALL_SECRET;
             const detected = backendSecret
-                ? (hostCallOptions?.endpoint ?? backendEnv.RSC_BACKEND ?? backendEnv.APP_URL ?? '')
-                : '';
-            const fallbackOrigin = options.devFallback === false ? '' : (options.devFallback ?? detected);
-            writeFileSync(join(genDir, 'entry.rsc.tsx'), generateEntryRsc(fallbackOrigin));
-            writeFileSync(join(genDir, 'entry.ssr.tsx'), generateEntrySsr());
-            writeFileSync(join(genDir, 'entry.browser.tsx'), generateEntryBrowser());
+                ? (hostCallOptions?.endpoint ??
+                    backendEnv.RSC_BACKEND ??
+                    backendEnv.APP_URL ??
+                    "")
+                : "";
+            const fallbackOrigin = options.devFallback === false ? "" : (options.devFallback ?? detected);
+            writeFileSync(join(genDir, "entry.rsc.tsx"), generateEntryRsc(fallbackOrigin));
+            writeFileSync(join(genDir, "entry.ssr.tsx"), generateEntrySsr());
+            writeFileSync(join(genDir, "entry.browser.tsx"), generateEntryBrowser());
             // Written beside the entries, for a host to read instead of walking the
             // route tree itself. Laravel scans it a second time today; a JS host
             // would otherwise have to write a third walk of the same directories.
-            writeFileSync(join(outDir, 'routes.json'), JSON.stringify(manifest, null, 2));
+            writeFileSync(join(outDir, "routes.json"), JSON.stringify(manifest, null, 2));
             return {
                 // Off, not merely unused: Vite warns when publicDir sits inside outDir,
                 // and assetsDir is normally a directory under the build output. An app
@@ -3961,7 +4153,7 @@ export function rscKit(options = {}) {
                  * answer travels with the bundle instead of with whoever starts it.
                  */
                 define: {
-                    'process.env.NODE_ENV': JSON.stringify(env.mode === 'development' ? 'development' : 'production'),
+                    "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),
@@ -3998,7 +4190,7 @@ export function rscKit(options = {}) {
                 // "The server is configured with a public base URL", which reads as a
                 // routing bug rather than as this line. In dev the pages are the root;
                 // the assets come from the same origin either way.
-                base: '/',
+                base: "/",
                 // Where the generated entries live, so Vite resolves them as its own
                 // source. A build concern only.
                 //
@@ -4018,7 +4210,7 @@ export function rscKit(options = {}) {
                 // built bundles reference it zero times — deduping it was a no-op left
                 // over from the hand-rolled engine.
                 resolve: {
-                    dedupe: ['react', 'react-dom', '@vitejs/plugin-rsc'],
+                    dedupe: ["react", "react-dom", "@vitejs/plugin-rsc"],
                     // `import Link from '<packageAlias>/Link'` resolves to the client
                     // runtime shipped here, for hosts that vendor this package outside
                     // node_modules. Installed from npm the name resolves on its own.
@@ -4026,15 +4218,35 @@ export function rscKit(options = {}) {
                 },
                 build: { emptyOutDir: true },
                 environments: {
-                    // Server bundles — stay under the (non-public) out dir.
-                    rsc: { build: { rollupOptions: { input: { index: join(genDir, 'entry.rsc.tsx') } } } },
-                    ssr: { build: { rollupOptions: { input: { index: join(genDir, 'entry.ssr.tsx') } } } },
+                    // Server bundles — stay under the (non-public) out dir. `bun` and
+                    // `bun:*` are the runtime's own modules, like `node:*`: nothing to
+                    // bundle, and a build under Node has nothing to resolve them to.
+                    // Left as imports for the runtime that has them.
+                    rsc: {
+                        build: {
+                            rollupOptions: {
+                                input: { index: join(genDir, "entry.rsc.tsx") },
+                                external: RUNTIME_BUILTINS,
+                            },
+                        },
+                    },
+                    ssr: {
+                        build: {
+                            rollupOptions: {
+                                input: { index: join(genDir, "entry.ssr.tsx") },
+                                external: RUNTIME_BUILTINS,
+                            },
+                        },
+                    },
                     // Client bundle — emitted into public/ for the web server to serve.
                     client: {
                         build: {
                             outDir: publicAssetsDir,
                             emptyOutDir: true,
-                            rollupOptions: { input: { index: join(genDir, 'entry.browser.tsx') } },
+                            rollupOptions: {
+                                input: { index: join(genDir, "entry.browser.tsx") },
+                                output: { chunkFileNames: clientChunkFileName },
+                            },
                         },
                     },
                 },
@@ -4061,22 +4273,24 @@ export function rscKit(options = {}) {
             // no host installed every rpc() is refused — so a page whose data comes
             // from the backend renders its shell and then blanks, which reads as a
             // hydration bug rather than a missing wire.
-            server.httpServer?.once('listening', async () => {
+            server.httpServer?.once("listening", async () => {
                 const env = server.environments?.rsc;
                 if (!env?.runner)
                     return;
                 // The app's own .env, unprefixed. A Laravel app already has both of
                 // these, which is what makes this need no configuring: APP_URL is the
                 // backend and RSC_HOST_CALL_SECRET is the secret it checks.
-                const fromEnv = loadEnv(server.config.mode, projectRoot, '');
+                const fromEnv = loadEnv(server.config.mode, projectRoot, "");
                 const secret = hostCallOptions?.secret ?? fromEnv.RSC_HOST_CALL_SECRET;
                 const origin = hostCallOptions?.endpoint ?? fromEnv.RSC_BACKEND ?? fromEnv.APP_URL;
                 if (!secret || !origin)
                     return;
-                const path = hostCallOptions?.path ?? fromEnv.RSC_HOST_CALL_PATH ?? '/__rsc/host-call';
-                const endpoint = origin.replace(/\/$/, '') + path;
+                const path = hostCallOptions?.path ??
+                    fromEnv.RSC_HOST_CALL_PATH ??
+                    "/__rsc/host-call";
+                const endpoint = origin.replace(/\/$/, "") + path;
                 try {
-                    const entry = await env.runner.import(join(genDir, 'entry.rsc.tsx'));
+                    const entry = await env.runner.import(join(genDir, "entry.rsc.tsx"));
                     const install = entry.installHostFn;
                     install?.(httpHostCalls({ endpoint, secret }));
                 }
@@ -4099,7 +4313,7 @@ export function rscKit(options = {}) {
                     }
                     catch { }
                 };
-                server.httpServer?.once('listening', () => {
+                server.httpServer?.once("listening", () => {
                     // The url Vite resolved, not one built from the port. A dev server
                     // whose port is already taken on IPv4 binds IPv6 only and keeps the
                     // number — so http://127.0.0.1:<port> is a reachable-looking address
@@ -4108,25 +4322,25 @@ export function rscKit(options = {}) {
                     const resolved = server.resolvedUrls?.local?.[0];
                     const address = server.httpServer?.address();
                     const url = resolved ??
-                        (typeof address === 'object' && address
-                            ? `http://${address.family === 'IPv6' ? `[${address.address}]` : address.address}:${address.port}`
+                        (typeof address === "object" && address
+                            ? `http://${address.family === "IPv6" ? `[${address.address}]` : address.address}:${address.port}`
                             : null);
                     if (!url)
                         return;
                     mkdirSync(dirname(hotFile), { recursive: true });
-                    writeFileSync(hotFile, url.replace(/\/$/, ''));
+                    writeFileSync(hotFile, url.replace(/\/$/, ""));
                 });
-                for (const signal of ['SIGINT', 'SIGTERM', 'exit']) {
+                for (const signal of ["SIGINT", "SIGTERM", "exit"]) {
                     process.once(signal, remove);
                 }
-                server.httpServer?.once('close', remove);
+                server.httpServer?.once("close", remove);
             }
             const shapes = new Set(ROUTE_FILES.map((name) => name));
             const affectsRouting = (file) => {
                 if (!file.startsWith(sourceDir))
                     return false;
-                const base = file.split('/').pop() ?? '';
-                const stem = base.replace(/\.(tsx|jsx|ts|js)$/, '');
+                const base = file.split("/").pop() ?? "";
+                const stem = base.replace(/\.(tsx|jsx|ts|js)$/, "");
                 // The host's route-config file, whatever it named it. Hardcoding one
                 // here would put a backend's convention back into a plugin that is
                 // published without any — generic-host.test.ts fails if it reappears.
@@ -4143,8 +4357,8 @@ export function rscKit(options = {}) {
             // Watched explicitly: the Vite root is the *out* directory, so the app's
             // source tree is outside it and nothing would report a file appearing.
             server.watcher.add(sourceDir);
-            server.watcher.on('add', restart);
-            server.watcher.on('unlink', restart);
+            server.watcher.on("add", restart);
+            server.watcher.on("unlink", restart);
         },
         /**
          * Freeze what can be frozen, once every bundle exists.
@@ -4180,7 +4394,8 @@ export function rscKit(options = {}) {
             // differ — <outDir>/dist/rsc on its own, node_modules/.nitro/… under
             // Nitro — and hard-coding the first is what silently skipped the second.
             // Both environments emit `index.js`, so this is one path, not a branch.
-            const rscOut = builder?.environments?.rsc?.config?.build?.outDir ?? join(outDir, 'dist/rsc');
+            const rscOut = builder?.environments?.rsc?.config?.build?.outDir ??
+                join(outDir, "dist/rsc");
             const bundle = resolveRscBundle(rscOut);
             // Where the frozen pages go, which is not the same question.
             //
@@ -4192,9 +4407,19 @@ export function rscKit(options = {}) {
             // they are in place by the time it does.
             const clientOut = builder?.environments?.client?.config?.build?.outDir;
             const staticDir = clientOut
-                ? join(dirname(clientOut), 'server', NITRO_STATIC_DIR)
+                ? join(dirname(clientOut), "server", NITRO_STATIC_DIR)
                 : join(outDir, NITRO_STATIC_DIR);
             const { frozen, results } = await prerenderAfterBundles(bundle, staticDir, clientOut ?? publicAssetsDir, builder ? knownActionsOf(builder.config, projectRoot) : []);
+            // The same pages once more, as a module. A Worker has no filesystem, and
+            // until this existed every Cloudflare deploy rendered its "static" pages
+            // live, silently - the reader found no directory and fell through. The
+            // module is uploaded as a sibling of the bundle and imported at runtime
+            // when the directory is not there. Only under Nitro, whose presets are
+            // the ones without a disk; on its own the plugin serves from outDir.
+            if (clientOut && existsSync(staticDir)) {
+                const { inlineModuleName, inlineModuleSource } = await import("./files.js");
+                writeFileSync(join(dirname(staticDir), inlineModuleName(NITRO_STATIC_DIR)), await inlineModuleSource(staticDir));
+            }
             // 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
@@ -4208,11 +4433,12 @@ export function rscKit(options = {}) {
         },
         configResolved(config) {
             isWatch = config.build?.watch != null;
-            const nitroMain = config.plugins.find((p) => p.name === 'nitro:main');
+            resolvedConfig = config;
+            const nitroMain = config.plugins.find((p) => p.name === "nitro:main");
             if (nitroMain?.hotUpdate) {
                 const original = nitroMain.hotUpdate;
                 nitroMain.hotUpdate = function (ctx) {
-                    if (this.environment?.name === 'rsc')
+                    if (this.environment?.name === "rsc")
                         return;
                     return original.call(this, ctx);
                 };
@@ -4221,12 +4447,12 @@ export function rscKit(options = {}) {
             // placed ahead of it sees the wrong graph and fails in ways that are hard
             // to trace back here. Cheaper to refuse than to let it through.
             const names = config.plugins.map((p) => p.name);
-            const rscAt = names.findIndex((n) => n === 'rsc' || n.startsWith('rsc:'));
+            const rscAt = names.findIndex((n) => n === "rsc" || n.startsWith("rsc:"));
             const jsxAt = names.findIndex((n) => JSX_PLUGIN_PATTERN.test(n));
             if (rscAt !== -1 && jsxAt !== -1 && jsxAt < rscAt) {
                 throw new Error(`[rsc-kit] Plugin "${names[jsxAt]}" is resolved ahead of rsc(), so it would ` +
-                    'transform JSX before the client/server split.\n' +
-                    'Put rscKit() first in your plugins array. If it already is, that plugin ' +
+                    "transform JSX before the client/server split.\n" +
+                    "Put rscKit() first in your plugins array. If it already is, that plugin " +
                     "sets enforce: 'pre' and needs to be moved after rsc() explicitly.");
             }
         },
@@ -4255,6 +4481,7 @@ export function rscKit(options = {}) {
             clientChunks: (meta) => meta.normalizedId,
             ...actionEncryptionKey(),
         }),
+        extendableClientReferences(),
         routesPlugin,
     ];
 }
@@ -4303,14 +4530,14 @@ function actionEncryptionKey() {
     // the key is read, so what ships is the lookup rather than the secret. A
     // literal here would put the key in the bundle, which is the thing being
     // avoided.
-    return { defineEncryptionKey: 'process.env.RSC_ACTION_ENCRYPTION_KEY' };
+    return { defineEncryptionKey: "process.env.RSC_ACTION_ENCRYPTION_KEY" };
 }
 async function appPluginRsc(options = {}) {
     try {
         // Resolved against a file *in* the root, since a directory specifier
         // resolves relative to its parent.
-        const fromApp = createRequire(join(projectRoot, 'package.json'));
-        const entry = fromApp.resolve('@vitejs/plugin-rsc');
+        const fromApp = createRequire(join(projectRoot, "package.json"));
+        const entry = fromApp.resolve("@vitejs/plugin-rsc");
         const mod = (await import(pathToFileURL(entry).href));
         return (mod.default ?? rsc)(options);
     }