vinext 0.1.1 → 0.1.2

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

@@ -1,10 +1,11 @@
 import { VINEXT_MOUNTED_SLOTS_HEADER } from "./headers.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
 import { encodeCacheTag } from "../utils/encode-cache-tag.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
+import { decideIsr } from "./isr-decision.js";
 import { buildAppPageCacheValue } from "./isr-cache.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { readStreamAsText } from "../utils/text-stream.js";
-import { applyCdnResponseHeaders, buildCachedRevalidateCacheControl } from "./cache-control.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { hasCompleteNegativeRequestApiProof } from "./cache-proof.js";
@@ -52,9 +53,6 @@ function buildAppPageCacheTags(pathname, extraTags) {
 	for (const tag of extraTags) if (!tags.includes(tag)) tags.push(tag);
 	return tags.map(encodeCacheTag);
 }
-function buildAppPageCacheControl(cacheState, revalidateSeconds, expireSeconds) {
-	return buildCachedRevalidateCacheControl(cacheState, revalidateSeconds, expireSeconds);
-}
 function buildAppPageCachedHeaders(options) {
 	const headers = new Headers({
 		"Content-Type": options.contentType,
@@ -87,9 +85,13 @@ function resolveAppPageCacheWritePolicy(options) {
 }
 function buildAppPageCachedResponse(cachedValue, options) {
 	const status = options.middlewareStatus ?? (cachedValue.status || 200);
-	const revalidateSeconds = options.cacheControl?.revalidate ?? options.revalidateSeconds;
-	const expireSeconds = options.cacheControl === void 0 ? void 0 : options.cacheControl.expire ?? options.expireSeconds;
-	const cacheControl = buildAppPageCacheControl(options.cacheState, revalidateSeconds, expireSeconds);
+	const { cacheControl } = decideIsr({
+		cacheState: options.cacheState,
+		kind: "app-page",
+		revalidateSeconds: options.revalidateSeconds,
+		expireSeconds: options.expireSeconds,
+		cacheControlMeta: options.cacheControl
+	});
 	if (options.isRscRequest) {
 		if (!cachedValue.rscData) return null;
 		const rscHeaders = buildAppPageCachedHeaders({

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

@@ -51,6 +51,12 @@ type AppPageModule = {
   dynamic?: unknown;
   revalidate?: unknown;
 };
+type AppPageDispatchSlot = {
+  default?: AppPageModule | null;
+  page?: AppPageModule | null;
+  slotPatternParts?: readonly string[] | null;
+  slotParamNames?: readonly string[] | null;
+};
 type AppPageDispatchRoute = {
   __buildTimeClassifications?: LayoutClassificationOptions["buildTimeClassifications"];
   __buildTimeReasons?: LayoutClassificationOptions["buildTimeReasons"];
@@ -67,6 +73,7 @@ type AppPageDispatchRoute = {
   params: readonly string[];
   pattern: string;
   routeSegments: readonly string[];
+  slots?: Readonly<Record<string, AppPageDispatchSlot>>;
   unauthorized?: AppPageModule | null;
   unauthorizeds?: readonly (AppPageModule | null | undefined)[];
 };
@@ -87,6 +94,7 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker) => Promise<AppPageElement>;
   clientReuseManifest?: ClientReuseManifestParseResult;
   cleanPathname: string;
+  displayPathname?: string;
   clearRequestContext: () => void;
   createRscOnErrorHandler: (pathname: string, routePath: string) => AppPageBoundaryOnError;
   debugClassification?: (layoutId: string, reason: ClassificationReason) => void;

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

@@ -18,9 +18,10 @@ import { resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessB
 import { isAppSsrRenderResult } from "./app-page-stream.js";
 import { createAppLayoutParamAccessTracker, isAppLayoutObservationUnsafeForStaticReuse } from "./app-layout-param-observation.js";
 import { resolveAppPageMethodResponse } from "./app-page-method.js";
+import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
+import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
 import { renderAppPageLifecycle } from "./app-page-render.js";
-import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import React from "react";
@@ -124,7 +125,7 @@ async function runAppPageRevalidationContext(options, renderFn) {
 		ensureFetchPatch();
 		setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], options.routeSegments));
 		options.setNavigationContext({
-			pathname: options.cleanPathname,
+			pathname: options.displayPathname ?? options.cleanPathname,
 			searchParams: new URLSearchParams(),
 			params: options.params
 		});
@@ -183,10 +184,11 @@ async function dispatchAppPageInner(options) {
 			routeKind: "page",
 			routePattern: route.pattern
 		}));
+		const staticNavigationParams = resolveAppPageNavigationParams(route, options.params, options.cleanPathname, null);
 		options.setNavigationContext({
-			pathname: options.cleanPathname,
+			pathname: options.displayPathname ?? options.cleanPathname,
 			searchParams: new URLSearchParams(),
-			params: options.params
+			params: staticNavigationParams
 		});
 	}
 	if (shouldReadAppPageCache({
@@ -233,9 +235,11 @@ async function dispatchAppPageInner(options) {
 						return toInterceptOptions(options.interceptionContext, intercept);
 					}
 				});
+				revalidationTarget.navigationParams = resolveAppPageNavigationParams(revalidationTarget.route, revalidationTarget.navigationParams, options.cleanPathname, revalidationTarget.interceptOpts);
 				await options.ensureRouteLoaded?.(revalidationTarget.route);
 				return runAppPageRevalidationContext({
 					cleanPathname: options.cleanPathname,
+					displayPathname: options.displayPathname,
 					currentFetchCacheMode: options.resolveRouteFetchCacheMode?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? options.fetchCache ?? null : null),
 					draftModeSecret: options.draftModeSecret,
 					dynamicConfig,
@@ -352,6 +356,9 @@ async function dispatchAppPageInner(options) {
 		},
 		isRscRequest: options.isRscRequest,
 		layoutParamAccess,
+		resolveNavigationParams(sourceRoute, navigationParams, pathname, interceptOpts) {
+			return resolveAppPageNavigationParams(sourceRoute, navigationParams, pathname, interceptOpts);
+		},
 		renderInterceptResponse(sourceRoute, interceptElement) {
 			const interceptOnError = options.createRscOnErrorHandler(options.cleanPathname, sourceRoute.pattern);
 			const interceptStream = options.renderToReadableStream(interceptElement, { onError: interceptOnError });
@@ -387,6 +394,12 @@ async function dispatchAppPageInner(options) {
 		resolveSpecialError: resolveAppPageSpecialError
 	});
 	if (pageBuildResult.response) return pageBuildResult.response;
+	const navigationParams = resolveAppPageNavigationParams(route, options.params, options.cleanPathname, interceptResult.interceptOpts);
+	options.setNavigationContext({
+		pathname: options.displayPathname ?? options.cleanPathname,
+		searchParams: options.searchParams,
+		params: navigationParams
+	});
 	const layoutClassifications = getEffectiveLayoutClassifications(route, options.debugClassification);
 	return renderAppPageLifecycle({
 		basePath: options.basePath,
@@ -442,6 +455,7 @@ async function dispatchAppPageInner(options) {
 		layoutCount: route.layouts.length,
 		loadSsrHandler: options.loadSsrHandler,
 		middlewareContext: options.middlewareContext,
+		navigationParams,
 		params: options.params,
 		layoutParamAccess,
 		rootParams: options.rootParams,
@@ -495,7 +509,6 @@ async function dispatchAppPageInner(options) {
 			return renderPageSpecialError(options, specialError);
 		},
 		renderToReadableStream: options.renderToReadableStream,
-		routeHasLocalBoundary: Boolean(route.error?.default || route.errors?.some((errorModule) => errorModule?.default)),
 		routePattern: route.pattern,
 		runWithSuppressedHookWarning(probe) {
 			return options.runWithSuppressedHookWarning(probe);

package/dist/server/app-page-element-builder.d.ts

@@ -49,9 +49,28 @@ type BuildPageElementsOptions<TModule extends AppPageModule = AppPageModule, TEr
    * Configured next.config `basePath`. Threaded through `resolveAppPageHead`
    * so file-based metadata route URLs emitted in <head> are prefixed.
    */
-  basePath?: string; /** Serialized next.config `htmlLimitedBots` regexp source. */
+  basePath?: string; /** Configured next.config `trailingSlash`, threaded into canonical URL rendering. */
+  trailingSlash?: boolean; /** Serialized next.config `htmlLimitedBots` regexp source. */
   htmlLimitedBots?: string;
 };
+type AppPageNavigationParamModule = {
+  default?: unknown;
+};
+type AppPageNavigationParamSlot = {
+  default?: AppPageNavigationParamModule | null;
+  page?: AppPageNavigationParamModule | null;
+  slotPatternParts?: readonly string[] | null;
+  slotParamNames?: readonly string[] | null;
+};
+type AppPageNavigationParamRoute = {
+  params?: readonly string[] | null;
+  slots?: Readonly<Record<string, AppPageNavigationParamSlot>> | null;
+};
+type AppPageNavigationParamInterceptOptions = {
+  interceptPage?: unknown;
+  interceptParams?: AppPageParams | null;
+  interceptSlotKey?: string | null;
+};
 /**
  * Build the App Router element tree for a matched route.
  *
@@ -69,5 +88,6 @@ type BuildPageElementsOptions<TModule extends AppPageModule = AppPageModule, TEr
  * {@link https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/create-metadata.tsx|create-metadata.tsx}.
  */
 declare function buildPageElements<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule>(options: BuildPageElementsOptions<TModule, TErrorModule>): Promise<AppElements>;
+declare function resolveAppPageNavigationParams(route: AppPageNavigationParamRoute, routeParams: AppPageParams, routePath: string, opts?: AppPageNavigationParamInterceptOptions | null): AppPageParams;
 //#endregion
-export { AppPageBuildRoute, type AppPageErrorModule, AppPageInterceptOptions, AppPagePageRequest, type AppPageRouteWiringRoute, BuildPageElementsOptions, buildPageElements };
+export { AppPageBuildRoute, type AppPageErrorModule, AppPageInterceptOptions, AppPagePageRequest, type AppPageRouteWiringRoute, BuildPageElementsOptions, buildPageElements, resolveAppPageNavigationParams };

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

@@ -8,8 +8,8 @@ import { resolveActiveParallelRouteHeadInputs, resolveAppPageHead } from "./app-
 import { makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
 import { buildAppPageElements, createAppPageTreePath } from "./app-page-route-wiring.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
-import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import "./app-rsc-route-matching.js";
+import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { createElement } from "react";
 //#region src/server/app-page-element-builder.ts
 /**
@@ -118,7 +118,8 @@ async function buildPageElements(options) {
 		route,
 		searchParams: pageSearchParamsThenable,
 		slotOverrides,
-		renderMode
+		renderMode,
+		trailingSlash: options.trailingSlash
 	});
 }
 /**
@@ -142,6 +143,18 @@ function buildSlotOverrides(route, routeParams, routePath, opts) {
 		pageModule: opts.interceptPage,
 		params: opts.interceptParams || routeParams
 	};
+	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
+	for (const [slotKey, params] of Object.entries(slotParamOverrides ?? {})) {
+		const existing = overrides[slotKey];
+		overrides[slotKey] = existing ? {
+			...existing,
+			params
+		} : { params };
+	}
+	return Object.keys(overrides).length > 0 ? overrides : null;
+}
+function resolveSlotParamOverrides(route, routePath) {
+	const overrides = {};
 	const slots = route.slots;
 	if (slots) {
 		let urlParts = null;
@@ -154,19 +167,35 @@ function buildSlotOverrides(route, routeParams, routePath, opts) {
 			if (urlParts === null) urlParts = routePath.split("/").filter(Boolean);
 			const matched = matchRoutePattern(urlParts, patternParts);
 			if (!matched) continue;
-			const existing = overrides[slotKey];
-			overrides[slotKey] = existing ? {
-				...existing,
-				params: matched
-			} : { params: matched };
+			overrides[slotKey] = matched;
 		}
 	}
 	return Object.keys(overrides).length > 0 ? overrides : null;
 }
+function mergeAppPageParams(target, source) {
+	for (const [key, value] of Object.entries(source)) target[key] = value;
+}
+function isDefaultExportModule(module) {
+	return typeof module === "object" && module !== null;
+}
+function hasDefaultExport(module) {
+	if (!isDefaultExportModule(module)) return false;
+	return module?.default !== null && module?.default !== void 0;
+}
+function resolveAppPageNavigationParams(route, routeParams, routePath, opts) {
+	const navigationParams = { ...routeParams };
+	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
+	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
+		const isInterceptedSlot = opts?.interceptSlotKey === slotKey && opts.interceptSlotKey !== "__vinext_page_intercept" && hasDefaultExport(opts.interceptPage);
+		if (!isInterceptedSlot && !hasDefaultExport(slot.page) && !hasDefaultExport(slot.default)) continue;
+		mergeAppPageParams(navigationParams, isInterceptedSlot ? opts?.interceptParams ?? routeParams : slotParamOverrides?.[slotKey] ?? routeParams);
+	}
+	return navigationParams;
+}
 function collectParamNameSet(params) {
 	const set = /* @__PURE__ */ new Set();
 	if (params) for (const name of params) set.add(name);
 	return set;
 }
 //#endregion
-export { buildPageElements };
+export { buildPageElements, resolveAppPageNavigationParams };

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

@@ -103,7 +103,7 @@ type LayoutClassificationOptions = {
    * unsafe even if the older dynamic scope did not report dynamic usage.
    */
   isLayoutObservationDynamic?: (layoutId: string) => boolean; /** Runs a function with isolated dynamic usage tracking per layout. */
-  runWithIsolatedDynamicScope: <T>(fn: () => T) => Promise<{
+  runWithIsolatedDynamicScope: <T>(fn: () => T | Promise<T>) => Promise<{
     result: T;
     dynamicDetected: boolean;
   }>;

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

@@ -1,5 +1,6 @@
 import { addBasePathToPathname } from "../utils/base-path.js";
 import { VINEXT_RSC_REDIRECT_HEADER } from "./headers.js";
+import { runWithConnectionProbe } from "../shims/headers.js";
 import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
@@ -180,10 +181,15 @@ async function buildAppPageSpecialErrorResponse(options) {
 	}
 	if (options.renderFallbackPage) {
 		const fallbackResponse = await options.renderFallbackPage(options.specialError.statusCode);
-		if (fallbackResponse) return mergeAppPageSpecialErrorHeaders(fallbackResponse, options.middlewareContext);
+		if (fallbackResponse) return mergeAppPageSpecialErrorHeaders(options.specialError.fromMetadata === true && options.serveStreamingMetadata !== false ? new Response(fallbackResponse.body, {
+			headers: fallbackResponse.headers,
+			status: 200,
+			statusText: fallbackResponse.statusText
+		}) : fallbackResponse, options.middlewareContext);
 	}
 	options.clearRequestContext();
-	return mergeAppPageSpecialErrorHeaders(new Response(getAppPageStatusText(options.specialError.statusCode), { status: options.specialError.statusCode }), options.middlewareContext);
+	const responseStatus = options.specialError.fromMetadata === true && options.serveStreamingMetadata !== false ? 200 : options.specialError.statusCode;
+	return mergeAppPageSpecialErrorHeaders(new Response(getAppPageStatusText(options.specialError.statusCode), { status: responseStatus }), options.middlewareContext);
 }
 /** See `LayoutFlags` type docblock in app-elements.ts for lifecycle. */
 async function probeAppPageLayouts(options) {
@@ -210,7 +216,10 @@ async function probeAppPageLayouts(options) {
 				if (cls) {
 					const layoutId = cls.getLayoutId(layoutIndex);
 					try {
-						const { dynamicDetected } = await cls.runWithIsolatedDynamicScope(() => options.probeLayoutAt(layoutIndex));
+						const { dynamicDetected } = await cls.runWithIsolatedDynamicScope(async () => {
+							const outcome = await runWithConnectionProbe(() => options.probeLayoutAt(layoutIndex));
+							return outcome.completed ? outcome.result : null;
+						});
 						const observationDynamic = cls.isLayoutObservationDynamic?.(layoutId) === true;
 						const layoutDynamic = dynamicDetected || observationDynamic;
 						layoutFlags[layoutId] = layoutDynamic ? "d" : "s";
@@ -239,25 +248,31 @@ async function probeAppPageLayouts(options) {
 	};
 }
 async function probeLayoutForErrors(options, layoutIndex) {
-	try {
-		const layoutResult = options.probeLayoutAt(layoutIndex);
-		if (isPromiseLike(layoutResult)) await layoutResult;
-	} catch (error) {
-		return options.onLayoutError(error, layoutIndex);
-	}
-	return null;
-}
-async function probeAppPageComponent(options) {
-	return options.runWithSuppressedHookWarning(async () => {
+	const outcome = await runWithConnectionProbe(async () => {
 		try {
-			const pageResult = options.probePage();
-			if (isPromiseLike(pageResult)) if (options.awaitAsyncResult) await pageResult;
-			else Promise.resolve(pageResult).catch(() => {});
+			const layoutResult = options.probeLayoutAt(layoutIndex);
+			if (isPromiseLike(layoutResult)) await layoutResult;
 		} catch (error) {
-			return options.onError(error);
+			return options.onLayoutError(error, layoutIndex);
 		}
 		return null;
 	});
+	return outcome.completed ? outcome.result : null;
+}
+async function probeAppPageComponent(options) {
+	return options.runWithSuppressedHookWarning(async () => {
+		const outcome = await runWithConnectionProbe(async () => {
+			try {
+				const pageResult = options.probePage();
+				if (isPromiseLike(pageResult)) if (options.awaitAsyncResult) await pageResult;
+				else Promise.resolve(pageResult).catch(() => {});
+			} catch (error) {
+				return options.onError(error);
+			}
+			return null;
+		});
+		return outcome.completed ? outcome.result : null;
+	});
 }
 async function readAppPageBinaryStream(stream) {
 	const reader = stream.getReader();

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

@@ -68,6 +68,7 @@ type RenderAppPageLifecycleOptions = {
   layoutCount: number;
   loadSsrHandler: () => Promise<AppPageSsrHandler>;
   middlewareContext: AppPageMiddlewareContext;
+  navigationParams: Record<string, unknown>;
   params: Record<string, unknown>;
   rootParams?: RootParams;
   peekRenderObservationState?: () => AppPageRenderObservationState;
@@ -82,7 +83,6 @@ type RenderAppPageLifecycleOptions = {
   renderToReadableStream: (element: ReactNode | AppOutgoingElements, options: {
     onError: AppPageBoundaryOnError;
   }) => ReadableStream<Uint8Array>;
-  routeHasLocalBoundary: boolean;
   routePattern: string;
   runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
   scriptNonce?: string;

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

@@ -1,8 +1,8 @@
+import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
 import { createArtifactCompatibilityEnvelope, createArtifactCompatibilityGraphVersion } from "./artifact-compatibility.js";
 import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
-import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
 import { buildAppPageHtmlResponse, buildAppPageRscResponse, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy } from "./app-page-response.js";
 import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageSpecialError, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
 import { probeAppPageBeforeRender } from "./app-page-probe.js";
@@ -10,7 +10,7 @@ import { DEFAULT_CACHE_VARIANT_BUDGET, buildCacheVariantWithRouteBudget, buildRe
 import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
 import { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache.js";
 import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
-import { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError } from "./app-page-stream.js";
+import { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
 import { getStaticLayoutObservationSkipRejection } from "./app-layout-param-observation.js";
 import { hasDigest } from "./app-rsc-errors.js";
 import { createClientReuseSkipTransportPlan, crossCheckClientReuseManifestEntryWithCache } from "./skip-cache-proof.js";
@@ -293,7 +293,7 @@ async function renderAppPageLifecycle(options) {
 		cleanPathname: options.cleanPathname,
 		completeness: "partial",
 		output: rscOutputScope,
-		params: options.params,
+		params: options.navigationParams,
 		state: options.peekRenderObservationState?.() ?? createEmptyAppPageRenderObservationState()
 	});
 	const skipDisposition = options.skipDisposition ?? createRenderLifecycleSkipDisposition({
@@ -349,7 +349,7 @@ async function renderAppPageLifecycle(options) {
 			isEdgeRuntime: options.isEdgeRuntime,
 			middlewareContext: options.middlewareContext,
 			mountedSlotsHeader: options.mountedSlotsHeader,
-			params: options.params,
+			params: options.navigationParams,
 			policy: rscResponsePolicy,
 			timing: buildResponseTiming({
 				compileEnd,
@@ -371,7 +371,7 @@ async function renderAppPageLifecycle(options) {
 					cleanPathname: options.cleanPathname,
 					completeness: "complete",
 					output: rscOutputScope,
-					params: options.params,
+					params: options.navigationParams,
 					state: input.state
 				});
 			},
@@ -448,13 +448,6 @@ async function renderAppPageLifecycle(options) {
 			}
 		}
 	}
-	if (shouldRerenderAppPageWithGlobalError({
-		capturedError: rscErrorTracker.getCapturedError(),
-		hasLocalBoundary: options.routeHasLocalBoundary
-	})) {
-		const cleanResponse = await options.renderErrorBoundaryResponse(rscErrorTracker.getCapturedError());
-		if (cleanResponse) return cleanResponse;
-	}
 	if (options.isPrerender === true) {
 		await settleCapturedRscRenderForCacheMetadata(htmlRender.capturedRscData);
 		({expireSeconds, revalidateSeconds} = applyRequestCacheLife({
@@ -516,7 +509,7 @@ async function renderAppPageLifecycle(options) {
 					cleanPathname: options.cleanPathname,
 					completeness: "complete",
 					output: htmlOutputScope,
-					params: options.params,
+					params: options.navigationParams,
 					state: input.state
 				});
 			},
@@ -528,7 +521,7 @@ async function renderAppPageLifecycle(options) {
 					cleanPathname: options.cleanPathname,
 					completeness: "complete",
 					output: rscOutputScope,
-					params: options.params,
+					params: options.navigationParams,
 					state: input.state
 				});
 			},

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

@@ -87,6 +87,7 @@ type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
   getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
   isRscRequest: boolean;
   layoutParamAccess?: AppLayoutParamAccessTracker;
+  resolveNavigationParams: (route: TRoute, params: AppPageParams, pathname: string, interceptOpts: TInterceptOpts) => AppPageParams;
   renderInterceptResponse: (route: TRoute, element: TElement) => Promise<Response> | Response;
   searchParams: URLSearchParams;
   setNavigationContext: (context: {

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

@@ -155,13 +155,14 @@ async function resolveAppPageIntercept(options) {
 	});
 	if (interceptState.kind === "source-route") {
 		const renderRoute = interceptState.sourceRoute;
+		const interceptOpts = options.toInterceptOpts(interceptState.intercept);
 		const renderParams = pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute));
 		options.setNavigationContext({
-			params: interceptState.intercept.matchedParams,
+			params: options.resolveNavigationParams(renderRoute, interceptState.intercept.matchedParams, options.cleanPathname, interceptOpts),
 			pathname: options.cleanPathname,
 			searchParams: options.searchParams
 		});
-		const interceptElement = await options.buildPageElement(renderRoute, renderParams, options.toInterceptOpts(interceptState.intercept), options.searchParams, options.layoutParamAccess);
+		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, options.searchParams, options.layoutParamAccess);
 		return {
 			interceptOpts: void 0,
 			response: await options.renderInterceptResponse(renderRoute, interceptElement)

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

@@ -1,7 +1,7 @@
 import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildRevalidateCacheControl } from "./cache-control.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 //#region src/server/app-page-response.ts
 function applyTimingHeader(headers, timing) {

package/dist/server/app-page-route-wiring.d.ts

@@ -113,6 +113,7 @@ type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModu
   resolvedMetadata: Metadata | null;
   resolvedMetadataPathname?: string;
   resolvedViewport: Viewport;
+  trailingSlash?: boolean;
   rootForbiddenModule?: TModule | null;
   rootNotFoundModule?: TModule | null;
   rootUnauthorizedModule?: TModule | null;
@@ -142,6 +143,7 @@ declare function createAppPageLayoutEntries<TModule extends AppPageModule, TErro
   forbiddens?: readonly (TModule | null | undefined)[] | null;
   unauthorizeds?: readonly (TModule | null | undefined)[] | null;
 }): AppPageLayoutEntry<TModule, TErrorModule>[];
+declare function createAppPageRouteBodyMetadata(metadata: Metadata | null, pathname: string, metadataPlacement: "body" | "head", trailingSlash?: boolean): ReactNode;
 declare function buildAppPageElements<TModule extends AppPageModule, TErrorModule extends AppPageErrorModule>(options: BuildAppPageElementsOptions<TModule, TErrorModule>): AppElements;
 //#endregion
-export { AppPageErrorModule, AppPageModule, AppPageRouteWiringRoute, AppPageSlotOverride, buildAppPageElements, createAppPageLayoutEntries, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };
+export { AppPageErrorModule, AppPageModule, AppPageRouteWiringRoute, AppPageSlotOverride, buildAppPageElements, createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };

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

@@ -139,21 +139,22 @@ function createAppPageSlotBindings(route, layoutEntries, resolveSlotOverride, op
 	}
 	return normalizeAppElementsSlotBindings(bindings, { layoutIds: layoutEntries.map((entry) => entry.id) });
 }
-function createAppPageRouteHead(metadata, viewport, pathname, metadataPlacement) {
+function createAppPageRouteHead(metadata, viewport, pathname, metadataPlacement, trailingSlash) {
 	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
 		/* @__PURE__ */ jsx("meta", { charSet: "utf-8" }),
 		metadata && metadataPlacement === "head" ? /* @__PURE__ */ jsx(MetadataHead, {
 			metadata,
-			pathname
+			pathname,
+			trailingSlash
 		}) : null,
 		/* @__PURE__ */ jsx(ViewportHead, { viewport })
 	] });
 }
-function createAppPageRouteBodyMetadata(metadata, pathname, metadataPlacement) {
+function createAppPageRouteBodyMetadata(metadata, pathname, metadataPlacement, trailingSlash) {
 	if (!metadata || metadataPlacement !== "body") return null;
 	return /* @__PURE__ */ jsx("div", {
 		hidden: true,
-		dangerouslySetInnerHTML: { __html: renderMetadataToHtml(metadata, pathname) }
+		dangerouslySetInnerHTML: { __html: renderMetadataToHtml(metadata, pathname, { trailingSlash }) }
 	});
 }
 function buildAppPageElements(options) {
@@ -431,12 +432,12 @@ function buildAppPageElements(options) {
 		children: routeChildren
 	});
 	elements[routeId] = /* @__PURE__ */ jsxs(Fragment$1, { children: [
-		createAppPageRouteHead(options.resolvedMetadata, options.resolvedViewport, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement),
+		createAppPageRouteHead(options.resolvedMetadata, options.resolvedViewport, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement, options.trailingSlash),
 		routeChildren,
-		createAppPageRouteBodyMetadata(options.resolvedMetadata, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement)
+		createAppPageRouteBodyMetadata(options.resolvedMetadata, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement, options.trailingSlash)
 	] });
 	registerAppElementRenderDependencies(elements, renderDependenciesByElementId);
 	return elements;
 }
 //#endregion
-export { buildAppPageElements, createAppPageLayoutEntries, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };
+export { buildAppPageElements, createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };

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

@@ -129,10 +129,6 @@ type AppPageRscErrorTracker = {
   getCapturedSpecialError: () => unknown;
   onRenderError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
 };
-type ShouldRerenderAppPageWithGlobalErrorOptions = {
-  capturedError: unknown;
-  hasLocalBoundary: boolean;
-};
 declare function createAppPageFontData(options: CreateAppPageFontDataOptions): AppPageFontData;
 declare function renderAppPageHtmlStream(options: RenderAppPageHtmlStreamOptions): Promise<AppSsrRenderResult>;
 /**
@@ -146,6 +142,5 @@ declare function deferUntilStreamConsumed(stream: ReadableStream<Uint8Array>, on
 declare function renderAppPageHtmlResponse(options: RenderAppPageHtmlResponseOptions): Promise<Response>;
 declare function renderAppPageHtmlStreamWithRecovery<TSpecialError>(options: RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError>): Promise<AppPageHtmlStreamRecoveryResult>;
 declare function createAppPageRscErrorTracker(baseOnError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown): AppPageRscErrorTracker;
-declare function shouldRerenderAppPageWithGlobalError(options: ShouldRerenderAppPageWithGlobalErrorOptions): boolean;
 //#endregion
-export { AppPageFontData, AppPageSsrHandler, AppSsrRenderResult, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
+export { AppPageFontData, AppPageSsrHandler, AppSsrRenderResult, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };

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

@@ -166,8 +166,5 @@ function createAppPageRscErrorTracker(baseOnError) {
 		}
 	};
 }
-function shouldRerenderAppPageWithGlobalError(options) {
-	return Boolean(options.capturedError) && !options.hasLocalBoundary;
-}
 //#endregion
-export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
+export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };

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

@@ -1,7 +1,8 @@
 import "./headers.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { NEVER_CACHE_CONTROL, STATIC_CACHE_CONTROL, applyCdnResponseHeaders, buildCachedRevalidateCacheControl } from "./cache-control.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
+import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-route-handler-response.ts
@@ -11,11 +12,6 @@ function hasMiddlewareHeader(headers) {
 	for (const key of headers.keys()) if (key.startsWith("x-middleware-")) return true;
 	return false;
 }
-function buildRouteHandlerCacheControl(cacheState, revalidateSeconds, expireSeconds) {
-	if (revalidateSeconds === 0) return NEVER_CACHE_CONTROL;
-	if (revalidateSeconds === Infinity) return STATIC_CACHE_CONTROL;
-	return buildCachedRevalidateCacheControl(cacheState, revalidateSeconds, expireSeconds);
-}
 function applyRouteHandlerMiddlewareContext(response, middlewareContext) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
 	const responseHeaders = new Headers(response.headers);
@@ -35,9 +31,14 @@ function buildRouteHandlerCachedResponse(cachedValue, options) {
 	for (const [key, value] of Object.entries(cachedValue.headers)) if (Array.isArray(value)) for (const entry of value) headers.append(key, entry);
 	else headers.set(key, value);
 	setCacheStateHeaders(headers, options.cacheState);
-	const revalidateSeconds = options.cacheControl?.revalidate ?? options.revalidateSeconds;
-	const expireSeconds = options.cacheControl === void 0 ? void 0 : options.cacheControl.expire ?? options.expireSeconds;
-	applyCdnResponseHeaders(headers, { cacheControl: buildRouteHandlerCacheControl(options.cacheState, revalidateSeconds, expireSeconds) });
+	const { cacheControl } = decideIsr({
+		cacheState: options.cacheState,
+		kind: "app-route",
+		revalidateSeconds: options.revalidateSeconds,
+		expireSeconds: options.expireSeconds,
+		cacheControlMeta: options.cacheControl
+	});
+	applyCdnResponseHeaders(headers, { cacheControl });
 	return new Response(options.isHead ? null : cachedValue.body, {
 		status: cachedValue.status,
 		headers
@@ -45,7 +46,7 @@ function buildRouteHandlerCachedResponse(cachedValue, options) {
 }
 function applyRouteHandlerRevalidateHeader(response, revalidateSeconds, expireSeconds, tags) {
 	applyCdnResponseHeaders(response.headers, {
-		cacheControl: buildRouteHandlerCacheControl("HIT", revalidateSeconds, expireSeconds),
+		cacheControl: buildAppRouteMissIsrCacheControl(revalidateSeconds, expireSeconds),
 		tags
 	});
 }