vinext 1.4.4 → 1.4.5

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

@@ -1,10 +1,10 @@
 import { isrCacheControl, resolveRouteExpireSeconds } from "./isr-cache.js";
-import { applyRouteHandlerMiddlewareContext, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse } from "./app-route-handler-response.js";
-import { makeThenableParams } from "../shims/thenable-params.js";
+import { applyRouteHandlerMiddlewareContext, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, stripAppRouteHandlerRouteMissMarker } from "./app-route-handler-response.js";
 import { markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { resolveAppRouteHandlerSpecialError } from "./app-route-handler-policy.js";
+import { makeThenableParams } from "../shims/thenable-params.js";
 import { completeAppRouteHandlerResponse, runAppRouteHandler, traceAppRouteHandlerExecution } from "./app-route-handler-execution.js";
-//#region src/server/app-route-handler-cache.ts
+// src/server/app-route-handler-cache.ts
 const EMPTY_PARAMS = Object.freeze({});
 function getCachedAppRouteValue(entry) {
 	return entry?.value.value && entry.value.value.kind === "APP_ROUTE" ? entry.value.value : null;
@@ -77,7 +77,7 @@ async function readAppRouteHandlerCacheResponse(options) {
 					return;
 				}
 				const routeTags = options.buildPageCacheTags(options.cleanPathname, options.getCollectedFetchTags());
-				const routeCacheValue = await buildAppRouteCacheValue(completed.response, response.headers.get("Cache-Control") ?? void 0);
+				const routeCacheValue = await buildAppRouteCacheValue(stripAppRouteHandlerRouteMissMarker(completed.response), response.headers.get("Cache-Control") ?? void 0);
 				await options.isrSet(routeKey, routeCacheValue, {
 					cacheControl: isrCacheControl(options.revalidateSeconds === Infinity ? false : options.revalidateSeconds, { expireSeconds: resolveRouteExpireSeconds(options.revalidateSeconds, options.expireSeconds) }),
 					tags: routeTags
@@ -99,5 +99,4 @@ async function readAppRouteHandlerCacheResponse(options) {
 	}
 	return null;
 }
-//#endregion
 export { readAppRouteHandlerCacheResponse };

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

@@ -1,9 +1,8 @@
 import { NextI18nConfig } from "../config/next-config.js";
 import { ISRCacheEntry } from "./isr-cache.js";
-import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
 import { AppRouteHandlerModule } from "./app-route-handler-policy.js";
 import { AppRouteDebugLogger, AppRouteParams, RouteHandlerCacheSetter } from "./app-route-handler-execution.js";
-//#region src/server/app-route-handler-dispatch.d.ts
+import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
 type AppRouteHandlerDispatchRoute = {
   pattern: string;
   routeHandler: AppRouteHandlerModule;
@@ -40,11 +39,17 @@ type DispatchAppRouteHandlerOptions = {
    * (`params ? await params : null`) resolves to `null`.
    */
   params: AppRouteParams | null;
+  /** Render the not-found page Next.js serves for an unmatched URL. */
+  renderNotFound?: () => Promise<Response>;
+  /**
+   * Called on a dynamicParams = false miss. When it returns true, routing
+   * resumes with the fallback rewrites, so the miss renders no 404.
+   */
+  resumeRoutingAfterMiss?: () => boolean;
   request: Request;
   route: AppRouteHandlerDispatchRoute;
   scheduleBackgroundRegeneration: RouteHandlerBackgroundRegenerator;
   searchParams: URLSearchParams;
 };
 export declare function dispatchAppRouteHandler(options: DispatchAppRouteHandlerOptions): Promise<Response>;
-//#endregion
 export {};

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

@@ -1,32 +1,135 @@
-import { closeAfterResponse, createRequestContext, getRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
-import { getRequestExecutionContext } from "../shims/request-context.js";
 import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
-import { reportRequestError } from "./instrumentation.js";
-import { beginRouteCacheability, getRouteCacheabilityDynamicReason } from "../shims/cacheability-classification.js";
-import { applyCdnResponseBuildIdentityHeaders } from "./cache-control.js";
-import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
+import { workUnitAsyncStorage } from "../shims/internal/work-unit-async-storage.js";
+import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
+import { consumeDynamicUsage, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, restoreDraftModeCookieHeader, setHeadersAccessPhase } from "../shims/headers.js";
+import "../shims/navigation.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { closeAfterResponse, createRequestContext, getRequestContext, runWithRequestContext, runWithUnifiedStateMutation } from "../shims/unified-request-context.js";
 import { coalesceOnDemandResponse } from "./isr-cache.js";
+import { notFoundResponse } from "./http-error-responses.js";
 import { markDynamicUsage } from "../shims/internal/headers-state.js";
-import { consumeDynamicUsage, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, setHeadersAccessPhase } from "../shims/headers.js";
-import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
-import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
-import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
-import { traceResponseStart } from "./response-start-tracing.js";
+import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, resolveAppRouteHandlerMethod, resolveAppRouteHandlerStaticParamsEnforcement, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
+import { readAppRouteHandlerCacheResponse } from "./app-route-handler-cache.js";
+import { applyDraftModeCachePolicy, executeAppRouteHandler } from "./app-route-handler-execution.js";
+import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
+import { beginRouteCacheability, getRouteCacheabilityDynamicReason } from "../shims/cacheability-classification.js";
 import { applyRouteHandlerMiddlewareContext, finalizeRouteHandlerResponse } from "./app-route-handler-response.js";
-import { makeThenableParams } from "../shims/thenable-params.js";
 import { setNavigationContext } from "../shims/navigation-context-state.js";
-import "../shims/navigation.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
-import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
-import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
+import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
-import { applyDraftModeCachePolicy, executeAppRouteHandler } from "./app-route-handler-execution.js";
-import { readAppRouteHandlerCacheResponse } from "./app-route-handler-cache.js";
-//#region src/server/app-route-handler-dispatch.ts
+import { buildAppStaticParamsTags, buildPageCacheTags } from "./implicit-tags.js";
+import { makeThenableParams } from "../shims/thenable-params.js";
+import { reportRequestError } from "./instrumentation.js";
+import { applyCdnResponseBuildIdentityHeaders } from "./cache-control.js";
+import { markRouteMissResponse } from "./route-miss-response.js";
+import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
+import { traceResponseStart } from "./response-start-tracing.js";
+// src/server/app-route-handler-dispatch.ts
 function isAppRouteHandlerFunction(value) {
 	return typeof value === "function";
 }
+function encodeAppRouteParams(params) {
+	const encoded = Object.create(null);
+	for (const [key, value] of Object.entries(params)) encoded[key] = Array.isArray(value) ? value.map((item) => encodeURIComponent(item)) : encodeURIComponent(value);
+	return encoded;
+}
+/**
+* Runs a route's generateStaticParams as Next.js does, in a work store of its
+* own: root params come only from parent params, which a route handler's
+* generator has none of, request APIs throw because there is no request, and
+* its fetches leave the request's tags, revalidate and dynamic-usage
+* observations alone.
+* https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/build/static-paths/app.ts
+*/
+function runStaticParamsGeneration(handler, pattern, routeSegments, fn) {
+	const afterPromises = [];
+	let afterTaskError = null;
+	let generatorContext;
+	const generate = async () => {
+		let result;
+		try {
+			result = await workUnitAsyncStorage.run({ type: "generate-static-params" }, fn);
+		} catch (error) {
+			if (generatorContext) {
+				generatorContext.afterContext.cancelled = true;
+				generatorContext.afterContext.callbacks.length = 0;
+				closeAfterResponse(generatorContext);
+			}
+			throw error;
+		}
+		if (generatorContext) {
+			await closeAfterResponse(generatorContext);
+			while (afterPromises.length > 0) {
+				await Promise.all(afterPromises.splice(0));
+				await closeAfterResponse(generatorContext);
+			}
+		}
+		if (afterTaskError) throw afterTaskError.error;
+		return result;
+	};
+	return runWithUnifiedStateMutation((ctx) => {
+		generatorContext = ctx;
+		ctx.afterContext = {
+			callbacks: [],
+			responseClosed: false,
+			pendingCallbacks: 0,
+			pendingPromises: 0,
+			completion: null,
+			resolveCompletion: null,
+			waitUntil: (promise) => afterPromises.push(promise),
+			onTaskError: (error) => {
+				afterTaskError ??= { error };
+			}
+		};
+		ctx.rootParams = {};
+		ctx.currentRequestTags = [];
+		ctx.currentFetchSoftTags = buildAppStaticParamsTags(routeSegments, "route");
+		ctx.dynamicFetchUrls = /* @__PURE__ */ new Set();
+		ctx.isFetchDedupeActive = true;
+		ctx.currentFetchDedupeEntries = /* @__PURE__ */ new Map();
+		ctx.nextFetchId = 1;
+		ctx.isOnDemandRevalidate = false;
+		ctx.requestCache = /* @__PURE__ */ new WeakMap();
+		ctx._privateCache = /* @__PURE__ */ new Map();
+		ctx.headersContext = {
+			headers: new Headers(),
+			cookies: /* @__PURE__ */ new Map(),
+			staticParamsRoute: pattern,
+			accessError: /* @__PURE__ */ new Error(`Route ${pattern} used a request API such as \`headers()\`, \`cookies()\`, \`connection()\` or \`draftMode()\` inside \`generateStaticParams\`. This is not supported because \`generateStaticParams\` runs at build time without an HTTP request. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`)
+		};
+		ctx.dynamicUsageDetected = false;
+		ctx.renderDynamicLatch = {
+			dynamic: false,
+			listeners: /* @__PURE__ */ new Set()
+		};
+		ctx.renderRequestApiUsage = /* @__PURE__ */ new Set();
+		ctx.currentFetchCacheMode = resolveAppRouteHandlerFetchCacheMode(handler);
+		ctx.currentFetchRevalidate = null;
+		ctx.currentForceDynamicFetchDefault = false;
+	}, generate);
+}
+/**
+* Whether a route handler rejects these params under `dynamicParams = false`,
+* where Next.js throws `NoFallbackError` and resumes routing. Draft mode skips
+* the check, so the caller decides whether to run it.
+* https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/build/templates/app-route.ts
+*/
+async function isAppRouteHandlerParamsMiss(options) {
+	const { handler } = options;
+	if (resolveAppRouteHandlerStaticParamsEnforcement(handler, options.isProduction) === "skip") return false;
+	const patternParts = options.pattern.split("/");
+	const { routePatternOptionalCatchAllParamNames, routePatternParamNames, validateAppPageDynamicParams } = await import("./app-page-request.js");
+	return await runStaticParamsGeneration(handler, options.pattern, options.routeSegments, () => validateAppPageDynamicParams({
+		enforceStaticParamsOnly: true,
+		generateStaticParams: handler.generateStaticParams,
+		isDynamicRoute: true,
+		optionalCatchAllParamNames: routePatternOptionalCatchAllParamNames(patternParts),
+		params: encodeAppRouteParams(options.params),
+		requiredParamNames: routePatternParamNames(patternParts)
+	})) !== null;
+}
 function buildRouteHandlerPageCacheTags(pathname, extraTags, routeSegments) {
 	return buildPageCacheTags(pathname, extraTags, routeSegments, "route");
 }
@@ -87,10 +190,37 @@ async function dispatchAppRouteHandlerImpl(options) {
 		options.clearRequestContext();
 		return applyCdnResponseBuildIdentityHeaders(applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(finalized, options.middlewareContext, { appendResponseLink }), isDraftMode || hasDraftModeTransition));
 	};
+	const rejectUnlistedParams = async () => {
+		const params = options.params;
+		if (params === null || isDraftMode) return null;
+		if (!await isAppRouteHandlerParamsMiss({
+			handler,
+			isProduction,
+			params,
+			pattern: route.pattern,
+			routeSegments: route.routeSegments
+		})) return null;
+		setCurrentFetchSoftTags([]);
+		setCurrentFetchCacheMode(null);
+		setCurrentFetchRevalidate(null);
+		setCurrentForceDynamicFetchDefault(false);
+		if (options.resumeRoutingAfterMiss?.()) {
+			if (initialDraftModeCookie) restoreDraftModeCookieHeader(initialDraftModeCookie);
+			return new Response(null, { status: 404 });
+		}
+		if (!options.renderNotFound) return markRouteMissResponse(finalizeFrameworkResponse(notFoundResponse()));
+		const miss = markRouteMissResponse(await options.renderNotFound());
+		if (initialDraftModeCookie) miss.headers.append("Set-Cookie", initialDraftModeCookie);
+		return miss;
+	};
 	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 fetchCacheMode = resolveAppRouteHandlerFetchCacheMode(handler);
+	setCurrentFetchCacheMode(fetchCacheMode);
+	setCurrentFetchRevalidate(configuredRevalidateSeconds);
+	setCurrentForceDynamicFetchDefault(handler.dynamic === "force-dynamic");
+	if (!isValidHTTPMethod(method)) return await rejectUnlistedParams() ?? finalizeFrameworkResponse(new Response(null, { status: 400 }));
 	const { allowHeaderForOptions, handlerFn, isAutoHead, shouldAutoRespondToOptions } = resolveAppRouteHandlerMethod(handler, method);
-	if (shouldAutoRespondToOptions) return finalizeFrameworkResponse(new Response(null, {
+	if (shouldAutoRespondToOptions) return await rejectUnlistedParams() ?? finalizeFrameworkResponse(new Response(null, {
 		status: 204,
 		headers: { Allow: allowHeaderForOptions }
 	}));
@@ -108,10 +238,6 @@ async function dispatchAppRouteHandlerImpl(options) {
 	});
 	const shouldReadRouteCache = isStoredRoute && !isOnDemandRevalidate;
 	const revalidateReason = isOnDemandRevalidate ? "on-demand" : shouldReadRouteCache && revalidateSeconds !== Infinity ? "stale" : void 0;
-	const fetchCacheMode = resolveAppRouteHandlerFetchCacheMode(handler);
-	setCurrentFetchCacheMode(fetchCacheMode);
-	setCurrentFetchRevalidate(configuredRevalidateSeconds);
-	setCurrentForceDynamicFetchDefault(handler.dynamic === "force-dynamic");
 	let isRevalidation = isStoredRoute && isOnDemandRevalidate;
 	if (shouldReadRouteCache && resolvedHandlerFn) {
 		const cachedRouteResponse = await readAppRouteHandlerCacheResponse({
@@ -169,6 +295,8 @@ async function dispatchAppRouteHandlerImpl(options) {
 		});
 		if (cachedRouteResponse) return applyCdnResponseBuildIdentityHeaders(cachedRouteResponse);
 	}
+	const unlistedParamsResponse = await rejectUnlistedParams();
+	if (unlistedParamsResponse) return unlistedParamsResponse;
 	if (resolvedHandlerFn) {
 		const handlerOptions = {
 			isRevalidation,
@@ -220,5 +348,4 @@ async function dispatchAppRouteHandlerImpl(options) {
 	}
 	return finalizeFrameworkResponse(new Response(null, { status: 405 }));
 }
-//#endregion
 export { dispatchAppRouteHandler };

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

@@ -1,14 +1,13 @@
 import { NextI18nConfig } from "../config/next-config.js";
+import "../shims/headers.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
-import { NextRequest } from "../shims/server.js";
-import { FrameworkSpan } from "./framework-tracer.js";
 import { CachedRouteValue } from "../shims/cache-handler.js";
+import { NextRequest } from "../shims/server.js";
 import { IsrWritePolicy } from "./isr-cache.js";
 import { HeadersAccessPhase } from "../shims/internal/headers-state.js";
-import "../shims/headers.js";
-import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
 import { AppRouteHandlerModule } from "./app-route-handler-policy.js";
-//#region src/server/app-route-handler-execution.d.ts
+import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
+import { FrameworkSpan } from "./framework-tracer.js";
 export type AppRouteParams = Record<string, string | string[]>;
 export type AppRouteDynamicUsageFn = () => boolean;
 export type MarkAppRouteDynamicUsageFn = () => void;
@@ -104,5 +103,4 @@ type ExecuteAppRouteHandlerOptions = {
 export declare function runAppRouteHandler(options: RunAppRouteHandlerOptions): Promise<RunAppRouteHandlerResult>;
 export declare function executeAppRouteHandler(options: ExecuteAppRouteHandlerOptions): Promise<Response>;
 export declare function traceAppRouteHandlerExecution<T>(routePattern: string, callback: (span: FrameworkSpan) => T): T;
-//#endregion
 export {};

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

@@ -1,22 +1,22 @@
 import { isFullyBufferedBody } from "./fully-buffered-response.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
-import { frameworkTracer } from "./tracer.js";
-import { logRequestError } from "./request-error-log.js";
-import { getRouteCacheabilityCaptureOptions, getRouteCacheabilityDynamicReason, isRouteCacheabilityEvaluation, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete, recordRouteCacheability } from "../shims/cacheability-classification.js";
+import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
+import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
+import { runWithRootParamsUsage } from "../shims/root-params.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy, hasExplicitNonCacheableResponsePolicy } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl } from "./isr-decision.js";
 import { isrCacheControl, resolveRouteExpireSeconds } from "./isr-cache.js";
-import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
-import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
+import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
+import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldCompleteAppRouteHandlerResponse, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
 import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
-import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
-import { runWithRootParamsUsage } from "../shims/root-params.js";
-import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss, stripAppRouteHandlerRouteMissMarker } from "./app-route-handler-response.js";
 import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
-import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldCompleteAppRouteHandlerResponse, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
-import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+import { getRouteCacheabilityCaptureOptions, getRouteCacheabilityDynamicReason, isRouteCacheabilityEvaluation, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete, recordRouteCacheability } from "../shims/cacheability-classification.js";
 import { CACHEABILITY_ADMISSION_RESPONSE_BODY_LIMIT } from "./cacheability-limits.js";
-//#region src/server/app-route-handler-execution.ts
+import { frameworkTracer } from "./tracer.js";
+import { logRequestError } from "./request-error-log.js";
+// src/server/app-route-handler-execution.ts
 function hasExplicitCacheableResponsePolicy(headers) {
 	return !hasExplicitNonCacheableResponsePolicy(headers) && hasCdnResponsePolicy(headers);
 }
@@ -225,6 +225,7 @@ async function executeAppRouteHandlerImpl(options) {
 			const dynamicUsedDuringCompletion = options.consumeDynamicUsage();
 			dynamicUsedInHandler = handlerResult.didAccessDynamicRequest() || dynamicUsedDuringCompletion || dynamicUsedInHandler;
 		}
+		response = stripAppRouteHandlerRouteMissMarker(response);
 		const browserCacheControl = response.headers.get("Cache-Control") ?? void 0;
 		const handlerSetCachePolicy = hasCdnResponsePolicy(response.headers);
 		if (handlerSetCachePolicy) markRouteCacheabilityExplicitResponsePolicy();
@@ -356,5 +357,4 @@ async function executeAppRouteHandlerImpl(options) {
 		if (!cleanupDeferredToBody) options.setHeadersAccessPhase(previousHeadersPhase);
 	}
 }
-//#endregion
 export { applyDraftModeCachePolicy, completeAppRouteHandlerResponse, executeAppRouteHandler, runAppRouteHandler, traceAppRouteHandlerExecution };

package/dist/server/app-route-handler-middleware-context.d.ts

@@ -1,9 +1,7 @@
 import { MiddlewareResponseMergeOptions } from "./middleware-response-headers.js";
-//#region src/server/app-route-handler-middleware-context.d.ts
 export type RouteHandlerMiddlewareContext = {
   headers: Headers | null;
   status: number | null;
 };
 /** Apply request-stage middleware response metadata to a route-handler response. */
-export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: MiddlewareResponseMergeOptions): Response;
-//#endregion
+export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: MiddlewareResponseMergeOptions): Response;

package/dist/server/app-route-handler-middleware-context.js

@@ -1,5 +1,5 @@
 import { mergeMiddlewareResponseHeadersOntoResponse } from "./middleware-response-headers.js";
-//#region src/server/app-route-handler-middleware-context.ts
+// src/server/app-route-handler-middleware-context.ts
 /** Apply request-stage middleware response metadata to a route-handler response. */
 function applyRouteHandlerMiddlewareContext(response, middlewareContext, options = {}) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
@@ -11,5 +11,4 @@ function applyRouteHandlerMiddlewareContext(response, middlewareContext, options
 		headers: responseHeaders
 	});
 }
-//#endregion
 export { applyRouteHandlerMiddlewareContext };

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

@@ -1,8 +1,8 @@
-import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { RouteHandlerHttpMethod, RouteHandlerModule } from "./app-route-handler-runtime.js";
-//#region src/server/app-route-handler-policy.d.ts
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 export type AppRouteHandlerModule = {
   dynamic?: string;
+  dynamicParams?: unknown;
   fetchCache?: unknown;
   generateStaticParams?: unknown;
   revalidate?: unknown;
@@ -53,6 +53,22 @@ export declare function getAppRouteHandlerRevalidateSeconds(handler: Pick<AppRou
 export declare function hasAppRouteHandlerDefaultExport(handler: RouteHandlerModule): boolean;
 /** Match Next.js methods that force an App Route out of static generation. */
 export declare function hasNonStaticAppRouteHandlerMethods(handler: RouteHandlerModule): boolean;
+/**
+ * How a dynamic App Route admits params outside its `generateStaticParams`.
+ * Next.js enforces `dynamicParams = false` through the route's prerender
+ * manifest entry. Dev writes that entry from `generateStaticParams`.
+ * A production build leaves out routes that bail out of static generation,
+ * and lists a route without `generateStaticParams` only when it is static.
+ * Edge routes never prerender, so they have no entry.
+ *
+ * Non-static methods bail out only while a generated path prerenders, so
+ * Next.js still lists such a route when its generator returns no params.
+ * vinext doesn't run the generator per request to find that case: as soon
+ * as it lists one param, Next.js serves every param too.
+ * https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/build/index.ts
+ * https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/build/templates/app-route.ts
+ */
+export declare function resolveAppRouteHandlerStaticParamsEnforcement(handler: AppRouteHandlerModule, isProduction: boolean): "enforce" | "skip";
 export declare function resolveAppRouteHandlerMethod(handler: AppRouteHandlerModule, method: string): ResolvedAppRouteHandlerMethod;
 export declare function shouldReadAppRouteHandlerCache(options: AppRouteHandlerCacheReadOptions): boolean;
 export declare function shouldApplyAppRouteHandlerRevalidateHeader(options: Omit<AppRouteHandlerResponseCacheOptions, "dynamicConfig" | "isProduction">): boolean;
@@ -65,5 +81,4 @@ export declare function shouldApplyAppRouteHandlerRevalidateHeader(options: Omit
 export declare function shouldCompleteAppRouteHandlerResponse(options: AppRouteHandlerResponseCacheOptions): boolean;
 export declare function shouldWriteAppRouteHandlerCache(options: AppRouteHandlerResponseCacheOptions): boolean;
 export declare function resolveAppRouteHandlerSpecialError(error: unknown, options?: AppRouteHandlerSpecialErrorOptions): AppRouteHandlerSpecialError | null;
-//#endregion
 export { isPossibleAppRouteActionRequest };

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

@@ -1,7 +1,7 @@
-import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
-import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { buildRouteHandlerAllowHeader, collectRouteHandlerMethods } from "./app-route-handler-runtime.js";
-//#region src/server/app-route-handler-policy.ts
+import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+// src/server/app-route-handler-policy.ts
 function getAppRouteHandlerRevalidateSeconds(handler) {
 	const { revalidate } = handler;
 	if (revalidate === false) return Infinity;
@@ -17,6 +17,30 @@ function hasAppRouteHandlerDefaultExport(handler) {
 function hasNonStaticAppRouteHandlerMethods(handler) {
 	return Boolean(handler.POST || handler.PUT || handler.DELETE || handler.PATCH || handler.OPTIONS);
 }
+/**
+* How a dynamic App Route admits params outside its `generateStaticParams`.
+* Next.js enforces `dynamicParams = false` through the route's prerender
+* manifest entry. Dev writes that entry from `generateStaticParams`.
+* A production build leaves out routes that bail out of static generation,
+* and lists a route without `generateStaticParams` only when it is static.
+* Edge routes never prerender, so they have no entry.
+*
+* Non-static methods bail out only while a generated path prerenders, so
+* Next.js still lists such a route when its generator returns no params.
+* vinext doesn't run the generator per request to find that case: as soon
+* as it lists one param, Next.js serves every param too.
+* https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/build/index.ts
+* https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/build/templates/app-route.ts
+*/
+function resolveAppRouteHandlerStaticParamsEnforcement(handler, isProduction) {
+	if (handler.dynamicParams !== false) return "skip";
+	const hasGenerateStaticParams = typeof handler.generateStaticParams === "function";
+	if (!isProduction) return hasGenerateStaticParams ? "enforce" : "skip";
+	if (handler.runtime === "edge" || handler.runtime === "experimental-edge") return "skip";
+	if (handler.dynamic === "force-dynamic" || handler.revalidate === 0) return "skip";
+	if (!hasGenerateStaticParams) return handler.dynamic === "force-static" || handler.dynamic === "error" ? "enforce" : "skip";
+	return hasNonStaticAppRouteHandlerMethods(handler) ? "skip" : "enforce";
+}
 function resolveAppRouteHandlerMethod(handler, method) {
 	const exportedMethods = collectRouteHandlerMethods(handler);
 	const allowHeaderForOptions = buildRouteHandlerAllowHeader(exportedMethods);
@@ -69,5 +93,4 @@ function resolveAppRouteHandlerSpecialError(error, options) {
 	};
 	return null;
 }
-//#endregion
-export { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldCompleteAppRouteHandlerResponse, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };
+export { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, resolveAppRouteHandlerStaticParamsEnforcement, shouldApplyAppRouteHandlerRevalidateHeader, shouldCompleteAppRouteHandlerResponse, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };

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

@@ -1,6 +1,5 @@
-import { MiddlewareResponseMergeOptions } from "./middleware-response-headers.js";
 import { CacheControlMetadata, CachedRouteValue } from "../shims/cache-handler.js";
-//#region src/server/app-route-handler-response.d.ts
+import { MiddlewareResponseMergeOptions } from "./middleware-response-headers.js";
 export type RouteHandlerMiddlewareContext = {
   headers: Headers | null;
   status: number | null;
@@ -22,10 +21,11 @@ export declare function applyRouteHandlerMiddlewareContext(response: Response, m
   appendResponseLink?: boolean;
 }): Response;
 export declare function assertSupportedAppRouteHandlerResponse(response: Response): void;
+/** Drop a route-miss marker the handler set, so only routing can mark a miss. */
+export declare function stripAppRouteHandlerRouteMissMarker(response: Response): Response;
 export declare function buildRouteHandlerCachedResponse(cachedValue: CachedRouteValue, options: BuildRouteHandlerCachedResponseOptions): Response;
 export declare function applyRouteHandlerRevalidateHeader(response: Response, revalidateSeconds: number, expireSeconds?: number, tags?: readonly string[]): void;
 export declare function markRouteHandlerCacheMiss(response: Response): void;
 export declare function buildAppRouteCacheValue(response: Response, browserCacheControl?: string): Promise<CachedRouteValue>;
 export declare function finalizeRouteHandlerResponse(response: Response, options: FinalizeRouteHandlerResponseOptions): Response;
-//#endregion
 export {};

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

@@ -1,15 +1,15 @@
-import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
-import "../utils/protocol-headers.js";
-import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER } from "./headers.js";
-import { processMiddlewareHeaders } from "./request-pipeline.js";
 import { markRouteCacheabilityExplicitResponsePolicy, recordRouteCacheability } from "../shims/cacheability-classification.js";
+import "../utils/protocol-headers.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
+import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_ROUTE_MISS_HEADER } from "./headers.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { markEdgeRouteHandlerLinkHeaders } from "./app-response-header-provenance.js";
 import { mergeMiddlewareResponseHeadersOntoResponse } from "./middleware-response-headers.js";
+import { processMiddlewareHeaders } from "./request-pipeline.js";
 import { getSetCookieName } from "./cookie-utils.js";
-//#region src/server/app-route-handler-response.ts
+import { copyLinkHeaderProvenance, markEdgeRouteHandlerLinkHeaders } from "./app-response-header-provenance.js";
+import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+// src/server/app-route-handler-response.ts
 const APP_ROUTE_REWRITE_ERROR = "NextResponse.rewrite() was used in a app route handler, this is not currently supported. Please remove the invocation to continue.";
 const APP_ROUTE_NEXT_ERROR = "NextResponse.next() was used in a app route handler, this is not supported. See here for more info: https://nextjs.org/docs/messages/next-response-next-in-app-route-handler";
 const ROUTE_HANDLER_FRAMING_HEADERS = [
@@ -59,12 +59,25 @@ function assertSupportedAppRouteHandlerResponse(response) {
 	if (response.headers.has("x-middleware-rewrite")) throw new Error(APP_ROUTE_REWRITE_ERROR);
 	if (response.headers.get("x-middleware-next") === "1") throw new Error(APP_ROUTE_NEXT_ERROR);
 }
+/** Drop a route-miss marker the handler set, so only routing can mark a miss. */
+function stripAppRouteHandlerRouteMissMarker(response) {
+	if (!response.headers.has("x-vinext-route-miss")) return response;
+	try {
+		response.headers.delete(VINEXT_ROUTE_MISS_HEADER);
+		return response;
+	} catch {}
+	const rebuilt = preserveFullyBufferedBodyMetadata(response, new Response(response.body, response));
+	copyLinkHeaderProvenance(response.headers, rebuilt.headers);
+	rebuilt.headers.delete(VINEXT_ROUTE_MISS_HEADER);
+	return rebuilt;
+}
 function buildRouteHandlerCachedResponse(cachedValue, options) {
 	const headers = new Headers();
 	for (const [key, value] of Object.entries(cachedValue.headers)) if (Array.isArray(value)) for (const entry of value) headers.append(key, entry);
 	else headers.set(key, value);
 	headers.delete(NEXT_CACHE_TAGS_HEADER);
 	headers.delete(VINEXT_METADATA_ROUTE_CACHE_HEADER);
+	headers.delete(VINEXT_ROUTE_MISS_HEADER);
 	if (shouldDropRouteHandlerFramingHeaders(headers)) deleteRouteHandlerFramingHeaders(headers);
 	setCacheStateHeaders(headers, options.cacheState);
 	const { cacheControl } = decideIsr({
@@ -188,5 +201,4 @@ function finalizeRouteHandlerResponse(response, options) {
 		headers
 	});
 }
-//#endregion
-export { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss, stripRouteHandlerFramingHeaders };
+export { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss, stripAppRouteHandlerRouteMissMarker, stripRouteHandlerFramingHeaders };

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

@@ -1,6 +1,5 @@
 import { NextI18nConfig } from "../config/next-config.js";
 import { NextRequest } from "../shims/server.js";
-//#region src/server/app-route-handler-runtime.d.ts
 declare const ROUTE_HANDLER_HTTP_METHODS: readonly ["GET", "HEAD", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
 export type RouteHandlerHttpMethod = (typeof ROUTE_HANDLER_HTTP_METHODS)[number];
 export type RouteHandlerModule = Partial<Record<RouteHandlerHttpMethod | "default", unknown>>;
@@ -39,5 +38,4 @@ type TrackedAppRouteRequest = {
   didAccessDynamicRequest(): boolean;
 };
 export declare function createTrackedAppRouteRequest(request: Request, options?: TrackedAppRouteRequestOptions): TrackedAppRouteRequest;
-//#endregion
 export {};

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

@@ -1,10 +1,10 @@
-import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
-import { addBasePathToPathname } from "../utils/base-path.js";
-import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
 import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
 import { throwIfInsideCacheScope } from "../shims/internal/headers-state.js";
+import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
+import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
+import { addBasePathToPathname } from "../utils/base-path.js";
 import { BUILT_IN_REQUEST_PROPERTIES } from "./app-route-request-built-ins.js";
-//#region src/server/app-route-handler-runtime.ts
+// src/server/app-route-handler-runtime.ts
 const BUILT_IN_REQUEST_PROPERTY_MAP = new Map(BUILT_IN_REQUEST_PROPERTIES.map((property) => [property.key, property]));
 const ROUTE_HANDLER_HTTP_METHODS = [
 	"GET",
@@ -438,5 +438,4 @@ function createTrackedAppRouteRequest(request, options = {}) {
 		}
 	};
 }
-//#endregion
 export { buildRouteHandlerAllowHeader, collectRouteHandlerMethods, createTrackedAppRouteRequest, isKnownDynamicAppRoute, isValidHTTPMethod, markKnownDynamicAppRoute };

package/dist/server/app-route-module-loader.d.ts

@@ -1,4 +1,3 @@
-//#region src/server/app-route-module-loader.d.ts
 /**
  * Lazy route-module hydration for the App Router RSC entry.
  *
@@ -141,5 +140,4 @@ export declare function loadAppInterceptLayouts(intercept: LazyLoadableIntercept
  * `null`/`undefined` routes and on eager routes that have no lazy thunks.
  */
 export declare function ensureAppRouteModulesLoaded<TRoute extends LazyLoadableRoute>(route: TRoute | null | undefined): TRoute | Promise<TRoute>;
-//#endregion
 export {};

package/dist/server/app-route-module-loader.js

@@ -1,6 +1,6 @@
 import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
 import { shareIsolatePromise } from "./isolate-shared-promise.js";
-//#region src/server/app-route-module-loader.ts
+// src/server/app-route-module-loader.ts
 /**
 * Lazy route-module hydration for the App Router RSC entry.
 *
@@ -164,5 +164,4 @@ function ensureAppRouteModulesLoaded(route) {
 	route.__loading = loading;
 	return loading;
 }
-//#endregion
 export { ensureAppRouteModulesLoaded, loadAppInterceptLayouts, loadAppInterceptNotFound, loadAppInterceptPage };

package/dist/server/app-route-request-built-ins.d.ts

@@ -1,4 +1,3 @@
-//#region src/server/app-route-request-built-ins.d.ts
 export type BuiltInRequestProperty = {
   descriptor: PropertyDescriptor;
   instanceOnly: boolean;
@@ -11,5 +10,4 @@ export type BuiltInRequestProperty = {
  * The production RSC entry imports this module ahead of userland; the global
  * symbol also preserves that first snapshot for the lazy dispatch chunk.
  */
-export declare const BUILT_IN_REQUEST_PROPERTIES: readonly BuiltInRequestProperty[];
-//#endregion
+export declare const BUILT_IN_REQUEST_PROPERTIES: readonly BuiltInRequestProperty[];