vinext 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/server/app-page-http-access-fallback-metadata.js

@@ -0,0 +1,106 @@
+import { mergeViewport, resolveModuleViewport } from "../shims/metadata.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
+import { resolveOrderedAppPageMetadata } from "./app-page-head.js";
+//#region src/server/app-page-http-access-fallback-metadata.ts
+function isPresent(value) {
+	return value !== null && value !== void 0;
+}
+/**
+* Translate HTTP-access boundary semantics into the exact metadata source
+* order used by Next.js's loader-tree walk.
+*
+* The not-found convention is appended at every active leaf. A sibling
+* intercept is the primary leaf and therefore precedes the ordinary slot
+* branches; otherwise the convention also represents the primary page leaf.
+*/
+function createHttpAccessFallbackPlan(options, fallbackLeafMode) {
+	const routeSegments = options.routeSegments ?? [];
+	const plan = [];
+	for (const [index, layoutModule] of options.layoutModules.entries()) {
+		if (!isPresent(layoutModule)) continue;
+		const treePosition = options.layoutTreePositions?.[index] ?? 0;
+		plan.push({
+			kind: "source",
+			source: {
+				includeWhenEmpty: true,
+				module: layoutModule,
+				params: resolveAppPageSegmentParams(routeSegments, treePosition, options.params),
+				routeSegments: routeSegments.slice(0, treePosition)
+			}
+		});
+	}
+	let activeBoundaryModule = options.boundaryModule;
+	let activeBoundaryParams = options.boundaryParams;
+	let activeBoundaryRouteSegments = routeSegments;
+	const appendFallbackLeaf = () => {
+		if (fallbackLeafMode === "final") {
+			plan.push({ kind: "fallback-leaf" });
+			return;
+		}
+		if (!activeBoundaryModule) return;
+		plan.push({
+			kind: "source",
+			source: {
+				includeWhenEmpty: true,
+				module: activeBoundaryModule,
+				params: activeBoundaryParams,
+				routeSegments: activeBoundaryRouteSegments
+			}
+		});
+	};
+	if (!options.primaryParallelBranch) appendFallbackLeaf();
+	const parallelBranches = [...options.primaryParallelBranch ? [options.primaryParallelBranch] : [], ...[...options.parallelBranches ?? []].sort((left, right) => right.ownerTreePosition - left.ownerTreePosition)];
+	for (const branch of parallelBranches) {
+		const parallelRoute = branch.head;
+		const parallelParams = parallelRoute.params ?? options.params;
+		const parallelRouteSegments = parallelRoute.routeSegments ?? routeSegments;
+		const layoutModules = [...parallelRoute.layoutModules ?? [], parallelRoute.layoutModule].filter(isPresent);
+		const layoutTreePositions = parallelRoute.layoutTreePositions ?? [];
+		const layoutParams = parallelRoute.layoutParams ?? [];
+		for (const [index, layoutModule] of layoutModules.entries()) plan.push({
+			kind: "source",
+			source: {
+				includeWhenEmpty: true,
+				module: layoutModule,
+				params: layoutParams[index] ?? resolveAppPageBranchParams(parallelRouteSegments, layoutTreePositions[index] ?? 0, parallelParams),
+				routeSegments: parallelRouteSegments
+			}
+		});
+		if (options.branchNotFoundConventions !== false && branch.notFoundModule) {
+			activeBoundaryModule = branch.notFoundModule;
+			activeBoundaryParams = branch.notFoundParams ?? parallelParams;
+			activeBoundaryRouteSegments = parallelRouteSegments;
+		}
+		appendFallbackLeaf();
+	}
+	return plan.flatMap((item) => {
+		if (item.kind === "source") return [item.source];
+		if (!activeBoundaryModule) return [];
+		return [{
+			includeWhenEmpty: true,
+			module: activeBoundaryModule,
+			params: activeBoundaryParams,
+			routeSegments: activeBoundaryRouteSegments
+		}];
+	});
+}
+function createHttpAccessFallbackMetadataPlan(options) {
+	return createHttpAccessFallbackPlan(options, "final");
+}
+function resolveHttpAccessFallbackMetadata(options) {
+	return resolveOrderedAppPageMetadata({
+		applyFileBasedMetadata: options.applyFileBasedMetadata,
+		basePath: options.basePath,
+		fallbackOnFileMetadataError: options.fallbackOnFileMetadataError,
+		metadataRoutes: options.metadataRoutes,
+		params: options.params,
+		routePath: options.routePath,
+		routeSegments: options.routeSegments,
+		sources: createHttpAccessFallbackMetadataPlan(options)
+	});
+}
+async function resolveHttpAccessFallbackViewport(options) {
+	return mergeViewport((await Promise.all(createHttpAccessFallbackPlan(options, "snapshot").map((source) => resolveModuleViewport(source.module, source.params)))).filter(isPresent));
+}
+//#endregion
+export { createHttpAccessFallbackMetadataPlan, resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport };

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

