@rsc-kit/core 0.20.7 → 0.20.10

package/dist/host.js

@@ -28,6 +28,7 @@ import { compressed } from "./compress.js";
 import { withCache } from "./cache.js";
 import { takeAfterWork, withRequest, withResponseDraft } from "./request.js";
 import { criticalAssetsOf, linkHeader, mergeAssets } from "./earlyHints.js";
+import { withHead } from "./shellHead.js";
 /**
  * @internal For a host adapter that embeds the engine. An app imports this
  * from `@rsc-kit/core/redirect` - the one the guides teach, and the one an
@@ -328,10 +329,23 @@ export function createRscHandler(options) {
         return options.props ? await options.props(match, request) : match.params;
     }
     /** The page a server action was invoked from, so it can re-render regions of it. */
-    function pageContext(match, props) {
+    /** Whether a document at this url is served from the route's pattern shell: no page or shell of its own, and one for the pattern. */
+    async function servedFromPatternShell(url, match) {
+        const source = options.prerendered;
+        if (!source)
+            return false;
+        const key = pathKey(url.pathname);
+        if ((await source(`${key}.html`)) !== null)
+            return false;
+        if ((await source(`${key}.ppr.html`)) !== null)
+            return false;
+        return (await source(`${patternKey(match.route)}.ppr.html`)) !== null;
+    }
+    function pageContext(match, props, url) {
         return {
             component: match.route.component,
             props,
+            url,
             layouts: match.route.layouts.map((component) => ({
                 component,
                 props: {},
@@ -360,7 +374,6 @@ export function createRscHandler(options) {
     /** What a stored document's head names, read once per file, for the Link header. */
     const hinted = new WeakMap();
     const hintsByKey = new Map();
-    const EMPTY_ASSETS = { styles: [], modules: [], fonts: [] };
     /**
      * The page a payload url belongs to, if this is one.
      *
@@ -468,7 +481,7 @@ export function createRscHandler(options) {
             // document, stored ones included - a stored document's own head
             // names its fonts; a rendered one's is not known until too late.
             if (response.status === 200 && (response.headers.get("Content-Type") ?? "").startsWith("text/html")) {
-                const link = linkHeader(mergeAssets(hinted.get(response) ?? EMPTY_ASSETS, engine.criticalAssets?.() ?? null));
+                const link = linkHeader(mergeAssets(hinted.get(response) ?? null, engine.criticalAssets?.() ?? null));
                 if (link)
                     response.headers.set("Link", link);
             }
@@ -742,6 +755,13 @@ export function createRscHandler(options) {
             });
         }
         const from = sharedDepth(request.headers.get(HEADER.segments), chain);
+        // A boot - X-RSC and no segments - of a document served from a pattern
+        // shell: the shell was rendered for no url, and the client hydrates
+        // this payload against it, so the hooks are told nothing here either
+        // and read the browser's url once hydration is done. A navigation to
+        // the same url renders for it, as it is client-rendered, not hydrated.
+        const boot = request.headers.get(HEADER.segments) === null;
+        const pathname = boot && (await servedFromPatternShell(url, match)) ? null : url.pathname;
         // Proposed by the host, decided by the engine: an interceptor can force a
         // wider render than the client asked for, so what goes back is the depth
         // that came out, never the one that went in.
@@ -749,7 +769,7 @@ export function createRscHandler(options) {
             let stream;
             let segmentDepth;
             try {
-                ({ stream, segmentDepth } = await engine.handleRscStream(match.route.component, props, layouts, match.route.loadings, match.route.slots, {}, from, url.pathname));
+                ({ stream, segmentDepth } = await engine.handleRscStream(match.route.component, props, layouts, match.route.loadings, match.route.slots, {}, from, url.pathname, pathname));
             }
             catch (error) {
                 // Same reasoning as the document path: what the render recorded is
@@ -940,7 +960,7 @@ export function createRscHandler(options) {
         const state = shellKey === null ? null : await read(`${shellKey}.postponed.json`);
         if (state === null)
             return new Response("Nothing to resume", { status: 404 });
-        const { htmlStream } = await engine.handleRscResume(route.route.component, route.params, route.route.layouts.map((component) => ({ component, props: {} })), route.route.loadings, route.route.slots, {}, JSON.parse(state), undefined, shellKey === key ? pathname : "");
+        const { htmlStream } = await engine.handleRscResume(route.route.component, route.params, route.route.layouts.map((component) => ({ component, props: {} })), route.route.loadings, route.route.slots, {}, JSON.parse(state), undefined, shellKey === key ? pathname : "", pathname);
         // Carries the build version so a caller holding a cached shell can tell
         // that it no longer belongs to this origin. A shell from an older build
         // does not make the resume fail — it replays against slots that have moved
@@ -1024,13 +1044,23 @@ export function createRscHandler(options) {
             // A shell found under the route's pattern was frozen for no particular
             // url, so it was rendered with no page key. Handing one over now would
             // key the tree differently from the one being resumed.
-            shellKey === key ? url.pathname : "");
+            shellKey === key ? url.pathname : "", 
+            // But the url itself, for the hooks: the holes are rendered for it.
+            url.pathname);
+            // A shell stored for the pattern was built without a url, so its title
+            // is the layouts' - the page's generateMetadata reads the params and
+            // was left out. This request has the params.
+            const served = shellKey === key || !engine.resolveMetadata
+                ? shell
+                : withHead(shell, await engine
+                    .resolveMetadata(route.route.component, route.params, route.route.layouts.map((component) => ({ component, props: {} })))
+                    .catch(() => null));
             // The shell first, then whatever the resume writes. React's own script
             // travels with the resumed segments and moves them into place, so this is
             // a plain concatenation and the holes land without hydration.
             const body = new ReadableStream({
                 async start(controller) {
-                    controller.enqueue(new TextEncoder().encode(shell));
+                    controller.enqueue(new TextEncoder().encode(served));
                     const reader = htmlStream.getReader();
                     try {
                         while (true) {
@@ -1392,7 +1422,7 @@ export function createRscHandler(options) {
         const from = refererPath(request.headers.get(HEADER.referer), url.origin, siteHosts);
         const match = from ? matchRoute(routes, from) : null;
         const page = match
-            ? pageContext(match, await propsFor(match, request))
+            ? pageContext(match, await propsFor(match, request), from ?? undefined)
             : undefined;
         // Scoped to this action: revalidate() called anywhere inside it, at any
         // depth, marks here and nowhere else — two requests can be in flight and