@rsc-kit/core 0.30.28 → 0.30.30

package/dist/host.js

@@ -81,7 +81,7 @@ export { redirect } from "./redirect.js";
 // public surface so a host imports from one place.
 /** @internal For a host adapter. An app never matches its own routes. */
 export { matchIntercept, matchRoute, sharedDepth } from "./routing.js";
-import { FLIGHT_TYPE, HEADER, HTML_TYPE, PER_CLIENT, PER_REQUEST, REVALIDATE, PPR, VARY_ON_RSC, } from "./headers.js";
+import { FLIGHT_TYPE, HEADER, HTML_TYPE, PER_CLIENT, PER_REQUEST, REVALIDATE, EDGE, VARY_ON_RSC, } from "./headers.js";
 import { ServerAuthenticationError, ServerAuthorizationError, } from "./js/errors.js";
 import { assertSigningSecret, serveChanges } from "./changed.js";
 /**
@@ -433,6 +433,8 @@ export function createRscHandler(options) {
     // own. Resolved on the first request: the engine reads it from a build
     // product it only has at runtime.
     let version = engine.buildId ? undefined : options.version;
+    // The edge contract's marker, as the build left it beside the pages - see edgeMarker.
+    let edgeMarkerRead = null;
     const maxActionBody = options.maxActionBody ?? DEFAULT_MAX_ACTION_BODY;
     const compress = options.compress ?? true;
     // Annotated rather than inferred: the narrowing below is lost inside the
@@ -517,6 +519,9 @@ export function createRscHandler(options) {
     const siteHosts = manifest.build?.hosts ?? [];
     /** Whether responses say what built them. How they were served is always said. */
     const identify = Boolean(manifest.build?.identify);
+    // rscKit({ headers }): every response, and every page an edge serves.
+    const pageHeaders = manifest.build?.headers ?? {};
+    const hasPageHeaders = Object.keys(pageHeaders).length > 0;
     /** How a response was answered, for X-RSC-Kit: a file the build wrote, or a shell of one. */
     const servedFrom = new WeakMap();
     /** What a stored document's head names, read once per file, for the Link header. */