@@ -3,11 +3,11 @@ import { AppOutgoingElements } from "./app-elements-wire.js";
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
+import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
-import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { CachedAppPageValue } from "../shims/cache-handler.js";
-import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageRenderObservationState } from "./app-page-render-observation.js";
 import { ReactNode } from "react";
 import { ReactFormState } from "react-dom/client";

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

@@ -11,10 +11,10 @@ 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-finalizer.js";
 import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
+import { hasDigest } from "./app-rsc-errors.js";
 import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, 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";
 //#region src/server/app-page-render.ts
 function buildResponseTiming(options) {

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

@@ -11,7 +11,13 @@ type GenerateStaticParamsModule = {
   generateStaticParams?: GenerateStaticParams | null;
 };
 type GenerateStaticParamsSource = {
+  /**
+   * Primary loader-tree sources execute top-down as one chain. Each source
+   * receives the complete params object produced by the sources before it.
+   */
+  chained?: true;
   generateStaticParams: GenerateStaticParams;
+  independentChain?: number;
   paramAliases?: Readonly<Record<string, string>>;
   paramPatternParts?: readonly string[];
   routePatternParts?: readonly string[];
@@ -56,14 +62,20 @@ type AppPageInterceptMatch<TPage = unknown> = {
   interceptLayouts?: readonly unknown[] | null;
   interceptLayoutSegments?: readonly (readonly string[])[] | null;
   interceptBranchSegments?: readonly string[] | null;
+  interceptNotFoundBranchSegments?: readonly string[] | null;
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   matchedParams: AppPageParams;
   sourceMatchedParams?: AppPageParams;
   page: TPage;
   __pageLoader?: (() => Promise<TPage>) | null;
+  notFound?: unknown;
+  __loadNotFound?: (() => Promise<unknown>) | null;
+  notFoundTreePosition?: number | null;
   __loadState?: {
     page: TPage;
     pageLoading: Promise<TPage> | null;
+    notFound?: unknown;
+    notFoundLoading?: Promise<unknown> | null;
     interceptLayoutsLoading: Promise<readonly unknown[]> | null;
   };
   slotId?: string | null;

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

@@ -46,8 +46,14 @@ function collectParentParamNames(routeSegments, boundaryPosition) {
 	}
 	return names;
 }
-function getLayoutGenerateStaticParamsBoundary(layoutTreePosition) {
-	return (layoutTreePosition ?? 0) - 1;
+function getLayoutGenerateStaticParamsBoundary(routeSegments, layoutTreePosition) {
+	let boundary = Math.min((layoutTreePosition ?? 0) - 1, routeSegments.length - 1);
+	while (boundary >= 0) {
+		const segment = routeSegments[boundary];
+		if (!segment.startsWith("@") && !(segment.startsWith("(") && segment.endsWith(")"))) break;
+		boundary -= 1;
+	}
+	return boundary;
 }
 function getParallelParentParamNames(routeParamNames, branch, boundaryPosition) {
 	const slotParamNames = branch.paramNames ?? routeParamNames;
@@ -64,11 +70,13 @@ function resolveAppPageGenerateStaticParamsSources(options) {
 	options.layouts?.forEach((layout, index) => {
 		if (typeof layout?.generateStaticParams !== "function") return;
 		sources.push({
+			chained: true,
 			generateStaticParams: layout.generateStaticParams,
-			parentParamNames: collectParentParamNames(options.routeSegments, getLayoutGenerateStaticParamsBoundary(options.layoutTreePositions?.[index]))
+			parentParamNames: collectParentParamNames(options.routeSegments, getLayoutGenerateStaticParamsBoundary(options.routeSegments, options.layoutTreePositions?.[index]))
 		});
 	});
 	if (typeof options.page?.generateStaticParams === "function") sources.push({
+		chained: true,
 		generateStaticParams: options.page.generateStaticParams,
 		parentParamNames: collectParentParamNames(options.routeSegments, Math.max(0, options.routeSegments.length - 1))
 	});
@@ -76,7 +84,7 @@ function resolveAppPageGenerateStaticParamsSources(options) {
 		const name = getAppPageSegmentParamName(segment);
 		return name ? [name] : [];
 	});
-	for (const parallelBranch of options.parallelBranches ?? []) {
+	for (const [independentChain, parallelBranch] of (options.parallelBranches ?? []).entries()) {
 		if (!parallelBranch) continue;
 		const slotParamNames = parallelBranch.paramNames ?? routeParamNames;
 		const paramAliases = Object.fromEntries(routeParamNames.flatMap((routeParamName, index) => {
@@ -87,6 +95,7 @@ function resolveAppPageGenerateStaticParamsSources(options) {
 			if (typeof module?.generateStaticParams !== "function") return;
 			sources.push({
 				generateStaticParams: module.generateStaticParams,
+				independentChain,
 				...Object.keys(paramAliases).length > 0 ? { paramAliases } : {},
 				...parallelBranch.patternParts ? { paramPatternParts: parallelBranch.patternParts } : {},
 				...options.routePatternParts ? { routePatternParts: options.routePatternParts } : {},
@@ -95,24 +104,101 @@ function resolveAppPageGenerateStaticParamsSources(options) {
 		};
 		addParallelSource(parallelBranch.layout, -1);
 		parallelBranch.configLayouts?.forEach((layout, index) => {
-			addParallelSource(layout, getLayoutGenerateStaticParamsBoundary(parallelBranch.configLayoutTreePositions?.[index]));
+			addParallelSource(layout, getLayoutGenerateStaticParamsBoundary(parallelBranch.routeSegments ?? [], parallelBranch.configLayoutTreePositions?.[index]));
 		});
 		addParallelSource(parallelBranch.page, Math.max(0, (parallelBranch.routeSegments?.length ?? 0) - 1));
 	}
 	return sources;
 }
-function areStaticParamsAllowed(params, staticParams) {
+function areStaticParamsAllowed(params, staticParams, allowMissingValues = false) {
 	const paramKeys = Object.keys(params);
+	const stringParamMatches = (value, staticValue) => value === encodeURIComponent(staticValue);
 	return staticParams.some((staticParamSet) => paramKeys.every((key) => {
 		const value = params[key];
 		const staticValue = staticParamSet[key];
-		if (staticValue === void 0) return true;
-		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 (!Object.hasOwn(staticParamSet, key)) return allowMissingValues;
+		if (Array.isArray(value)) return Array.isArray(staticValue) && value.length === staticValue.length && value.every((part, index) => typeof staticValue[index] === "string" ? stringParamMatches(part, staticValue[index]) : part === staticValue[index]);
+		if (typeof staticValue === "string") return stringParamMatches(value, staticValue);
 		if (typeof staticValue === "number" || typeof staticValue === "boolean") return String(value) === String(staticValue);
 		return JSON.stringify(value) === JSON.stringify(staticValue);
 	}));
 }
+function remapStaticParamsToRouteParams(staticParams, source) {
+	if (!source.paramAliases) return [...staticParams];
+	const routeParamNamesBySourceName = new Map(Object.entries(source.paramAliases).map(([routeParamName, sourceParamName]) => [sourceParamName, routeParamName]));
+	return staticParams.map((params) => Object.fromEntries(Object.entries(params).map(([name, value]) => [routeParamNamesBySourceName.get(name) ?? name, value])));
+}
+async function generateIndependentStaticParams(sources, primaryParams, requestParams) {
+	let rows = (primaryParams ?? []).map((params) => ({
+		params,
+		branchParams: {}
+	}));
+	let hasParentParams = rows.length > 0;
+	let validated = false;
+	for (const source of sources) {
+		const parents = hasParentParams ? rows : [{
+			params: {},
+			branchParams: {}
+		}];
+		const nextRows = [];
+		for (const parent of parents) {
+			const sourceParams = remapRouteParams({
+				...requestParams,
+				...parent.params
+			}, source);
+			const branchParams = remapRouteParams(parent.branchParams, source);
+			const result = await runWithFetchDedupe(() => source.generateStaticParams({ params: {
+				...pickRouteParams(sourceParams, source.parentParamNames),
+				...branchParams
+			} }));
+			if (!Array.isArray(result)) {
+				if (hasParentParams) nextRows.push(parent);
+				continue;
+			}
+			validated = true;
+			const routeResults = remapStaticParamsToRouteParams(result, source);
+			if (routeResults.length === 0) {
+				if (hasParentParams) nextRows.push(parent);
+				continue;
+			}
+			for (const routeResult of routeResults) nextRows.push({
+				params: {
+					...parent.params,
+					...routeResult
+				},
+				branchParams: {
+					...parent.branchParams,
+					...routeResult
+				}
+			});
+		}
+		rows = nextRows;
+		hasParentParams = rows.length > 0;
+	}
+	return {
+		staticParams: rows.map((row) => row.params),
+		validated
+	};
+}
+async function generateChainedStaticParams(sources) {
+	let generatedParams = [];
+	for (const source of sources) {
+		const hasParentParams = generatedParams.length > 0;
+		const parents = hasParentParams ? generatedParams : [{}];
+		const nextParams = [];
+		for (const parentParams of parents) {
+			const result = await runWithFetchDedupe(() => source.generateStaticParams({ params: parentParams }));
+			if (Array.isArray(result) && result.length > 0) {
+				for (const item of result) if (item !== null && typeof item === "object" && !Array.isArray(item)) nextParams.push({
+					...parentParams,
+					...item
+				});
+			} else if (hasParentParams) nextParams.push(parentParams);
+		}
+		generatedParams = nextParams;
+	}
+	return generatedParams;
+}
 function normalizeGenerateStaticParams(generateStaticParams) {
 	return (Array.isArray(generateStaticParams) ? generateStaticParams : [generateStaticParams]).flatMap((source) => {
 		if (typeof source === "function") return [{
@@ -130,10 +216,28 @@ async function validateAppPageDynamicParams(options) {
 		options.clearRequestContext();
 		return notFoundResponse();
 	}
-	for (const source of generateStaticParamsSources) {
-		const sourceParams = remapRouteParams(options.params, source);
-		const staticParams = await runWithFetchDedupe(() => source.generateStaticParams({ params: pickRouteParams(sourceParams, source.parentParamNames) }));
-		if (Array.isArray(staticParams) && !areStaticParamsAllowed(sourceParams, staticParams)) {
+	const chainedSources = generateStaticParamsSources.filter((source) => source.chained);
+	let chainedStaticParams = null;
+	if (chainedSources.length > 0) chainedStaticParams = await generateChainedStaticParams(chainedSources);
+	const independentChains = /* @__PURE__ */ new Map();
+	for (const source of generateStaticParamsSources.filter((source) => !source.chained)) {
+		const chain = independentChains.get(source.independentChain ?? source) ?? [];
+		chain.push(source);
+		independentChains.set(source.independentChain ?? source, chain);
+	}
+	let validatedIndependentResults = false;
+	for (const sources of independentChains.values()) {
+		const result = await generateIndependentStaticParams(sources, chainedStaticParams, options.params);
+		if (result.validated) {
+			validatedIndependentResults = true;
+			if (!areStaticParamsAllowed(options.params, result.staticParams, true)) {
+				options.clearRequestContext();
+				return notFoundResponse();
+			}
+		}
+	}
+	if (chainedStaticParams && !validatedIndependentResults) {
+		if (!areStaticParamsAllowed(options.params, chainedStaticParams)) {
 			options.clearRequestContext();
 			return notFoundResponse();
 		}
@@ -187,6 +291,22 @@ async function resolveAppPageInterceptState(options) {
 		if (loadState) loadState.pageLoading = loading;
 		await loading;
 	}
+	if (loadState?.notFound != null) intercept.notFound = loadState.notFound;
+	if (intercept.__loadNotFound && intercept.notFound == null) {
+		const loading = loadState?.notFoundLoading ?? intercept.__loadNotFound().then((notFound) => {
+			intercept.notFound = notFound;
+			if (loadState) {
+				loadState.notFound = notFound;
+				loadState.notFoundLoading = null;
+			}
+			return notFound;
+		}).catch((error) => {
+			if (loadState) loadState.notFoundLoading = null;
+			throw error;
+		});
+		if (loadState) loadState.notFoundLoading = loading;
+		await loading;
+	}
 	if (intercept.__loadInterceptLayouts) await loadAppInterceptLayouts(intercept);
 	const sourceRoute = await options.getSourceRoute(intercept.sourceRouteIndex);
 	if (!sourceRoute) return { kind: "none" };

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

@@ -37,6 +37,8 @@ type AppPageRouteWiringSlot<TModule extends AppPageModule = AppPageModule, TErro
   layout?: TModule | null;
   layoutIndex: number;
   loading?: TModule | null;
+  notFound?: TModule | null;
+  notFoundTreePosition?: number | null;
   page?: TModule | null;
   routeSegments?: readonly string[] | null;
   /**
@@ -59,9 +61,12 @@ type AppPageRouteWiringRoute<TModule extends AppPageModule = AppPageModule, TErr
   loading?: TModule | null;
   notFound?: TModule | null;
   notFounds?: readonly (TModule | null | undefined)[] | null;
+  notFoundTreePosition?: number | null;
   forbidden?: TModule | null;
+  forbiddenTreePosition?: number | null;
   forbiddens?: readonly (TModule | null | undefined)[] | null;
   unauthorized?: TModule | null;
+  unauthorizedTreePosition?: number | null;
   unauthorizeds?: readonly (TModule | null | undefined)[] | null;
   routeSegments?: readonly string[];
   childrenRouteSegments?: readonly string[] | null;
@@ -124,6 +129,10 @@ type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModu
   resolvedMetadata: Metadata | null;
   resolvedMetadataPathname?: string;
   resolvedViewport: Viewport;
+  streamingMetadata?: Promise<Metadata | null> | null;
+  streamingMetadataOutlet?: Promise<unknown> | null;
+  streamingMetadataOutletSuspended?: boolean;
+  streamingMetadataTags?: Promise<Metadata | null> | null;
   trailingSlash?: boolean;
   rootForbiddenModule?: TModule | null;
   rootNotFoundModule?: TModule | null;

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

@@ -179,6 +179,37 @@ function createAppPageRouteBodyMetadata(metadata, pathname, metadataPlacement, t
 		dangerouslySetInnerHTML: { __html: renderMetadataToHtml(metadata, pathname, { trailingSlash }) }
 	});
 }
+async function AppPageStreamingMetadata(props) {
+	try {
+		return createAppPageRouteBodyMetadata(await props.metadata, props.pathname, "body", props.trailingSlash);
+	} catch {
+		return null;
+	}
+}
+AppPageStreamingMetadata.displayName = "Vinext.StreamingMetadata";
+async function AppPageMetadataOutlet(props) {
+	await props.metadata;
+	return null;
+}
+AppPageMetadataOutlet.displayName = "Vinext.MetadataOutlet";
+function createAppPageStreamingMetadataOutlet(elementId, suspended = true) {
+	if (!elementId) return null;
+	const outlet = /* @__PURE__ */ jsx(Slot, { id: elementId });
+	return suspended ? /* @__PURE__ */ jsx(Suspense, {
+		fallback: null,
+		children: outlet
+	}) : outlet;
+}
+function createAppPageStreamingMetadataBody(elementId) {
+	if (!elementId) return null;
+	return /* @__PURE__ */ jsx("div", {
+		hidden: true,
+		children: /* @__PURE__ */ jsx(Suspense, {
+			fallback: null,
+			children: /* @__PURE__ */ jsx(Slot, { id: elementId })
+		})
+	});
+}
 function buildAppPageElements(options) {
 	const renderIdentity = options.renderIdentity;
 	const interceptionContext = renderIdentity?.interceptionContext ?? options.interceptionContext ?? null;
@@ -188,6 +219,8 @@ function buildAppPageElements(options) {
 	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 streamingMetadataBodyId = options.streamingMetadata ? `__vinext_streaming_metadata_body:${routeId}` : null;
+	const streamingMetadataOutletId = options.streamingMetadataOutlet ? `__vinext_streaming_metadata_outlet:${routeId}` : null;
 	const layoutEntries = createAppPageLayoutEntries(options.route);
 	const templateEntries = createAppPageTemplateEntries(options.route);
 	const errorEntries = createAppPageErrorEntries(options.route);
@@ -237,6 +270,12 @@ function buildAppPageElements(options) {
 		})
 	}) };
 	if (options.route.staticSiblings && options.route.staticSiblings.length > 0) elements[APP_STATIC_SIBLINGS_KEY] = options.route.staticSiblings;
+	if (options.streamingMetadata && streamingMetadataBodyId) elements[streamingMetadataBodyId] = /* @__PURE__ */ jsx(AppPageStreamingMetadata, {
+		metadata: options.streamingMetadataTags ?? options.streamingMetadata,
+		pathname: options.resolvedMetadataPathname ?? options.routePath,
+		trailingSlash: options.trailingSlash
+	});
+	if (options.streamingMetadataOutlet && streamingMetadataOutletId) elements[streamingMetadataOutletId] = /* @__PURE__ */ jsx(AppPageMetadataOutlet, { metadata: options.streamingMetadataOutlet });
 	const getEffectiveSlotParams = (slotKey, slotName) => resolveSlotOverride(slotKey, slotName)?.params ?? options.matchedParams;
 	for (const treePosition of orderedTreePositions) {
 		const layoutIndex = layoutIndicesByTreePosition.get(treePosition);
@@ -365,11 +404,11 @@ function buildAppPageElements(options) {
 		});
 		elements[slotId] = renderAfterAppDependencies(slotElement, targetIndex >= 0 ? slotDependenciesByLayoutIndex[targetIndex] ?? [] : []);
 	}
-	let routeChildren = /* @__PURE__ */ jsx(LayoutSegmentProvider, {
+	let routeChildren = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(LayoutSegmentProvider, {
 		providerId: pageElementId,
 		segmentMap: { children: [APP_PAGE_SEGMENT_KEY] },
 		children: /* @__PURE__ */ jsx(Slot, { id: pageElementId })
-	});
+	}), createAppPageStreamingMetadataOutlet(streamingMetadataOutletId, options.streamingMetadataOutletSuspended)] });
 	if (isPrefetchLoadingShell) if (routeLoadingComponent === null) routeChildren = null;
 	else routeChildren = /* @__PURE__ */ jsx(routeLoadingComponent, {});
 	else {
@@ -479,7 +518,8 @@ function buildAppPageElements(options) {
 	elements[routeId] = /* @__PURE__ */ jsxs(Fragment$1, { children: [
 		createAppPageRouteHead(options.resolvedMetadata, options.resolvedViewport, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement, options.trailingSlash),
 		routeChildren,
-		createAppPageRouteBodyMetadata(options.resolvedMetadata, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement, options.trailingSlash)
+		createAppPageRouteBodyMetadata(options.resolvedMetadata, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement, options.trailingSlash),
+		createAppPageStreamingMetadataBody(streamingMetadataBodyId)
 	] });
 	registerAppElementRenderDependencies(elements, renderDependenciesByElementId);
 	return elements;

package/dist/server/app-post-middleware-context.d.ts

@@ -1,4 +1,4 @@
-import { RequestContext } from "../config/config-matchers.js";
+import { RequestContext } from "../config/request-context.js";
 
 //#region src/server/app-post-middleware-context.d.ts
 /**

package/dist/server/app-post-middleware-context.js

@@ -1,4 +1,4 @@
-import { normalizeHost, requestContextFromRequest } from "../config/config-matchers.js";
+import { normalizeHost, requestContextFromRequest } from "../config/request-context.js";
 import { getHeadersContext } from "../shims/headers.js";
 //#region src/server/app-post-middleware-context.ts
 /**

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

@@ -1,17 +1,18 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
-import { consumeDynamicUsage, getAndClearPendingCookies, getDraftModeCookieHeader, markDynamicUsage, setHeadersAccessPhase } from "../shims/headers.js";
+import { consumeDynamicUsage, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, markDynamicUsage, setHeadersAccessPhase } from "../shims/headers.js";
+import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { setNavigationContext } from "../shims/navigation-context-state.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import "../shims/navigation.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
-import { applyRouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
+import { applyRouteHandlerMiddlewareContext, finalizeRouteHandlerResponse } from "./app-route-handler-response.js";
 import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
-import { executeAppRouteHandler } from "./app-route-handler-execution.js";
+import { applyDraftModeCachePolicy, executeAppRouteHandler } from "./app-route-handler-execution.js";
 import { readAppRouteHandlerCacheResponse } from "./app-route-handler-cache.js";
 import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 //#region src/server/app-route-handler-dispatch.ts
@@ -37,7 +38,11 @@ async function runInRouteHandlerRevalidationContext(options, renderFn) {
 		setCurrentFetchSoftTags(buildRouteHandlerPageCacheTags(options.cleanPathname, [], options.routeSegments));
 		setCurrentFetchCacheMode(options.fetchCacheMode);
 		setCurrentForceDynamicFetchDefault(options.dynamicConfig === "force-dynamic");
-		await renderFn();
+		try {
+			await renderFn();
+		} finally {
+			await _drainPendingRevalidations();
+		}
 	});
 }
 async function dispatchAppRouteHandler(options) {
@@ -47,19 +52,25 @@ async function dispatchAppRouteHandler(options) {
 	const revalidateSeconds = getAppRouteHandlerRevalidateSeconds(handler);
 	const isDevelopment = options.isDevelopment ?? process.env.NODE_ENV === "development";
 	const isProduction = options.isProduction ?? process.env.NODE_ENV === "production";
-	if (hasAppRouteHandlerDefaultExport(handler) && isDevelopment) console.error("[vinext] Detected default export in route handler " + route.pattern + ". Export a named export for each HTTP method instead.");
-	if (!isValidHTTPMethod(method)) {
+	const isDraftMode = getActiveDraftModeState() ?? isDraftModeRequest(options.request, options.draftModeSecret);
+	const initialDraftModeCookie = getDraftModeCookieHeader();
+	const hasDraftModeTransition = initialDraftModeCookie != null;
+	const finalizeFrameworkResponse = (response, isHead = false) => {
+		const finalized = finalizeRouteHandlerResponse(response, {
+			pendingCookies: getAndClearPendingCookies(),
+			draftCookie: initialDraftModeCookie,
+			isHead
+		});
 		options.clearRequestContext();
-		return applyRouteHandlerMiddlewareContext(new Response(null, { status: 400 }), options.middlewareContext);
-	}
+		return applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(finalized, options.middlewareContext), isDraftMode || hasDraftModeTransition);
+	};
+	if (hasAppRouteHandlerDefaultExport(handler) && isDevelopment) console.error("[vinext] Detected default export in route handler " + route.pattern + ". Export a named export for each HTTP method instead.");
+	if (!isValidHTTPMethod(method)) return finalizeFrameworkResponse(new Response(null, { status: 400 }));
 	const { allowHeaderForOptions, handlerFn, isAutoHead, shouldAutoRespondToOptions } = resolveAppRouteHandlerMethod(handler, method);
-	if (shouldAutoRespondToOptions) {
-		options.clearRequestContext();
-		return applyRouteHandlerMiddlewareContext(new Response(null, {
-			status: 204,
-			headers: { Allow: allowHeaderForOptions }
-		}), options.middlewareContext);
-	}
+	if (shouldAutoRespondToOptions) return finalizeFrameworkResponse(new Response(null, {
+		status: 204,
+		headers: { Allow: allowHeaderForOptions }
+	}));
 	const resolvedHandlerFn = isAppRouteHandlerFunction(handlerFn) ? handlerFn : void 0;
 	const fetchCacheMode = resolveAppRouteHandlerFetchCacheMode(handler);
 	setCurrentFetchCacheMode(fetchCacheMode);
@@ -69,6 +80,7 @@ async function dispatchAppRouteHandler(options) {
 		handlerFn: resolvedHandlerFn,
 		isAutoHead,
 		isKnownDynamic: isKnownDynamicAppRoute(route.pattern),
+		isDraftMode: isDraftMode || hasDraftModeTransition,
 		isProduction,
 		method,
 		revalidateSeconds
@@ -133,12 +145,15 @@ async function dispatchAppRouteHandler(options) {
 		executionContext: getRequestExecutionContext(),
 		getAndClearPendingCookies,
 		getCollectedFetchTags,
+		getActiveDraftModeState,
 		getDraftModeCookieHeader,
 		handler,
 		handlerFn: resolvedHandlerFn,
 		i18n: options.i18n,
 		trailingSlash: options.trailingSlash,
 		isAutoHead,
+		initialDraftModeCookie,
+		isDraftMode,
 		isProduction,
 		isrDebug: options.isrDebug,
 		isrRouteKey: options.isrRouteKey,
@@ -157,8 +172,7 @@ async function dispatchAppRouteHandler(options) {
 		routePattern: route.pattern,
 		setHeadersAccessPhase
 	});
-	options.clearRequestContext();
-	return applyRouteHandlerMiddlewareContext(new Response(null, { status: 405 }), options.middlewareContext);
+	return finalizeFrameworkResponse(new Response(null, { status: 405 }));
 }
 //#endregion
 export { dispatchAppRouteHandler };

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

@@ -42,6 +42,7 @@ type RunAppRouteHandlerOptions = {
   dynamicConfig?: string;
   handlerFn: AppRouteHandlerFunction;
   i18n?: NextI18nConfig | null;
+  isDraftMode?: boolean;
   trailingSlash?: boolean;
   markDynamicUsage: MarkAppRouteDynamicUsageFn;
   middlewareRequestHeaders?: Headers | null;
@@ -58,6 +59,7 @@ type RunAppRouteHandlerResult = {
   dynamicUsedInHandler: boolean;
   response: Response;
 };
+declare function applyDraftModeCachePolicy(response: Response, isDraftMode: boolean): Response;
 type ExecuteAppRouteHandlerOptions = {
   buildPageCacheTags: (pathname: string, extraTags: string[]) => string[];
   clearRequestContext: () => void;
@@ -65,9 +67,12 @@ type ExecuteAppRouteHandlerOptions = {
   executionContext: ExecutionContextLike | null;
   getAndClearPendingCookies: () => string[];
   getCollectedFetchTags: () => string[];
+  getActiveDraftModeState?: () => boolean | null;
   getDraftModeCookieHeader: () => string | null | undefined;
   handler: AppRouteHandlerModule;
   isAutoHead: boolean;
+  initialDraftModeCookie?: string | null;
+  isDraftMode?: boolean;
   isProduction: boolean;
   isrDebug?: AppRouteDebugLogger;
   isrRouteKey: (pathname: string) => string;
@@ -83,4 +88,4 @@ type ExecuteAppRouteHandlerOptions = {
 declare function runAppRouteHandler(options: RunAppRouteHandlerOptions): Promise<RunAppRouteHandlerResult>;
 declare function executeAppRouteHandler(options: ExecuteAppRouteHandlerOptions): Promise<Response>;
 //#endregion
-export { AppRouteDebugLogger, AppRouteDynamicUsageFn, AppRouteHandlerFunction, AppRouteParams, MarkAppRouteDynamicUsageFn, RouteHandlerCacheSetter, executeAppRouteHandler, runAppRouteHandler };
+export { AppRouteDebugLogger, AppRouteDynamicUsageFn, AppRouteHandlerFunction, AppRouteParams, MarkAppRouteDynamicUsageFn, RouteHandlerCacheSetter, applyDraftModeCachePolicy, executeAppRouteHandler, runAppRouteHandler };