@rsc-kit/core 0.16.0 → 0.16.2

package/dist/prerender.js

@@ -14,10 +14,10 @@
 //
 // The file layout matches the one Laravel writes, so both hosts serve the same
 // shapes and anything that reads them works for either.
-import { withRedirect } from './redirect.js';
-import { withCache } from './cache.js';
-import { requestReadBy, requestWasRead, withRequest } from './request.js';
-import { watchNondeterminism, whileRendering } from './nondeterminism.js';
+import { withRedirect } from "./redirect.js";
+import { withCache } from "./cache.js";
+import { requestReadBy, requestReadWhere, requestWasRead, withRequest, } from "./request.js";
+import { watchNondeterminism, whileRendering } from "./nondeterminism.js";
 /** What a prerenderer needs from the built bundle, beyond serving a request. */
 /**
  * How long the root-fallback diagnostic waits before answering.
@@ -49,11 +49,11 @@ const DEFAULT_PRERENDER_CONCURRENCY = 4;
  * else in the list is the app's, and needs the runtime.
  */
 const RUNTIME_OWN = new Set([
-    'DocumentTitle',
-    'PathnameProvider',
-    'RouteErrorBoundary',
-    'SegmentBoundary',
-    'SlotBoundary',
+    "DocumentTitle",
+    "PathnameProvider",
+    "RouteErrorBoundary",
+    "SegmentBoundary",
+    "SlotBoundary",
 ]);
 /**
  * The one line the bootstrap would have run for the worker, for a document
@@ -62,9 +62,23 @@ const RUNTIME_OWN = new Set([
  * no closing body tag is left alone.
  */
 const WORKER_REGISTRATION = "<script>'serviceWorker'in navigator&&addEventListener('load',function(){navigator.serviceWorker.register('/sw.js').catch(function(){})})</script>";
