vinext 0.1.2 → 0.1.3

package/dist/server/app-segment-config.js

@@ -88,8 +88,7 @@ function resolveAppPageSegmentConfig(options) {
 	}
 	if (config.dynamicConfig === "force-dynamic") config.revalidateSeconds = 0;
 	if (config.fetchCache === void 0) {
-		if (config.dynamicConfig === "force-dynamic") config.fetchCache = "force-no-store";
-		else if (config.dynamicConfig === "error") config.fetchCache = "only-cache";
+		if (config.dynamicConfig === "error") config.fetchCache = "only-cache";
 	}
 	if (config.dynamicParamsConfig === void 0 && (config.dynamicConfig === "error" || config.dynamicConfig === "force-static")) config.dynamicParamsConfig = false;
 	return config;
@@ -97,8 +96,18 @@ function resolveAppPageSegmentConfig(options) {
 function resolveAppPageFetchCacheMode(options) {
 	return resolveAppPageSegmentConfig(options).fetchCache ?? null;
 }
+/**
+* Resolve the `fetchCache` segment config exported by a route handler module.
+*
+* Route handlers have no layout chain, so the module's own export applies
+* directly. Mirrors upstream's app-route module, which copies
+* `userland.fetchCache` into the work store before invoking the handler.
+*/
+function resolveAppRouteHandlerFetchCacheMode(handler) {
+	return isRouteSegmentFetchCache(handler.fetchCache) ? handler.fetchCache : null;
+}
 function isEdgeRuntime(runtime) {
 	return isEdgeApiRuntime(runtime);
 }
 //#endregion
-export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig };
+export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig, resolveAppRouteHandlerFetchCacheMode };

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

@@ -173,6 +173,7 @@ type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActio
   renderToReadableStream: (model: AppServerActionRscModel<TElement>, options: RenderServerActionRscStreamOptions<TTemporaryReferences>) => BodyInit | null | Promise<BodyInit | null>;
   reportRequestError: AppServerActionErrorReporter;
   resolveRouteFetchCacheMode?: (route: TRoute) => FetchCacheMode | null;
+  resolveRouteDynamicConfig?: (route: TRoute) => string | null | undefined;
   resolveRouteRuntime?: (route: TRoute) => AppServerActionRouteRuntime;
   request: Request;
   sanitizeErrorForClient: (error: unknown) => unknown;

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

@@ -7,7 +7,7 @@ import { validateCsrfOrigin, validateServerActionPayload } from "./request-pipel
 import { headersContextFromRequest, setHeadersContext } from "../shims/headers.js";
 import { getAndClearActionRevalidationKind } from "../shims/cache.js";
 import { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI } from "./app-rsc-render-mode.js";
