vinext 1.0.0-beta.0 → 1.0.0-beta.2

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;
@@ -57,18 +63,20 @@ function getParallelParentParamNames(routeParamNames, branch, boundaryPosition)
 		return name ? [name] : [];
 	}));
 	const ownerParamNames = slotParamNames.filter((name) => !branchParamNameSet.has(name));
-	return [...new Set([...ownerParamNames, ...branchParamNames])];
+	return [.../* @__PURE__ */ new Set([...ownerParamNames, ...branchParamNames])];
 }
 function resolveAppPageGenerateStaticParamsSources(options) {
 	const sources = [];
 	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);
@@ -213,7 +246,7 @@ function buildAppPageElements(options) {
 		const slotName = slot.name;
 		slotNameCounts.set(slotName, (slotNameCounts.get(slotName) ?? 0) + 1);
 	}
-	const orderedTreePositions = Array.from(new Set([
+	const orderedTreePositions = Array.from(/* @__PURE__ */ new Set([
 		...layoutEntries.map((entry) => entry.treePosition),
 		...templateEntries.map((entry) => entry.treePosition),
 		...errorEntries.map((entry) => entry.treePosition)
@@ -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 };

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

@@ -1,4 +1,6 @@
+import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
 import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
+import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
 import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { runWithRootParamsUsage } from "../shims/root-params.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
@@ -6,10 +8,20 @@ import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-ro
 import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
 import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
 //#region src/server/app-route-handler-execution.ts
+function applyDraftModeCachePolicy(response, isDraftMode) {
+	if (!isDraftMode) return response;
+	const headers = new Headers(response.headers);
+	applyCdnResponseHeaders(headers, { cacheControl: NEVER_CACHE_CONTROL });
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
 function configureAppRouteStaticGenerationContext(options) {
 	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") {
 		setHeadersContext(createStaticGenerationHeadersContext({
-			draftModeEnabled: options.draftModeSecret !== void 0 && isDraftModeRequest(options.request, options.draftModeSecret),
+			draftModeEnabled: options.isDraftMode ?? (options.draftModeSecret !== void 0 && isDraftModeRequest(options.request, options.draftModeSecret)),
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig: options.dynamicConfig,
 			routeKind: "route",
@@ -46,18 +58,30 @@ async function runAppRouteHandler(options) {
 async function executeAppRouteHandler(options) {
 	const previousHeadersPhase = options.setHeadersAccessPhase("route-handler");
 	try {
-		const { dynamicUsedInHandler, response } = await runAppRouteHandler({
-			...options,
-			dynamicConfig: options.handler.dynamic
-		});
+		let handlerResult;
+		try {
+			handlerResult = await runAppRouteHandler({
+				...options,
+				dynamicConfig: options.handler.dynamic
+			});
+		} finally {
+			await _drainPendingRevalidations();
+		}
+		const { dynamicUsedInHandler, response } = handlerResult;
 		assertSupportedAppRouteHandlerResponse(response);
 		const handlerSetCacheControl = response.headers.has("cache-control");
 		if (dynamicUsedInHandler) markKnownDynamicAppRoute(options.routePattern);
+		const pendingCookies = options.getAndClearPendingCookies();
+		const handlerDraftCookie = options.getDraftModeCookieHeader();
+		const draftCookie = handlerDraftCookie ?? options.initialDraftModeCookie;
+		const shouldApplyDraftPolicy = (options.getActiveDraftModeState?.() ?? options.isDraftMode === true) || draftCookie != null;
+		if (handlerDraftCookie != null) markKnownDynamicAppRoute(options.routePattern);
 		const routeTags = options.buildPageCacheTags(options.cleanPathname, options.getCollectedFetchTags());
 		if (shouldApplyAppRouteHandlerRevalidateHeader({
 			dynamicUsedInHandler,
 			handlerSetCacheControl,
 			isAutoHead: options.isAutoHead,
+			isDraftMode: shouldApplyDraftPolicy,
 			method: options.method,
 			revalidateSeconds: options.revalidateSeconds
 		})) {
@@ -70,6 +94,7 @@ async function executeAppRouteHandler(options) {
 			dynamicUsedInHandler,
 			handlerSetCacheControl,
 			isAutoHead: options.isAutoHead,
+			isDraftMode: shouldApplyDraftPolicy,
 			isProduction: options.isProduction,
 			method: options.method,
 			revalidateSeconds: options.revalidateSeconds
@@ -90,29 +115,30 @@ async function executeAppRouteHandler(options) {
 			})();
 			options.executionContext?.waitUntil(routeWritePromise);
 		}
-		const pendingCookies = options.getAndClearPendingCookies();
-		const draftCookie = options.getDraftModeCookieHeader();
 		options.clearRequestContext();
-		return applyRouteHandlerMiddlewareContext(finalizeRouteHandlerResponse(response, {
+		return applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(finalizeRouteHandlerResponse(response, {
 			pendingCookies,
 			draftCookie,
 			isHead: options.isAutoHead
-		}), options.middlewareContext);
+		}), options.middlewareContext), shouldApplyDraftPolicy);
 	} catch (error) {
 		const pendingCookies = options.getAndClearPendingCookies();
-		const draftCookie = options.getDraftModeCookieHeader();
+		const handlerDraftCookie = options.getDraftModeCookieHeader();
+		const draftCookie = handlerDraftCookie ?? options.initialDraftModeCookie;
+		const shouldApplyDraftPolicy = (options.getActiveDraftModeState?.() ?? options.isDraftMode === true) || draftCookie != null;
+		if (handlerDraftCookie != null) markKnownDynamicAppRoute(options.routePattern);
 		const specialError = resolveAppRouteHandlerSpecialError(error, options.request.url, { isAction: isPossibleAppRouteActionRequest(options.request) });
 		options.clearRequestContext();
 		if (specialError) {
-			if (specialError.kind === "redirect") return applyRouteHandlerMiddlewareContext(finalizeRouteHandlerResponse(new Response(null, {
+			if (specialError.kind === "redirect") return applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(finalizeRouteHandlerResponse(new Response(null, {
 				status: specialError.statusCode,
 				headers: { Location: specialError.location }
 			}), {
 				pendingCookies,
 				draftCookie,
 				isHead: options.isAutoHead
-			}), options.middlewareContext);
-			return applyRouteHandlerMiddlewareContext(new Response(null, { status: specialError.statusCode }), options.middlewareContext);
+			}), options.middlewareContext), shouldApplyDraftPolicy);
+			return applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(new Response(null, { status: specialError.statusCode }), options.middlewareContext), shouldApplyDraftPolicy);
 		}
 		console.error("[vinext] Route handler error:", error);
 		options.reportRequestError(error instanceof Error ? error : new Error(String(error)), {
@@ -124,10 +150,10 @@ async function executeAppRouteHandler(options) {
 			routePath: options.routePattern,
 			routeType: "route"
 		});
-		return applyRouteHandlerMiddlewareContext(new Response(null, { status: 500 }), options.middlewareContext);
+		return applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(new Response(null, { status: 500 }), options.middlewareContext), shouldApplyDraftPolicy);
 	} finally {
 		options.setHeadersAccessPhase(previousHeadersPhase);
 	}
 }
 //#endregion
-export { executeAppRouteHandler, runAppRouteHandler };
+export { applyDraftModeCachePolicy, executeAppRouteHandler, runAppRouteHandler };

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

@@ -20,6 +20,7 @@ type AppRouteHandlerCacheReadOptions = {
   handlerFn: unknown;
   isAutoHead: boolean;
   isKnownDynamic: boolean;
+  isDraftMode?: boolean;
   isProduction: boolean;
   method: string;
   revalidateSeconds: number | null;
@@ -29,6 +30,7 @@ type AppRouteHandlerResponseCacheOptions = {
   dynamicUsedInHandler: boolean;
   handlerSetCacheControl: boolean;
   isAutoHead: boolean;
+  isDraftMode?: boolean;
   isProduction: boolean;
   method: string;
   revalidateSeconds: number | null;

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

@@ -30,13 +30,13 @@ function resolveAppRouteHandlerMethod(handler, method) {
 	};
 }
 function shouldReadAppRouteHandlerCache(options) {
-	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.revalidateSeconds !== Infinity && options.dynamicConfig !== "force-dynamic" && !options.isKnownDynamic && (options.method === "GET" || options.isAutoHead) && typeof options.handlerFn === "function";
+	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.revalidateSeconds !== Infinity && options.dynamicConfig !== "force-dynamic" && !options.isDraftMode && !options.isKnownDynamic && (options.method === "GET" || options.isAutoHead) && typeof options.handlerFn === "function";
 }
 function shouldApplyAppRouteHandlerRevalidateHeader(options) {
-	return options.revalidateSeconds !== null && !options.dynamicUsedInHandler && (options.method === "GET" || options.isAutoHead) && !options.handlerSetCacheControl;
+	return options.revalidateSeconds !== null && !options.isDraftMode && !options.dynamicUsedInHandler && (options.method === "GET" || options.isAutoHead) && !options.handlerSetCacheControl;
 }
 function shouldWriteAppRouteHandlerCache(options) {
-	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.revalidateSeconds !== Infinity && options.dynamicConfig !== "force-dynamic" && shouldApplyAppRouteHandlerRevalidateHeader(options);
+	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.revalidateSeconds !== Infinity && options.dynamicConfig !== "force-dynamic" && !options.isDraftMode && shouldApplyAppRouteHandlerRevalidateHeader(options);
 }
 function resolveAppRouteHandlerSpecialError(error, requestUrl, options) {
 	if (!(error && typeof error === "object" && "digest" in error)) return null;