@rsc-kit/core 0.30.27 → 0.30.29

package/dist/vite.d.ts

@@ -421,6 +421,21 @@ export declare function bootsTheApp(file: string): boolean;
  * that changes what the worker holds is a new worker.
  */
 export declare function workerVersion(precache: string[], storedDir: string | null): string;
+/**
+ * The PPR contract's build: what an edge checks a cached shell against.
+ *
+ * Not the client's build id, which is what a browser tab is told and covers
+ * only what the browser downloads - a release that changed only what the
+ * server renders kept it, and an edge holding the old shell would have joined
+ * it to the new server's holes. So it is that id and the bytes of every shell
+ * and its postponed state. A server change that reaches a shell is a new
+ * build to the edge; one that leaves them all byte for byte the same is not,
+ * because the shell the edge holds is then this build's. A tab is not made to
+ * reload for either.
+ */
+export declare function pprBuildId(clientBuild: string, storedDir: string): string;
+/** Where the host reads the PPR build back, beside the shells it describes. */
+export declare const PPR_BUILD_FILE = "_ppr.build";
 export declare function smallStylesheetReader(assetsDir: string, setting: "auto" | true | number): (href: string) => string | null;
 /** A server action the bundle registered: where it is and what it is called. */
 export interface KnownAction {

package/dist/vite.js

@@ -23,6 +23,7 @@ import rsc, { getPluginApi } from "@vitejs/plugin-rsc";
 import { loadEnv, parseAst } from "vite";
 import { stampDisplayNames } from "./stableNames.js";
 import { REPORT_FILE, buildReport } from "./buildReport.js";
+import { edgeShells, pprMarker } from "./edgeShells.js";
 import { MANIFEST_PATH, manifestWarning, webManifest } from "./webManifest.js";
 import { ASSET_BASE, allAppAssets, assetFile, appAssets, headTags, shareImageUrls, typeOf, } from "./appAssets.js";
 import { reactCacheImports } from "./reactCache.js";
@@ -1607,6 +1608,41 @@ export function workerVersion(precache, storedDir) {
     }
     return version.digest("hex").slice(0, 12);
 }
+/**
+ * The PPR contract's build: what an edge checks a cached shell against.
+ *
+ * Not the client's build id, which is what a browser tab is told and covers
+ * only what the browser downloads - a release that changed only what the
+ * server renders kept it, and an edge holding the old shell would have joined
+ * it to the new server's holes. So it is that id and the bytes of every shell
+ * and its postponed state. A server change that reaches a shell is a new
+ * build to the edge; one that leaves them all byte for byte the same is not,
+ * because the shell the edge holds is then this build's. A tab is not made to
+ * reload for either.
+ */
+export function pprBuildId(clientBuild, storedDir) {
+    const id = createHash("sha256");
+    id.update(clientBuild);
+    const shells = [];
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(path);
+            else if (/\.(?:ppr\.html|postponed\.json)$/.test(entry.name))
+                shells.push(path);
+        }
+    };
+    if (existsSync(storedDir))
+        walk(storedDir);
+    for (const path of shells.sort()) {
+        id.update("\n" + relative(storedDir, path) + "\n");
+        id.update(readFileSync(path));
+    }
+    return id.digest("hex").slice(0, 16);
+}
+/** Where the host reads the PPR build back, beside the shells it describes. */
+export const PPR_BUILD_FILE = "_ppr.build";
 function writeServiceWorker(clientDir, frozen = [], offlineUrl = null, 
 // The pages the build stored, which the worker serves cache-first. Their
 // bytes are part of what a version is - see below.
@@ -1764,6 +1800,7 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
     const collected = [];
     let refusal = null;
     let results;
+    const build = await engine.buildId?.();
     try {
         results = await prerender({
             engine,
@@ -1774,7 +1811,7 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions
             // them, and replayed against a different bundle React finds the
             // wrong name in every slot. Unstamped - which is what every build
             // before this one wrote - the host cannot tell and resumes anyway.
-            version: await engine.buildId?.(),
+            version: build,
             serviceWorker: offline,
             stylesheet: inlineStylesheets === false
                 ? undefined
@@ -1972,6 +2009,8 @@ ${legend(counted)}
             .filter((r) => existsSync(join(staticDir, pathKeyOf(r.url) + ".html")))
             .map((r) => r.url),
         results,
+        shells: edgeShells(results, manifest.routes),
+        build,
     };
 }
 /**
@@ -8073,7 +8112,12 @@ export function rscKit(options = {}) {
             const staticDir = clientOut
                 ? 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) : []);
+            const { frozen, results, shells, build: clientBuild } = await prerenderAfterBundles(bundle, staticDir, clientOut ?? publicAssetsDir, builder ? knownActionsOf(builder.config, projectRoot) : []);
+            // Before the pages are packed into a module or the assets, so the host
+            // finds it wherever it reads the shells from.
+            const build = clientBuild ? pprBuildId(clientBuild, staticDir) : undefined;
+            if (build && existsSync(staticDir))
+                writeFileSync(join(staticDir, PPR_BUILD_FILE), build);
             // 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
@@ -8109,6 +8153,9 @@ export function rscKit(options = {}) {
             // after the prerender, and an export taken any earlier left them out.
             if (output === "export")
                 await exportAfterPrerender(results, staticDir, clientOut ?? publicAssetsDir);
+            if (shells.left.length) {
+                log(`ppr: not listed for an edge in ppr.json, so served by the origin: ${shells.left.join("; ")}`);
+            }
             // What this build produced, where a deploy can read it without parsing
             // vite.config.ts - which can turn export on through RSC_OUTPUT, or
             // compute it - or knowing where rsc-kit keeps things inside .output.
@@ -8122,6 +8169,20 @@ export function rscKit(options = {}) {
                         ...compileStep(projectRoot),
                         ...(buildCommands().length ? { commands: buildCommands().map((c) => c.name) } : {}),
                     }, null, 2) + "\n");
+                // The PPR contract's marker: the pages an edge may answer from a
+                // cached shell, and the build both endpoints will say they belong to.
+                // Written by every server build, with an empty list when there is no
+                // PPR page, so a platform can tell "none" from "an rsc-kit too old to
+                // say". Not by an export, which has no origin to resume against.
+                const marker = join(dirname(clientOut), "ppr.json");
+                if (output !== "export" && build) {
+                    writeFileSync(marker, JSON.stringify(pprMarker(build, shells.shells), null, 2) + "\n");
+                }
+                else {
+                    // One left by an earlier server build would promise an origin that
+                    // is not there.
+                    rmSync(marker, { force: true });
+                }
             }
         },
         configResolved(config) {