vinext 0.1.8 → 0.2.1

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

@@ -1,5 +1,6 @@
 import { notFoundResponse } from "./http-error-responses.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
+import { matchRoutePattern } from "../routing/route-pattern.js";
 import { getAppPageSegmentParamName } from "./app-page-params.js";
 import { loadAppInterceptLayouts } from "./app-route-module-loader.js";
 //#region src/server/app-page-request.ts
@@ -11,6 +12,31 @@ function pickRouteParams(matchedParams, routeParamNames) {
 	}
 	return params;
 }
+function remapRouteParams(matchedParams, source) {
+	if (source.paramPatternParts && source.routePatternParts) {
+		const urlParts = [];
+		for (const part of source.routePatternParts) {
+			if (!part.startsWith(":")) {
+				urlParts.push(part);
+				continue;
+			}
+			const value = matchedParams[part.slice(1).replace(/[+*]$/, "")];
+			if (Array.isArray(value)) urlParts.push(...value.map(encodeURIComponent));
+			else if (value !== void 0) urlParts.push(encodeURIComponent(value));
+		}
+		const slotParams = matchRoutePattern(urlParts, source.paramPatternParts);
+		if (slotParams) return slotParams;
+	}
+	if (!source.paramAliases) return matchedParams;
+	const params = { ...matchedParams };
+	for (const [routeParamName, sourceParamName] of Object.entries(source.paramAliases)) {
+		const value = matchedParams[routeParamName];
+		if (value === void 0) continue;
+		delete params[routeParamName];
+		params[sourceParamName] = value;
+	}
+	return params;
+}
 function collectParentParamNames(routeSegments, boundaryPosition) {
 	const limit = Math.max(0, Math.min(boundaryPosition, routeSegments.length));
 	const names = [];
@@ -23,6 +49,16 @@ function collectParentParamNames(routeSegments, boundaryPosition) {
 function getLayoutGenerateStaticParamsBoundary(layoutTreePosition) {
 	return (layoutTreePosition ?? 0) - 1;
 }
+function getParallelParentParamNames(routeParamNames, branch, boundaryPosition) {
+	const slotParamNames = branch.paramNames ?? routeParamNames;
+	const branchParamNames = collectParentParamNames(branch.routeSegments ?? [], boundaryPosition);
+	const branchParamNameSet = new Set((branch.routeSegments ?? []).flatMap((segment) => {
+		const name = getAppPageSegmentParamName(segment);
+		return name ? [name] : [];
+	}));
+	const ownerParamNames = slotParamNames.filter((name) => !branchParamNameSet.has(name));
+	return [...new Set([...ownerParamNames, ...branchParamNames])];
+}
 function resolveAppPageGenerateStaticParamsSources(options) {
 	const sources = [];
 	options.layouts?.forEach((layout, index) => {
@@ -36,6 +72,33 @@ function resolveAppPageGenerateStaticParamsSources(options) {
 		generateStaticParams: options.page.generateStaticParams,
 		parentParamNames: collectParentParamNames(options.routeSegments, Math.max(0, options.routeSegments.length - 1))
 	});
+	const routeParamNames = options.routeSegments.flatMap((segment) => {
+		const name = getAppPageSegmentParamName(segment);
+		return name ? [name] : [];
+	});
+	for (const parallelBranch of options.parallelBranches ?? []) {
+		if (!parallelBranch) continue;
+		const slotParamNames = parallelBranch.paramNames ?? routeParamNames;
+		const paramAliases = Object.fromEntries(routeParamNames.flatMap((routeParamName, index) => {
+			const slotParamName = slotParamNames[index];
+			return slotParamName && slotParamName !== routeParamName ? [[routeParamName, slotParamName]] : [];
+		}));
+		const addParallelSource = (module, boundaryPosition) => {
+			if (typeof module?.generateStaticParams !== "function") return;
+			sources.push({
+				generateStaticParams: module.generateStaticParams,
+				...Object.keys(paramAliases).length > 0 ? { paramAliases } : {},
+				...parallelBranch.patternParts ? { paramPatternParts: parallelBranch.patternParts } : {},
+				...options.routePatternParts ? { routePatternParts: options.routePatternParts } : {},
+				parentParamNames: getParallelParentParamNames(routeParamNames, parallelBranch, boundaryPosition)
+			});
+		};
+		addParallelSource(parallelBranch.layout, -1);
+		parallelBranch.configLayouts?.forEach((layout, index) => {
+			addParallelSource(layout, getLayoutGenerateStaticParamsBoundary(parallelBranch.configLayoutTreePositions?.[index]));
+		});
+		addParallelSource(parallelBranch.page, Math.max(0, (parallelBranch.routeSegments?.length ?? 0) - 1));
+	}
 	return sources;
 }
 function areStaticParamsAllowed(params, staticParams) {
@@ -44,8 +107,9 @@ function areStaticParamsAllowed(params, staticParams) {
 		const value = params[key];
 		const staticValue = staticParamSet[key];
 		if (staticValue === void 0) return true;
-		if (Array.isArray(value)) return JSON.stringify(value) === JSON.stringify(staticValue);
-		if (typeof staticValue === "string" || typeof staticValue === "number" || typeof staticValue === "boolean") return String(value) === String(staticValue);
+		if (Array.isArray(value)) return Array.isArray(staticValue) && value.length === staticValue.length && value.every((part, index) => typeof staticValue[index] === "string" ? part.toLowerCase() === staticValue[index].toLowerCase() : part === staticValue[index]);
+		if (typeof staticValue === "string") return value.toLowerCase() === staticValue.toLowerCase();
+		if (typeof staticValue === "number" || typeof staticValue === "boolean") return String(value) === String(staticValue);
 		return JSON.stringify(value) === JSON.stringify(staticValue);
 	}));
 }
@@ -67,8 +131,9 @@ async function validateAppPageDynamicParams(options) {
 		return notFoundResponse();
 	}
 	for (const source of generateStaticParamsSources) {
-		const staticParams = await runWithFetchDedupe(() => source.generateStaticParams({ params: pickRouteParams(options.params, source.parentParamNames) }));
-		if (Array.isArray(staticParams) && !areStaticParamsAllowed(options.params, staticParams)) {
+		const sourceParams = remapRouteParams(options.params, source);
+		const staticParams = await runWithFetchDedupe(() => source.generateStaticParams({ params: pickRouteParams(sourceParams, source.parentParamNames) }));
+		if (Array.isArray(staticParams) && !areStaticParamsAllowed(sourceParams, staticParams)) {
 			options.clearRequestContext();
 			return notFoundResponse();
 		}

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

@@ -15,6 +15,10 @@ type AppPageResponsePolicy = {
   cacheControl?: string;
   cacheState?: "MISS" | "STATIC";
 };
+type AppPagePrerenderCacheLife = {
+  expire?: number;
+  revalidate?: number;
+};
 type ResolveAppPageResponsePolicyBaseOptions = {
   isDraftMode: boolean;
   isDynamicError: boolean;
@@ -42,6 +46,8 @@ type BuildAppPageRscResponseOptions = {
   mountedSlotsHeader?: string | null;
   params?: Record<string, unknown>;
   policy: AppPageResponsePolicy;
+  renderedPathAndSearch?: string | null;
+  requestCacheLife?: AppPagePrerenderCacheLife | null;
   timing?: AppPageResponseTiming;
 };
 type BuildAppPageHtmlResponseOptions = {
@@ -50,6 +56,7 @@ type BuildAppPageHtmlResponseOptions = {
   isEdgeRuntime?: boolean;
   middlewareContext: AppPageMiddlewareContext;
   policy: AppPageResponsePolicy;
+  requestCacheLife?: AppPagePrerenderCacheLife | null;
   timing?: AppPageResponseTiming;
 };
 declare function resolveAppPageRscResponsePolicy(options: ResolveAppPageRscResponsePolicyOptions): AppPageResponsePolicy;

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 { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
 import { setCacheStateHeaders } from "./cache-headers.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 { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 //#region src/server/app-page-response.ts
 function applyTimingHeader(headers, timing) {
@@ -14,6 +14,14 @@ function applyTimingHeader(headers, timing) {
 function applyDynamicStaleTimeHeader(headers, dynamicStaleTimeSeconds) {
 	if (dynamicStaleTimeSeconds !== void 0 && Number.isInteger(dynamicStaleTimeSeconds) && dynamicStaleTimeSeconds >= 0) headers.set(VINEXT_DYNAMIC_STALE_TIME_HEADER, String(dynamicStaleTimeSeconds));
 }
+function applyPrerenderCacheLifeHeader(headers, requestCacheLife) {
+	if (!requestCacheLife) return;
+	const payload = {};
+	if (typeof requestCacheLife.revalidate === "number" && Number.isFinite(requestCacheLife.revalidate)) payload.revalidate = requestCacheLife.revalidate;
+	if (typeof requestCacheLife.expire === "number" && Number.isFinite(requestCacheLife.expire)) payload.expire = requestCacheLife.expire;
+	if (payload.revalidate === void 0 && payload.expire === void 0) return;
+	headers.set(VINEXT_PRERENDER_CACHE_LIFE_HEADER, JSON.stringify(payload));
+}
 function resolveAppPageRscResponsePolicy(options) {
 	if (options.isDraftMode) return { cacheControl: NO_STORE_CACHE_CONTROL };
 	if (options.isForceDynamic || options.dynamicUsedDuringBuild) return { cacheControl: NO_STORE_CACHE_CONTROL };
@@ -51,8 +59,8 @@ function resolveAppPageHtmlResponsePolicy(options) {
 	};
 	if ((options.isForceStatic || options.isDynamicError) && options.revalidateSeconds === null) return {
 		cacheControl: STATIC_CACHE_CONTROL,
-		cacheState: "STATIC",
-		shouldWriteToCache: false
+		cacheState: options.isProduction ? "MISS" : "STATIC",
+		shouldWriteToCache: options.isProduction
 	};
 	if (options.dynamicUsedDuringRender) return {
 		cacheControl: NO_STORE_CACHE_CONTROL,
@@ -92,7 +100,10 @@ function buildAppPageRscResponse(body, options) {
 	if (options.policy.cacheControl) headers.set("Cache-Control", options.policy.cacheControl);
 	if (options.policy.cacheState) setCacheStateHeaders(headers, options.policy.cacheState);
 	mergeMiddlewareResponseHeaders(headers, options.middlewareContext.headers);
+	if (options.renderedPathAndSearch) headers.set(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, encodeURIComponent(options.renderedPathAndSearch));
 	applyRscCompatibilityIdHeader(headers);
+	applyRscDeploymentIdHeader(headers);
+	applyPrerenderCacheLifeHeader(headers, options.requestCacheLife);
 	applyTimingHeader(headers, options.timing);
 	return new Response(body, {
 		status: options.middlewareContext.status ?? 200,
@@ -110,6 +121,7 @@ function buildAppPageHtmlResponse(body, options) {
 	if (options.draftCookie) headers.append("Set-Cookie", options.draftCookie);
 	if (options.linkHeader) headers.set("Link", options.linkHeader);
 	mergeMiddlewareResponseHeaders(headers, options.middlewareContext.headers);
+	applyPrerenderCacheLifeHeader(headers, options.requestCacheLife);
 	applyTimingHeader(headers, options.timing);
 	return new Response(body, {
 		status: options.middlewareContext.status ?? 200,

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

@@ -1,5 +1,5 @@
 import { AppRouteSemanticIds } from "../routing/app-route-graph.js";
-import { AppElements, AppElementsInterception } from "./app-elements-wire.js";
+import { AppElements, AppElementsInterception, AppElementsSlotBinding } from "./app-elements-wire.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { ThenableParamsObserver } from "../shims/thenable-params.js";
 import { Metadata, Viewport } from "../shims/metadata.js";
@@ -64,10 +64,16 @@ type AppPageRouteWiringRoute<TModule extends AppPageModule = AppPageModule, TErr
   unauthorized?: TModule | null;
   unauthorizeds?: readonly (TModule | null | undefined)[] | null;
   routeSegments?: readonly string[];
+  childrenRouteSegments?: readonly string[] | null;
   /**
    * Keyed by stable slot id (name + owner path), not necessarily the slot prop name.
    */
   slots?: Readonly<Record<string, AppPageRouteWiringSlot<TModule, TErrorModule>>> | null;
+  childrenSlot?: {
+    id: string;
+    ownerTreePath: string;
+    state: AppElementsSlotBinding["state"];
+  } | null;
   /**
    * Static sibling segment names at each dynamic URL level for this route. Used
    * by the client router to determine if a cached prefetch of the dynamic
@@ -96,6 +102,7 @@ type AppPageSlotOverride<TModule extends AppPageModule = AppPageModule> = {
   pageModule?: TModule | null;
   params?: AppPageParams;
   props?: Readonly<Record<string, unknown>>;
+  routeSegments?: readonly string[] | null;
 };
 type AppPageLayoutEntry<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule> = {
   errorModule?: TErrorModule | null | undefined;

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

@@ -10,7 +10,7 @@ import { MetadataHead, ViewportHead, renderMetadataToHtml } from "../shims/metad
 import { Children as Children$1, ParallelSlot, Slot } from "../shims/slot.js";
 import { resolveAppPageBranchParams, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { probeReactServerSubtree } from "./app-page-probe.js";
-import { resolveAppPageChildSegments, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey } from "./app-page-segment-state.js";
+import { APP_PAGE_SEGMENT_KEY, resolveAppPageChildSegments, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey } from "./app-page-segment-state.js";
 import { Fragment, Suspense } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/server/app-page-route-wiring.tsx
@@ -93,6 +93,10 @@ function createAppPageTemplateEntries(route) {
 function createAppPageSourcePage(routeSegments) {
 	return `/${[...routeSegments ?? [], "page"].join("/")}`;
 }
+function resolveAppPageLayoutSegmentProviderSegments(routeSegments, treePosition, params) {
+	const segments = resolveAppPageChildSegments(routeSegments, treePosition, params);
+	return segments.at(-1) === "__PAGE__" ? segments.slice(0, -1) : segments;
+}
 function createAppPageErrorEntries(route) {
 	return (route.errorPaths ?? route.errors ?? []).flatMap((errorModule, index) => {
 		if (!errorModule) return [];
@@ -104,7 +108,7 @@ function createAppPageErrorEntries(route) {
 		}];
 	});
 }
-function createAppPageParallelSlotEntries(layoutIndex, layoutEntries, route, getEffectiveSlotParams) {
+function createAppPageParallelSlotEntries(layoutIndex, layoutEntries, route, getEffectiveSlotParams, resolveSlotOverride) {
 	const parallelSlots = {};
 	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
 		const slotName = slot.name;
@@ -112,8 +116,10 @@ function createAppPageParallelSlotEntries(layoutIndex, layoutEntries, route, get
 		if (targetIndex !== layoutIndex) continue;
 		const slotId = resolveAppPageSlotId(slot, layoutEntries[targetIndex]?.treePath ?? "/");
 		const slotParams = getEffectiveSlotParams(slotKey, slotName);
+		const routeSegments = resolveSlotOverride(slotKey, slotName)?.routeSegments ?? slot.routeSegments;
 		parallelSlots[slotName] = /* @__PURE__ */ jsx(LayoutSegmentProvider, {
-			segmentMap: { children: slot.routeSegments ? resolveAppPageChildSegments(slot.routeSegments, 0, slotParams) : [] },
+			providerId: slotId,
+			segmentMap: { children: routeSegments ? resolveAppPageLayoutSegmentProviderSegments(routeSegments, 0, slotParams) : [] },
 			children: /* @__PURE__ */ jsx(Slot, { id: slotId })
 		});
 	}
@@ -131,6 +137,14 @@ function resolveAppPageSlotBindingState(slot, override) {
 }
 function createAppPageSlotBindings(route, layoutEntries, resolveSlotOverride, options) {
 	const bindings = [];
+	if (route.childrenSlot) {
+		const ownerLayoutId = layoutEntries.find((layoutEntry) => layoutEntry.treePath === route.childrenSlot?.ownerTreePath)?.id;
+		bindings.push({
+			ownerLayoutId: ownerLayoutId ?? null,
+			slotId: route.childrenSlot.id,
+			state: route.childrenSlot.state
+		});
+	}
 	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
 		const layoutEntry = layoutEntries[slot.layoutIndex >= 0 ? slot.layoutIndex : layoutEntries.length - 1] ?? null;
 		const ownerLayoutId = layoutEntry?.id ?? null;
@@ -173,6 +187,7 @@ function buildAppPageElements(options) {
 	const routeResetKey = resolveAppPageRouteStateKey(routeSegments, options.matchedParams);
 	const routeId = renderIdentity?.routeId ?? AppElementsWire.encodeRouteId(options.routePath, interceptionContext);
 	const pageId = renderIdentity?.pageId ?? AppElementsWire.encodePageId(options.routePath, interceptionContext);
+	const pageElementId = options.route.childrenSlot?.id ?? pageId;
 	const layoutEntries = createAppPageLayoutEntries(options.route);
 	const templateEntries = createAppPageTemplateEntries(options.route);
 	const errorEntries = createAppPageErrorEntries(options.route);
@@ -246,19 +261,13 @@ function buildAppPageElements(options) {
 	const routeLoadingComponent = getDefaultExport(options.route.loading);
 	const isPrefetchLoadingShell = renderMode === APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL;
 	if (isPrefetchLoadingShell && routeLoadingComponent !== null) elements[APP_PREFETCH_LOADING_SHELL_MARKER_KEY] = "LoadingBoundary";
-	elements[pageId] = isPrefetchLoadingShell ? null : renderAfterAppDependencies(options.element, pageDependencies);
+	elements[pageElementId] = isPrefetchLoadingShell ? null : renderAfterAppDependencies(options.element, pageDependencies);
 	for (const templateEntry of templateEntries) {
 		const templateComponent = getDefaultExport(templateEntry.templateModule);
 		if (!templateComponent) continue;
 		const TemplateComponent = templateComponent;
 		const templateDependency = templateDependenciesById.get(templateEntry.id);
-		const templateElement = templateDependency ? renderWithAppDependencyBarrier(/* @__PURE__ */ jsx(TemplateComponent, {
-			params: options.matchedParams,
-			children: /* @__PURE__ */ jsx(Children$1, {})
-		}), templateDependency) : /* @__PURE__ */ jsx(TemplateComponent, {
-			params: options.matchedParams,
-			children: /* @__PURE__ */ jsx(Children$1, {})
-		});
+		const templateElement = templateDependency ? renderWithAppDependencyBarrier(/* @__PURE__ */ jsx(TemplateComponent, { children: /* @__PURE__ */ jsx(Children$1, {}) }), templateDependency) : /* @__PURE__ */ jsx(TemplateComponent, { children: /* @__PURE__ */ jsx(Children$1, {}) });
 		elements[templateEntry.id] = renderAfterAppDependencies(templateElement, templateDependenciesBeforeById.get(templateEntry.id) ?? []);
 	}
 	for (let index = 0; index < layoutEntries.length; index++) {
@@ -296,7 +305,7 @@ function buildAppPageElements(options) {
 		const slotId = resolveAppPageSlotId(slot, layoutEntries[targetIndex]?.treePath ?? "/");
 		const slotOverride = resolveSlotOverride(slotKey, slotName);
 		const slotParams = getEffectiveSlotParams(slotKey, slotName);
-		const slotRouteSegments = slot.routeSegments ?? [];
+		const slotRouteSegments = slotOverride?.routeSegments ?? slot.routeSegments ?? [];
 		const slotOwnerParams = resolveAppPageSegmentParams(options.route.routeSegments, layoutEntries[targetIndex]?.treePosition ?? 0, options.matchedParams);
 		const slotResetKey = resolveAppPageRouteStateKey(slotRouteSegments, slotParams);
 		const overrideOrPageComponent = getDefaultExport(slotOverride?.pageModule) ?? getDefaultExport(slot.page);
@@ -338,7 +347,7 @@ function buildAppPageElements(options) {
 				children: slotElement
 			});
 		}
-		const slotLayoutComponent = getDefaultExport(slot.layout);
+		const slotLayoutComponent = overrideOrPageComponent ? getDefaultExport(slot.layout) : null;
 		if (slotLayoutComponent) slotElement = /* @__PURE__ */ jsx(slotLayoutComponent, {
 			params: options.makeThenableParams(slotOwnerParams),
 			children: slotElement
@@ -357,8 +366,9 @@ function buildAppPageElements(options) {
 		elements[slotId] = renderAfterAppDependencies(slotElement, targetIndex >= 0 ? slotDependenciesByLayoutIndex[targetIndex] ?? [] : []);
 	}
 	let routeChildren = /* @__PURE__ */ jsx(LayoutSegmentProvider, {
-		segmentMap: { children: [] },
-		children: /* @__PURE__ */ jsx(Slot, { id: pageId })
+		providerId: pageElementId,
+		segmentMap: { children: [APP_PAGE_SEGMENT_KEY] },
+		children: /* @__PURE__ */ jsx(Slot, { id: pageElementId })
 	});
 	if (isPrefetchLoadingShell) if (routeLoadingComponent === null) routeChildren = null;
 	else routeChildren = /* @__PURE__ */ jsx(routeLoadingComponent, {});
@@ -438,18 +448,22 @@ function buildAppPageElements(options) {
 		}
 		const layoutHasElement = getDefaultExport(layoutEntry.layoutModule) !== null;
 		const layoutIndex = layoutIndicesByTreePosition.get(treePosition) ?? -1;
-		const segmentMap = { children: resolveAppPageChildSegments(routeSegments, layoutEntry.treePosition, options.matchedParams) };
+		const segmentMap = { children: resolveAppPageLayoutSegmentProviderSegments(options.route.childrenRouteSegments ?? routeSegments, layoutEntry.treePosition, options.matchedParams) };
 		for (const [slotKey, slot] of Object.entries(options.route.slots ?? {})) {
 			const slotName = slot.name;
 			if ((slot.layoutIndex >= 0 ? slot.layoutIndex : layoutEntries.length - 1) !== layoutIndex) continue;
 			const slotParams = getEffectiveSlotParams(slotKey, slotName);
-			segmentMap[slotName] = slot.routeSegments ? resolveAppPageChildSegments(slot.routeSegments, 0, slotParams) : [];
+			const slotOverride = resolveSlotOverride(slotKey, slotName);
+			if (!(getDefaultExport(slotOverride?.pageModule) !== null || getDefaultExport(slot.page) !== null) && options.isRscRequest && options.mountedSlotIds?.has(resolveAppPageSlotId(slot, layoutEntry.treePath))) continue;
+			const slotRouteSegments = slotOverride?.routeSegments ?? slot.routeSegments;
+			segmentMap[slotName] = slotRouteSegments ? resolveAppPageLayoutSegmentProviderSegments(slotRouteSegments, 0, slotParams) : [];
 		}
 		routeChildren = /* @__PURE__ */ jsx(LayoutSegmentProvider, {
+			providerId: layoutEntry.id,
 			segmentMap,
 			children: layoutHasElement ? /* @__PURE__ */ jsx(Slot, {
 				id: layoutEntry.id,
-				parallelSlots: createAppPageParallelSlotEntries(layoutIndex, layoutEntries, options.route, getEffectiveSlotParams),
+				parallelSlots: createAppPageParallelSlotEntries(layoutIndex, layoutEntries, options.route, getEffectiveSlotParams, resolveSlotOverride),
 				children: segmentChildren
 			}) : segmentChildren
 		});

package/dist/server/app-page-segment-state.d.ts

@@ -1,9 +1,10 @@
 import { AppPageParams } from "./app-page-boundary.js";
 
 //#region src/server/app-page-segment-state.d.ts
+declare const APP_PAGE_SEGMENT_KEY = "__PAGE__";
 declare function resolveAppPageChildSegments(routeSegments: readonly string[], treePosition: number, params: AppPageParams): string[];
 declare function resolveAppPageSegmentStateKey(routeSegments: readonly string[], treePosition: number, params: AppPageParams): string;
 declare function resolveAppPageRouteStateKey(routeSegments: readonly string[], params: AppPageParams): string;
 declare function resolveAppPageLeafSegmentStateKey(routeSegments: readonly string[], params: AppPageParams): string;
 //#endregion
-export { resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };
+export { APP_PAGE_SEGMENT_KEY, resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };

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

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

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

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

@@ -1,4 +1,5 @@
 import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
+import { runWithRootParamsUsage } from "../shims/root-params.js";
 import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
 import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
@@ -33,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-tree-prefetch.d.ts

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