vinext 0.1.7 → 0.2.0

package/dist/server/app-page-segment-state.js

@@ -1,5 +1,6 @@
 import { isCatchAllSegment, isOptionalCatchAllSegment } from "../routing/utils.js";
 //#region src/server/app-page-segment-state.ts
+const APP_PAGE_SEGMENT_KEY = "__PAGE__";
 function isDynamicSegment(segment) {
 	return segment.startsWith("[") && segment.endsWith("]") && !segment.includes(".");
 }
@@ -58,6 +59,7 @@ function resolveAppPageChildSegments(routeSegments, treePosition, params) {
 		}
 		resolvedSegments.push(segment);
 	}
+	resolvedSegments.push(APP_PAGE_SEGMENT_KEY);
 	return resolvedSegments;
 }
 function resolveAppPageSegmentStateKey(routeSegments, treePosition, params) {
@@ -77,4 +79,4 @@ function resolveAppPageLeafSegmentStateKey(routeSegments, params) {
 	return "";
 }
 //#endregion
-export { resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };
+export { APP_PAGE_SEGMENT_KEY, resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };

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

@@ -1,6 +1,7 @@
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { RootParams } from "../shims/root-params.js";
+import { InitialNavigationCacheMetadata } from "./app-ssr-stream.js";
 import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { ReactFormState } from "react-dom/client";
 
@@ -72,9 +73,13 @@ type AppPageSsrHandler = {
      *  default `__next_error__` error-document shell (with the original
      *  flight payload and bootstrap) instead of rejecting. See handleSsr. */
     fallbackToErrorDocumentOnShellError?: boolean;
+    dynamicStaleTimeSeconds?: number;
+    getInitialNavigationCacheMetadata?: () => InitialNavigationCacheMetadata;
   }) => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
 };
 type RenderAppPageHtmlStreamOptions = {
+  dynamicStaleTimeSeconds?: number;
+  getInitialNavigationCacheMetadata?: () => InitialNavigationCacheMetadata;
   fontData: AppPageFontData;
   formState?: ReactFormState | null;
   navigationContext: NavigationContext | null;

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

@@ -68,7 +68,9 @@ async function renderAppPageHtmlStream(options) {
 		pprFallbackShellSignal: options.pprFallbackShellSignal,
 		waitForAllReady: options.waitForAllReady,
 		initialDevServerError: options.initialDevServerError,
-		fallbackToErrorDocumentOnShellError: options.waitForAllReady !== true && options.hasCustomGlobalError === false
+		fallbackToErrorDocumentOnShellError: options.waitForAllReady !== true && options.hasCustomGlobalError === false,
+		dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
+		getInitialNavigationCacheMetadata: options.getInitialNavigationCacheMetadata
 	};
 	return normalizeAppSsrRenderResult(await options.ssrHandler.handleSsr(options.rscStream, options.navigationContext, options.fontData, ssrOptions), options.capturedRscDataRef?.value ?? null);
 }

package/dist/server/app-ppr-fallback-shell-render.d.ts

@@ -4,7 +4,7 @@ import { ReactNode } from "react";
 //#region src/server/app-ppr-fallback-shell-render.d.ts
 type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
 type AppPageRenderableElement = ReactNode | Record<string, ReactNode>;
