vinext 0.2.0 → 1.0.0-beta.0

package/dist/server/app-page-route-wiring.js

@@ -1,6 +1,6 @@
 import { createAppRenderDependency, registerAppElementRenderDependencies, renderAfterAppDependencies, renderWithAppDependencyBarrier } from "./app-render-dependency.js";
 import { APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
-import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
+import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "./app-rsc-render-mode.js";
 import { APP_PREFETCH_LOADING_SHELL_MARKER_KEY } from "./app-elements.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
 import { ErrorBoundary, ForbiddenBoundary, GlobalErrorBoundary, NotFoundBoundary, RedirectBoundary, UnauthorizedBoundary } from "../shims/error-boundary.js";
@@ -353,7 +353,7 @@ function buildAppPageElements(options) {
 			children: slotElement
 		});
 		const slotLoadingComponent = getDefaultExport(slot.loading);
-		if (slotLoadingComponent && !shouldSuppressLoadingBoundaries(renderMode)) slotElement = /* @__PURE__ */ jsx(Suspense, {
+		if (slotLoadingComponent) slotElement = /* @__PURE__ */ jsx(Suspense, {
 			fallback: /* @__PURE__ */ jsx(slotLoadingComponent, {}),
 			children: slotElement
 		}, slotResetKey);
@@ -374,7 +374,7 @@ function buildAppPageElements(options) {
 	else routeChildren = /* @__PURE__ */ jsx(routeLoadingComponent, {});
 	else {
 		routeChildren = /* @__PURE__ */ jsx(RedirectBoundary, { children: routeChildren });
-		if (routeLoadingComponent && !shouldSuppressLoadingBoundaries(renderMode)) routeChildren = /* @__PURE__ */ jsx(Suspense, {
+		if (routeLoadingComponent) routeChildren = /* @__PURE__ */ jsx(Suspense, {
 			fallback: /* @__PURE__ */ jsx(routeLoadingComponent, {}),
 			children: routeChildren
 		}, routeResetKey);

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

@@ -107,7 +107,8 @@ type RenderAppPageHtmlStreamOptions = {
     value: Promise<ArrayBuffer> | null;
   }; /** Abort signal for a build-time PPR fallback-shell static render. */
   pprFallbackShellSignal?: AbortSignal; /** When true, wait for the full React tree before emitting bytes. */
-  waitForAllReady?: boolean; /** Dev-only: original server error to surface in the browser overlay. */
+  waitForAllReady?: boolean; /** Override the default shell-error recovery decision passed to handleSsr. */
+  fallbackToErrorDocumentOnShellError?: boolean; /** Dev-only: original server error to surface in the browser overlay. */
   initialDevServerError?: unknown;
   /** True when the app supplies a custom global-error.tsx. Disables the
    *  default error-document shell fallback so SSR shell errors keep driving

package/dist/server/app-page-stream.js

@@ -68,7 +68,7 @@ async function renderAppPageHtmlStream(options) {
 		pprFallbackShellSignal: options.pprFallbackShellSignal,
 		waitForAllReady: options.waitForAllReady,
 		initialDevServerError: options.initialDevServerError,
-		fallbackToErrorDocumentOnShellError: options.waitForAllReady !== true && options.hasCustomGlobalError === false,
+		fallbackToErrorDocumentOnShellError: options.fallbackToErrorDocumentOnShellError ?? (options.waitForAllReady !== true && options.hasCustomGlobalError === false),
 		dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
 		getInitialNavigationCacheMetadata: options.getInitialNavigationCacheMetadata
 	};

package/dist/server/app-route-handler-execution.d.ts

@@ -1,7 +1,7 @@
 import { NextI18nConfig } from "../config/next-config.js";
-import { CachedRouteValue } from "../shims/cache-handler.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
 import { NextRequest } from "../shims/server.js";
+import { CachedRouteValue } from "../shims/cache-handler.js";
 import { HeadersAccessPhase } from "../shims/headers.js";
 import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
 import { AppRouteHandlerModule } from "./app-route-handler-policy.js";

package/dist/server/app-route-tree-prefetch.d.ts

@@ -0,0 +1,43 @@
+//#region src/server/app-route-tree-prefetch.d.ts
+type DynamicParamTypeShort = "d" | "c" | "oc";
+type TreePrefetchParam = {
+  type: DynamicParamTypeShort;
+  key: null;
+  siblings: readonly string[] | null;
+};
+type AppRouteTreePrefetchSlot = {
+  configLayouts?: readonly unknown[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
+  default?: unknown;
+  layout?: unknown;
+  layoutIndex?: number;
+  name: string;
+  page?: unknown;
+  routeSegments?: readonly string[] | null;
+};
+type AppRouteTreePrefetchRoute = {
+  layoutTreePositions?: readonly number[];
+  layouts?: readonly unknown[];
+  page?: unknown;
+  routeSegments: readonly string[];
+  slots?: Readonly<Record<string, AppRouteTreePrefetchSlot>> | null;
+};
+type TreePrefetch = {
+  name: string;
+  param: TreePrefetchParam | null;
+  prefetchHints: number;
+  slots: null | Record<string, TreePrefetch>;
+};
+type RouteTreePrefetchResponseOptions = {
+  buildId?: string | null;
+  deploymentId?: string;
+  prefetchInlining?: PrefetchInliningConfig;
+};
+type PrefetchInliningConfig = false | {
+  maxBundleSize: number;
+  maxSize: number;
+};
+declare function isRouteTreePrefetchRequest(request: Request): boolean;
+declare function createRouteTreePrefetchResponse(route: AppRouteTreePrefetchRoute, options?: RouteTreePrefetchResponseOptions): Promise<Response>;
+//#endregion
+export { AppRouteTreePrefetchRoute, PrefetchInliningConfig, TreePrefetch, createRouteTreePrefetchResponse, isRouteTreePrefetchRequest };

package/dist/server/app-route-tree-prefetch.js

@@ -0,0 +1,187 @@
+import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
+import { getDeploymentId } from "../utils/deployment-id.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+//#region src/server/app-route-tree-prefetch.ts
+const PARENT_INLINED_INTO_SELF = 32;
+const INLINED_INTO_CHILD = 64;
+const HEAD_INLINED_INTO_SELF = 128;
+const PAGE_SEGMENT = "__PAGE__";
+const SLOT_SEGMENT = "(__SLOT__)";
+const SEGMENT_INLINE_SIZE = 1;
+const SEGMENT_OUTLINE_SIZE = 4096;
+const DEFAULT_SEGMENT_INLINE_THRESHOLD = 2048;
+const HEAD_INLINE_SIZE = 1;
+const DEFAULT_MAX_INLINE_BUNDLE_SIZE = 10240;
+const NEXT_DID_POSTPONE_HEADER = "x-nextjs-postponed";
+function isRouteTreePrefetchRequest(request) {
+	return request.headers.get("RSC") === "1" && request.headers.get("Next-Router-Prefetch") === "1" && request.headers.get("Next-Router-Segment-Prefetch") === "/_tree";
+}
+function createNode(segment, module) {
+	const { name, param } = routeTreeSegment(segment);
+	return {
+		name,
+		param,
+		prefetchSize: estimatePrefetchSize(module) ?? ((module === null || module === void 0) && segment !== PAGE_SEGMENT ? SEGMENT_INLINE_SIZE : null),
+		prefetchHints: 0,
+		slots: null
+	};
+}
+function ensureSlots(node) {
+	if (node.slots === null) node.slots = {};
+	return node.slots;
+}
+function addChild(node, key, child) {
+	ensureSlots(node)[key] = child;
+}
+function routeTreeSegment(segment) {
+	if (segment.startsWith(":")) {
+		const rest = segment.slice(1);
+		if (rest.endsWith("+")) return dynamicRouteTreeSegment(rest.slice(0, -1), "c");
+		if (rest.endsWith("*")) return dynamicRouteTreeSegment(rest.slice(0, -1), "oc");
+		return dynamicRouteTreeSegment(rest, "d");
+	}
+	if (segment.startsWith("[[...") && segment.endsWith("]]")) return dynamicRouteTreeSegment(segment.slice(5, -2), "oc");
+	if (segment.startsWith("[...") && segment.endsWith("]")) return dynamicRouteTreeSegment(segment.slice(4, -1), "c");
+	if (segment.startsWith("[") && segment.endsWith("]")) return dynamicRouteTreeSegment(segment.slice(1, -1), "d");
+	return {
+		name: segment,
+		param: null
+	};
+}
+function dynamicRouteTreeSegment(name, type) {
+	return {
+		name,
+		param: {
+			key: null,
+			siblings: null,
+			type
+		}
+	};
+}
+function explicitPrefetchSize(module) {
+	if (typeof module !== "object" || module === null) return null;
+	const value = module.prefetchSize;
+	if (value === "large") return SEGMENT_OUTLINE_SIZE;
+	if (value === "small") return SEGMENT_INLINE_SIZE;
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function estimatePrefetchSize(module) {
+	const explicitSize = explicitPrefetchSize(module);
+	if (explicitSize !== null) return explicitSize;
+	if (typeof module !== "object" || module === null) return null;
+	return typeof module.default === "function" ? SEGMENT_INLINE_SIZE : null;
+}
+function layoutModuleByTreePosition(route) {
+	const layouts = route.layouts ?? [];
+	const positions = route.layoutTreePositions ?? [];
+	const byPosition = /* @__PURE__ */ new Map();
+	for (const [index, position] of positions.entries()) byPosition.set(position, layouts[index]);
+	return byPosition;
+}
+function modulesByTreePosition(modules, positions) {
+	const byPosition = /* @__PURE__ */ new Map();
+	for (const [index, position] of (positions ?? []).entries()) byPosition.set(position, modules?.[index]);
+	return byPosition;
+}
+async function buildTree(route) {
+	const layoutsByPosition = layoutModuleByTreePosition(route);
+	const root = createNode("", layoutsByPosition.get(0));
+	const nodesByPosition = new Map([[0, root]]);
+	let current = root;
+	for (const [index, segment] of route.routeSegments.entries()) {
+		const position = index + 1;
+		const child = createNode(segment, layoutsByPosition.get(position));
+		addChild(current, "children", child);
+		nodesByPosition.set(position, child);
+		current = child;
+	}
+	addChild(current, "children", createNode(PAGE_SEGMENT, route.page));
+	for (const slot of Object.values(route.slots ?? {})) {
+		const ownerPosition = slot.layoutIndex === void 0 || slot.layoutIndex < 0 ? route.routeSegments.length : route.layoutTreePositions?.[slot.layoutIndex] ?? route.routeSegments.length;
+		const owner = nodesByPosition.get(ownerPosition) ?? current;
+		const slotRoot = createNode(SLOT_SEGMENT, slot.layout);
+		let slotCurrent = slotRoot;
+		const slotConfigLayoutsByPosition = modulesByTreePosition(slot.configLayouts, slot.configLayoutTreePositions);
+		const slotRouteSegments = slot.routeSegments ?? [];
+		for (const [index, segment] of slotRouteSegments.entries()) {
+			const position = index + 1;
+			const child = createNode(segment, slotConfigLayoutsByPosition.get(position));
+			addChild(slotCurrent, "children", child);
+			slotCurrent = child;
+		}
+		addChild(slotCurrent, "children", createNode(PAGE_SEGMENT, slot.page ?? slot.default));
+		addChild(owner, slot.name, slotRoot);
+	}
+	return root;
+}
+function computePrefetchHints(node, parentGzipSize, headInlineState, config) {
+	const currentGzipSize = node.prefetchSize;
+	const sizeToInline = currentGzipSize !== null && currentGzipSize < config.maxSize ? currentGzipSize : null;
+	let didInlineIntoChild = false;
+	let acceptingChildInlinedBytes = 0;
+	let smallestChildInlinedBytes = Number.POSITIVE_INFINITY;
+	let hasChildren = false;
+	for (const child of Object.values(node.slots ?? {})) {
+		hasChildren = true;
+		const childInlinedBytes = computePrefetchHints(child, didInlineIntoChild ? null : sizeToInline, headInlineState, config);
+		if ((child.prefetchHints & PARENT_INLINED_INTO_SELF) !== 0) {
+			didInlineIntoChild = true;
+			acceptingChildInlinedBytes = childInlinedBytes;
+		} else if (!didInlineIntoChild && childInlinedBytes < smallestChildInlinedBytes) smallestChildInlinedBytes = childInlinedBytes;
+	}
+	if (!hasChildren) smallestChildInlinedBytes = 0;
+	let hints = node.prefetchHints;
+	if (didInlineIntoChild) hints |= INLINED_INTO_CHILD;
+	let inlinedBytes = didInlineIntoChild ? acceptingChildInlinedBytes : smallestChildInlinedBytes;
+	const isBundleTerminal = !didInlineIntoChild;
+	if (!headInlineState.inlined && isBundleTerminal && node.name === PAGE_SEGMENT && inlinedBytes + HEAD_INLINE_SIZE < config.maxBundleSize) {
+		hints |= HEAD_INLINED_INTO_SELF;
+		inlinedBytes += HEAD_INLINE_SIZE;
+		headInlineState.inlined = true;
+	}
+	if (parentGzipSize !== null) {
+		if (inlinedBytes + parentGzipSize < config.maxBundleSize) {
+			hints |= PARENT_INLINED_INTO_SELF;
+			inlinedBytes += parentGzipSize;
+		}
+	}
+	node.prefetchHints = hints;
+	return inlinedBytes;
+}
+function stripMutableFields(node) {
+	const slots = node.slots === null ? null : Object.fromEntries(Object.entries(node.slots).map(([key, child]) => [key, stripMutableFields(child)]));
+	return {
+		name: node.name,
+		param: node.param,
+		prefetchHints: node.prefetchHints,
+		slots
+	};
+}
+function resolvePrefetchInliningConfig(config) {
+	if (config) return config;
+	return {
+		maxBundleSize: DEFAULT_MAX_INLINE_BUNDLE_SIZE,
+		maxSize: DEFAULT_SEGMENT_INLINE_THRESHOLD
+	};
+}
+async function createRouteTreePrefetchResponse(route, options = {}) {
+	const tree = await buildTree(route);
+	computePrefetchHints(tree, null, { inlined: false }, resolvePrefetchInliningConfig(options.prefetchInlining));
+	const headers = new Headers({
+		"Cache-Control": "no-store",
+		"Content-Type": VINEXT_RSC_CONTENT_TYPE,
+		[NEXT_DID_POSTPONE_HEADER]: "2",
+		Vary: VINEXT_RSC_VARY_HEADER
+	});
+	applyRscCompatibilityIdHeader(headers);
+	const deploymentId = options.deploymentId ?? getDeploymentId();
+	if (deploymentId) headers.set(NEXTJS_DEPLOYMENT_ID_HEADER, deploymentId);
+	const payload = {
+		tree: stripMutableFields(tree),
+		staleTime: -1
+	};
+	if (options.buildId) payload.buildId = options.buildId;
+	return new Response(`0:${JSON.stringify(payload)}\n`, { headers });
+}
+//#endregion
+export { createRouteTreePrefetchResponse, isRouteTreePrefetchRequest };

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

@@ -4,8 +4,8 @@ import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "../utils/protocol-headers.
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
-import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 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 rscHandler, { __assetPrefix, __basePath, __imageAllowedWidths, __imageConfig } from "virtual:vinext-rsc-entry";

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

@@ -24,6 +24,7 @@ type ResolveInvalidRscCacheBustingRequestOptions = {
 };
 declare function getVinextRscCompatibilityId(): string | null;
 declare function applyRscCompatibilityIdHeader(headers: Headers, compatibilityId?: string | null | undefined): void;
+declare function applyRscDeploymentIdHeader(headers: Headers): void;
 declare function isRscCompatibilityIdCompatible(responseCompatibilityId: string | null | undefined, clientCompatibilityId?: string | null | undefined): boolean;
 type RscCompatibilityNavigationDecision = {
   kind: "compatible";
@@ -61,4 +62,4 @@ declare function createServerActionRequestUrl(href: string): string;
 declare function createRscRedirectLocation(location: string, request: Request): Promise<string>;
 declare function resolveInvalidRscCacheBustingRequest(options: ResolveInvalidRscCacheBustingRequestOptions): Promise<Response | null>;
 //#endregion
-export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };

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

@@ -1,7 +1,7 @@
-import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, 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 { NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, 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 { fnv1a64 } from "../utils/hash.js";
 import { parseAppRscRenderMode } from "./app-rsc-render-mode.js";
-import { applyDeploymentIdHeader } from "../utils/deployment-id.js";
+import { applyDeploymentIdHeader, getDeploymentId } from "../utils/deployment-id.js";
 //#region src/server/app-rsc-cache-busting.ts
 /**
 * RSC cache-busting hashes cover the headers that make an RSC payload vary.
@@ -14,7 +14,6 @@ const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-Id";
 const VINEXT_RSC_CONTENT_TYPE = "text/x-component";
 const VINEXT_RSC_VARY_HEADER = [
 	"RSC",
-	"Accept",
 	NEXT_ROUTER_STATE_TREE_HEADER,
 	NEXT_ROUTER_PREFETCH_HEADER,
 	NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,
@@ -44,6 +43,11 @@ function applyRscCompatibilityIdHeader(headers, compatibilityId = getVinextRscCo
 	if (normalized) headers.set(VINEXT_RSC_COMPATIBILITY_ID_HEADER, normalized);
 	else headers.delete(VINEXT_RSC_COMPATIBILITY_ID_HEADER);
 }
+function applyRscDeploymentIdHeader(headers) {
+	const deploymentId = getDeploymentId();
+	if (deploymentId) headers.set(NEXTJS_DEPLOYMENT_ID_HEADER, deploymentId);
+	else headers.delete(NEXTJS_DEPLOYMENT_ID_HEADER);
+}
 function isRscCompatibilityIdCompatible(responseCompatibilityId, clientCompatibilityId = getVinextRscCompatibilityId()) {
 	const normalizedResponseCompatibilityId = normalizeCompatibilityId(responseCompatibilityId);
 	const normalizedClientCompatibilityId = normalizeCompatibilityId(clientCompatibilityId);
@@ -184,7 +188,7 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	const url = new URL(options.request.url);
 	const actualHash = url.searchParams.get(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM);
 	const expectedHash = await computeRscCacheBustingSearchParam(options.request.headers);
-	if (actualHash === null && expectedHash === "") return null;
+	if (actualHash === null && expectedHash === "" && url.pathname.endsWith(".rsc")) return null;
 	const acceptedHashes = new Set([expectedHash]);
 	if (actualHash !== null && actualHash !== expectedHash) {
 		acceptedHashes.add(computeLegacyRscCacheBustingSearchParam(options.request.headers));
@@ -203,4 +207,4 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	});
 }
 //#endregion
-export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };

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

@@ -6,6 +6,7 @@ import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
 import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
+import { AppRouteTreePrefetchRoute, PrefetchInliningConfig } from "./app-route-tree-prefetch.js";
 import { ReactFormState } from "react-dom/client";
 
 //#region src/server/app-rsc-handler.d.ts
@@ -24,12 +25,15 @@ type AppRscHandlerRoute = {
   __loadPage?: unknown;
   __loadRouteHandler?: unknown;
   isDynamic: boolean;
+  layouts?: readonly unknown[];
+  layoutTreePositions?: readonly number[];
   params?: readonly string[];
   page?: unknown;
   pattern: string;
   rootParamNames?: readonly string[];
   routeHandler?: unknown;
   routeSegments: readonly string[];
+  slots?: AppRouteTreePrefetchRoute["slots"];
 };
 type AppRscRouteMatch<TRoute> = {
   params: AppPageParams;
@@ -63,6 +67,7 @@ type DispatchMatchedPageOptions<TRoute> = {
   staticParamsValidationParams?: AppPageParams;
   rootParams?: RootParams;
   request: Request;
+  renderedPathAndSearch?: string | null;
   route: TRoute;
   scriptNonce?: string;
   searchParams: URLSearchParams;
@@ -189,6 +194,7 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   matchRoute: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   runMiddleware?: (options: RunAppMiddlewareOptions) => Promise<ApplyAppMiddlewareResult>;
   publicFiles: ReadonlySet<string>;
+  prefetchInlining?: PrefetchInliningConfig;
   renderNotFound: (options: RenderNotFoundOptions<TRoute>) => Promise<Response | null>;
   renderPagesFallback?: (options: RenderPagesFallbackOptions) => Promise<Response | null>;
   rootParamNamesByPattern?: RootParamNamesMap;

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

@@ -1,7 +1,7 @@
 import { 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 } from "../utils/protocol-headers.js";
+import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
 import { ACTION_REVALIDATED_HEADER } from "./headers.js";
 import { isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { notFoundResponse } from "./http-error-responses.js";
@@ -23,6 +23,7 @@ import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } fr
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
 import { pickRootParams, setRootParams } from "../shims/root-params.js";
+import { createRouteTreePrefetchResponse, isRouteTreePrefetchRequest } from "./app-route-tree-prefetch.js";
 import { flattenErrorCauses } from "../utils/error-cause.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
@@ -163,10 +164,10 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			headers: { Location: location }
 		});
 	}
-	const rscCacheBustingRedirect = await resolveInvalidRscCacheBustingRequest({
+	const rscCacheBustingRedirect = hadBasePath ? await resolveInvalidRscCacheBustingRequest({
 		isRscRequest,
 		request
-	});
+	}) : null;
 	if (rscCacheBustingRedirect) return rscCacheBustingRedirect;
 	const normalizedUserlandRequest = requestWithoutRscSuffix(request);
 	const userlandRequest = requestWithoutRscCacheBustingSearchParam(normalizedUserlandRequest);
@@ -200,6 +201,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareContext.headers);
 	const postMiddlewareRequestContext = buildPostMwRequestContext(userlandRequest);
 	let filesystemRouteEligible = hadBasePath || didMiddlewareRewrite;
+	const validateClaimedOutsideBasePathRsc = async () => {
+		if (hadBasePath || !filesystemRouteEligible) return null;
+		return resolveInvalidRscCacheBustingRequest({
+			isRscRequest,
+			request
+		});
+	};
 	for (const rewrite of options.configRewrites.beforeFiles) {
 		const beforeFilesRewrite = await applyRewrite({
 			basePathState,
@@ -215,6 +223,51 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			filesystemRouteEligible = true;
 		}
 	}
+	const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
+	if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
+	const actionId = request.headers.get("x-rsc-action") ?? request.headers.get("next-action");
+	const isPostRequest = request.method.toUpperCase() === "POST";
+	const contentType = request.headers.get("content-type") || "";
+	const isProgressiveActionRequest = isPostRequest && !actionId && contentType.startsWith("multipart/form-data");
+	let resolvedLateRewritesForAction = false;
+	if (!filesystemRouteEligible && (actionId || isProgressiveActionRequest)) {
+		let actionMatch = null;
+		for (const rewrite of options.configRewrites.afterFiles) {
+			const rewritten = await applyRewrite({
+				basePathState,
+				clearRequestContext: options.clearRequestContext,
+				request: normalizedUserlandRequest,
+				requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+				rewrites: [rewrite]
+			}, matchPathname(cleanPathname));
+			if (rewritten instanceof Response) return rewritten;
+			if (!rewritten) continue;
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
+			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+			filesystemRouteEligible = true;
+			actionMatch = options.matchRoute(cleanPathname);
+			if (actionMatch) break;
+		}
+		if (!actionMatch) for (const rewrite of options.configRewrites.fallback) {
+			const rewritten = await applyRewrite({
+				basePathState,
+				clearRequestContext: options.clearRequestContext,
+				request: normalizedUserlandRequest,
+				requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+				rewrites: [rewrite]
+			}, matchPathname(cleanPathname));
+			if (rewritten instanceof Response) return rewritten;
+			if (!rewritten) continue;
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
+			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+			filesystemRouteEligible = true;
+			actionMatch = options.matchRoute(cleanPathname);
+			if (actionMatch) break;
+		}
+		resolvedLateRewritesForAction = filesystemRouteEligible;
+	}
+	const lateActionRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
+	if (lateActionRscCacheBustingRedirect) return lateActionRscCacheBustingRedirect;
 	if (filesystemRouteEligible && isImageOptimizationPath(cleanPathname)) {
 		const imageRedirect = resolveDevImageRedirect(url, [...options.imageConfig?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...options.imageConfig?.imageSizes ?? DEFAULT_IMAGE_SIZES], options.imageConfig?.qualities, { isDev: options.isDev });
 		if (!imageRedirect) return new Response("Invalid image optimization parameters", { status: 400 });
@@ -255,9 +308,18 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	});
 	const preActionMatch = filesystemRouteEligible ? options.matchRoute(cleanPathname) : null;
 	if (preActionMatch) setRootParams(pickRootParams(preActionMatch.params, preActionMatch.route.rootParamNames));
-	const actionId = request.headers.get("x-rsc-action") ?? request.headers.get("next-action");
-	const contentType = request.headers.get("content-type") || "";
-	const isPostRequest = request.method.toUpperCase() === "POST";
+	if (pagesDataRequest && didMiddlewareRewritePathname && preActionMatch) {
+		const headers = new Headers();
+		mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+		headers.set("content-type", "application/json");
+		headers.set("x-nextjs-rewrite", resolvedUrl);
+		options.clearRequestContext();
+		return new Response("{}", { headers });
+	}
+	if (!filesystemRouteEligible && isPostRequest && actionId) {
+		options.clearRequestContext();
+		return notFoundResponse();
+	}
 	let progressiveActionResult = null;
 	if (filesystemRouteEligible && isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) {
 		if (options.handleProgressiveActionRequest) progressiveActionResult = await options.handleProgressiveActionRequest({
@@ -322,7 +384,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		options.clearRequestContext();
 		return staticPagesFallbackResponse;
 	}
-	if (!match || match.route.isDynamic) for (const rewrite of options.configRewrites.afterFiles) {
+	if (!resolvedLateRewritesForAction && (!match || match.route.isDynamic)) for (const rewrite of options.configRewrites.afterFiles) {
 		const afterFilesRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
@@ -335,6 +397,8 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, afterFilesRewrite);
 		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
 		filesystemRouteEligible = true;
+		const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
+		if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
 		match = options.matchRoute(cleanPathname);
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
@@ -353,7 +417,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		options.clearRequestContext();
 		return dynamicPagesFallbackResponse;
 	}
-	if (!match) for (const rewrite of options.configRewrites.fallback) {
+	if (!resolvedLateRewritesForAction && !match) for (const rewrite of options.configRewrites.fallback) {
 		const fallbackRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
@@ -366,6 +430,8 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
 		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
 		filesystemRouteEligible = true;
+		const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
+		if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
 		match = options.matchRoute(cleanPathname);
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
@@ -391,6 +457,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			const response = buildNextDataNotFoundResponse();
 			const headers = new Headers(response.headers);
 			headers.set("x-nextjs-matched-path", matchPathname(canonicalPathname));
+			if (resolvedUrl !== originalResolvedUrl) headers.set("x-nextjs-rewrite", resolvedUrl);
 			return new Response("{}", {
 				status: 200,
 				headers
@@ -418,11 +485,19 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}
 	const { route, params } = match;
 	if (options.ensureRouteLoaded) await options.ensureRouteLoaded(route);
+	const resolvedSearchParams = getResolvedSearchParams();
+	if (isRouteTreePrefetchRequest(request) && !route.routeHandler) {
+		const response = await createRouteTreePrefetchResponse(route, {
+			buildId: options.buildId,
+			prefetchInlining: options.prefetchInlining
+		});
+		options.clearRequestContext();
+		return applyMiddlewareContextToResponse(response, middlewareContext);
+	}
 	const prerenderRouteParamsMatch = matchPrerenderRouteParamsPayload(readTrustedPrerenderRouteParams(request), route.pattern, params);
 	const prerenderRouteParams = prerenderRouteParamsMatch?.params ?? null;
 	const isPrerenderFallbackShell = prerenderRouteParamsMatch?.kind === "fallback-shell";
 	const renderParams = prerenderRouteParams ?? params;
-	const resolvedSearchParams = getResolvedSearchParams();
 	let runtimeFallbackShells = [];
 	if (options.createPprFallbackShells && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params) runtimeFallbackShells = options.createPprFallbackShells({
 		params: route.params,
@@ -476,6 +551,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		staticParamsValidationParams: prerenderRouteParams === null || isPrerenderFallbackShell ? void 0 : params,
 		rootParams,
 		request,
+		renderedPathAndSearch: resolvedUrl,
 		route,
 		scriptNonce,
 		searchParams: resolvedSearchParams,
@@ -525,14 +601,16 @@ function createAppRscHandler(options) {
 		const pagesDataInScope = !options.basePath || hasBasePath(pagesDataUrl.pathname, options.basePath);
 		if (pagesDataInScope) pagesDataUrl.pathname = stripBasePath(pagesDataUrl.pathname, options.basePath);
 		const pagesDataCandidate = pagesDataInScope ? cloneRequestWithUrl(rawRequest, pagesDataUrl.toString()) : null;
-		const pagesDataNormalization = options.renderPagesFallback && pagesDataCandidate ? normalizePagesDataRequest(pagesDataCandidate, options.buildId) : null;
+		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 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);
 		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);
+		if (isTrustedSpeculativePrerender) filteredHeaders.set(VINEXT_PRERENDER_SPECULATIVE_HEADER, "1");
 		let appRequest = rawRequest;
 		if (pagesDataNormalization?.isDataReq) {
 			const appRequestUrl = new URL(pagesDataNormalization.request.url);

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

@@ -1,11 +1,9 @@
 //#region src/server/app-rsc-render-mode.d.ts
-type AppRscRenderMode = "navigation" | "prefetch-loading-shell" | "refresh-preserve-ui" | "action-rerender-preserve-ui";
+type AppRscRenderMode = "navigation" | "prefetch-dynamic-shell" | "prefetch-loading-shell";
 declare const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
+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 const APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI = "refresh-preserve-ui";
-declare const APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI = "action-rerender-preserve-ui";
-declare function shouldSuppressLoadingBoundaries(mode: AppRscRenderMode): boolean;
 declare function getRscRenderModeCacheVariant(mode: AppRscRenderMode): string | null;
 declare function parseAppRscRenderMode(value: string | null): AppRscRenderMode;
 //#endregion
-export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };
+export { APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode };