vinext 1.3.0 → 1.4.0

package/dist/server/app-server-action-execution.d.ts

@@ -1,10 +1,10 @@
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
-import { ActionRevalidationKind } from "../shims/cache-request-state.js";
 import { AppRenderErrorContextOverrides } from "./app-rsc-error-handler.js";
 import { FetchCacheMode } from "../shims/fetch-cache-state.js";
 import "../shims/fetch-cache.js";
 import { HeadersAccessPhase } from "../shims/internal/headers-state.js";
 import "../shims/headers.js";
+import { ActionRevalidationKind } from "../shims/cache-request-state.js";
 import { ReactFormState } from "react-dom/client";
 //#region src/server/app-server-action-execution.d.ts
 type AppPageParams = Record<string, string | string[]>;
@@ -156,6 +156,8 @@ export type HandleProgressiveServerActionRequestOptions = {
    * routes fall through. See issue #1340.
    */
   hasPageRoute: boolean;
+  /** The App Router route the form posted to, whose implicit tags the action runs with. */
+  currentRoute?: AppServerActionRoute | null;
   maxActionBodySize: number;
   middlewareHeaders: Headers | null;
   readFormDataWithLimit: ReadFormDataWithLimit;
@@ -282,4 +284,5 @@ export declare function applyActionRedirectBasePath(url: string, basePath: strin
 export declare function isProgressiveServerActionRequest(request: Pick<Request, "method">, contentType: string, actionId: string | null): boolean;
 export declare function handleProgressiveServerActionRequest(options: HandleProgressiveServerActionRequestOptions): Promise<Response | ProgressiveServerActionResult | null>;
 export declare function handleServerActionRscRequest<TElement, TRoute extends AppServerActionRoute, TInterceptOpts, TTemporaryReferences, TPage = unknown>(options: HandleServerActionRscRequestOptions<TElement, TRoute, TInterceptOpts, TTemporaryReferences, TPage>): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-server-action-execution.js

@@ -1,11 +1,12 @@
 import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { VINEXT_MW_CTX_HEADER } from "../utils/protocol-headers.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { NEXT_ROUTER_STATE_TREE_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
-import { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "./headers.js";
+import { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, VINEXT_MOUNTED_LAYOUTS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "./headers.js";
 import { internalServerErrorResponse, payloadTooLargeResponse } from "./http-error-responses.js";
 import { attachRequestCfMetadata, validateCsrfOrigin, validateServerActionPayload } from "./request-pipeline.js";
 import { splitPathSegments } from "../routing/utils.js";
@@ -16,17 +17,16 @@ import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
 import { _drainPendingRevalidations, getAndClearActionRevalidationKind } from "../shims/cache-request-state.js";
 import { setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, createRscRequestUrl, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, createRscRequestUrl, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
+import { getSetCookieName } from "./cookie-utils.js";
+import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { hasDigest } from "./app-rsc-errors.js";
-import { buildAppPageTags } from "./implicit-tags.js";
-import "./app-page-stream.js";
-import { getSetCookieName } from "./cookie-utils.js";
-import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
+import "./app-page-stream.js";
+import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageActionRerenderTarget } from "./app-page-request.js";
 import { createRootParamsUsageController, runWithRootParamsUsage } from "../shims/root-params.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
@@ -211,6 +211,7 @@ async function createActionRedirectTargetRequest(options) {
 	headers.set("cookie", cookieHeader ?? "");
 	headers.set("RSC", "1");
 	headers.delete(NEXT_ROUTER_STATE_TREE_HEADER);
+	headers.delete(VINEXT_MOUNTED_LAYOUTS_HEADER);
 	stripRscCacheBustingSearchParam(options.url);
 	const requestPath = await createRscRequestUrl(`${options.url.pathname}${options.url.search}`, headers);
 	const requestUrl = new URL(requestPath, options.url.origin);
@@ -614,6 +615,7 @@ async function handleProgressiveServerActionRequest(options) {
 		let actionThrew = false;
 		let actionResult;
 		const rootParamsUsage = createRootParamsUsageController();
+		if (options.currentRoute) setCurrentFetchSoftTags(buildServerActionPageTags(options.currentRoute, options.cleanPathname));
 		const previousHeadersPhase = options.setHeadersAccessPhase("action");
 		try {
 			actionResult = await runWithRootParamsUsage({ kind: "server-action" }, action, rootParamsUsage);
@@ -823,6 +825,7 @@ async function handleServerActionRscRequest(options) {
 		let actionThrew = false;
 		const actionWasForwarded = Boolean(options.request.headers.get(ACTION_FORWARDED_HEADER));
 		const rootParamsUsage = createRootParamsUsageController();
+		if (options.currentRouteMatch) setCurrentFetchSoftTags(buildServerActionPageTags(options.currentRouteMatch.route, options.cleanPathname));
 		const previousHeadersPhase = options.setHeadersAccessPhase("action");
 		try {
 			try {

package/dist/server/app-ssr-entry.d.ts

@@ -25,6 +25,8 @@ export declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navCont
     value: Promise<ArrayBuffer> | null;
   };
   pprFallbackShellSignal?: AbortSignal;
+  /** Aborts a streaming render whose document is given up. */
+  signal?: AbortSignal;
   /**
    * Pattern of the route this render shows, whose client references load
    * before it starts, or null for a render without a route (a route-miss
@@ -70,6 +72,12 @@ export declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navCont
    */
   isCacheCandidate?: boolean;
   fallbackToErrorDocumentOnShellError?: boolean;
+  /**
+   * The parallel slot not-found boundaries that catch the error that
+   * rejected the shell, or null when none catches it. The document then
+   * renders again from the same payload with them caught.
+   */
+  resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
   dynamicStaleTimeSeconds?: number;
   getInitialNavigationCacheMetadata?: () => InitialNavigationCacheMetadata;
 }): Promise<AppSsrRenderResult>;

package/dist/server/app-ssr-entry.js

@@ -1,3 +1,4 @@
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped, repeatedSlashRedirectResponse } from "./open-redirect.js";
 import "./server-globals.js";
@@ -8,23 +9,24 @@ import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, safeJsonStringify } from "./html.js";
 import { getClientTraceMetadataHTML, markClientTraceMetadataBlock } from "./client-trace-metadata.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { setPagesClientAssets } from "./pages-client-assets.js";
+import { RSC_FORM_STATE_GLOBAL } from "../client/browser-globals.js";
+import { createNavigationRuntimeRenderedSearchScript, createNavigationRuntimeRscCompatibilityScript, createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, rewriteInlineCssStylesheetLinks, waitAtLeastOneReactRenderTask } from "./app-ssr-stream.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { createInitialBfcacheMaps } from "./app-bfcache-identity.js";
 import { ServerInsertedHTMLContext, clearServerInsertedHTML, getBfcacheIdMapContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "../shims/navigation-context-state.js";
 import "../shims/navigation-server.js";
-import DefaultGlobalError from "../shims/default-global-error.js";
 import { BfcacheIdentityMapContext } from "../shims/slot.js";
-import { getNextErrorDigest } from "./next-error-digest.js";
-import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
-import { createRenderStreamCancellation, isAppRenderAbortError } from "./app-render-abort-error.js";
-import { RSC_FORM_STATE_GLOBAL } from "../client/browser-globals.js";
-import { createNavigationRuntimeRenderedSearchScript, createNavigationRuntimeRscCompatibilityScript, createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, waitAtLeastOneReactRenderTask } from "./app-ssr-stream.js";
-import { createInitialBfcacheMaps } from "./app-bfcache-identity.js";
 import { createAppRouteTree } from "./app-route-tree.js";
+import DefaultGlobalError from "../shims/default-global-error.js";
+import { CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL, withCaughtNotFoundBoundaries } from "../shims/caught-not-found-boundaries.js";
+import { ssrServerConsumerManifest } from "./app-client-reference-manifest.js";
 import { createClientReferencePreloader, resolveRouteClientReferences } from "./app-client-reference-preloader.js";
+import { getNextErrorDigest } from "./next-error-digest.js";
+import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
 import { createClientPageSsrSearchParamsSource } from "./app-page-search-params-observation.js";
+import { createRenderStreamCancellation, isAppRenderAbortError } from "./app-render-abort-error.js";
 import { runWithRootParamsScope } from "../shims/root-params.js";
 import { runWithNavigationContext } from "../shims/navigation-state.js";
 import { startCandidateSearchParamsGate } from "./app-ssr-search-params-gate.js";
@@ -32,10 +34,11 @@ import { withAppRouterTree } from "../shims/app-router-tree-context.js";
 import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
 import { renderBeforeInteractiveInlineScripts } from "./before-interactive-head.js";
 import { createInitialDevServerErrorScript } from "./dev-initial-server-error.js";
+import { createStreamedClientReferences, renderStreamedStylesheets, resetStreamedClientReferences, runWithStreamedClientReferences, wrapClientReferenceRequire } from "./app-streamed-client-references.js";
 import { ssrAppRouterInstance } from "./app-ssr-router-instance.js";
 import { Fragment, createElement, use } from "react";
-import { renderToReadableStream, renderToStaticMarkup } from "react-dom/server.edge";
-import { preinitModule } from "react-dom";
+import { renderToReadableStream, renderToStaticMarkup } from "react-dom/server";
+import { preinitModule, preloadModule } from "react-dom";
 import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
 import clientReferences, { routeClientReferences } from "virtual:vite-rsc/client-references";
 import pagesClientAssets from "virtual:vinext-pages-client-assets";
@@ -48,33 +51,18 @@ setPagesClientAssets(pagesClientAssets);
 * the response-layer combine cap.
 */
 const DEFAULT_REACT_MAX_HEADERS_LENGTH = 6e3;
-function isReactDevelopmentRuntime() {
-	if (process.env.NODE_ENV === "production") return false;
-	if (process.env.NODE_ENV === "development") return true;
-	return Function.prototype.toString.call(createElement).includes("getOwner");
-}
+/**
+* plugin-rsc's SSR `createFromReadableStream` spreads these over its own
+* options, whose type leaves out the consumer manifest.
+*/
+const SSR_FLIGHT_OPTIONS = { serverConsumerManifest: ssrServerConsumerManifest };
 function isStaticPrerenderModule(value) {
 	return typeof value === "object" && value !== null && "prerender" in value && typeof value.prerender === "function";
 }
 async function loadStaticPrerender() {
-	const staticRenderer = await import("react-dom/static.edge");
+	const staticRenderer = await import("react-dom/static");
 	if (isStaticPrerenderModule(staticRenderer)) return staticRenderer.prerender;
-	if (isReactDevelopmentRuntime()) try {
-		const [{ createRequire }, path] = await Promise.all([import("node:module"), import("node:path")]);
-		const reactDomPackageJson = createRequire(import.meta.url).resolve("react-dom/package.json");
-		const reactDomDir = path.dirname(reactDomPackageJson);
-		const devRenderer = await import(
-			/* @vite-ignore */
-			path.join(reactDomDir, "cjs/react-dom-server.edge.development.js")
-);
-		if (isStaticPrerenderModule(devRenderer)) return devRenderer.prerender;
-		const devRendererDefault = typeof devRenderer === "object" && devRenderer !== null && "default" in devRenderer && devRenderer.default;
-		if (isStaticPrerenderModule(devRendererDefault)) return devRendererDefault.prerender;
-		throw new Error("react-dom development renderer did not expose prerender().");
-	} catch (error) {
-		throw new Error("[vinext] Failed to load React static development renderer.", { cause: error });
-	}
-	throw new Error("[vinext] react-dom/static.edge did not expose prerender().");
+	throw new Error("[vinext] react-dom/static did not expose prerender().");
 }
 function createUtf8Stream(html) {
 	const encoder = new TextEncoder();
@@ -85,7 +73,7 @@ function createUtf8Stream(html) {
 }
 function buildBootstrapModuleScript(bootstrapModuleUrl, nonce) {
 	if (!bootstrapModuleUrl) return "";
-	return `<script type="module"${createNonceAttribute(nonce)} src="` + escapeHtmlAttr(bootstrapModuleUrl) + "\" id=\"_R_\" async=\"\"><\/script>";
+	return `<script type="module"${createNonceAttribute(nonce)} src="` + escapeHtmlAttr(bootstrapModuleUrl) + "\" id=\"_R_\" async=\"\" fetchPriority=\"low\"><\/script>";
 }
 function renderSsrErrorDocumentShell(bootstrapModuleUrl, nonce) {
 	const html = renderToStaticMarkup(createElement(DefaultGlobalError, { error: null })).replace("<style>", "<style data-vinext-error-shell-style=\"\">");
@@ -95,6 +83,10 @@ function renderSsrErrorDocumentShell(bootstrapModuleUrl, nonce) {
 	if (!html.endsWith(documentClose)) return createUtf8Stream(`<!DOCTYPE html>${html}${bootstrapScript}`);
 	return createUtf8Stream(`<!DOCTYPE html>${html.slice(0, -14)}${bootstrapScript}${documentClose}`);
 }
+if (process.env.NODE_ENV === "production") {
+	const async = routeClientReferences?.async;
+	wrapClientReferenceRequire(new Set(Array.isArray(async) ? async.map((index) => routeClientReferences.references[index]) : []), (id) => clientReferences[id]);
+}
 const clientReferencePreloader = createClientReferencePreloader({
 	getReferences() {
 		return clientReferences;
@@ -158,9 +150,9 @@ function extractBootstrapModuleUrl(bootstrapScriptContent) {
 }
 function buildModulePreloadHtml(bootstrapModuleUrl, nonce) {
 	if (!bootstrapModuleUrl) return "";
-	return `<link rel="modulepreload"${createNonceAttribute(nonce)} href="${escapeHtmlAttr(bootstrapModuleUrl)}" crossorigin="${pagesClientAssets.crossOrigin ?? ""}" />\n`;
+	return `<link rel="modulepreload"${createNonceAttribute(nonce)} href="${escapeHtmlAttr(bootstrapModuleUrl)}" crossorigin="${pagesClientAssets.crossOrigin ?? ""}" fetchPriority="low" />\n`;
 }
-function buildHeadInjectionHtml(navContext, bootstrapModuleUrl, formState, insertedHTML, fontHTML, dynamicStaleTimeSeconds, searchParamsFromBrowser, scriptNonce) {
+function buildHeadInjectionHtml(navContext, bootstrapPreloadUrl, formState, insertedHTML, fontHTML, dynamicStaleTimeSeconds, searchParamsFromBrowser, scriptNonce) {
 	const navPayload = {
 		pathname: navContext.pathname,
 		searchParams: [...navContext.searchParams.entries()]
@@ -169,7 +161,7 @@ function buildHeadInjectionHtml(navContext, bootstrapModuleUrl, formState, inser
 	const compatibilityScript = createNavigationRuntimeRscCompatibilityScript();
 	const rscCompatibilityScript = compatibilityScript === "" ? "" : createInlineScriptTag(compatibilityScript, scriptNonce);
 	const formStateScript = formState === null ? "" : createInlineScriptTag("self[" + safeJsonStringify(RSC_FORM_STATE_GLOBAL) + "]=" + safeJsonStringify(formState), scriptNonce);
-	return rscMetadataScript + rscCompatibilityScript + formStateScript + buildModulePreloadHtml(bootstrapModuleUrl, scriptNonce) + insertedHTML + fontHTML;
+	return rscMetadataScript + rscCompatibilityScript + formStateScript + buildModulePreloadHtml(bootstrapPreloadUrl, scriptNonce) + insertedHTML + fontHTML;
 }
 function requireNavigationContext(navContext) {
 	if (!navContext) throw new Error("App SSR requires navigation context for BFCache state keys");
@@ -194,7 +186,9 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 				isPprFallbackShell: options?.pprFallbackShellSignal !== void 0
 			})
 		};
-		await clientReferencePreloader.preload(options?.pprFallbackShellSignal ? void 0 : resolveRouteClientReferences(routeClientReferences, options?.preloadRoutePattern));
+		const routeReferences = options?.pprFallbackShellSignal ? void 0 : resolveRouteClientReferences(routeClientReferences, options?.preloadRoutePattern);
+		const streamedReferences = createStreamedClientReferences(routeReferences, options?.scriptNonce, assetCrossOrigin);
+		await clientReferencePreloader.preload(routeReferences?.references, streamedReferences?.streamed);
 		setNavigationContext(ssrNavigationContext);
 		clearServerInsertedHTML();
 		const cleanup = () => {
@@ -230,9 +224,16 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					for (const moduleUrl of pagesClientAssets.appBootstrapPreinitModules ?? []) preinitModule(moduleUrl, {
 						as: "script",
 						crossOrigin: assetCrossOrigin,
+						fetchPriority: "low",
+						nonce: options?.scriptNonce
+					});
+					if (pagesClientAssets.appRouteManifestModule) preloadModule(pagesClientAssets.appRouteManifestModule, {
+						as: "script",
+						crossOrigin: assetCrossOrigin,
+						fetchPriority: "low",
 						nonce: options?.scriptNonce
 					});
-					if (!flightRoot) flightRoot = createFromReadableStream(ssrStream);
+					if (!flightRoot) flightRoot = createFromReadableStream(ssrStream, SSR_FLIGHT_OPTIONS);
 					const wireElements = use(flightRoot);
 					const elements = AppElementsWire.decode(wireElements);
 					const metadata = AppElementsWire.readMetadata(elements);
@@ -276,6 +277,7 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 						if (link) reactLinkHeader = link;
 					} : void 0,
 					maxHeadersLength: captureHeaders ? maxHeadersLength : void 0,
+					signal: options?.signal,
 					onError(error) {
 						if (pprFallbackShellSignal && isPprFallbackShellAbortError(error)) return;
 						if (isAppRenderAbortError(error) || htmlCancellation.isReason(error)) return;
@@ -290,29 +292,74 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 				let htmlStream;
 				let renderComplete = Promise.resolve();
 				let shellErrorRecovered = false;
+				let caughtShellError;
+				let caughtBoundaries = null;
 				let shouldDelayInitialHtmlPull = false;
+				const prepareCaughtNotFoundRoot = (error) => {
+					const caughtNotFoundBoundaries = options?.resolveCaughtNotFoundBoundaries?.(error) ?? null;
+					if (!caughtNotFoundBoundaries || caughtNotFoundBoundaries.length === 0) return null;
+					const replayedRscStream = rscEmbed.replay({ keepOpen: pprFallbackShellSignal !== void 0 });
+					if (!replayedRscStream) return null;
+					ssrStream = replayedRscStream;
+					flightRoot = null;
+					beforeInteractiveInlineScripts.length = 0;
+					clearServerInsertedHTML();
+					resetStreamedClientReferences(streamedReferences, routeReferences);
+					const boundaries = {
+						ids: new Set(caughtNotFoundBoundaries),
+						rendered: /* @__PURE__ */ new Set()
+					};
+					caughtBoundaries = boundaries;
+					return withCaughtNotFoundBoundaries(boundaries, ssrRoot);
+				};
 				if (pprFallbackShellSignal) {
 					const prerender = await loadStaticPrerender();
-					const htmlAbortController = new AbortController();
-					const pendingHtml = prerender(ssrRoot, {
-						...renderOptions,
-						signal: htmlAbortController.signal
-					});
-					setTimeout(() => htmlAbortController.abort(), 0);
-					htmlStream = (await pendingHtml).prelude;
+					const prerenderFallbackShell = async (root) => {
+						const htmlAbortController = new AbortController();
+						const pendingHtml = runWithStreamedClientReferences(streamedReferences, () => prerender(root, {
+							...renderOptions,
+							signal: htmlAbortController.signal
+						}));
+						setTimeout(() => htmlAbortController.abort(), 0);
+						return (await pendingHtml).prelude;
+					};
+					try {
+						htmlStream = await prerenderFallbackShell(ssrRoot);
+					} catch (error) {
+						const caughtRoot = prepareCaughtNotFoundRoot(error);
+						if (!caughtRoot) throw error;
+						htmlStream = await prerenderFallbackShell(caughtRoot);
+						caughtShellError = error;
+					}
 				} else {
 					let streamingHtmlStream;
 					try {
-						streamingHtmlStream = await renderToReadableStream(ssrRoot, { ...renderOptions });
+						streamingHtmlStream = await runWithStreamedClientReferences(streamedReferences, () => renderToReadableStream(ssrRoot, { ...renderOptions }));
 						renderComplete = streamingHtmlStream.allReady;
 						if (options?.waitForAllReady === true) await streamingHtmlStream.allReady;
 						else shouldDelayInitialHtmlPull = true;
 						htmlStream = streamingHtmlStream;
 					} catch (error) {
 						streamingHtmlStream?.cancel().catch(() => {});
-						if (options?.fallbackToErrorDocumentOnShellError !== true || options?.waitForAllReady === true || typeof error?.digest === "string") throw error;
-						shellErrorRecovered = true;
-						htmlStream = renderSsrErrorDocumentShell(bootstrapModuleUrl, options?.scriptNonce);
+						const caughtRoot = prepareCaughtNotFoundRoot(error);
+						if (caughtRoot) {
+							let caughtHtmlStream;
+							try {
+								caughtHtmlStream = await runWithStreamedClientReferences(streamedReferences, () => renderToReadableStream(caughtRoot, renderOptions));
+								if (options?.waitForAllReady === true) await caughtHtmlStream.allReady;
+							} catch (caughtRenderError) {
+								caughtHtmlStream?.cancel().catch(() => {});
+								throw caughtRenderError;
+							}
+							renderComplete = caughtHtmlStream.allReady;
+							shouldDelayInitialHtmlPull = options?.waitForAllReady !== true;
+							caughtShellError = error;
+							htmlStream = caughtHtmlStream;
+						} else if (options?.fallbackToErrorDocumentOnShellError !== true || options?.waitForAllReady === true || typeof error?.digest === "string") throw error;
+						else {
+							shellErrorRecovered = true;
+							htmlStream = renderSsrErrorDocumentShell(bootstrapModuleUrl, options?.scriptNonce);
+						}
 					}
 				}
 				const inlineCssManifest = globalThis.__VINEXT_INLINE_CSS__;
@@ -347,7 +394,7 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					return buildHeadInjectionHtml(hidesQuery ? {
 						...ssrNavigationContext,
 						searchParams: new URLSearchParams()
-					} : ssrNavigationContext, bootstrapModuleUrl, options?.formState ?? null, insertedHTML + errorMetaHTML + getTraceMetaHTML() + initialDevServerErrorHTML, fontHTML, options?.dynamicStaleTimeSeconds, isSearchParamsFromBrowser, options?.scriptNonce);
+					} : ssrNavigationContext, shellErrorRecovered ? bootstrapModuleUrl : void 0, options?.formState ?? null, insertedHTML + errorMetaHTML + (caughtBoundaries === null ? "" : createInlineScriptTag(`self.${CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL}=${safeJsonStringify([...caughtBoundaries.rendered])}`, options?.scriptNonce)) + getTraceMetaHTML() + initialDevServerErrorHTML + rewriteInlineCssStylesheetLinks(renderStreamedStylesheets(streamedReferences), inlineCssManifest, "", options?.scriptNonce).html, fontHTML, options?.dynamicStaleTimeSeconds, isSearchParamsFromBrowser, options?.scriptNonce);
 				};
 				const getBeforeInteractiveHeadHTML = () => renderBeforeInteractiveInlineScripts(beforeInteractiveInlineScripts);
 				if (shouldDelayInitialHtmlPull) await waitAtLeastOneReactRenderTask();
@@ -357,6 +404,7 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					renderComplete,
 					capturedRscData: options?.capturedRscDataRef?.value ?? null,
 					shellErrorRecovered,
+					...caughtShellError === void 0 ? {} : { caughtShellError },
 					linkHeader: reactLinkHeader
 				};
 			} catch (error) {

package/dist/server/app-ssr-error-meta.d.ts

@@ -9,4 +9,5 @@ type SsrErrorMetaRenderer = {
 };
 export declare function renderSsrErrorMetaTags(errors: readonly unknown[], options?: SsrErrorMetaRenderOptions): string;
 export declare function createSsrErrorMetaRenderer(options?: SsrErrorMetaRenderOptions): SsrErrorMetaRenderer;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-ssr-search-params-gate.d.ts

@@ -17,4 +17,5 @@ type CandidateSearchParamsGate = {
  * server component can mark the render dynamic any more.
  */
 export declare function startCandidateSearchParamsGate(): CandidateSearchParamsGate;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-ssr-stream.d.ts

@@ -1,10 +1,22 @@
 //#region src/server/app-ssr-stream.d.ts
 type RscEmbedTransform = {
-  flush(): string;
-  finalize(): Promise<string>;
+  /** UTF-8 bytes of the scripts for the chunks read since the last flush. */
+  flush(): Uint8Array | null;
+  finalize(): Promise<Uint8Array>;
   /** Resolves when all raw bytes from the embed stream have been read. */
   getRawBuffer(): Promise<ArrayBuffer>;
 };
+type ReplayableRscEmbedTransform = RscEmbedTransform & {
+  /**
+   * The embed stream again from its start, for a render that replaces one
+   * that already read it, or null once its bytes are released. `keepOpen`
+   * leaves it open after the last byte, like a PPR fallback shell's SSR
+   * stream, whose omitted references stay suspended.
+   */
+  replay(options?: {
+    keepOpen?: boolean;
+  }): ReadableStream<Uint8Array> | null;
+};
 type RscEmbedTransformOptions = {
   /**
    * Mirror inline Flight chunks into Next.js's `self.__next_f` transport. A
@@ -26,6 +38,10 @@ export type InitialNavigationCacheMetadata = {
    */
   staleTimeSeconds?: number;
 };
+type InlineCssRewriteResult = {
+  html: string;
+  consumedPrependCss: boolean;
+};
 export declare function waitAtLeastOneReactRenderTask(): Promise<void>;
 export declare function navigationRuntimeRscBootstrapExpression(): string;
 export declare function createNavigationRuntimeRscMetadataScript(params: Record<string, string | string[]>, nav: {
@@ -48,13 +64,8 @@ export declare function createNavigationRuntimeRenderedSearchScript(search: stri
  * Create a helper that progressively embeds RSC chunks as inline <script> tags.
  * The browser entry turns the embedded chunks back into Uint8Array data.
  */
-export declare function createRscEmbedTransform(embedStream: ReadableStream<Uint8Array>, optionsOrNonce?: RscEmbedTransformOptions | string): RscEmbedTransform;
-/**
- * Fix invalid preload "as" values in server-rendered HTML.
- * React Fizz emits <link rel="preload" as="stylesheet"> for CSS, but the
- * HTML spec requires as="style" for <link rel="preload">.
- */
-export declare function fixPreloadAs(html: string): string;
+export declare function createRscEmbedTransform(embedStream: ReadableStream<Uint8Array>, optionsOrNonce?: RscEmbedTransformOptions | string): ReplayableRscEmbedTransform;
+export declare function rewriteInlineCssStylesheetLinks(html: string, inlineCssManifest: InlineCssManifest | undefined, prependCss: string, ssrScriptNonce: string | undefined): InlineCssRewriteResult;
 /**
  * Create the tick-buffered HTML transform that injects RSC scripts between
  * React Fizz flush cycles without corrupting split HTML chunks.
@@ -83,4 +94,5 @@ export declare function fixPreloadAs(html: string): string;
  *    position) ship as-is.
  */
 export declare function createTickBufferedTransform(rscEmbed: RscEmbedTransform, injectHTML?: HtmlInsertion, injectAfterHeadOpenHTML?: HtmlInsertion, inlineCssManifest?: InlineCssManifest, inlineCssPrependCss?: string, inlineCssPrependFallbackHTML?: string, inlineCssScriptNonce?: string): TransformStream<Uint8Array, Uint8Array>;
-//#endregion
+//#endregion
+export {};