+/**
+ * Every `<link rel="stylesheet">` whose source the reader answers for,
+ * replaced by a `<style>` holding it. A link the reader declines - too big,
+ * or not the build's - is left as it was.
+ */
+export function withInlineStylesheets(html, read) {
+    return html.replace(/<link\b[^>]*\brel="stylesheet"[^>]*>/g, (tag) => {
+        const href = /\bhref="([^"]+)"/.exec(tag)?.[1];
+        const css = href ? read(href) : null;
+        return css === null ? tag : `<style>${css}</style>`;
+    });
+}
 export function withWorkerRegistration(html) {
-    const at = html.lastIndexOf('</body>');
-    return at === -1 ? html : html.slice(0, at) + WORKER_REGISTRATION + html.slice(at);
+    const at = html.lastIndexOf("</body>");
+    return at === -1
+        ? html
+        : html.slice(0, at) + WORKER_REGISTRATION + html.slice(at);
 }
 /**
  * The build's refusal to store a route it cannot answer ahead of time.
@@ -79,33 +93,35 @@ export class NotPrerenderable extends Error {
         // Two different problems arrive here, and the advice for one is useless for
         // the other. A page that reads the request above every boundary needs a
         // boundary; a page whose render threw needs whatever it was reaching for.
-        const threw = routes.filter((r) => r.reason?.startsWith('could not be rendered'));
-        const unpaintable = routes.filter((r) => !r.reason?.startsWith('could not be rendered'));
+        const threw = routes.filter((r) => r.reason?.startsWith("could not be rendered"));
+        const unpaintable = routes.filter((r) => !r.reason?.startsWith("could not be rendered"));
         const advice = [];
         if (unpaintable.length > 0) {
-            advice.push('These read request data — params, headers, cookies, or the host — above\n' +
-                'every Suspense boundary, so nothing can paint without it:\n\n' +
-                unpaintable.map((r) => `  ${r.url} — ${r.reason ?? 'nothing to paint'}`).join('\n') +
-                '\n\nPut the part that waits inside <Suspense>, or add a loading.tsx beside\n' +
-                'the page, so there is something to store while the rest arrives.');
+            advice.push("These read request data — params, headers, cookies, or the host — above\n" +
+                "every Suspense boundary, so nothing can paint without it:\n\n" +
+                unpaintable
+                    .map((r) => `  ${r.url} — ${r.reason ?? "nothing to paint"}`)
+                    .join("\n") +
+                "\n\nPut the part that waits inside <Suspense>, or add a loading.tsx beside\n" +
+                "the page, so there is something to store while the rest arrives.");
         }
         if (threw.length > 0) {
-            advice.push('These failed while rendering:\n\n' +
-                threw.map((r) => `  ${r.url} — ${r.reason}`).join('\n') +
-                '\n\nPrerendering runs your application code, so it needs whatever that code\n' +
-                'needs. If the page is fine and this machine simply cannot reach a\n' +
-                'database or an API, either give the build access or turn prerendering\n' +
-                'off with `rscKit({ prerender: false })`.\n\n' +
-                'Reaching for data through the host — `await rpc(...)` — avoids this\n' +
-                'entirely: the build stubs that call, so the page freezes a shell\n' +
-                'without the data being available.');
+            advice.push("These failed while rendering:\n\n" +
+                threw.map((r) => `  ${r.url} — ${r.reason}`).join("\n") +
+                "\n\nPrerendering runs your application code, so it needs whatever that code\n" +
+                "needs. If the page is fine and this machine simply cannot reach a\n" +
+                "database or an API, either give the build access or put `await connection()`\n" +
+                "before the read: the page then renders per request and the rest is still stored.\n\n" +
+                "Reaching for data through the host — `await rpc(...)` — avoids this\n" +
+                "entirely: the build stubs that call, so the page freezes a shell\n" +
+                "without the data being available.");
         }
-        super('Some routes could not be prerendered.\n\n' + advice.join('\n\n') + '\n');
-        this.name = 'NotPrerenderable';
+        super("Some routes could not be prerendered.\n\n" + advice.join("\n\n") + "\n");
+        this.name = "NotPrerenderable";
         this.routes = routes;
         // Not enumerable: Vite prints an error's own properties under its stack,
         // and this list is the message again, as an object dump.
-        Object.defineProperty(this, 'routes', { value: routes, enumerable: false });
+        Object.defineProperty(this, "routes", { value: routes, enumerable: false });
     }
 }
 /**
@@ -117,16 +133,16 @@ export class NotPrerenderable extends Error {
  * route matches, including the ones the app never listed.
  */
 export function patternKey(route) {
-    const parts = route.segments.map((s) => (s.type === 'static' ? s.value : `_${s.value}_`));
-    return parts.join('/') || 'index';
+    const parts = route.segments.map((s) => s.type === "static" ? s.value : `_${s.value}_`);
+    return parts.join("/") || "index";
 }
 /** Close a document the render was aborted in the middle of. */
 export function closeDocument(html) {
     let out = html;
     if (!/<\/body>/i.test(out) && /<body/i.test(out))
-        out += '</body>';
+        out += "</body>";
     if (!/<\/html>/i.test(out) && /<html/i.test(out))
-        out += '</html>';
+        out += "</html>";
     return out;
 }
 /**
@@ -151,19 +167,19 @@ export function closeDocument(html) {
 export function legend(results) {
     const has = (type) => results.some((r) => r.type === type);
     const lines = [];
-    if (has('frozen')) {
-        lines.push('  \u25CB  (Static)             prerendered as static content');
+    if (has("frozen")) {
+        lines.push("  \u25CB  (Static)             prerendered as static content");
     }
-    if (has('shell')) {
-        lines.push('  \u25D0  (Partial Prerender)  prerendered as static HTML with dynamic server-streamed content');
+    if (has("shell")) {
+        lines.push("  \u25D0  (Partial Prerender)  prerendered as static HTML with dynamic server-streamed content");
     }
-    if (has('dynamic')) {
-        lines.push('  \u0192  (Dynamic)            server-rendered on demand');
+    if (has("dynamic")) {
+        lines.push("  \u0192  (Dynamic)            server-rendered on demand");
     }
-    if (has('error') || has('blocked')) {
-        lines.push('  \u2717  (Failed)             did not render, or painted nothing — the build stops here');
+    if (has("error") || has("blocked")) {
+        lines.push("  \u2717  (Failed)             did not render, or painted nothing — the build stops here");
     }
-    return lines.join('\n');
+    return lines.join("\n");
 }
 /**
  * How much JavaScript a route makes the browser download.
@@ -178,7 +194,7 @@ export function legend(results) {
  */
 export function clientJsSize(bytes) {
     if (bytes === 0)
-        return 'no js';
+        return "no js";
     const kb = bytes / 1000;
     return `${kb < 10 ? kb.toFixed(1) : Math.round(kb)} kB`;
 }