-declare function warmPprFallbackShellCaches(options: {
+type WarmPprFallbackShellCachesOptions = {
   element: AppPageRenderableElement;
   onError: AppPageBoundaryOnError;
   renderToReadableStream: (element: AppPageRenderableElement, options: {
@@ -12,6 +12,7 @@ declare function warmPprFallbackShellCaches(options: {
     signal?: AbortSignal;
   }) => ReadableStream<Uint8Array>;
   state: PprFallbackShellState;
-}): Promise<void>;
+};
+declare function warmPprFallbackShellCaches(options: WarmPprFallbackShellCachesOptions): Promise<void>;
 //#endregion
-export { warmPprFallbackShellCaches };
+export { WarmPprFallbackShellCachesOptions, warmPprFallbackShellCaches };

package/dist/server/app-route-handler-dispatch.js

@@ -24,6 +24,7 @@ function buildRouteHandlerPageCacheTags(pathname, extraTags, routeSegments) {
 async function runInRouteHandlerRevalidationContext(options, renderFn) {
 	await runWithRequestContext(createRequestContext({
 		headersContext: createStaticGenerationHeadersContext({
+			draftModeEnabled: false,
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig: options.dynamicConfig,
 			routeKind: "route",

package/dist/server/app-route-handler-execution.js

@@ -1,5 +1,6 @@
-import { setHeadersContext } from "../shims/headers.js";
+import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
 import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+import { runWithRootParamsUsage } from "../shims/root-params.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
 import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
@@ -8,6 +9,7 @@ import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidat
 function configureAppRouteStaticGenerationContext(options) {
 	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") {
 		setHeadersContext(createStaticGenerationHeadersContext({
+			draftModeEnabled: options.draftModeSecret !== void 0 && isDraftModeRequest(options.request, options.draftModeSecret),
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig: options.dynamicConfig,
 			routeKind: "route",
@@ -32,7 +34,10 @@ async function runAppRouteHandler(options) {
 			return getAppRouteStaticGenerationErrorMessage(options.routePattern, expression);
 		}
 	});
-	const response = await options.handlerFn(trackedRequest.request, { params: options.params });
+	const response = await runWithRootParamsUsage({
+		kind: "route-handler",
+		routePattern: options.routePattern ?? new URL(options.request.url).pathname
+	}, () => options.handlerFn(trackedRequest.request, { params: options.params }));
 	return {
 		dynamicUsedInHandler: options.consumeDynamicUsage(),
 		response

package/dist/server/app-route-handler-response.js

@@ -1,3 +1,4 @@
+import "../utils/protocol-headers.js";
 import "./headers.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
 import { setCacheStateHeaders } from "./cache-headers.js";

package/dist/server/app-route-handler-runtime.js

@@ -1,5 +1,5 @@
 import { addBasePathToPathname } from "../utils/base-path.js";
-import { buildRequestHeadersFromMiddlewareResponse } from "./middleware-request-headers.js";
+import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
 //#region src/server/app-route-handler-runtime.ts
 const ROUTE_HANDLER_HTTP_METHODS = [

package/dist/server/app-route-module-loader.d.ts

@@ -36,11 +36,13 @@ type LazyLoadableSlot = {
   page?: unknown;
   default?: unknown;
   layout?: unknown;
+  configLayouts?: readonly unknown[];
   loading?: unknown;
   error?: unknown;
   __loadPage?: LazyModuleThunk | null;
   __loadDefault?: LazyModuleThunk | null;
   __loadLayout?: LazyModuleThunk | null;
+  __loadConfigLayouts?: LazyModuleLoaderArray | null;
   __loadLoading?: LazyModuleThunk | null;
   __loadError?: LazyModuleThunk | null; /** Hydrated only after an intercept matches, not with the slot's base modules. */
   intercepts?: LazyLoadableIntercept[];

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

@@ -61,6 +61,7 @@ function ensureAppRouteModulesLoaded(route) {
 		pushFieldLoad(loads, slot, "page", slot.__loadPage);
 		pushFieldLoad(loads, slot, "default", slot.__loadDefault);
 		pushFieldLoad(loads, slot, "layout", slot.__loadLayout);
+		pushArrayLoads(loads, slot.configLayouts, slot.__loadConfigLayouts);
 		pushFieldLoad(loads, slot, "loading", slot.__loadLoading);
 		pushFieldLoad(loads, slot, "error", slot.__loadError);
 	}

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

@@ -1,14 +1,16 @@
 import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_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";
+import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
-import { resolveStaticAssetSignal } from "./worker-utils.js";
+import { finalizeMissingStaticAssetResponse, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
-import rscHandler, { __assetPrefix, __basePath } from "virtual:vinext-rsc-entry";
+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";
 //#region src/server/app-router-entry.ts
 const __workerBasePath = typeof __basePath === "string" ? __basePath : "";
 const __workerAssetPathPrefix = assetPrefixPathname(typeof __assetPrefix === "string" ? __assetPrefix : "");
@@ -17,14 +19,19 @@ var app_router_entry_default = { async fetch(request, env, ctx) {
 } };
 async function handleRequest(request, env, ctx) {
 	registerConfiguredCacheAdapters(env);
+	registerConfiguredImageOptimizer(env);
 	const url = new URL(request.url);
+	if (isImageOptimizationPath(url.pathname) && env?.ASSETS && getImageOptimizer()) {
+		const assetFetcher = env.ASSETS;
+		return handleConfiguredImageOptimization(request, (assetPath) => Promise.resolve(assetFetcher.fetch(new Request(new URL(assetPath, request.url)))), __imageAllowedWidths, __imageConfig);
+	}
 	if (isOpenRedirectShaped(url.pathname)) return notFoundResponse();
 	try {
 		decodeURIComponent(url.pathname);
 	} catch {
 		return badRequestResponse();
 	}
-	if (isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix)) return notFoundStaticAssetResponse();
+	const missingBuildAsset = isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix);
 	{
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
 		const filteredHeaders = filterInternalHeaders(request.headers);
@@ -35,14 +42,15 @@ async function handleRequest(request, env, ctx) {
 	const handleFn = () => rscHandler(request, ctx);
 	const result = await (ctx ? runWithExecutionContext(ctx, handleFn) : handleFn());
 	if (result instanceof Response) {
+		let response = result;
 		if (env?.ASSETS) {
 			const assetFetcher = env.ASSETS;
-			const assetResponse = await resolveStaticAssetSignal(result, { fetchAsset: (path) => Promise.resolve(assetFetcher.fetch(new Request(new URL(path, request.url)))) });
-			if (assetResponse) return assetResponse;
+			const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path) => Promise.resolve(assetFetcher.fetch(new Request(new URL(path, request.url)))) });
+			if (assetResponse) response = assetResponse;
 		}
-		return result;
+		return finalizeMissingStaticAssetResponse(response, missingBuildAsset);
 	}
-	if (result === null || result === void 0) return notFoundResponse();
+	if (result === null || result === void 0) return missingBuildAsset ? notFoundStaticAssetResponse() : notFoundResponse();
 	return new Response(String(result), { status: 200 });
 }
 //#endregion

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

@@ -53,7 +53,13 @@ function createRscOnErrorHandler(options) {
 		}
 		if (options.requestInfo && options.errorContext && error) options.reportRequestError(error instanceof Error ? error : new Error(getThrownValueMessage(error)), options.requestInfo, options.errorContext);
 		if (hasDigest(error)) return String(error.digest);
-		if (nodeEnv === "production" && error) return errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
+		if (error) {
+			const digest = errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
+			if (error instanceof Error) try {
+				Object.assign(error, { digest });
+			} catch {}
+			return digest;
+		}
 	};
 }
 //#endregion

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

@@ -4,6 +4,7 @@ import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware.js";
 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 { ReactFormState } from "react-dom/client";
 
@@ -15,6 +16,7 @@ type AppRscMiddlewareContext = AppMiddlewareContext;
 type RunAppMiddlewareOptions = {
   cleanPathname: string;
   context: AppRscMiddlewareContext;
+  hadBasePath: boolean;
   isDataRequest: boolean;
   request: Request;
 };
@@ -151,7 +153,6 @@ type NavigationContextValue = {
 type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   basePath: string;
   buildId: string | null;
-  cacheComponents?: boolean;
   clearRequestContext: () => void;
   configHeaders: NextHeader[];
   configRedirects: NextRedirect[];
@@ -179,6 +180,7 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   registerCacheAdapters: (env?: Record<string, unknown>) => void;
   handleProgressiveActionRequest?: (options: HandleProgressiveActionRequestOptions) => Promise<Response | ProgressiveActionFormStateResult | null>;
   handleMetadataRouteRequest?: (cleanPathname: string) => Promise<Response | null>;
+  createPprFallbackShells?: (route: Pick<AppRscHandlerRoute, "params" | "pattern" | "rootParamNames">, params: AppPageParams) => AppPagePprFallbackCacheShell[];
   handleServerActionRequest?: (options: HandleServerActionRequestOptions) => Promise<Response | null>;
   i18nConfig: NextI18nConfig | null;
   imageConfig?: ImageConfig;

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

@@ -1,7 +1,8 @@
 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 { ACTION_REVALIDATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
+import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_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";
 import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute } from "./request-pipeline.js";
@@ -10,18 +11,19 @@ import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.
 import { mergeRewriteQuery } from "../utils/query.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, resolveDevImageRedirect } from "./image-optimization.js";
 import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
-import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
+import { parseNextHttpErrorDigest } from "./next-error-digest.js";
 import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
-import { flattenErrorCauses } from "../utils/error-cause.js";
-import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
+import { pickRootParams, setRootParams } from "../shims/root-params.js";
+import { flattenErrorCauses } from "../utils/error-cause.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
 import { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
@@ -53,8 +55,8 @@ function createMissingServerActionResponse(options, actionId) {
 	options.clearRequestContext();
 	return createServerActionNotFoundResponse();
 }
-function redirectDestinationWithBasePath(destination, basePath) {
-	if (!basePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
+function redirectDestinationWithBasePath(destination, basePath, hadBasePath) {
+	if (!basePath || !hadBasePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
 	return basePath + destination;
 }
 async function applyRewrite(options, cleanPathname) {
@@ -111,15 +113,22 @@ function requestWithoutRscSuffix(request) {
 	url.pathname = pathname;
 	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
 }
-async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest) {
+async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, isMiddlewareDataRequest, pagesDataRequest) {
 	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
 	if (process.env.NODE_ENV !== "production") {
 		const originBlock = options.validateDevRequestOrigin?.(request);
 		if (originBlock) return originBlock;
 	}
-	const normalized = normalizeRscRequest(request, options.basePath);
+	const canHandleOutsideBasePath = Boolean(options.runMiddleware) || [
+		...options.configRedirects,
+		...options.configRewrites.beforeFiles,
+		...options.configRewrites.afterFiles,
+		...options.configRewrites.fallback,
+		...options.configHeaders
+	].some((rule) => rule.basePath === false);
+	const normalized = normalizeRscRequest(request, options.basePath, canHandleOutsideBasePath);
 	if (normalized instanceof Response) return normalized;
-	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest } = normalized;
+	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest, hadBasePath } = normalized;
 	let { pathname, cleanPathname } = normalized;
 	let resolvedUrl = cleanPathname + url.search;
 	const originalResolvedUrl = resolvedUrl;
@@ -127,7 +136,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const canonicalPathname = cleanPathname;
 	const basePathState = {
 		basePath: options.basePath,
-		hadBasePath: true
+		hadBasePath
 	};
 	if (pathname === "/__vinext/prerender/static-params" || pathname === "/__vinext/prerender/pages-static-paths") {
 		const { handleAppPrerenderEndpoint } = await import("./app-prerender-endpoints.js");
@@ -142,17 +151,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		});
 		if (prerenderEndpointResponse) return prerenderEndpointResponse;
 	}
-	const trailingSlashRedirect = normalizeTrailingSlash(pathname, options.basePath, options.trailingSlash, url.search);
+	const trailingSlashRedirect = normalizeTrailingSlash(pathname, hadBasePath ? options.basePath : "", options.trailingSlash, url.search);
 	if (trailingSlashRedirect) return trailingSlashRedirect;
 	const matchPathname = (p) => normalizeDefaultLocalePathname(p, options.i18nConfig, { hostname: url.hostname });
 	const redirect = matchRedirect(matchPathname(stripRscSuffix(pathname)), options.configRedirects, preMiddlewareRequestContext, basePathState);
 	if (redirect) {
-		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath));
+		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath, hadBasePath));
 		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : preserveRedirectDestinationQuery(destination, url.search);
-		if (isDataRequest) return new Response(null, {
-			status: 200,
-			headers: { "x-nextjs-redirect": location }
-		});
 		return new Response(null, {
 			status: redirect.permanent ? 308 : 307,
 			headers: { Location: location }
@@ -171,11 +176,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		status: null
 	};
 	let didMiddlewareRewrite = false;
+	let didMiddlewareRewritePathname = false;
 	if (options.runMiddleware) {
 		const middlewareResult = await options.runMiddleware({
 			cleanPathname,
 			context: middlewareContext,
-			isDataRequest,
+			hadBasePath,
+			isDataRequest: isMiddlewareDataRequest,
 			request: userlandRequest
 		});
 		if (middlewareResult.kind === "response") return applyConfigHeadersToMiddlewareRedirect(middlewareResult.response, {
@@ -185,12 +192,14 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			requestContext: preMiddlewareRequestContext
 		});
 		cleanPathname = middlewareResult.cleanPathname;
-		didMiddlewareRewrite = cleanPathname !== normalized.cleanPathname;
+		didMiddlewareRewrite = middlewareResult.rewritten;
+		didMiddlewareRewritePathname = cleanPathname !== normalized.cleanPathname;
 		if (middlewareResult.search !== null) url.search = middlewareResult.search;
 		resolvedUrl = cleanPathname + url.search;
 	}
 	const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareContext.headers);
 	const postMiddlewareRequestContext = buildPostMwRequestContext(userlandRequest);
+	let filesystemRouteEligible = hadBasePath || didMiddlewareRewrite;
 	for (const rewrite of options.configRewrites.beforeFiles) {
 		const beforeFilesRewrite = await applyRewrite({
 			basePathState,
@@ -203,14 +212,15 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (beforeFilesRewrite) {
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, beforeFilesRewrite);
 			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+			filesystemRouteEligible = true;
 		}
 	}
-	if (isImageOptimizationPath(cleanPathname)) {
+	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 });
 		return Response.redirect(new URL(imageRedirect, url.origin).href, 302);
 	}
-	if (options.handleMetadataRouteRequest) {
+	if (filesystemRouteEligible && options.handleMetadataRouteRequest) {
 		const metadataRouteResponse = await options.handleMetadataRouteRequest(cleanPathname);
 		if (metadataRouteResponse) {
 			applyConfigHeadersToResponse(metadataRouteResponse.headers, {
@@ -223,13 +233,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
 		}
 	}
-	const publicFileResponse = resolvePublicFileRoute({
+	const publicFileResponse = filesystemRouteEligible ? resolvePublicFileRoute({
 		cleanPathname,
 		middlewareContext,
 		pathname,
 		publicFiles: options.publicFiles,
 		request
-	});
+	}) : null;
 	if (publicFileResponse) {
 		options.clearRequestContext();
 		return publicFileResponse;
@@ -243,13 +253,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: getResolvedSearchParams(),
 		params: {}
 	});
-	const preActionMatch = options.matchRoute(cleanPathname);
+	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";
 	let progressiveActionResult = null;
-	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) {
+	if (filesystemRouteEligible && isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) {
 		if (options.handleProgressiveActionRequest) progressiveActionResult = await options.handleProgressiveActionRequest({
 			actionId,
 			cleanPathname,
@@ -266,7 +276,11 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const failedProgressiveActionResult = progressiveActionFormState && "actionError" in progressiveActionFormState ? progressiveActionFormState : null;
 	const actionFailed = failedProgressiveActionResult !== null;
 	const actionError = failedProgressiveActionResult?.actionError;
-	const serverActionResponse = isPostRequest && actionId && options.handleServerActionRequest ? await options.handleServerActionRequest({
+	const actionErrorDigest = actionError && typeof actionError === "object" && "digest" in actionError ? String(actionError.digest) : null;
+	const actionHttpFallbackStatus = actionErrorDigest ? parseNextHttpErrorDigest(actionErrorDigest)?.status ?? null : null;
+	const normalizedProgressiveActionError = actionHttpFallbackStatus === null || actionHttpFallbackStatus === 404 ? actionError : { digest: "NEXT_NOT_FOUND" };
+	if (actionFailed && middlewareContext.status === null && actionHttpFallbackStatus === null) middlewareContext.status = 500;
+	const serverActionResponse = filesystemRouteEligible && isPostRequest && actionId && options.handleServerActionRequest ? await options.handleServerActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -278,12 +292,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: getResolvedSearchParams()
 	}) : null;
 	if (serverActionResponse) return serverActionResponse;
-	if (isPostRequest && actionId && !options.handleServerActionRequest) return createMissingServerActionResponse(options, actionId);
+	if (filesystemRouteEligible && isPostRequest && actionId && !options.handleServerActionRequest) return createMissingServerActionResponse(options, actionId);
 	let match = preActionMatch;
 	const renderPagesForMatchKind = async (matchKind) => {
+		if (!filesystemRouteEligible) return null;
 		const response = match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
 			appRouteMatch: match ?? null,
-			allowRscDocumentFallback: didMiddlewareRewrite,
+			allowRscDocumentFallback: didMiddlewareRewritePathname,
 			isDataRequest,
 			isRscRequest,
 			matchKind,
@@ -319,6 +334,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (!afterFilesRewrite) continue;
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, afterFilesRewrite);
 		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		filesystemRouteEligible = true;
 		match = options.matchRoute(cleanPathname);
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
@@ -349,6 +365,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (!fallbackRewrite) continue;
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
 		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		filesystemRouteEligible = true;
 		match = options.matchRoute(cleanPathname);
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
@@ -362,8 +379,23 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		}
 		if (match) break;
 	}
+	if (!filesystemRouteEligible) {
+		options.clearRequestContext();
+		const headers = new Headers();
+		mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+		return notFoundResponse({ headers });
+	}
 	if (pagesDataRequest) {
 		options.clearRequestContext();
+		if (options.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));
+			return new Response("{}", {
+				status: 200,
+				headers
+			});
+		}
 		return buildNextDataNotFoundResponse();
 	}
 	if (!match) {
@@ -392,14 +424,11 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const renderParams = prerenderRouteParams ?? params;
 	const resolvedSearchParams = getResolvedSearchParams();
 	let runtimeFallbackShells = [];
-	if (options.cacheComponents === true && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params) {
-		const { createAppPprFallbackShells } = await import("./app-ppr-fallback-shell.js");
-		runtimeFallbackShells = createAppPprFallbackShells({
-			params: route.params,
-			pattern: route.pattern,
-			rootParamNames: route.rootParamNames
-		}, params);
-	}
+	if (options.createPprFallbackShells && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params) runtimeFallbackShells = options.createPprFallbackShells({
+		params: route.params,
+		pattern: route.pattern,
+		rootParamNames: route.rootParamNames
+	}, params);
 	options.setNavigationContext({
 		pathname: canonicalPathname,
 		searchParams: resolvedSearchParams,
@@ -428,7 +457,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		cleanPathname,
 		displayPathname: canonicalPathname,
 		formState,
-		actionError,
+		actionError: normalizedProgressiveActionError,
 		actionFailed,
 		handlerStart,
 		interceptionContext: interceptionContextHeader,
@@ -492,14 +521,13 @@ function createAppRscHandler(options) {
 		options.registerCacheAdapters();
 		await options.ensureInstrumentation?.();
 		const mwCtx = rawRequest.headers.get(VINEXT_MW_CTX_HEADER);
-		const hasDataRequestHeader = rawRequest.headers.get("x-nextjs-data") === "1";
 		const pagesDataUrl = new URL(rawRequest.url);
 		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;
 		if (pagesDataNormalization?.notFoundResponse) return pagesDataNormalization.notFoundResponse;
-		const isDataRequest = hasDataRequestHeader || pagesDataNormalization?.isDataReq === true;
+		const isPagesDataRequest = pagesDataNormalization?.isDataReq === true;
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(rawRequest);
 		const filteredHeaders = filterInternalHeaders(rawRequest.headers);
 		if (mwCtx !== null) filteredHeaders.set(VINEXT_MW_CTX_HEADER, mwCtx);
@@ -523,7 +551,7 @@ function createAppRscHandler(options) {
 			const preMiddlewareRequestContext = requestContextFromRequest(request);
 			let response;
 			try {
-				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest);
+				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isPagesDataRequest, isPagesDataRequest, pagesDataRequest);
 			} catch (error) {
 				if (process.env.NODE_ENV !== "production") flattenErrorCauses(error);
 				throw error;

package/dist/server/app-rsc-request-normalization.d.ts

@@ -11,7 +11,8 @@ type NormalizedRscRequest = {
   interceptionContextHeader: string | null; /** Normalized x-vinext-mounted-slots header (deduplicated, sorted). null when absent or blank. */
   mountedSlotsHeader: string | null; /** Semantic RSC payload mode. HTML requests always normalize to "navigation". */
   renderMode: AppRscRenderMode; /** Parsed ClientReuseManifest hint. Verification and skip authorization happen later. */
-  clientReuseManifest: ClientReuseManifestParseResult;
+  clientReuseManifest: ClientReuseManifestParseResult; /** Whether the incoming pathname included the configured basePath. */
+  hadBasePath: boolean;
 };
 /**
  * Normalize an App Router RSC request.
@@ -43,6 +44,6 @@ type NormalizedRscRequest = {
  * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
  *          or a NormalizedRscRequest for valid requests.
  */
-declare function normalizeRscRequest(request: Request, basePath: string): Response | NormalizedRscRequest;
+declare function normalizeRscRequest(request: Request, basePath: string, allowOutsideBasePath?: boolean): Response | NormalizedRscRequest;
 //#endregion
 export { NormalizedRscRequest, normalizeMountedSlotsHeader, normalizeRscRequest };

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

@@ -40,7 +40,7 @@ import { normalizeInterceptionContextHeader } from "./app-interception-context-h
 * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
 *          or a NormalizedRscRequest for valid requests.
 */
-function normalizeRscRequest(request, basePath) {
+function normalizeRscRequest(request, basePath, allowOutsideBasePath = false) {
 	const url = new URL(request.url);
 	const protoGuard = guardProtocolRelativeUrl(url.pathname);
 	if (protoGuard) return protoGuard;
@@ -51,9 +51,11 @@ function normalizeRscRequest(request, basePath) {
 		return badRequestResponse();
 	}
 	let pathname = normalizePath(decoded);
+	let hadBasePath = true;
 	if (basePath) {
-		if (!hasBasePath(pathname, basePath) && !pathname.startsWith("/__vinext/")) return notFoundResponse();
-		pathname = stripBasePath(pathname, basePath);
+		hadBasePath = hasBasePath(pathname, basePath);
+		if (!hadBasePath && !pathname.startsWith("/__vinext/") && !allowOutsideBasePath) return notFoundResponse();
+		if (hadBasePath) pathname = stripBasePath(pathname, basePath);
 	}
 	const isRscRequest = pathname.endsWith(".rsc") || request.headers.get("RSC") === "1" && url.searchParams.has("_rsc");
 	const cleanPathname = stripRscSuffix(pathname);
@@ -62,6 +64,7 @@ function normalizeRscRequest(request, basePath) {
 	const renderMode = isRscRequest ? parseAppRscRenderMode(request.headers.get(VINEXT_RSC_RENDER_MODE_HEADER)) : APP_RSC_RENDER_MODE_NAVIGATION;
 	return {
 		clientReuseManifest: isRscRequest ? parseClientReuseManifestHeader(request.headers.get(VINEXT_CLIENT_REUSE_MANIFEST_HEADER)) : { kind: "absent" },
+		hadBasePath,
 		url,
 		pathname,
 		cleanPathname,