-import { setCurrentFetchCacheMode, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
+import { setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
@@ -15,9 +15,9 @@ import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
 import { deferUntilStreamConsumed } from "./app-page-stream.js";
+import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { resolveAppPageActionRerenderTarget } from "./app-page-request.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-server-action-execution.ts
 /**
@@ -46,6 +46,10 @@ function resolveActionRevalidationKind(hasModifiedCookies) {
 	if (hasModifiedCookies) return ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC;
 	return revalidationKind;
 }
+function clearRejectedActionSideEffects(getAndClearPendingCookies) {
+	getAndClearPendingCookies();
+	getAndClearActionRevalidationKind();
+}
 function cloneActionRedirectHeaders(requestHeaders) {
 	const headers = new Headers(requestHeaders);
 	for (const header of ACTION_REDIRECT_RENDER_STRIPPED_HEADERS) headers.delete(header);
@@ -233,7 +237,7 @@ function applyActionRedirectBasePath(url, basePath) {
 	return `${addBasePathToPathname(pathname, basePath)}${suffix}`;
 }
 function buildServerActionPageTags(route, pathname) {
-	return buildPageCacheTags(pathname, [], [...route.routeSegments ?? []], "page");
+	return buildAppPageTags(pathname, [], route.routeSegments ?? []);
 }
 function resolveInternalActionRedirectTarget(redirectUrl, requestUrl, basePath) {
 	if (isExternalUrl(redirectUrl)) {
@@ -331,6 +335,7 @@ async function handleProgressiveServerActionRequest(options) {
 		}
 		const payloadResponse = await validateServerActionPayload(body);
 		if (payloadResponse) {
+			clearRejectedActionSideEffects(options.getAndClearPendingCookies);
 			options.clearRequestContext();
 			return payloadResponse;
 		}
@@ -482,6 +487,24 @@ async function handleServerActionRscRequest(options) {
 	if (csrfResponse) return csrfResponse;
 	if (parseInt(options.request.headers.get("content-length") || "0", 10) > options.maxActionBodySize) return renderFetchActionBodyExceededResponse(options);
 	try {
+		let action;
+		if (options.contentType.startsWith("multipart/form-data")) {
+			let loadedAction;
+			try {
+				loadedAction = await options.loadServerAction(options.actionId);
+			} catch (error) {
+				if (isServerActionNotFoundError(error, options.actionId)) return createActionNotFoundResponse(options.actionId, {
+					clearRequestContext: options.clearRequestContext,
+					getAndClearPendingCookies: options.getAndClearPendingCookies
+				});
+				throw error;
+			}
+			if (!isAppServerActionFunction(loadedAction)) return createActionNotFoundResponse(options.actionId, {
+				clearRequestContext: options.clearRequestContext,
+				getAndClearPendingCookies: options.getAndClearPendingCookies
+			});
+			action = loadedAction;
+		}
 		let body;
 		try {
 			body = options.contentType.startsWith("multipart/form-data") ? await options.readFormDataWithLimit(options.request, options.maxActionBodySize) : await options.readBodyWithLimit(options.request, options.maxActionBodySize);
@@ -491,23 +514,27 @@ async function handleServerActionRscRequest(options) {
 		}
 		const payloadResponse = await validateServerActionPayload(body);
 		if (payloadResponse) {
+			clearRejectedActionSideEffects(options.getAndClearPendingCookies);
 			options.clearRequestContext();
 			return payloadResponse;
 		}
-		let action;
-		try {
-			action = await options.loadServerAction(options.actionId);
-		} catch (error) {
-			if (isServerActionNotFoundError(error, options.actionId)) return createActionNotFoundResponse(options.actionId, {
+		if (action === void 0) {
+			let loadedAction;
+			try {
+				loadedAction = await options.loadServerAction(options.actionId);
+			} catch (error) {
+				if (isServerActionNotFoundError(error, options.actionId)) return createActionNotFoundResponse(options.actionId, {
+					clearRequestContext: options.clearRequestContext,
+					getAndClearPendingCookies: options.getAndClearPendingCookies
+				});
+				throw error;
+			}
+			if (!isAppServerActionFunction(loadedAction)) return createActionNotFoundResponse(options.actionId, {
 				clearRequestContext: options.clearRequestContext,
 				getAndClearPendingCookies: options.getAndClearPendingCookies
 			});
-			throw error;
+			action = loadedAction;
 		}
-		if (!isAppServerActionFunction(action)) return createActionNotFoundResponse(options.actionId, {
-			clearRequestContext: options.clearRequestContext,
-			getAndClearPendingCookies: options.getAndClearPendingCookies
-		});
 		const temporaryReferences = options.createTemporaryReferenceSet();
 		const args = await options.decodeReply(body, { temporaryReferences });
 		let returnValue;
@@ -599,6 +626,7 @@ async function handleServerActionRscRequest(options) {
 				params: redirectNavigationParams
 			});
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(targetMatch.route) ?? null);
+			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(targetMatch.route) === "force-dynamic");
 			setCurrentFetchSoftTags(buildServerActionPageTags(targetMatch.route, targetPathname));
 			const element = options.buildPageElement({
 				cleanPathname: targetPathname,
@@ -677,6 +705,7 @@ async function handleServerActionRscRequest(options) {
 			});
 			await options.ensureRouteLoaded?.(actionRerenderTarget.route);
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(actionRerenderTarget.route) ?? null);
+			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(actionRerenderTarget.route) === "force-dynamic");
 			setCurrentFetchSoftTags(buildServerActionPageTags(actionRerenderTarget.route, options.cleanPathname));
 			element = options.buildPageElement({
 				cleanPathname: options.cleanPathname,

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

@@ -22,6 +22,7 @@ declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navContext: Na
   capturedRscDataRef?: {
     value: Promise<ArrayBuffer> | null;
   };
+  pprFallbackShellSignal?: AbortSignal;
   formState?: ReactFormState | null;
   basePath?: string;
   /**
@@ -42,6 +43,7 @@ declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navContext: Na
    *  to resolve before returning the HTML stream. Used for static prerender
    *  and ISR cache writes to avoid caching fallback content. */
   waitForAllReady?: boolean;
+  fallbackToErrorDocumentOnShellError?: boolean;
 }): Promise<AppSsrRenderResult>;
 declare const _default: {
   fetch(request: Request): Promise<Response>;

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

@@ -1,23 +1,26 @@
 import "./server-globals.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./request-pipeline.js";
+import { isPprFallbackShellAbortError } from "../shims/ppr-fallback-shell.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
+import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { ServerInsertedHTMLContext, appRouterInstance, clearServerInsertedHTML, getBfcacheIdMapContext, renderServerInsertedHTML, setNavigationContext, useServerInsertedHTML } from "../shims/navigation.js";
 import { runWithNavigationContext } from "../shims/navigation-state.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, safeJsonStringify } from "./html.js";
 import { getClientTraceMetadataHTML } from "./client-trace-metadata.js";
+import DefaultGlobalError from "../shims/default-global-error.js";
 import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
 import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
 import { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform } from "./app-ssr-stream.js";
+import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
+import { runWithRootParamsScope } from "../shims/root-params.js";
 import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-browser-state.js";
 import { RSC_FORM_STATE_GLOBAL } from "./app-browser-hydration.js";
 import { createClientReferencePreloader } from "./app-client-reference-preloader.js";
 import { deferUntilStreamConsumed } from "./app-page-stream.js";
-import { runWithRootParamsScope } from "../shims/root-params.js";
-import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
 import { createInitialDevServerErrorScript } from "./dev-initial-server-error.js";
 import { Fragment, createElement, use } from "react";
 import { renderToReadableStream, renderToStaticMarkup } from "react-dom/server.edge";
@@ -31,6 +34,50 @@ import clientReferences from "virtual:vite-rsc/client-references";
 * 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");
+}
+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");
+	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(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().");
+}
+function createUtf8Stream(html) {
+	const encoder = new TextEncoder();
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(encoder.encode(html));
+		controller.close();
+	} });
+}
+function buildBootstrapModuleScript(bootstrapModuleUrl, nonce) {
+	if (!bootstrapModuleUrl) return "";
+	return `<script type="module"${createNonceAttribute(nonce)} src="` + escapeHtmlAttr(bootstrapModuleUrl) + "\" id=\"_R_\" async=\"\"><\/script>";
+}
+function renderSsrErrorDocumentShell(bootstrapModuleUrl, nonce) {
+	const html = renderToStaticMarkup(createElement(DefaultGlobalError, { error: null })).replace("<style>", "<style data-vinext-error-shell-style=\"\">");
+	const bootstrapScript = buildBootstrapModuleScript(bootstrapModuleUrl, nonce);
+	if (!bootstrapScript) return createUtf8Stream(`<!DOCTYPE html>${html}`);
+	const documentClose = "</body></html>";
+	if (!html.endsWith(documentClose)) return createUtf8Stream(`<!DOCTYPE html>${html}${bootstrapScript}`);
+	return createUtf8Stream(`<!DOCTYPE html>${html.slice(0, -14)}${bootstrapScript}${documentClose}`);
+}
 const clientReferencePreloader = createClientReferencePreloader({
 	getReferences() {
 		return clientReferences;
@@ -94,8 +141,8 @@ function renderFontHtml(fontData, nonce, options = {}) {
 	let fontHTML = "";
 	const nonceAttr = createNonceAttribute(nonce);
 	const includeStyles = options.includeStyles ?? true;
-	for (const url of fontData.links ?? []) fontHTML += `<link rel="stylesheet"${nonceAttr} href="${escapeHtmlAttr(url)}" />\n`;
-	for (const preload of fontData.preloads ?? []) fontHTML += `<link rel="preload"${nonceAttr} href="${escapeHtmlAttr(preload.href)}" as="font" type="${escapeHtmlAttr(preload.type)}" crossorigin />\n`;
+	for (const url of fontData.links ?? []) fontHTML += `<link rel="stylesheet"${nonceAttr} href="${escapeHtmlAttr(appendAssetDeploymentIdQuery(url))}" />\n`;
+	for (const preload of fontData.preloads ?? []) fontHTML += `<link rel="preload"${nonceAttr} href="${escapeHtmlAttr(appendAssetDeploymentIdQuery(preload.href))}" as="font" type="${escapeHtmlAttr(preload.type)}" crossorigin />\n`;
 	if (includeStyles && fontData.styles && fontData.styles.length > 0) fontHTML += `<style data-vinext-fonts${nonceAttr}>${fontData.styles.join("\n")}</style>\n`;
 	return fontHTML;
 }
@@ -182,24 +229,50 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 				const ssrRoot = withScriptNonce(createElement(BeforeInteractiveContext.Provider, { value: registerBeforeInteractiveInlineScript }, ssrTree), options?.scriptNonce);
 				const bootstrapModuleUrl = extractBootstrapModuleUrl(await import.meta.viteRsc.loadBootstrapScriptContent("index"));
 				const errorMetaRenderer = createSsrErrorMetaRenderer({ basePath: options?.basePath });
+				const pprFallbackShellSignal = options?.pprFallbackShellSignal;
 				let reactLinkHeader = "";
 				const maxHeadersLength = options?.reactMaxHeadersLength ?? DEFAULT_REACT_MAX_HEADERS_LENGTH;
 				const captureHeaders = maxHeadersLength > 0;
-				const htmlStream = await renderToReadableStream(ssrRoot, {
+				const renderOptions = {
+					bootstrapModules: bootstrapModuleUrl ? [bootstrapModuleUrl] : void 0,
+					formState: options?.formState ?? null,
+					nonce: options?.scriptNonce,
 					onHeaders: captureHeaders ? (headers) => {
 						const link = headers.get("Link");
 						if (link) reactLinkHeader = link;
 					} : void 0,
 					maxHeadersLength: captureHeaders ? maxHeadersLength : void 0,
-					bootstrapModules: bootstrapModuleUrl ? [bootstrapModuleUrl] : void 0,
-					formState: options?.formState ?? null,
-					nonce: options?.scriptNonce,
 					onError(error) {
+						if (pprFallbackShellSignal && isPprFallbackShellAbortError(error)) return;
 						errorMetaRenderer.capture(error);
 						if (error && typeof error === "object" && "digest" in error) return String(error.digest);
 						if (process.env.NODE_ENV === "production" && error) return ssrErrorDigest(getErrorMessage(error) + (error instanceof Error ? error.stack ?? "" : ""));
 					}
-				});
+				};
+				let htmlStream;
+				let shellErrorRecovered = false;
+				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;
+				} else {
+					let streamingHtmlStream;
+					try {
+						streamingHtmlStream = await renderToReadableStream(ssrRoot, { ...renderOptions });
+						if (options?.waitForAllReady === true) await streamingHtmlStream.allReady;
+						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 inlineCssManifest = globalThis.__VINEXT_INLINE_CSS__;
 				const fontStyles = fontData?.styles ?? [];
 				const mergeFontStylesIntoInlineCss = fontStyles.length > 0 && hasInlineCssManifest(inlineCssManifest);
@@ -221,11 +294,11 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					return buildHeadInjectionHtml(ssrNavigationContext, bootstrapModuleUrl, options?.formState ?? null, insertedHTML + errorMetaHTML + getTraceMetaHTML() + initialDevServerErrorHTML, fontHTML, options?.scriptNonce);
 				};
 				const getBeforeInteractiveHeadHTML = () => renderBeforeInteractiveInlineScripts(beforeInteractiveInlineScripts);
-				if (options?.waitForAllReady === true) await htmlStream.allReady;
 				return {
 					htmlStream: deferUntilStreamConsumed(htmlStream.pipeThrough(createTickBufferedTransform(rscEmbed, getInsertedHTML, getBeforeInteractiveHeadHTML, inlineCssManifest, inlineCssFontStyles, inlineCssFontStyleFallbackHTML, options?.scriptNonce)), cleanup),
 					metadataReady: Promise.resolve(),
 					capturedRscData: options?.capturedRscDataRef?.value ?? null,
+					shellErrorRecovered,
 					linkHeader: reactLinkHeader
 				};
 			} catch (error) {

package/dist/server/cache-control.js

@@ -19,6 +19,10 @@ function applyCdnResponseHeaders(headers, input) {
 	headers.delete("Cache-Control");
 	const map = getCdnCacheAdapter().buildResponseHeaders(input);
 	for (const [name, value] of Object.entries(map)) {
+		if (value === null) {
+			headers.delete(name);
+			continue;
+		}
 		if (value === "") continue;
 		headers.set(name, value);
 	}

package/dist/server/dev-server.d.ts

@@ -43,7 +43,7 @@ declare function createSSRHandler(server: ViteDevServer, runner: ModuleImporter,
  * `next.config`. When undefined or empty, no meta tags are emitted.
  */
 
-clientTraceMetadata?: readonly string[]): (req: IncomingMessage, res: ServerResponse, url: string, /** Status code override — propagated from middleware rewrite status. */
+clientTraceMetadata?: readonly string[], htmlLimitedBots?: string): (req: IncomingMessage, res: ServerResponse, url: string, /** Status code override — propagated from middleware rewrite status. */
 
 statusCode?: number,
 /**
@@ -53,6 +53,6 @@ statusCode?: number,
  * client-side navigations in the Pages Router.
  */
 
-isDataReq?: boolean) => Promise<void>;
+isDataReq?: boolean, originalUrl?: string) => Promise<void>;
 //#endregion
 export { createSSRHandler, detectLocaleFromHeaders, extractLocaleFromUrl, parseCookieLocale };