@@ -201,27 +217,29 @@ export function notes(results) {
     // root layout leaves: one cookies() in a header component and nothing on
     // the site can be stored. The build cannot see which component read it -
     // only that every page did - so it says what that usually means.
-    const pages = results.filter((r) => r.type && r.type !== 'error' && r.type !== 'blocked');
-    const reasons = new Set(pages.map((r) => r.reason ?? ''));
-    if (pages.length > 1 && !pages.some((r) => r.type === 'frozen') && reasons.size === 1) {
+    const pages = results.filter((r) => r.type && r.type !== "error" && r.type !== "blocked");
+    const reasons = new Set(pages.map((r) => r.reason ?? ""));
+    if (pages.length > 1 &&
+        !pages.some((r) => r.type === "frozen") &&
+        reasons.size === 1) {
         const [reason] = reasons;
         parts.push(`  Every route ${reason}. When one read makes every page dynamic it is usually\n` +
-            '  in the root layout - a header reading the session, a locale from a cookie.\n' +
-            '  Move that read into the component that needs it, under a <Suspense>, and\n' +
-            '  the rest of the site can freeze around it.');
+            "  in the root layout - a header reading the session, a locale from a cookie.\n" +
+            "  Move that read into the component that needs it, under a <Suspense>, and\n" +
+            "  the rest of the site can freeze around it.");
     }
-    if (said('rpc('))
+    if (said("rpc("))
         parts.push(rpcNote());
-    return parts.join('\n\n');
+    return parts.join("\n\n");
 }
 function rpcNote() {
-    return ('  A build has no backend to call. rpc() suspends instead of answering, so a page\n' +
-        '  that reads through one ships a shell and finishes for whoever asks — which is\n' +
-        '  almost always what you want, since that data is rarely the same for everyone.\n' +
-        '\n' +
-        '  If a page really should be frozen, move the read out of rpc(). If it really\n' +
-        '  should be per visitor, say so with await connection() and the intent is on the\n' +
-        '  page rather than inferred from a call that happened to suspend.');
+    return ("  A build has no backend to call. rpc() suspends instead of answering, so a page\n" +
+        "  that reads through one ships a shell and finishes for whoever asks — which is\n" +
+        "  almost always what you want, since that data is rarely the same for everyone.\n" +
+        "\n" +
+        "  If a page really should be frozen, move the read out of rpc(). If it really\n" +
+        "  should be per visitor, say so with await connection() and the intent is on the\n" +
+        "  page rather than inferred from a call that happened to suspend.");
 }
 /**
  * The one-line tally under the legend, in the legend's own words.
@@ -229,20 +247,22 @@ function rpcNote() {
 export function summary(results) {
     const count = (type) => results.filter((r) => r.type === type).length;
     const parts = [];
-    if (count('frozen'))
-        parts.push(`${count('frozen')} static`);
-    if (count('shell'))
-        parts.push(`${count('shell')} partial prerender`);
-    if (count('dynamic'))
-        parts.push(`${count('dynamic')} dynamic`);
-    if (count('error') + count('blocked'))
-        parts.push(`${count('error') + count('blocked')} failed`);
-    return parts.join(', ') || 'nothing to store';
+    if (count("frozen"))
+        parts.push(`${count("frozen")} static`);
+    if (count("shell"))
+        parts.push(`${count("shell")} partial prerender`);
+    if (count("dynamic"))
+        parts.push(`${count("dynamic")} dynamic`);
+    if (count("error") + count("blocked"))
+        parts.push(`${count("error") + count("blocked")} failed`);
+    return parts.join(", ") || "nothing to store";
 }
 export function pathKey(url) {
-    const key = url.replace(/^\/+|\/+$/g, '') || 'index';
-    if (key.split('/').some((segment) => segment === '..' || segment === '.')) {
-        throw new Error('Refusing to store ' + JSON.stringify(url) + ': the path leaves the output directory. ' +
+    const key = url.replace(/^\/+|\/+$/g, "") || "index";
+    if (key.split("/").some((segment) => segment === ".." || segment === ".")) {
+        throw new Error("Refusing to store " +
+            JSON.stringify(url) +
+            ": the path leaves the output directory. " +
             'A url segment came from generateStaticParams() or a route param and contains "..".');
     }
     return key;
@@ -256,16 +276,20 @@ export function pathKey(url) {
  */
 export function urlFor(route, params) {
     const parts = route.segments.map((segment) => {
-        if (segment.type === 'static')
+        if (segment.type === "static")
             return segment.value;
-        const value = params[segment.value] ?? '';
-        if (segment.type !== 'catchAll' && /[/\\]/.test(value)) {
-            throw new Error('The ' + segment.value + ' param is ' + JSON.stringify(value) + ', which is not one url ' +
-                'segment. A value with a slash in it has to be a catch-all route, or be encoded.');
+        const value = params[segment.value] ?? "";
+        if (segment.type !== "catchAll" && /[/\\]/.test(value)) {
+            throw new Error("The " +
+                segment.value +
+                " param is " +
+                JSON.stringify(value) +
+                ", which is not one url " +
+                "segment. A value with a slash in it has to be a catch-all route, or be encoded.");
         }
         return value;
     });
-    return '/' + parts.filter((p) => p !== '').join('/');
+    return "/" + parts.filter((p) => p !== "").join("/");
 }
 /**
  * Every url this build should attempt, and the params each was built from.
@@ -278,15 +302,15 @@ export function urlFor(route, params) {
 function placeholders(route) {
     const params = {};
     for (const segment of route.segments) {
-        if (segment.type !== 'static')
-            params[segment.value] = '_';
+        if (segment.type !== "static")
+            params[segment.value] = "_";
     }
     return params;
 }
 export async function urlsToBuild(manifest, engine) {
     const entries = [];
     for (const route of manifest.routes) {
-        const parameterised = route.segments.some((s) => s.type !== 'static');
+        const parameterised = route.segments.some((s) => s.type !== "static");
         if (!parameterised) {
             entries.push({ route, params: {}, url: urlFor(route, {}) });
             continue;
@@ -294,7 +318,11 @@ export async function urlsToBuild(manifest, engine) {
         // A route that lists no urls still gets one attempt, with placeholder
         // params, so it can ship a shell. Nothing in a shell varies by param.
         if (!route.staticParams) {
-            entries.push({ route, params: placeholders(route), url: urlFor(route, placeholders(route)) });
+            entries.push({
+                route,
+                params: placeholders(route),
+                url: urlFor(route, placeholders(route)),
+            });
             continue;
         }
         const sets = (await engine.getStaticParams?.(route.component)) ?? null;
@@ -313,7 +341,7 @@ export async function prerender(options) {
     const { engine, write, version } = options;
     const manifest = options.manifest ?? engine.manifest?.();
     if (!manifest) {
-        throw new Error('No route table. Pass `manifest`, or build with a plugin version that embeds one.');
+        throw new Error("No route table. Pass `manifest`, or build with a plugin version that embeds one.");
     }
     const entries = await urlsToBuild(manifest, engine);
     const results = new Array(entries.length);
@@ -350,15 +378,19 @@ export async function prerender(options) {
     finally {
         unwatch();
     }
-    const refused = results.filter((r) => r.type === 'blocked');
+    const refused = results.filter((r) => r.type === "blocked");
     if (refused.length > 0) {
         throw new NotPrerenderable(refused);
     }
     return results;
     async function prerenderOne(route, params, url) {
         const props = options.props ? options.props(route, params) : params;
-        const layouts = route.layouts.map((component) => ({ component, props: {} }));
-        const unlistedNow = route.segments.some((seg) => seg.type !== 'static') && !route.staticParams;
+        const layouts = route.layouts.map((component) => ({
+            component,
+            props: {},
+        }));
+        const unlistedNow = route.segments.some((seg) => seg.type !== "static") &&
+            !route.staticParams;
         /**
          * Why this route ships a shell rather than a whole page.
          *
@@ -368,26 +400,27 @@ export async function prerender(options) {
          */
         const shellReason = (calls) => {
             if (calls.length)
-                return 'dynamic — called ' + calls.join(', ');
+                return "dynamic — called " + calls.join(", ");
             // One shell serving every url the route matches. generateStaticParams is
             // what turns it into a page per url.
             if (unlistedNow)
-                return 'one shell for every url — add generateStaticParams to store each';
+                return "one shell for every url — add generateStaticParams to store each";
             // Nothing reached for the request; the data simply took too long. The
             // page is fine, it just finishes per visitor.
             if (shell?.timedOut)
-                return 'data took longer than the build budget';
+                return "data took longer than the build budget";
             return null;
         };
         const said = (type, reason) => ({
             // A route standing in for many urls reports the pattern. Reporting the
             // placeholder url instead prints `/posts/_`, which looks like a page.
-            url: unlistedNow ? '/' + patternKey(route) : url,
+            url: unlistedNow ? "/" + patternKey(route) : url,
             component: route.component,
             type,
             reason,
         });
-        const unlisted = route.segments.some((seg) => seg.type !== 'static') && !route.staticParams;
+        const unlisted = route.segments.some((seg) => seg.type !== "static") &&
+            !route.staticParams;
         // Classify by rendering, never by asking. The probe is cheap and cannot
         // hang: anything still suspended when its budget expires is the answer.
         //
@@ -401,19 +434,22 @@ export async function prerender(options) {
         // must not share an answer just because they were built in the same run.
         // No request, deliberately: a page that reads one is caught below rather
         // than frozen holding whatever the build machine happened to send.
-        const [{ shell, redirected, readRequest, readBy }, nondeterministic] = await whileRendering(() => withRequest(null, () => withCache(() => withRedirect(async (taken) => {
+        const [{ shell, redirected, readRequest, readBy, readWhere }, nondeterministic,] = await whileRendering(() => withRequest(null, () => withCache(() => withRedirect(async (taken) => {
             try {
                 return {
                     shell: await engine.handleRscPprShell(route.component, props, layouts, route.loadings, route.slots, 
                     // Only when this shell serves one url. A parameterised route's
                     // shell is shared, so baking a url into it would put the wrong one
                     // on every page but the one that happened to be built.
-                    unlistedNow ? '' : url),
+                    unlistedNow ? "" : url),
                     redirected: taken(),
                     readRequest: requestWasRead(),
                     // What reached for it, so the build can name the call rather than
                     // only report that the page is dynamic.
                     readBy: requestReadBy(),
+                    // And from which component, so the message is a line to open
+                    // rather than a category to search for.
+                    readWhere: requestReadWhere(),
                 };
             }
             catch (error) {
@@ -424,7 +460,13 @@ export async function prerender(options) {
                 const refused = taken();
                 if (!refused)
                     throw error;
-                return { shell: null, redirected: refused, readRequest: requestWasRead(), readBy: requestReadBy() };
+                return {
+                    shell: null,
+                    redirected: refused,
+                    readRequest: requestWasRead(),
+                    readBy: requestReadBy(),
+                    readWhere: requestReadWhere(),
+                };
             }
         }))));
         // A page that leaves rather than renders is not a build failure, and it is
@@ -452,9 +494,21 @@ export async function prerender(options) {
          * the prerender.
          */
         async function withRootFallbackChecked(result) {
-            if (result.type !== 'shell')
+            if (result.type !== "shell")
+                return result;
+            if (!engine.handleRscPprShell)
                 return result;
-            if (route.loadings.length !== 1 || !engine.handleRscPprShell)
+            // Only when the one fallback in the chain is the root layout's. A page
+            // with its own loading.tsx beside it has put the boundary exactly where
+            // the waiting is, and this used to tell it otherwise - "exactly one
+            // loading" is not the same as "only the root one".
+            const [only] = route.loadings;
+            const root = route.layouts[0];
+            const dirOf = (name) => name.slice(0, name.lastIndexOf("/"));
+            if (route.loadings.length !== 1 ||
+                !only ||
+                !root ||
+                dirOf(only) !== dirOf(root))
                 return result;
             // A tenth of the shell budget, because this is a different question.
             //
@@ -465,10 +519,10 @@ export async function prerender(options) {
             // to learn what the first millisecond already said, which on this
             // example was 40% of the entire prerender.
             const withoutRoot = await withRequest(null, () => withCache(() => withRedirect(async () => engine.handleRscPprShell(route.component, props, layouts, [], route.slots, url, ROOT_FALLBACK_BUDGET_MS)))).catch(() => null);
-            if (withoutRoot && closeDocument(withoutRoot.shellHtml.trim()) === '') {
+            if (withoutRoot && closeDocument(withoutRoot.shellHtml.trim()) === "") {
                 result.warning =
-                    'nothing painted without the root loading.tsx — the fallback the whole app shares ' +
-                        'is standing in for this page. Put a boundary where the waiting is.';
+                    "nothing painted without the root loading.tsx — the fallback the whole app shares " +
+                        "is standing in for this page. Put a boundary where the waiting is.";
             }
             return result;
         }
@@ -476,13 +530,16 @@ export async function prerender(options) {
         // is the redirect, not a page. Rendering it per request re-derives a
         // constant, and on a static host there would be nothing to derive it with.
         if (redirected) {
-            await write(`${pathKey(url)}.redirect.json`, JSON.stringify({ status: redirected.status, location: redirected.location }));
-            return said('frozen', `redirects to ${redirected.location}`);
+            await write(`${pathKey(url)}.redirect.json`, JSON.stringify({
+                status: redirected.status,
+                location: redirected.location,
+            }));
+            return said("frozen", `redirects to ${redirected.location}`);
         }
         if (!shell)
-            return said('error', 'refused before it rendered');
+            return said("error", "refused before it rendered");
         if (shell.error)
-            return said('error', shell.error);
+            return said("error", shell.error);
         // Something failed while rendering. Not necessarily the page's fault — a
         // build machine that cannot reach the database produces this, and so does a
         // genuinely broken component — so it is not fatal. It is simply not
@@ -492,7 +549,7 @@ export async function prerender(options) {
         // Rendering per request is the honest answer. It works as soon as whatever
         // was missing is reachable, which at runtime it usually is.
         if (shell.renderFailure) {
-            return said('blocked', `could not be rendered at build time: ${shell.renderFailure}`);
+            return said("blocked", `could not be rendered at build time: ${shell.renderFailure}`);
         }
         // A timeout is the ordinary path for a page that streams, not a failure:
         // the probe hands the page a host global that never resolves, React
@@ -506,21 +563,29 @@ export async function prerender(options) {
             // ship — a page that blocks above every boundary can only be rendered on
             // demand. `reaches for the host` is the specific reason when both are
             // true; a page that merely ran long says the other thing.
-            if (body === '') {
-                return said('blocked', (readRequest
-                    ? 'reads the request'
+            if (body === "") {
+                return said("blocked", (readRequest
+                    ? "reads " +
+                        (readWhere.length
+                            ? readWhere
+                            : readBy.length
+                                ? readBy
+                                : ["the request"]).join(", ")
                     : shell.usedDynamicApis
-                        ? 'reaches for the host'
-                        : 'blocks') +
-                    ' before anything can paint. Add a loading.tsx beside it, or put a ' +
-                    '<Suspense> above the waiting, and it has a skeleton to store.');
+                        ? "reaches for the host"
+                        : "blocks") +
+                    " before anything can paint. Add a loading.tsx beside it, or put a " +
+                    "<Suspense> above the waiting, and it has a skeleton to store.");
             }
             await writeShell(route, url, body, shell.postponed);
             // Why it is a shell rather than a whole page. "◐ /orders" on its own
             // leaves someone reading the build output to guess what did it, which is
             // the question this line exists to answer.
-            const calls = [...(shell.dynamicBecause ?? []), ...(readBy ?? [])];
-            return await withRootFallbackChecked(said('shell', shellReason(calls)));
+            const calls = [
+                ...(shell.dynamicBecause ?? []),
+                ...(readWhere.length ? readWhere : readBy),
+            ];
+            return await withRootFallbackChecked(said("shell", shellReason(calls)));
         }
         // Warned, not refused.
         //
@@ -541,10 +606,10 @@ export async function prerender(options) {
             if (nondeterministic.length === 0)
                 return result;
             result.warning =
-                `froze ${nondeterministic.join(' and ')} — a stored page keeps whatever that ` +
-                    'returned at build time. If it should differ per visitor, await connection() so ' +
-                    'the page renders per request; if only the browser needs it, use(browser()) keeps ' +
-                    'it out of the build entirely.';
+                `froze ${nondeterministic.join(" and ")} — a stored page keeps whatever that ` +
+                    "returned at build time. If it should differ per visitor, await connection() so " +
+                    "the page renders per request; if only the browser needs it, use(browser()) keeps " +
+                    "it out of the build entirely.";
             return result;
         };
         // Rendered whole, with params that were invented because the route listed
@@ -554,14 +619,13 @@ export async function prerender(options) {
         // before it can paint, which is exactly the shape that cannot be shared
         // across urls.
         if (unlisted) {
-            return said('blocked', 'renders its params before it can paint, and lists no urls to build');
+            return said("blocked", "renders its params before it can paint, and lists no urls to build");
         }
-        const shipsJs = route.clientJs !== false;
         const rendered = await engine.handleRsc(route.component, props, null, layouts, 
         // Not empty: a page whose layout declares a parallel slot renders without
         // it otherwise, and nothing says so — the page comes out whole apart from
         // the missing region.
-        route.loadings, route.slots, 0, url, shipsJs, 
+        route.loadings, route.slots, 0, url, true, 
         // A build has no host to answer rpc(), so every host call must suspend
         // rather than resolve. Without this they found no host at all and the
         // page was frozen holding whatever undefined rendered to — a document
@@ -571,32 +635,37 @@ export async function prerender(options) {
         // everyone and there is no build-time answer for it. Not frozen: a shell
         // is shipped instead and the page finishes for whoever asks.
         if (rendered.usedDynamicApis) {
-            return said('shell', 'reaches the host for data');
-        }
-        // A client component without a runtime is inert markup — a button that
-        // does nothing. Refused rather than shipped, and named, because they are
-        // usually inherited from a shared layout rather than written on the page.
-        if (!shipsJs && rendered.clientComponents.length > 0) {
-            return said('error', `ships no client runtime, but the tree renders ${rendered.clientComponents.join(', ')}. ` +
-                'These usually come from a shared layout rather than the page itself.');
+            return said("shell", "reaches the host for data");
         }
         // Nothing for a runtime to do. No client component means nothing to
         // hydrate, and no server reference means no form that would post through
         // React - so the bootstrap is 70 kB of javascript that runs and changes
-        // nothing. Rendered once more without it and stored that way. Only when
-        // the page declared nothing: `clientJs = true` keeps the runtime, for a
-        // page that wants the service worker or the update prompt regardless.
+        // nothing. Rendered once more without it and stored that way.
+        //
+        // No declaration in either direction, on purpose. A page cannot need the
+        // runtime without a client component or an action in its tree - "use
+        // client" IS the opt-in - and a page that must stay this way is an
+        // assertion for the build report, not a switch.
         let note;
         let body = rendered.body;
-        if (route.clientJs === 'auto' &&
-            rendered.clientComponents.every((name) => RUNTIME_OWN.has(name)) &&
+        if (rendered.clientComponents.every((name) => RUNTIME_OWN.has(name)) &&
             !rendered.serverReferences) {
             // Only the document. The flight payload stays the bootstrap render's:
             // a Link elsewhere navigating here fetches it and expects the segment
             // and title wrappers that render puts in, which this one leaves out.
             const bare = await engine.handleRsc(route.component, props, null, layouts, route.loadings, route.slots, 0, url, false, false);
-            body = options.serviceWorker ? withWorkerRegistration(bare.body) : bare.body;
-            note = 'no client components, so ships no javascript';
+            body = options.serviceWorker
+                ? withWorkerRegistration(bare.body)
+                : bare.body;
+            let inlined = false;
+            if (options.stylesheet) {
+                const before = body;
+                body = withInlineStylesheets(body, options.stylesheet);
+                inlined = body !== before;
+            }
+            note =
+                "no client components, so ships no javascript" +
+                    (inlined ? "; stylesheet inlined" : "");
         }
         const key = pathKey(url);
         await write(`${key}.html`, body);
@@ -610,8 +679,12 @@ export async function prerender(options) {
             const { rscPayload } = await engine.handleRscPayload(route.component, props, layouts, route.loadings, route.slots, depth, url);
             await write(`${key}.seg${depth}.flight`, rscPayload);
         }
-        await write(`${key}.meta.json`, JSON.stringify({ layouts: route.layouts, component: route.component, version: version ?? null }, null, 2));
-        const frozen = noteNondeterminism(await withRootFallbackChecked(said('frozen', null)));
+        await write(`${key}.meta.json`, JSON.stringify({
+            layouts: route.layouts,
+            component: route.component,
+            version: version ?? null,
+        }, null, 2));
+        const frozen = noteNondeterminism(await withRootFallbackChecked(said("frozen", null)));
         return note ? { ...frozen, note } : frozen;
     }
     /**
@@ -624,7 +697,7 @@ export async function prerender(options) {
      * ones you could already freeze whole.
      */
     async function writeShell(route, url, body, postponed) {
-        const parameterised = route.segments.some((s) => s.type !== 'static');
+        const parameterised = route.segments.some((s) => s.type !== "static");
         const key = parameterised && !route.staticParams ? patternKey(route) : pathKey(url);
         await write(`${key}.ppr.html`, body);
         // Written only when there is something to resume from. Its absence is
@@ -634,7 +707,12 @@ export async function prerender(options) {
         if (postponed != null) {
             await write(`${key}.postponed.json`, JSON.stringify(postponed));
         }
-        await write(`${key}.ppr-meta.json`, JSON.stringify({ layouts: route.layouts, component: route.component, parameterised, version: version ?? null }, null, 2));
+        await write(`${key}.ppr-meta.json`, JSON.stringify({
+            layouts: route.layouts,
+            component: route.component,
+            parameterised,
+            version: version ?? null,
+        }, null, 2));
     }
 }
 //# sourceMappingURL=prerender.js.map