vinext 1.4.0 → 1.4.1

package/dist/server/app-optimistic-routing.js

@@ -3,7 +3,7 @@ import { stripBasePath } from "../utils/base-path.js";
 import { decodeMatchedParams, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { extractRawRoutePatternParams, matchRoutePattern } from "../routing/route-pattern.js";
 import { buildOptimisticRouteTrie, matchOptimisticRouteTrie } from "../routing/optimistic-route-trie.js";
-import { stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { createNestedBfcacheSlotSegmentId, deriveBfcacheSegmentIdentity, isNestedBfcacheSlotSegmentId } from "./bfcache-identity.js";
@@ -36,8 +36,7 @@ function hrefToRouteParts(href, basePath) {
 		return null;
 	}
 	stripRscCacheBustingSearchParam(url);
-	const withoutRscSuffix = stripRscSuffix(url.pathname);
-	const appPathname = stripBasePath(withoutRscSuffix, basePath);
+	const appPathname = stripBasePath(url.pathname, basePath);
 	const pathname = appPathname === "" ? "/" : appPathname;
 	return {
 		normalized: splitPathnameForRouteMatch(pathname),

package/dist/server/app-page-boundary-render.js

@@ -3,13 +3,12 @@ import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
 import { isRenderDynamicLatched, isStaticGenerationAccessError } from "../shims/internal/headers-state.js";
 import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
-import { stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { createArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
 import { ErrorBoundary, GlobalErrorBoundary, SerializedErrorBoundary } from "../shims/error-boundary.js";
-import { buildClientHookErrorMessage } from "../shims/client-hook-error.js";
+import { rewriteClientHookError } from "../shims/client-hook-error.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { withUseCacheLayoutMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { MetadataHead, ViewportHead } from "../shims/metadata.js";
@@ -258,7 +257,7 @@ async function renderAppPageHttpAccessFallback(options) {
 	if (!boundaryComponent) return null;
 	const layoutModules = options.layoutModules ?? options.route?.layouts ?? options.rootLayouts;
 	const pathname = new URL(options.requestUrl).pathname;
-	const routePathname = options.routePathname ?? stripRscSuffix(stripBasePath(pathname, options.basePath ?? ""));
+	const routePathname = options.routePathname ?? stripBasePath(pathname, options.basePath ?? "");
 	const headBoundaryModule = options.headBoundaryModule ?? boundaryModule;
 	const headLayoutModules = options.headLayoutModules ?? layoutModules;
 	const routeSegments = resolveHttpAccessFallbackHeadRouteSegments(options.route, headLayoutModules);
@@ -612,6 +611,7 @@ async function renderAppPageErrorBoundary(options) {
 			skipLayoutWrapping: errorBoundary.isGlobalError
 		});
 	};
+	const isErrorStatus = errorBoundary.isGlobalError || !options.isRscRequest;
 	const renderWith = async (BoundaryComponent) => {
 		const response = await renderAppPageBoundaryElementResponse({
 			...options,
@@ -621,9 +621,9 @@ async function renderAppPageErrorBoundary(options) {
 			navigationParams: matchedParams,
 			route: options.route,
 			routePattern: options.route?.pattern,
-			status: errorBoundary.isGlobalError ? 500 : 200
+			status: isErrorStatus ? 500 : 200
 		});
-		if (errorBoundary.isGlobalError) applyCdnResponseHeaders(response.headers, { cacheControl: NEVER_CACHE_CONTROL });
+		if (isErrorStatus) applyCdnResponseHeaders(response.headers, { cacheControl: NEVER_CACHE_CONTROL });
 		return response;
 	};
 	try {
@@ -636,10 +636,5 @@ async function renderAppPageErrorBoundary(options) {
 		throw renderError;
 	}
 }
-const _clientHookPattern = /\b(useState|useEffect|useReducer|useRef|useContext|useLayoutEffect|useInsertionEffect|useSyncExternalStore|useTransition|useImperativeHandle|useDeferredValue|useActionState|useOptimistic|useEffectEvent)\b.*is not a function/;
-function rewriteClientHookError(error) {
-	const match = error.message.match(_clientHookPattern);
-	if (match) error.message = buildClientHookErrorMessage(`${match[1]}()`);
-}
 //#endregion
 export { renderAppPageErrorBoundary, renderAppPageHttpAccessFallback };

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

@@ -200,7 +200,6 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   hasGenerateStaticParams: boolean;
   /** Whether any segment of the route exports `generateStaticParams`. */
   hasAnyGenerateStaticParams: boolean;
-  hasCustomGlobalError?: boolean;
   hasPageDefaultExport: boolean;
   hasPageModule: boolean;
   handlerStart: number;

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

@@ -692,7 +692,6 @@ async function dispatchAppPageInner(options) {
 			return renderPageSpecialError(options, specialError, serveStreamingMetadata, interceptResult.interceptOpts, renderOptions?.isCacheCandidate === true, renderOptions?.caughtDocument, renderedRouteHead);
 		},
 		renderToReadableStream: options.renderToReadableStream,
-		hasCustomGlobalError: options.hasCustomGlobalError,
 		prerenderToReadableStream: options.prerenderToReadableStream,
 		routePattern: route.pattern,
 		scriptNonce: options.scriptNonce,

package/dist/server/app-page-element-builder.js

@@ -451,9 +451,9 @@ async function buildPageElements(options) {
 *    slot-scoped params, which `app-page-route-wiring` then hands to the
 *    slot page instead of the route's matched params.
 *
-* `routePath` is the already-normalized request pathname (basePath stripped,
-* RSC suffix removed). Re-parsing `request.url` here would re-introduce the
-* basePath and silently break the match for any app that configures one.
+* `routePath` is the already-normalized request pathname (basePath stripped).
+* Re-parsing `request.url` here would re-introduce the basePath and silently
+* break the match for any app that configures one.
 */
 function buildSlotOverrides(route, routeParams, routePath, opts, interceptMetadataOutlet) {
 	const overrides = {};

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

@@ -1,7 +1,7 @@
 import { VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
 import { copyLinkHeaderProvenance, getFrameworkLinkHeader, markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createRscRedirectLocation, toPathAbsolutePathname } from "./app-rsc-cache-busting.js";
 import { isHTTPAccessFallbackError, isThrownNavigationError } from "../shims/navigation-errors.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
@@ -298,9 +298,11 @@ function toHeaderSafeUrlReference(location) {
 * header-safe, so a protocol-relative or scheme-relative target still resolves
 * against the page each client fetched. A relative target resolves against the
 * request's path to a path-only form, which the client resolves against its
-* own origin. Resolving against two placeholder origins tells these apart the
-* way the URL parser does, never depends on the request's origin, and cannot
-* mistake an absolute target naming one placeholder for a relative one.
+* own origin; a resolved pathname that begins with "//" keeps a "/." prefix
+* so that form stays a path rather than naming another host. Resolving
+* against two placeholder origins tells these apart the way the URL parser
+* does, never depends on the request's origin, and cannot mistake an absolute
+* target naming one placeholder for a relative one.
 */
 function resolveRedirectTargets(location, requestUrl) {
 	try {
@@ -310,9 +312,10 @@ function resolveRedirectTargets(location, requestUrl) {
 			headerUrl: toHeaderSafeUrlReference(location)
 		};
 		const { pathname, search, hash } = first.resolved;
+		const target = `${toPathAbsolutePathname(pathname)}${search}${hash}`;
 		return {
-			digestUrl: `${pathname}${search}${hash}`,
-			headerUrl: `${pathname}${search}${hash}`
+			digestUrl: target,
+			headerUrl: target
 		};
 	} catch {
 		return {

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

@@ -72,7 +72,6 @@ type RenderAppPageLifecycleOptionsBase = {
   peekRequestCacheLife?: () => AppPageRequestCacheLife | null;
   getDraftModeCookieHeader: () => string | null | undefined;
   handlerStart: number;
-  hasCustomGlobalError?: boolean;
   dynamicStaleTimeSeconds?: number;
   isDynamicError: boolean;
   isDraftMode: boolean;

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

@@ -13,6 +13,7 @@ import { isRenderDynamicLatched } from "../shims/internal/headers-state.js";
 import { peekDynamicUsage } from "../shims/headers.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
+import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
 import { copyLinkHeaderProvenance, getFrameworkLinkHeader } from "./app-response-header-provenance.js";
 import { traceResponseStartWithCompletion } from "./response-start-tracing.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
@@ -21,7 +22,6 @@ import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { appendRscCompletionMetadata } from "./rsc-completion-metadata.js";
 import { isBailoutToCSRError } from "../shims/navigation-errors.js";
-import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
 import { applyClientStaleTimeHeader, applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy, resolveUncacheableCacheControl } from "./app-page-response.js";
 import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
 import { getAppPageLayoutGate } from "./app-page-layout-gate.js";
@@ -230,7 +230,6 @@ async function prepareAppPageElement(options) {
 }
 async function renderAppPageLifecycleImpl(options, renderSpan) {
 	let dynamicUsageObserved = false;
-	let dynamicUsageFinalized = false;
 	const isCacheCandidateHtmlRender = options.isCacheCandidate === true && options.isPrerender !== true && !options.isRscRequest;
 	const readsRenderDynamicLatch = isCacheCandidateHtmlRender || !options.isRscRequest && options.pprFallbackShellSignal === void 0 && (options.isPrerender === true || isRouteCacheabilityEvaluation());
 	const readDynamicUsage = bindRequestContext(() => options.consumeDynamicUsage() || readsRenderDynamicLatch && isRenderDynamicLatched());
@@ -240,13 +239,6 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		if (!dynamicUsageObserved) dynamicUsageObserved = readDynamicUsage();
 		return dynamicUsageObserved;
 	};
-	const finalizeRenderDynamicUsage = () => {
-		if (!dynamicUsageFinalized) {
-			consumeRenderDynamicUsage();
-			dynamicUsageFinalized = true;
-		}
-		return dynamicUsageObserved;
-	};
 	const artifactCompatibility = createAppPageArtifactCompatibility(options.element, options.routePattern);
 	const rootBoundaryId = artifactCompatibility?.rootBoundaryId ?? null;
 	const renderEpoch = artifactCompatibility?.renderEpoch ?? null;
@@ -429,7 +421,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		const completionHeaders = new Headers(rscResponse.headers);
 		completionHeaders.set(VINEXT_RSC_COMPLETION_METADATA_HEADER, "1");
 		const completionResponse = dynamicStaleTimeSeconds !== void 0 && options.isPrerender !== true && !options.isForceStatic && rscResponse.body ? new Response(appendRscCompletionMetadata(rscResponse.body, () => {
-			if (!finalizeRenderDynamicUsage()) return void 0;
+			if (!consumeRenderDynamicUsage()) return void 0;
 			const completedServerStaleTimeSeconds = resolveClientStaleTimeSeconds(options.peekRequestCacheLife?.());
 			if (shouldEmitDynamicStaleTime && completedServerStaleTimeSeconds === void 0) return;
 			return {
@@ -447,7 +439,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 			bypassInterceptionContextCache: options.bypassInterceptionContextCache,
 			captureAdmittedDocument,
 			cleanPathname: options.cleanPathname,
-			consumeDynamicUsage: finalizeRenderDynamicUsage,
+			consumeDynamicUsage: consumeRenderDynamicUsage,
 			consumeRenderObservationState,
 			createHtmlRenderObservation(input) {
 				return createAppPageRenderObservation({
@@ -630,6 +622,12 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		copyLinkHeaderProvenance(response.headers, prerenderResponse.headers);
 		return prerenderResponse;
 	};
+	const markPrerenderedDynamicShellSpecialError = (response, specialError) => {
+		if (options.isPrerender === true && response.status === specialError.statusCode && resolveEarlyResponseCacheControl(options) !== null && response.headers.get("cache-control")?.includes("no-store")) getRequestExecutionContext()?.recordPrerenderSpecialError?.({
+			headers: resolveAppPageSpecialErrorStoredHeaders(specialError, options.basePath) ?? {},
+			status: response.status
+		});
+	};
 	const finalizeShellSpecialErrorResponse = (response, specialError) => {
 		if (response.status !== specialError.statusCode) return applyIneligibleRouteCachePolicy(response, options);
 		const dynamicUsedDuringRender = consumeRenderDynamicUsage();
@@ -687,7 +685,6 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				capturedRscDataRef,
 				getInitialNavigationCacheMetadata: () => resolveInitialNavigationCacheMetadata(dynamicUsedDuringHtmlRender || peekDynamicUsage(), options.isPrerender === true ? requestCacheLifeForPrerender ?? options.peekRequestCacheLife?.() : options.peekRequestCacheLife?.()),
 				fontData,
-				hasCustomGlobalError: options.hasCustomGlobalError,
 				navigationContext: options.getNavigationContext(),
 				basePath: options.basePath,
 				clientTraceMetadata: options.clientTraceMetadata,
@@ -701,7 +698,8 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				scriptNonce: options.scriptNonce,
 				sideStream: rscCapture.sideStream,
 				ssrHandler,
-				fallbackToErrorDocumentOnShellError: options.isPrerender === true && options.isSpeculativePrerender === true ? false : void 0,
+				fallbackToErrorDocumentOnShellError: !(options.isPrerender === true && options.isSpeculativePrerender === true),
+				isServerComponentError: rscErrorTracker.isCapturedError,
 				waitForAllReady: shouldWaitForAllReady,
 				isStaticGeneration: options.isPrerender === true,
 				isForceStatic: options.isForceStatic,
@@ -740,7 +738,9 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 	if (htmlRender.response) {
 		if (shellSpecialError && options.isProduction && options.isPrerender !== true && resolveEarlyResponseCacheControl(options) === null) return finalizeShellSpecialErrorResponse(htmlRender.response, shellSpecialError);
 		if (shellSpecialError && prerenderedSpecialError) return finalizePrerenderedShellSpecialErrorResponse(htmlRender.response, shellSpecialError, prerenderedSpecialError);
-		return applyIneligibleRouteCachePolicy(htmlRender.response, options);
+		const response = applyIneligibleRouteCachePolicy(htmlRender.response, options);
+		if (shellSpecialError) markPrerenderedDynamicShellSpecialError(response, shellSpecialError);
+		return response;
 	}
 	let htmlStream = htmlRender.htmlStream;
 	if (!htmlStream) throw new Error("[vinext] Expected an HTML stream when no fallback response was returned");

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

@@ -2,10 +2,10 @@ import { VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-v
 import { NEXT_CACHE_TAGS_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_STALE_TIME_PENDING_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildRevalidateCacheControl } from "./cache-control.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
+import { applyPrerenderCacheLifeHeader } from "./prerender-cache-life-header.js";
 import { markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
-import { applyPrerenderCacheLifeHeader } from "./prerender-cache-life-header.js";
 //#region src/server/app-page-response.ts
 function applyTimingHeader(headers, timing) {
 	if (!timing) return;

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

@@ -3,6 +3,7 @@ import { fnv1a64 } from "../utils/hash.js";
 import { createInlineScriptTag, escapeHtmlAttr } from "./html.js";
 import { APP_LAYOUT_IDS_KEY, APP_ROOT_LAYOUT_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import { APP_PREFETCH_LOADING_SHELL_MARKER_KEY, APP_STREAMING_METADATA_BODY_ID_PREFIX } from "./app-elements.js";
+import { createBfcacheChildSegmentStateKey } from "./bfcache-identity.js";
 import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
 import { hashMountedLayoutIdentity } from "./app-mounted-layouts.js";
 import { BfcacheChildrenBoundary, BfcacheSegmentBoundary, Children as Children$1, ParallelSlot, Slot } from "../shims/slot.js";
@@ -876,8 +877,20 @@ function buildAppPageElements(options) {
 		fallback: pageErrorComponent,
 		children: routeChildren
 	});
-	const renderedTreePositions = isPrefetchLoadingShell ? orderedTreePositions.filter(includesPrefetchTreePosition) : orderedTreePositions;
-	let childSegmentElementId = pageElementId;
+	const firstLayoutWithElementTreePosition = layoutEntries.find((entry) => getDefaultExport(entry.layoutModule) !== null)?.treePosition;
+	const keepsSegmentLevelLists = String(process.env.__NEXT_CACHE_COMPONENTS) === "true" && firstLayoutWithElementTreePosition !== void 0 && !options.route.childrenSlot && options.semanticPageIdentity === void 0;
+	const spineTreePositions = keepsSegmentLevelLists ? Array.from(/* @__PURE__ */ new Set([...orderedTreePositions, ...Array.from({ length: Math.max(0, routeSegments.length - firstLayoutWithElementTreePosition) }, (_, offset) => firstLayoutWithElementTreePosition + 1 + offset)])).sort((left, right) => left - right) : orderedTreePositions;
+	const renderedTreePositions = isPrefetchLoadingShell ? spineTreePositions.filter(includesPrefetchTreePosition) : spineTreePositions;
+	const firstLayoutBelowShell = keepsSegmentLevelLists && isPrefetchLoadingShell ? layoutEntries.find((entry) => !includesPrefetchTreePosition(entry.treePosition) && getDefaultExport(entry.layoutModule) !== null) : void 0;
+	let childSegmentElementId = firstLayoutBelowShell?.id ?? pageElementId;
+	let childSegmentTreePosition = firstLayoutBelowShell?.treePosition ?? routeSegments.length + 1;
+	const retainChildSegment = (treePosition, children) => treePosition === childSegmentTreePosition - 1 ? /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
+		id: childSegmentElementId,
+		children
+	}) : /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
+		stateKey: createBfcacheChildSegmentStateKey(resolveAppPageTemplateStateKey(routeSegments, treePosition, options.matchedParams)),
+		children
+	});
 	for (let index = renderedTreePositions.length - 1; index >= 0; index--) {
 		const treePosition = renderedTreePositions[index];
 		const segmentResetKey = resolveRouteSegmentResetKey(treePosition);
@@ -927,11 +940,12 @@ function buildAppPageElements(options) {
 				children: segmentChildren
 			}, String(process.env.__NEXT_CACHE_COMPONENTS) === "true" ? void 0 : templateStateKey);
 		}
+		const layoutHasElement = layoutEntry !== void 0 && getDefaultExport(layoutEntry.layoutModule) !== null;
+		if (keepsSegmentLevelLists && !layoutHasElement && treePosition > firstLayoutWithElementTreePosition && treePosition < childSegmentTreePosition) segmentChildren = retainChildSegment(treePosition, segmentChildren);
 		if (!layoutEntry) {
 			routeChildren = segmentChildren;
 			continue;
 		}
-		const layoutHasElement = getDefaultExport(layoutEntry.layoutModule) !== null;
 		const layoutIndex = layoutIndicesByTreePosition.get(treePosition) ?? -1;
 		const segmentMap = { children: resolveAppPageLayoutSegmentProviderSegments(options.route.childrenRouteSegments ?? routeSegments, layoutEntry.treePosition, options.matchedParams) };
 		for (const [slotKey, slot] of Object.entries(options.route.slots ?? {})) {
@@ -949,13 +963,16 @@ function buildAppPageElements(options) {
 			children: layoutHasElement ? /* @__PURE__ */ jsx(Slot, {
 				id: layoutEntry.id,
 				parallelSlots: createAppPageParallelSlotEntries(layoutIndex, layoutEntries, options.route, getEffectiveSlotParams, resolveSlotOverride),
-				children: /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
+				children: keepsSegmentLevelLists ? retainChildSegment(treePosition, segmentChildren) : /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
 					id: childSegmentElementId,
 					children: segmentChildren
 				})
 			}) : segmentChildren
 		});
-		if (layoutHasElement) childSegmentElementId = layoutEntry.id;
+		if (layoutHasElement) {
+			childSegmentElementId = layoutEntry.id;
+			childSegmentTreePosition = treePosition;
+		}
 	}
 	const globalErrorComponent = getErrorBoundaryExport(options.globalErrorModule);
 	routeChildren = /* @__PURE__ */ jsx(GlobalErrorBoundary, {

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

@@ -96,10 +96,13 @@ export type AppPageSsrHandler = {
     /** Mirror inline Flight chunks into Next.js's `self.__next_f` transport, or start
      *  mirroring once a function returns true. */
     mirrorNextFlight?: boolean | (() => boolean);
-    /** When true, an SSR-phase-only shell render error resolves to the
-     *  default `__next_error__` error-document shell (with the original
-     *  flight payload and bootstrap) instead of rejecting. See handleSsr. */
+    /** When true, a shell render error other than a redirect, HTTP access
+     *  fallback or bail-out resolves to the default `__next_error__`
+     *  error-document shell (with the original flight payload and
+     *  bootstrap) instead of rejecting. See handleSsr. */
     fallbackToErrorDocumentOnShellError?: boolean;
+    /** Whether the RSC render threw the given shell error. See handleSsr. */
+    isServerComponentError?: (error: unknown) => boolean;
     /** The parallel slot not-found boundaries that catch a shell error. See handleSsr. */
     resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
     dynamicStaleTimeSeconds?: number;
@@ -153,8 +156,11 @@ type RenderAppPageHtmlStreamOptions = {
   isForceStatic?: boolean;
   /** Production render that may be stored under a query-free key. */
   isCacheCandidate?: boolean;
-  /** Override the default shell-error recovery decision passed to handleSsr. */
+  /** Whether handleSsr answers a shell error with the error document. Off by
+   *  default: a boundary render that fails keeps rejecting. */
   fallbackToErrorDocumentOnShellError?: boolean;
+  /** Whether the RSC render threw the given shell error. See handleSsr. */
+  isServerComponentError?: (error: unknown) => boolean;
   /** The parallel slot not-found boundaries that catch a shell error. See handleSsr. */
   resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
   /** Dev-only: original server error to surface in the browser overlay. */
@@ -164,10 +170,6 @@ type RenderAppPageHtmlStreamOptions = {
   /** Mirror inline Flight chunks into Next.js's `self.__next_f` transport, or start
    *  mirroring once a function returns true. */
   mirrorNextFlight?: boolean | (() => boolean);
-  /** True when the app supplies a custom global-error.tsx. Disables the
-   *  default error-document shell fallback so SSR shell errors keep driving
-   *  the server-rendered global-error boundary re-render. */
-  hasCustomGlobalError?: boolean;
 };
 type RenderAppPageHtmlResponseOptions = {
   clearRequestContext: () => void;

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

@@ -86,7 +86,8 @@ async function renderAppPageHtmlStream(options) {
 		initialDevServerError: options.initialDevServerError,
 		onSsrError: options.onSsrError,
 		mirrorNextFlight: options.mirrorNextFlight,
-		fallbackToErrorDocumentOnShellError: options.fallbackToErrorDocumentOnShellError ?? (options.waitForAllReady !== true && options.hasCustomGlobalError === false),
+		fallbackToErrorDocumentOnShellError: options.fallbackToErrorDocumentOnShellError,
+		isServerComponentError: options.isServerComponentError,
 		resolveCaughtNotFoundBoundaries: options.resolveCaughtNotFoundBoundaries,
 		dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
 		getInitialNavigationCacheMetadata: options.getInitialNavigationCacheMetadata

package/dist/server/app-request-stage-independent-entry.js

@@ -32,7 +32,7 @@ function handleRequestStage(request, env, ctx, dispatchResponseStage) {
 			callback: () => handleRequest(request, env, ctx, dispatchResponseStage, ctx?.assets).then((response) => applyCdnResponseIdentityHeaders(response, originalRequest)),
 			getStatus: (response) => response?.status,
 			headers: request.headers,
-			isRsc: url.pathname.endsWith(".rsc") || request.headers.get("RSC") === "1",
+			isRsc: request.headers.get("RSC") === "1",
 			method: request.method,
 			target: url.pathname + url.search
 		});

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

@@ -1,6 +1,7 @@
 import { isFullyBufferedBody } from "./fully-buffered-response.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { frameworkTracer } from "./tracer.js";
+import { logRequestError } from "./request-error-log.js";
 import { getRouteCacheabilityCaptureOptions, getRouteCacheabilityDynamicReason, isRouteCacheabilityEvaluation, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete, recordRouteCacheability } from "../shims/cacheability-classification.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy, hasExplicitNonCacheableResponsePolicy } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl } from "./isr-decision.js";
@@ -117,7 +118,7 @@ async function runAppRouteHandler(options) {
 		onDynamicAccess() {
 			options.markDynamicUsage();
 		},
-		requestMode: options.dynamicConfig === "force-static" || options.dynamicConfig === "error" ? options.dynamicConfig : "auto",
+		requestMode: options.dynamicConfig === "force-dynamic" || options.dynamicConfig === "force-static" || options.dynamicConfig === "error" ? options.dynamicConfig : "auto",
 		signal: options.requestSignal,
 		staticGenerationErrorMessage(expression) {
 			return getAppRouteStaticGenerationErrorMessage(options.routePattern, expression);
@@ -339,7 +340,7 @@ async function executeAppRouteHandlerImpl(options) {
 			}), options.middlewareContext, middlewareMergeOptions), shouldApplyDraftPolicy);
 			return applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(new Response(null, { status: specialError.statusCode }), options.middlewareContext, middlewareMergeOptions), shouldApplyDraftPolicy);
 		}
-		console.error("[vinext] Route handler error:", error);
+		logRequestError("[vinext] Route handler error:", error);
 		await options.reportRequestError(error, {
 			path: options.cleanPathname,
 			method: options.request.method,

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

@@ -21,7 +21,7 @@ type NextUrlDynamicAccess = "nextUrl.search" | "nextUrl.searchParams" | "nextUrl
 type HostDerivedNextUrlDynamicAccess = "nextUrl.protocol" | "nextUrl.username" | "nextUrl.password" | "nextUrl.host" | "nextUrl.hostname" | "nextUrl.port" | DomainLocaleNextUrlDynamicAccess;
 type DomainLocaleNextUrlDynamicAccess = "nextUrl.locale" | "nextUrl.defaultLocale" | "nextUrl.domainLocale";
 type AppRouteDynamicRequestAccess = RequestDynamicAccess | NextUrlDynamicAccess;
-type AppRouteRequestMode = "auto" | "force-static" | "error";
+type AppRouteRequestMode = "auto" | "force-dynamic" | "force-static" | "error";
 type TrackedAppRouteRequestOptions = {
   basePath?: string;
   i18n?: NextI18nConfig | null;

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

@@ -2,6 +2,7 @@ import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-r
 import { addBasePathToPathname } from "../utils/base-path.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
 import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
+import { throwIfInsideCacheScope } from "../shims/internal/headers-state.js";
 import { BUILT_IN_REQUEST_PROPERTIES } from "./app-route-request-built-ins.js";
 //#region src/server/app-route-handler-runtime.ts
 const BUILT_IN_REQUEST_PROPERTY_MAP = new Map(BUILT_IN_REQUEST_PROPERTIES.map((property) => [property.key, property]));
@@ -150,7 +151,8 @@ function createTrackedAppRouteRequest(request, options = {}) {
 	let didAccessDynamicRequest = false;
 	const requestMode = options.requestMode ?? "auto";
 	const nextConfig = buildNextConfig(options);
-	const markDynamicAccess = (access) => {
+	const markDynamicAccess = (access, trackedByNext) => {
+		if (trackedByNext && requestMode !== "force-dynamic") throwIfInsideCacheScope(access);
 		didAccessDynamicRequest = true;
 		options.onDynamicAccess?.(access);
 	};
@@ -184,7 +186,7 @@ function createTrackedAppRouteRequest(request, options = {}) {
 	const wrapNextUrl = (nextUrl) => {
 		return new Proxy(nextUrl, { get(target, prop) {
 			if (isNextDynamicNextUrlProperty(prop) || isHostDerivedNextUrlProperty(prop)) {
-				markDynamicAccess(`nextUrl.${String(prop)}`);
+				markDynamicAccess(`nextUrl.${String(prop)}`, isNextDynamicNextUrlProperty(prop));
 				return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
 			}
 			if (prop === "clone") return () => wrapNextUrl(target.clone());
@@ -252,7 +254,7 @@ function createTrackedAppRouteRequest(request, options = {}) {
 		const accessCf = (read, forceStaticValue) => {
 			if (requestMode === "force-static") return forceStaticValue;
 			if (requestMode === "error") return throwStaticGenerationError("request.cf");
-			markDynamicAccess("request.cf");
+			markDynamicAccess("request.cf", false);
 			return read();
 		};
 		const controlledCfGetter = () => accessCf(sourceCfAccessor ? () => Reflect.apply(sourceCfAccessor, requestWithOverrides, []) : () => rawCfMetadata, void 0);
@@ -354,17 +356,19 @@ function createTrackedAppRouteRequest(request, options = {}) {
 						return proxiedNextUrl;
 					case "headers":
 					case "cookies":
-					case "ip":
-					case "geo":
 					case "url":
 					case "body":
 					case "blob":
-					case "bytes":
 					case "json":
 					case "text":
 					case "arrayBuffer":
 					case "formData":
-						markDynamicAccess(`request.${String(prop)}`);
+						markDynamicAccess(`request.${String(prop)}`, true);
+						return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
+					case "ip":
+					case "geo":
+					case "bytes":
+						markDynamicAccess(`request.${String(prop)}`, false);
 						return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
 					case "clone": return cloneTrackedRequest;
 					default: return getTrackedRequestProperty(target, prop, receiver);

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

@@ -37,7 +37,7 @@ var app_router_entry_default = {
 				callback: async () => applyCdnResponseIdentityHeaders(await handleRequest(request, env, ctx), request),
 				getStatus: (response) => response?.status,
 				headers: request.headers,
-				isRsc: url.pathname.endsWith(".rsc") || request.headers.get("RSC") === "1",
+				isRsc: request.headers.get("RSC") === "1",
 				method: request.method,
 				target: url.pathname + url.search
 			});

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

@@ -68,11 +68,6 @@ export declare function stripRscCacheBustingSearchParam(url: URL): void;
  * are dropped. Other requests keep no `_rsc`, because it selects nothing there.
  */
 export declare function keepOnlyValidatedRscCacheBustingSearchParam(url: URL, isRscRequest: boolean): void;
-/**
- * Remove a trailing `.rsc` suffix from a pathname. Returns the pathname
- * unchanged when the suffix is absent.
- */
-export declare function stripRscSuffix(pathname: string): string;
 export declare function createCanonicalRscRequestHeaders(deploymentId?: string | null | undefined): Headers;
 /** Headers for the deterministic loading-boundary prefetch representation. */
 export declare function createCanonicalLoadingShellRscRequestHeaders(deploymentId?: string | null | undefined): Headers;
@@ -96,13 +91,18 @@ export declare function canonicalizeLoadingShellRscRequestHeaders(headers: Heade
  * appended to the base instead of resolved against it.
  */
 export declare function parseRscRequestPath(href: string): URL;
+/**
+ * A pathname as the start of a path-absolute reference. One that begins with
+ * "//" would serialize as a protocol-relative URL naming another host, so it
+ * keeps a "/." prefix, as the WHATWG URL serializer does. URL resolution drops
+ * the dot segment, so the reference still targets the same pathname on the
+ * origin it is resolved against.
+ */
+export declare function toPathAbsolutePathname(pathname: string): string;
 /**
  * Serialize the path-absolute reference callers fetch against the app origin.
- * A pathname that begins with "//" would serialize as a protocol-relative URL
- * and send the request to another host, so it keeps a "/." prefix, as the
- * WHATWG URL serializer does. URL resolution drops the dot segment, so the
- * request still targets the same pathname on the app origin, as Next.js's
- * full-URL fetch does.
+ * A "//" pathname keeps its "/." prefix so the request still targets the same
+ * pathname on the app origin, as Next.js's full-URL fetch does.
  */
 export declare function formatRscRequestPath(url: URL): string;
 export declare function createRscRequestUrl(href: string, headers: Headers): Promise<string>;