vinext 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/server/app-route-module-loader.js

@@ -20,6 +20,7 @@ function loadAppInterceptLayouts(intercept) {
 	if (loadState?.interceptLayoutsLoading) return loadState.interceptLayoutsLoading;
 	const loads = [];
 	pushArrayLoads(loads, intercept.interceptLayouts, intercept.__loadInterceptLayouts);
+	pushArrayLoads(loads, intercept.interceptLoadings, intercept.__loadInterceptLoadings);
 	if (loads.length === 0) return Promise.resolve(intercept.interceptLayouts ?? []);
 	const loading = Promise.all(loads).then(() => {
 		if (loadState) loadState.interceptLayoutsLoading = null;
@@ -52,6 +53,7 @@ function ensureAppRouteModulesLoaded(route) {
 	pushFieldLoad(loads, route, "unauthorized", route.__loadUnauthorized);
 	pushArrayLoads(loads, route.layouts, route.__loadLayouts);
 	pushArrayLoads(loads, route.templates, route.__loadTemplates);
+	pushArrayLoads(loads, route.loadings, route.__loadLoadings);
 	pushArrayLoads(loads, route.errors, route.__loadErrors);
 	pushArrayLoads(loads, route.errorPaths, route.__loadErrorPaths);
 	pushArrayLoads(loads, route.notFounds, route.__loadNotFounds);
@@ -63,6 +65,7 @@ function ensureAppRouteModulesLoaded(route) {
 		pushFieldLoad(loads, slot, "layout", slot.__loadLayout);
 		pushArrayLoads(loads, slot.configLayouts, slot.__loadConfigLayouts);
 		pushFieldLoad(loads, slot, "loading", slot.__loadLoading);
+		pushArrayLoads(loads, slot.loadings, slot.__loadLoadings);
 		pushFieldLoad(loads, slot, "error", slot.__loadError);
 		pushFieldLoad(loads, slot, "notFound", slot.__loadNotFound);
 	}

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

@@ -1,6 +1,6 @@
 import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "../utils/protocol-headers.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
@@ -8,6 +8,7 @@ import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js"
 import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 import { finalizeMissingStaticAssetResponse, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import rscHandler, { __assetPrefix, __basePath, __imageAllowedWidths, __imageConfig } from "virtual:vinext-rsc-entry";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
@@ -17,7 +18,8 @@ const __workerAssetPathPrefix = assetPrefixPathname(typeof __assetPrefix === "st
 var app_router_entry_default = { async fetch(request, env, ctx) {
 	return handleRequest(request, env, ctx);
 } };
-async function handleRequest(request, env, ctx) {
+async function handleRequest(request, env, platformCtx) {
+	const ctx = platformCtx?.trustedRevalidateOrigin ? platformCtx : createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx));
 	registerConfiguredCacheAdapters(env);
 	registerConfiguredImageOptimizer(env);
 	const url = new URL(request.url);
@@ -34,7 +36,8 @@ async function handleRequest(request, env, ctx) {
 	const missingBuildAsset = isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix);
 	{
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
-		const filteredHeaders = filterInternalHeaders(request.headers);
+		const filteredHeaders = ctx.isInternalPagesRevalidation ? new Headers(request.headers) : filterInternalHeaders(request.headers);
+		filteredHeaders.delete(VINEXT_REVALIDATE_HOST_HEADER);
 		const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParamsPayload);
 		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
 		request = cloneRequestWithHeaders(request, filteredHeaders);

package/dist/server/app-rsc-cache-busting.d.ts

@@ -16,7 +16,14 @@ type CreateRscRequestHeadersOptions = {
   clientReuseManifestHeader?: string | null;
   interceptionContext?: string | null;
   mountedSlotsHeader?: string | null;
+  includePrefetchHeader?: boolean;
   renderMode?: AppRscRenderMode;
+  fetchPriority?: "auto" | "high" | "low";
+  nextUrl?: string | null;
+  prefetchRouterState?: {
+    pathAndSearch: string;
+    routeId: string;
+  } | null;
 };
 type ResolveInvalidRscCacheBustingRequestOptions = {
   isRscRequest: boolean;

package/dist/server/app-rsc-cache-busting.js

@@ -154,6 +154,12 @@ function createRscRequestHeaders(options = {}) {
 		["RSC"]: "1"
 	});
 	applyDeploymentIdHeader(headers);
+	if (options.prefetchRouterState) {
+		if (options.includePrefetchHeader !== false) headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+		headers.set(NEXT_ROUTER_STATE_TREE_HEADER, encodeURIComponent(JSON.stringify(options.prefetchRouterState)));
+	}
+	if (options.nextUrl) headers.set(NEXT_URL_HEADER, options.nextUrl);
+	if (process.env.__NEXT_TEST_MODE && options.fetchPriority) headers.set("Next-Test-Fetch-Priority", options.fetchPriority);
 	if (options.interceptionContext !== void 0 && options.interceptionContext !== null) headers.set(VINEXT_INTERCEPTION_CONTEXT_HEADER, options.interceptionContext);
 	if (options.mountedSlotsHeader !== void 0 && options.mountedSlotsHeader !== null) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
 	if (options.clientReuseManifestHeader !== void 0 && options.clientReuseManifestHeader !== null) headers.set(VINEXT_CLIENT_REUSE_MANIFEST_HEADER, options.clientReuseManifestHeader);

package/dist/server/app-rsc-errors.js

@@ -7,6 +7,11 @@ function hasDigest(error) {
 }
 const BAILOUT_TO_CSR_DIGEST = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
 const DYNAMIC_SERVER_USAGE_DIGEST = "DYNAMIC_SERVER_USAGE";
+function isAbortError(error) {
+	if (!error || typeof error !== "object") return false;
+	const name = Reflect.get(error, "name");
+	return name === "AbortError" || name === "ResponseAborted";
+}
 /**
 * vinext's mirror of Next.js's `getDigestForWellKnownError`: returns the digest
 * string only when the error is a genuine control-flow signal — a redirect,
@@ -52,6 +57,7 @@ function sanitizeErrorForClient(error, nodeEnv = process.env.NODE_ENV) {
 function createRscOnErrorHandler(options) {
 	return (error) => {
 		const nodeEnv = options.nodeEnv ?? process.env.NODE_ENV;
+		if (isAbortError(error)) return;
 		const wellKnownDigest = getDigestForWellKnownError(error);
 		if (wellKnownDigest !== void 0) return wellKnownDigest;
 		if (nodeEnv !== "production" && error instanceof Error && error.message.includes("Only plain objects, and a few built-ins, can be passed to Client Components")) {
@@ -62,6 +68,10 @@ function createRscOnErrorHandler(options) {
 			const reportableError = typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
 			options.reportRequestError(reportableError instanceof Error ? reportableError : new Error(getThrownValueMessage(reportableError)), options.requestInfo, options.errorContext);
 		}
+		if (nodeEnv !== "production" && error && !hasDigest(error)) {
+			const loggableError = typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
+			console.error("[vinext] Server render error:", loggableError);
+		}
 		if (hasDigest(error)) return String(error.digest);
 		if (error) {
 			const digest = errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));

package/dist/server/app-rsc-handler.d.ts

@@ -125,6 +125,7 @@ type HandleServerActionRequestOptions<TRoute> = {
   middlewareContext: AppRscMiddlewareContext;
   mountedSlotsHeader: string | null;
   request: Request;
+  scriptNonce?: string;
   routeMatch: AppRscRouteMatch<TRoute> | null;
   routePathname: string;
   searchParams: URLSearchParams;
@@ -195,6 +196,7 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   imageConfig?: ImageConfig;
   isDev: boolean;
   loadPrerenderPagesRoutes?: () => Promise<unknown>;
+  matchInterceptRoute?: (pathname: string, sourcePathname: string) => AppRscRouteMatch<TRoute> | null;
   matchRoute: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   matchRequestRoute?: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   runMiddleware?: (options: RunAppMiddlewareOptions) => Promise<ApplyAppMiddlewareResult>;

package/dist/server/app-rsc-handler.js

@@ -1,12 +1,13 @@
-import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { closeAfterResponse, closeAfterResponseWithBody, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
+import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
 import { ACTION_REVALIDATED_HEADER } from "./headers.js";
 import { requestContextFromRequest } from "../config/request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute } from "./request-pipeline.js";
+import { isOnDemandRevalidateRequest } from "./isr-cache.js";
 import { headersContextFromRequest } from "../shims/headers.js";
 import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { mergeRewriteQuery } from "../utils/query.js";
@@ -190,8 +191,9 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	};
 	let didMiddlewareRewrite = false;
 	let didMiddlewareRewritePathname = false;
-	if (options.runMiddleware) {
-		const middlewareResult = await options.runMiddleware({
+	const runMiddleware = isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate")) ? void 0 : options.runMiddleware;
+	if (runMiddleware) {
+		const middlewareResult = await runMiddleware({
 			cleanPathname,
 			context: middlewareContext,
 			hadBasePath,
@@ -326,7 +328,11 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: getResolvedSearchParams(),
 		params: {}
 	});
-	const preActionMatch = filesystemRouteEligible ? matchCleanPathname() : null;
+	const directPreActionMatch = filesystemRouteEligible ? matchCleanPathname() : null;
+	const preActionRoutePathname = cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname;
+	const interceptionPreActionMatch = filesystemRouteEligible && directPreActionMatch === null && isRscRequest && interceptionContextHeader !== null ? options.matchInterceptRoute?.(preActionRoutePathname, interceptionContextHeader) ?? null : null;
+	const preActionMatch = directPreActionMatch ?? interceptionPreActionMatch;
+	const isInterceptionMatch = interceptionPreActionMatch !== null;
 	if (preActionMatch) setRootParams(pickRootParams(preActionMatch.params, preActionMatch.route.rootParamNames));
 	if (pagesDataRequest && didMiddlewareRewritePathname && preActionMatch) {
 		const headers = new Headers();
@@ -372,8 +378,9 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		middlewareContext,
 		mountedSlotsHeader,
 		request,
+		scriptNonce,
 		routeMatch: preActionMatch,
-		routePathname: cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname,
+		routePathname: preActionRoutePathname,
 		searchParams: getResolvedSearchParams()
 	}) : null;
 	if (serverActionResponse) return serverActionResponse;
@@ -381,7 +388,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	let match = preActionMatch;
 	const renderPagesForMatchKind = async (matchKind) => {
 		if (!filesystemRouteEligible) return null;
-		const response = match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
+		const response = !isInterceptionMatch && (match === null || match.route.isDynamic) ? await options.renderPagesFallback?.({
 			appRouteMatch: match ?? null,
 			allowRscDocumentFallback: didMiddlewareRewritePathname,
 			isDataRequest,
@@ -407,7 +414,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		options.clearRequestContext();
 		return staticPagesFallbackResponse;
 	}
-	if (!resolvedLateRewritesForAction && (!match || match.route.isDynamic)) for (const rewrite of options.configRewrites.afterFiles) {
+	if (!isInterceptionMatch && !resolvedLateRewritesForAction && (!match || match.route.isDynamic)) for (const rewrite of options.configRewrites.afterFiles) {
 		const afterFilesRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
@@ -480,7 +487,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}
 	if (pagesDataRequest) {
 		options.clearRequestContext();
-		if (options.runMiddleware && (middlewareContext.status === null || middlewareContext.status === 200 || middlewareContext.status === 404)) {
+		if (runMiddleware && (middlewareContext.status === null || middlewareContext.status === 200 || middlewareContext.status === 404)) {
 			const response = buildNextDataNotFoundResponse();
 			const headers = new Headers(response.headers);
 			headers.set("x-nextjs-matched-path", matchPathname(canonicalPathname));
@@ -632,9 +639,11 @@ function createAppRscHandler(options) {
 		const pagesDataNormalization = options.renderPagesFallback && pagesDataCandidate ? normalizePagesDataRequest(pagesDataCandidate, options.buildId, "", typeof options.runMiddleware === "function" && options.trailingSlash) : null;
 		if (pagesDataNormalization?.notFoundResponse) return pagesDataNormalization.notFoundResponse;
 		const isPagesDataRequest = pagesDataNormalization?.isDataReq === true;
+		const executionContext = isExecutionContextLike(ctx) ? ctx : getRequestExecutionContext() ?? null;
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(rawRequest);
 		const isTrustedSpeculativePrerender = process.env.VINEXT_PRERENDER === "1" && rawRequest.headers.get("x-vinext-prerender-secret") !== null && rawRequest.headers.get("x-vinext-prerender-speculative") === "1";
-		const filteredHeaders = filterInternalHeaders(rawRequest.headers);
+		const filteredHeaders = executionContext?.isInternalPagesRevalidation ? new Headers(rawRequest.headers) : filterInternalHeaders(rawRequest.headers);
+		filteredHeaders.delete(VINEXT_REVALIDATE_HOST_HEADER);
 		if (mwCtx !== null) filteredHeaders.set(VINEXT_MW_CTX_HEADER, mwCtx);
 		const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParamsPayload);
 		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
@@ -647,12 +656,12 @@ function createAppRscHandler(options) {
 		}
 		const request = cloneRequestWithHeaders(appRequest, filteredHeaders);
 		const pagesDataRequest = pagesDataNormalization?.isDataReq ? cloneRequestWithHeaders(pagesDataCandidate, filteredHeaders) : null;
-		const executionContext = isExecutionContextLike(ctx) ? ctx : getRequestExecutionContext() ?? null;
-		return runWithRequestContext(createRequestContext({
+		const requestContext = createRequestContext({
 			headersContext: headersContextFromRequest(request, { draftModeSecret: options.draftModeSecret }),
 			executionContext,
 			unstableCacheRevalidation: "background"
-		}), () => runWithPrerenderWorkUnit(async () => {
+		});
+		const responsePromise = runWithRequestContext(requestContext, () => runWithPrerenderWorkUnit(async () => {
 			ensureFetchPatch();
 			const preMiddlewareRequestContext = requestContextFromRequest(request);
 			let response;
@@ -669,6 +678,14 @@ function createAppRscHandler(options) {
 				requestContext: preMiddlewareRequestContext
 			});
 		}, { route: () => new URL(request.url).pathname }));
+		let response;
+		try {
+			response = await responsePromise;
+		} catch (error) {
+			await closeAfterResponse(requestContext);
+			throw error;
+		}
+		return closeAfterResponseWithBody(response, requestContext);
 	};
 }
 //#endregion

package/dist/server/app-rsc-render-mode.d.ts

@@ -1,9 +1,10 @@
 //#region src/server/app-rsc-render-mode.d.ts
-type AppRscRenderMode = "navigation" | "prefetch-dynamic-shell" | "prefetch-loading-shell";
+type AppRscRenderMode = "navigation" | "prefetch-empty" | "prefetch-dynamic-shell" | "prefetch-loading-shell";
 declare const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
+declare const APP_RSC_RENDER_MODE_PREFETCH_EMPTY = "prefetch-empty";
 declare const APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL = "prefetch-dynamic-shell";
 declare const APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL = "prefetch-loading-shell";
 declare function getRscRenderModeCacheVariant(mode: AppRscRenderMode): string | null;
 declare function parseAppRscRenderMode(value: string | null): AppRscRenderMode;
 //#endregion
-export { APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode };
+export { APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_EMPTY, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode };

package/dist/server/app-rsc-render-mode.js

@@ -1,18 +1,21 @@
 //#region src/server/app-rsc-render-mode.ts
 const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
+const APP_RSC_RENDER_MODE_PREFETCH_EMPTY = "prefetch-empty";
 const APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL = "prefetch-dynamic-shell";
 const APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL = "prefetch-loading-shell";
 function getRscRenderModeCacheVariant(mode) {
+	if (mode === "prefetch-empty") return "prefetch-empty";
 	if (mode === "prefetch-dynamic-shell") return "prefetch-dynamic-shell";
 	if (mode === "prefetch-loading-shell") return "prefetch-loading-shell";
 	return null;
 }
 function parseAppRscRenderMode(value) {
 	switch (value) {
+		case APP_RSC_RENDER_MODE_PREFETCH_EMPTY: return APP_RSC_RENDER_MODE_PREFETCH_EMPTY;
 		case APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL: return APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL;
 		case APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL: return APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL;
 		default: return APP_RSC_RENDER_MODE_NAVIGATION;
 	}
 }
 //#endregion
-export { APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, getRscRenderModeCacheVariant, parseAppRscRenderMode };
+export { APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_EMPTY, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, getRscRenderModeCacheVariant, parseAppRscRenderMode };

package/dist/server/app-rsc-request-normalization.js

@@ -1,15 +1,63 @@
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
-import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
+import { NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { badRequestResponse, notFoundResponse } from "./http-error-responses.js";
 import { guardProtocolRelativeUrl } from "./request-pipeline.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
-import { APP_RSC_RENDER_MODE_NAVIGATION, parseAppRscRenderMode } from "./app-rsc-render-mode.js";
-import { stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_EMPTY, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, parseAppRscRenderMode } from "./app-rsc-render-mode.js";
+import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { parseClientReuseManifestHeader } from "./client-reuse-manifest.js";
 import { normalizeInterceptionContextHeader } from "./app-interception-context-header.js";
 //#region src/server/app-rsc-request-normalization.ts
+function extractFlightRouterStatePath(value, depth = 0) {
+	if (!Array.isArray(value) || value.length < 2 || depth > 64) return null;
+	const rawSegment = value[0];
+	const segment = Array.isArray(rawSegment) ? rawSegment[1] : rawSegment;
+	if (typeof segment !== "string") return null;
+	if (segment === "__DEFAULT__" || /^(?:\(\.\)|\(\.\.\)|\(\.\.\.\))/.test(segment)) return null;
+	const parallelRoutes = value[1];
+	if (!parallelRoutes || typeof parallelRoutes !== "object" || Array.isArray(parallelRoutes)) return null;
+	let childPath = null;
+	const children = Reflect.get(parallelRoutes, "children");
+	if (children !== void 0) childPath = extractFlightRouterStatePath(children, depth + 1);
+	if (childPath === null) for (const [key, child] of Object.entries(parallelRoutes)) {
+		if (key === "children") continue;
+		childPath = extractFlightRouterStatePath(child, depth + 1);
+		if (childPath !== null) break;
+	}
+	return `/${[segment === "" || segment === "children" || segment.startsWith("__PAGE__") || segment.startsWith("(") && segment.endsWith(")") ? "" : segment.replace(/^\/+/, ""), ...childPath === null ? [] : childPath.split("/")].filter(Boolean).join("/")}`;
+}
+function parsePrefetchRouterState(value) {
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(decodeURIComponent(value));
+		if (Array.isArray(parsed)) {
+			const pathAndSearch = extractFlightRouterStatePath(parsed);
+			return pathAndSearch === null ? null : { pathAndSearch };
+		}
+		if (!parsed || typeof parsed !== "object") return null;
+		const pathAndSearch = Reflect.get(parsed, "pathAndSearch");
+		const routeId = Reflect.get(parsed, "routeId");
+		if (typeof pathAndSearch !== "string" || !pathAndSearch.startsWith("/") || typeof routeId !== "string" || routeId.length === 0) return null;
+		return { pathAndSearch };
+	} catch {
+		return null;
+	}
+}
+function normalizeComparablePathAndSearch(value, basePath, baseUrl) {
+	const parsed = new URL(value, baseUrl);
+	const pathname = basePath && hasBasePath(parsed.pathname, basePath) ? stripBasePath(parsed.pathname, basePath) : parsed.pathname;
+	const search = parsed.searchParams.toString();
+	return `${pathname}${search ? `?${search}` : ""}`;
+}
+function tryNormalizeComparablePathAndSearch(value, basePath, baseUrl) {
+	try {
+		return normalizeComparablePathAndSearch(value, basePath, baseUrl);
+	} catch {
+		return null;
+	}
+}
 /**
 * Normalize an App Router RSC request.
 *
@@ -65,7 +113,20 @@ function normalizeRscRequest(request, basePath, allowOutsideBasePath = false) {
 	const requestCleanPathname = stripRscSuffix(requestPathname);
 	const interceptionContextHeader = normalizeInterceptionContextHeader(request.headers.get(VINEXT_INTERCEPTION_CONTEXT_HEADER));
 	const mountedSlotsHeader = normalizeMountedSlotsHeader(request.headers.get(VINEXT_MOUNTED_SLOTS_HEADER));
-	const renderMode = isRscRequest ? parseAppRscRenderMode(request.headers.get(VINEXT_RSC_RENDER_MODE_HEADER)) : APP_RSC_RENDER_MODE_NAVIGATION;
+	let renderMode = isRscRequest ? parseAppRscRenderMode(request.headers.get(VINEXT_RSC_RENDER_MODE_HEADER)) : APP_RSC_RENDER_MODE_NAVIGATION;
+	if (isRscRequest && renderMode === "navigation" && request.headers.get("Next-Router-Prefetch") === "1" && request.headers.get("Next-Router-Segment-Prefetch") === null) {
+		const nextUrl = request.headers.get(NEXT_URL_HEADER);
+		const routerState = parsePrefetchRouterState(request.headers.get(NEXT_ROUTER_STATE_TREE_HEADER));
+		if (nextUrl && routerState) {
+			const targetUrl = new URL(url);
+			targetUrl.pathname = cleanPathname;
+			targetUrl.searchParams.delete(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM);
+			const routerPathAndSearch = tryNormalizeComparablePathAndSearch(routerState.pathAndSearch, basePath, url);
+			const nextPathAndSearch = tryNormalizeComparablePathAndSearch(nextUrl, basePath, url);
+			const targetPathAndSearch = normalizeComparablePathAndSearch(targetUrl.href, basePath, url);
+			if (routerPathAndSearch !== null && nextPathAndSearch !== null) renderMode = routerPathAndSearch === nextPathAndSearch && routerPathAndSearch === targetPathAndSearch ? APP_RSC_RENDER_MODE_PREFETCH_EMPTY : APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL;
+		}
+	}
 	return {
 		clientReuseManifest: isRscRequest ? parseClientReuseManifestHeader(request.headers.get(VINEXT_CLIENT_REUSE_MANIFEST_HEADER)) : { kind: "absent" },
 		hadBasePath,

package/dist/server/app-rsc-route-matching.d.ts

@@ -33,8 +33,11 @@ type AppRscInterceptForMatching = {
   interceptLayouts: readonly unknown[];
   interceptLayoutSegments?: readonly (readonly string[])[];
   interceptBranchSegments?: readonly string[];
+  interceptLoadings?: readonly unknown[];
+  interceptLoadingTreePositions?: readonly number[];
   interceptNotFoundBranchSegments?: readonly string[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   notFound?: unknown;
@@ -54,8 +57,11 @@ type AppRscSiblingInterceptForMatching = {
   interceptLayouts: readonly unknown[];
   interceptLayoutSegments?: readonly (readonly string[])[];
   interceptBranchSegments?: readonly string[];
+  interceptLoadings?: readonly unknown[];
+  interceptLoadingTreePositions?: readonly number[];
   interceptNotFoundBranchSegments?: readonly string[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   notFound?: unknown;
@@ -93,8 +99,11 @@ type AppRscInterceptLookupEntry = {
   interceptLayouts: readonly unknown[];
   interceptLayoutSegments?: readonly (readonly string[])[];
   interceptBranchSegments?: readonly string[];
+  interceptLoadings?: readonly unknown[];
+  interceptLoadingTreePositions?: readonly number[];
   interceptNotFoundBranchSegments?: readonly string[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   notFound: unknown;

package/dist/server/app-rsc-route-matching.js

@@ -170,8 +170,11 @@ function createInterceptLookup(routes) {
 					interceptLayouts: intercept.interceptLayouts,
 					interceptLayoutSegments: intercept.interceptLayoutSegments,
 					interceptBranchSegments: intercept.interceptBranchSegments,
+					interceptLoadings: intercept.interceptLoadings,
+					interceptLoadingTreePositions: intercept.interceptLoadingTreePositions,
 					interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
 					__loadInterceptLayouts: intercept.__loadInterceptLayouts,
+					__loadInterceptLoadings: intercept.__loadInterceptLoadings,
 					page: intercept.page,
 					__pageLoader: intercept.__pageLoader,
 					notFound: intercept.notFound,
@@ -203,8 +206,11 @@ function createInterceptLookup(routes) {
 				interceptLayouts: intercept.interceptLayouts,
 				interceptLayoutSegments: intercept.interceptLayoutSegments,
 				interceptBranchSegments: intercept.interceptBranchSegments,
+				interceptLoadings: intercept.interceptLoadings,
+				interceptLoadingTreePositions: intercept.interceptLoadingTreePositions,
 				interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
 				__loadInterceptLayouts: intercept.__loadInterceptLayouts,
+				__loadInterceptLoadings: intercept.__loadInterceptLoadings,
 				page: intercept.page,
 				__pageLoader: intercept.__pageLoader,
 				notFound: intercept.notFound,

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

@@ -1,5 +1,5 @@
-import { ActionRevalidationKind } from "../shims/cache-request-state.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+import { ActionRevalidationKind } from "../shims/cache-request-state.js";
 import { FetchCacheMode } from "../shims/fetch-cache.js";
 import { HeadersAccessPhase } from "../shims/headers.js";
 import { ReactFormState } from "react-dom/client";

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

@@ -6,13 +6,12 @@ import "./app-elements.js";
 import { isPprFallbackShellAbortError } from "../shims/ppr-fallback-shell.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
-import { ServerInsertedHTMLContext, clearServerInsertedHTML, getBfcacheIdMapContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "../shims/navigation-context-state.js";
-import "../shims/navigation-server.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 { setPagesClientAssets } from "./pages-client-assets.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 { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
 import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
@@ -22,6 +21,7 @@ import { RSC_FORM_STATE_GLOBAL } from "./app-browser-hydration.js";
 import { createClientReferencePreloader } from "./app-client-reference-preloader.js";
 import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { runWithRootParamsScope } from "../shims/root-params.js";
+import { runWithNavigationContext } from "../shims/navigation-state.js";
 import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
 import { renderBeforeInteractiveInlineScripts } from "./before-interactive-head.js";
 import { createInitialDevServerErrorScript } from "./dev-initial-server-error.js";
@@ -123,7 +123,7 @@ function renderFontHtml(fontData, nonce, options = {}) {
 	const nonceAttr = createNonceAttribute(nonce);
 	const includeStyles = options.includeStyles ?? true;
 	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`;
+	for (const preload of fontData.preloads ?? []) fontHTML += `<link rel="preload"${nonceAttr} href="${escapeHtmlAttr(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;
 }

package/dist/server/app-visited-response-cache.d.ts

@@ -25,5 +25,10 @@ declare function isVisitedResponseCacheEntryFresh(entry: VisitedResponseCacheEnt
   navigationKind: VisitedResponseCacheNavigationKind;
   now: number;
 }): boolean;
+declare function findVisitedResponseCacheEntry(cache: Map<string, VisitedResponseCacheEntry>, rscUrl: string, interceptionContext: string | null): {
+  cacheKey: string;
+  entry: VisitedResponseCacheEntry;
+} | null;
+declare function deleteVisitedResponseCacheEntry(cache: Map<string, VisitedResponseCacheEntry>, rscUrl: string, interceptionContext: string | null): boolean;
 //#endregion
-export { MAX_TRAVERSAL_CACHE_TTL, VISITED_RESPONSE_CACHE_TTL, VisitedResponseCacheEntry, createVisitedResponseCacheEntry, isVisitedResponseCacheEntryFresh };
+export { MAX_TRAVERSAL_CACHE_TTL, VISITED_RESPONSE_CACHE_TTL, VisitedResponseCacheEntry, createVisitedResponseCacheEntry, deleteVisitedResponseCacheEntry, findVisitedResponseCacheEntry, isVisitedResponseCacheEntryFresh };

package/dist/server/app-visited-response-cache.js

@@ -1,3 +1,6 @@
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { resolveCachedRscResponseExpiresAt } from "../shims/navigation.js";
 //#region src/server/app-visited-response-cache.ts
 const VISITED_RESPONSE_CACHE_TTL = 5 * 6e4;
@@ -17,5 +20,50 @@ function isVisitedResponseCacheEntryFresh(entry, options) {
 	if (options.navigationKind === "traverse") return options.now - entry.createdAt < MAX_TRAVERSAL_CACHE_TTL;
 	return entry.expiresAt > options.now;
 }
+function normalizeVisitedResponseCacheLookupUrl(rscUrl) {
+	try {
+		const url = new URL(rscUrl, "http://vinext.local");
+		stripRscCacheBustingSearchParam(url);
+		return `${url.pathname}${url.search}`;
+	} catch {
+		return null;
+	}
+}
+function parseVisitedResponseCacheKey(cacheKey) {
+	const separatorIndex = cacheKey.indexOf("\0");
+	if (separatorIndex === -1) return {
+		interceptionContext: null,
+		rscUrl: cacheKey
+	};
+	return {
+		interceptionContext: cacheKey.slice(separatorIndex + 1),
+		rscUrl: cacheKey.slice(0, separatorIndex)
+	};
+}
+function findVisitedResponseCacheEntry(cache, rscUrl, interceptionContext) {
+	const exactCacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+	const exactEntry = cache.get(exactCacheKey);
+	if (exactEntry) return {
+		cacheKey: exactCacheKey,
+		entry: exactEntry
+	};
+	const normalizedTarget = normalizeVisitedResponseCacheLookupUrl(rscUrl);
+	if (normalizedTarget === null) return null;
+	for (const [cacheKey, entry] of cache) {
+		const source = parseVisitedResponseCacheKey(cacheKey);
+		if (source.interceptionContext !== interceptionContext) continue;
+		if (normalizeVisitedResponseCacheLookupUrl(source.rscUrl) !== normalizedTarget) continue;
+		return {
+			cacheKey,
+			entry
+		};
+	}
+	return null;
+}
+function deleteVisitedResponseCacheEntry(cache, rscUrl, interceptionContext) {
+	const match = findVisitedResponseCacheEntry(cache, rscUrl, interceptionContext);
+	if (!match) return false;
+	return cache.delete(match.cacheKey);
+}
 //#endregion
-export { MAX_TRAVERSAL_CACHE_TTL, VISITED_RESPONSE_CACHE_TTL, createVisitedResponseCacheEntry, isVisitedResponseCacheEntryFresh };
+export { MAX_TRAVERSAL_CACHE_TTL, VISITED_RESPONSE_CACHE_TTL, createVisitedResponseCacheEntry, deleteVisitedResponseCacheEntry, findVisitedResponseCacheEntry, isVisitedResponseCacheEntryFresh };

package/dist/server/cache-control.d.ts

@@ -26,7 +26,7 @@ declare function applyCdnResponseHeaders(headers: Headers, input: CdnCacheableHe
  * Next.js source:
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/cache-control.ts
  */
-declare function buildRevalidateCacheControl(revalidateSeconds: number, expireSeconds?: number): string;
+declare function buildRevalidateCacheControl(revalidateSeconds: number | false, expireSeconds?: number): string;
 /**
  * Builds Cache-Control for ISR cache reads. HIT responses and STALE responses
  * with stored expire metadata use the same route policy because Next.js derives
@@ -34,6 +34,6 @@ declare function buildRevalidateCacheControl(revalidateSeconds: number, expireSe
  * STALE entries without expire metadata keep vinext's legacy `s-maxage=0`
  * fallback so older cache entries are not treated as newly fresh downstream.
  */
-declare function buildCachedRevalidateCacheControl(cacheState: "HIT" | "STALE", revalidateSeconds: number, expireSeconds?: number): string;
+declare function buildCachedRevalidateCacheControl(cacheState: "HIT" | "STALE", revalidateSeconds: number | false, expireSeconds?: number): string;
 //#endregion
 export { BROWSER_REVALIDATE_CACHE_CONTROL, NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, applyCdnResponseHeaders, buildCachedRevalidateCacheControl, buildRevalidateCacheControl, shouldUseNextDeployCacheControl };

package/dist/server/cache-control.js

@@ -48,6 +48,7 @@ function applyCdnResponseHeaders(headers, input) {
 * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/cache-control.ts
 */
 function buildRevalidateCacheControl(revalidateSeconds, expireSeconds) {
+	if (revalidateSeconds === false) return STATIC_CACHE_CONTROL;
 	if (expireSeconds === void 0) return `s-maxage=${revalidateSeconds}, stale-while-revalidate`;
 	if (revalidateSeconds >= expireSeconds) return `s-maxage=${revalidateSeconds}`;
 	return `s-maxage=${revalidateSeconds}, stale-while-revalidate=${expireSeconds - revalidateSeconds}`;
@@ -60,7 +61,7 @@ function buildRevalidateCacheControl(revalidateSeconds, expireSeconds) {
 * fallback so older cache entries are not treated as newly fresh downstream.
 */
 function buildCachedRevalidateCacheControl(cacheState, revalidateSeconds, expireSeconds) {
-	if (revalidateSeconds === Infinity) return STATIC_CACHE_CONTROL;
+	if (revalidateSeconds === false || revalidateSeconds === Infinity) return STATIC_CACHE_CONTROL;
 	if (cacheState === "STALE" && expireSeconds === void 0) return STALE_REVALIDATE_CACHE_CONTROL;
 	return buildRevalidateCacheControl(revalidateSeconds, expireSeconds);
 }

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

@@ -53,7 +53,9 @@ clientTraceMetadata?: readonly string[], htmlLimitedBots?: string,
  * `nextConfig?.reactStrictMode === true`.
  */
 
-reactStrictMode?: boolean): (req: IncomingMessage, res: ServerResponse, url: string, /** Status code override — propagated from middleware rewrite status. */
+reactStrictMode?: boolean, /** Next.js `expireTime`, used when formatting terminal GSP responses. */
+
+expireTime?: number, crossOrigin?: string): (req: IncomingMessage, res: ServerResponse, url: string, /** Status code override — propagated from middleware rewrite status. */
 
 statusCode?: number,
 /**