@@ -635,6 +640,12 @@ export function createRscHandler(options) {
             if (!response)
                 return null;
             const collected = taken();
+            // Under whatever the answer already has, and before the middleware's,
+            // so a page or a middleware that asked for its own value keeps it.
+            for (const [name, value] of Object.entries(pageHeaders)) {
+                if (!response.headers.has(name))
+                    response.headers.set(name, value);
+            }
             collected.forEach((value, name) => {
                 // Set-Cookie is applied below, once per cookie: iterating a Headers
                 // gives it joined in some runtimes and per-cookie in others, and a
@@ -686,7 +697,7 @@ export function createRscHandler(options) {
             // plain bytes and compresses the page once, so gzip here would be
             // garbage in the middle of a document. The edge drops
             // Accept-Encoding, but this does not rely on it.
-            if (compress && !new URL(request.url).pathname.startsWith(PPR.prefix)) {
+            if (compress && !new URL(request.url).pathname.startsWith(EDGE.prefix)) {
                 const answer = await compressed(request, response, servedFrom.get(response) === "stored" ? storedKey(request, response) : undefined);
                 const from = servedFrom.get(response);
                 if (answer !== response && from)
@@ -805,10 +816,10 @@ export function createRscHandler(options) {
         if (url.pathname === HEADER.changesPath) {
             return await serveChanges(request);
         }
-        // The PPR contract, for a platform's edge. The whole prefix is reserved,
-        // and is a 404 to anyone without the release's token.
-        if (url.pathname.startsWith(PPR.prefix)) {
-            return await servePprContract(request, url);
+        // The edge contract, for a platform's edge. The whole prefix is reserved,
+        // and is a 404 to anyone without the token.
+        if (url.pathname.startsWith(EDGE.prefix)) {
+            return await serveEdgeContract(request, url);
         }
         // A form submitted before the page had a runtime: the browser posts it
         // to the page's own url, as React wrote it, with the action's id among
@@ -1178,7 +1189,7 @@ export function createRscHandler(options) {
         return answer;
     }
     /**
-     * A page's shell, by the rule both shell endpoints apply: a PPR page, on a
+     * A page's shell, by the rule the page endpoint applies: a PPR page, on a
      * route with no guard, whose shell the build wrote for this url or for its
      * pattern. Anything else is a 404 - the same pages edgeShells leaves out of
      * the marker, so the list and the origin cannot disagree.
@@ -1255,26 +1266,26 @@ export function createRscHandler(options) {
                     "Content-Type": HTML_TYPE,
                     // Rendered for whoever asked. Never cacheable.
                     "Cache-Control": PER_CLIENT,
-                    ...(version ? { [PPR.build]: version } : {}),
+                    ...(edgeMarkerRead ? { [EDGE.build]: edgeMarkerRead.build } : {}),
                 }),
             });
         });
     }
     /**
-     * The PPR contract's two endpoints, for a platform's edge. They exist only
-     * for a caller holding the release's PPR_TOKEN: unset, missing or wrong,
-     * everything under /_ppr/ is a 404, as if there were nothing here - so an
-     * app is safe wherever it runs, and only the platform can ask.
+     * The edge contract's two endpoints, for a platform's edge. They exist only
+     * for a caller holding the EDGE_TOKEN the platform set: unset, missing or
+     * wrong, everything under /_edge/ is a 404, as if there were nothing here -
+     * so an app is safe wherever it runs, and only the platform can ask.
      *
-     * The shell goes as JSON with an empty `state`: the resume reads its own
-     * from the build and ignores the body. Both answers name the build in
-     * PPR-Build.
+     * A page the marker lists as static goes whole, `complete`; a shell goes
+     * with an empty `state`, since the resume reads its own from the build and
+     * ignores the body. Both answers name the build in Edge-Build.
      */
-    async function servePprContract(request, url) {
-        const answer = await pprContractAnswer(request, url);
+    async function serveEdgeContract(request, url) {
+        const answer = await edgeContractAnswer(request, url);
         // Every answer here depends on the token, a 404 included: stored by a
         // cache in between, one would be served to callers with the wrong token
-        // or none - and a stored 404 would hide a real shell from the edge.
+        // or none - and a stored 404 would hide a real page from the edge.
         try {
             answer.headers.set("Cache-Control", "private, no-store");
             return answer;
@@ -1286,30 +1297,48 @@ export function createRscHandler(options) {
             });
         }
     }
-    async function pprContractAnswer(request, url) {
+    async function edgeContractAnswer(request, url) {
         const missing = new Response("Not found", { status: 404 });
         const read = options.prerendered;
-        if (!read || !version || !holdsSecret(request, PPR.token, PPR.tokenEnv))
+        if (!read || !holdsSecret(request, EDGE.token, EDGE.tokenEnv))
+            return missing;
+        const marker = await edgeMarker(read);
+        if (!marker)
             return missing;
-        if (url.pathname === PPR.shellPath && (request.method === "GET" || request.method === "HEAD")) {
-            const pathname = contractPathname(url.searchParams.get("path"), url);
+        const { build } = marker;
+        if (url.pathname === EDGE.pagePath && (request.method === "GET" || request.method === "HEAD")) {
+            const asked = url.searchParams.get("path");
+            const pathname = contractPathname(asked, url);
             if (pathname === null)
                 return missing;
-            const shell = await shellAt(pathname, read);
-            if (shell instanceof Response)
-                return shell;
-            return new Response(request.method === "HEAD" ? null : JSON.stringify({ v: 1, build: version, html: shell, state: "" }), {
+            // Whole only for a path the marker names, and only from the document
+            // the build stored for it; anything else is a shell or nothing.
+            const complete = marker.static.has(asked);
+            const html = complete ? await pageAt(pathname, read) : await shellAt(pathname, read);
+            if (html instanceof Response)
+                return html;
+            return new Response(request.method === "HEAD"
+                ? null
+                : JSON.stringify({
+                    v: 2,
+                    build,
+                    html,
+                    state: "",
+                    ...(complete ? { complete: true } : {}),
+                    // What the page itself goes out with, so the edge's copy does too.
+                    ...(hasPageHeaders ? { headers: pageHeaders } : {}),
+                }), {
                 headers: {
                     "Content-Type": "application/json",
                     // Fixed for the build, so no ETag. And never stored on the way:
                     // it was answered only for the token, and a cache between the
                     // edge and here would hand it to callers without one.
                     "Cache-Control": "private, no-store",
-                    [PPR.build]: version,
+                    [EDGE.build]: build,
                 },
             });
         }
-        if (url.pathname === PPR.resumePath && request.method === "POST") {
+        if (url.pathname === EDGE.resumePath && request.method === "POST") {
             const raw = url.searchParams.get("url");
             const at = raw === null ? -1 : raw.indexOf("?");
             const pathname = contractPathname(at === -1 ? raw : raw.slice(0, at), url);
@@ -1319,6 +1348,36 @@ export function createRscHandler(options) {
         }
         return missing;
     }
+    /**
+     * A static page's whole document, as the build stored it. The marker lists
+     * no guarded page, and this checks again rather than trusting the list:
+     * a document handed to an edge is served to everyone.
+     */
+    async function pageAt(pathname, read) {
+        const route = matchRoute(routes, pathname);
+        const key = route && !isGuarded(route) ? storedKeyFor(pathname, route) : null;
+        const html = key === null ? null : await read(`${key}.html`);
+        return html ?? new Response("No such page", { status: 404 });
+    }
+    /**
+     * The marker, which the build wrote beside the pages as well as into
+     * .output - its build is not the client's id this host sends a browser,
+     * which a server-only change keeps (see edgeBuildId), and its static list
+     * is what may go whole.
+     */
+    async function edgeMarker(read) {
+        if (edgeMarkerRead)
+            return edgeMarkerRead;
+        try {
+            const marker = JSON.parse((await read(EDGE.storedMarker)) ?? "null");
+            if (marker?.build)
+                edgeMarkerRead = { build: marker.build, static: new Set(marker.static ?? []) };
+        }
+        catch {
+            // A marker this build wrote and cannot read back: no edge, not a guess.
+        }
+        return edgeMarkerRead;
+    }
     /**
      * A contract path - absolute and decoded once - as the pathname this host
      * matches, or null for one that would not survive the trip unchanged: a