vinext 1.3.1 → 1.4.0

package/dist/server/headers.js

@@ -17,7 +17,7 @@ const VINEXT_CACHE_HEADER = "X-Vinext-Cache";
 const NEXTJS_CACHE_HEADER = "x-nextjs-cache";
 /** Next.js cache-tag metadata carried by prerendered App Router responses. */
 const NEXT_CACHE_TAGS_HEADER = "x-next-cache-tags";
-/** Timing metrics: `handlerStart,compileMs,renderMs`. */
+/** Timing metrics: `handlerStart,compileMs,renderMs` (handlerStart is wall-clock ms). */
 const VINEXT_TIMING_HEADER = "x-vinext-timing";
 /** Matched route returned from an independently hosted response stage. */
 const VINEXT_TRACE_ROUTE_HEADER = "X-Vinext-Trace-Route";
@@ -85,8 +85,11 @@ const VINEXT_PRERENDER_RENDER_ERROR_HEADER = "x-vinext-prerender-render-error";
 const VINEXT_PRERENDER_SPECIAL_ERROR_HEADER = "x-vinext-prerender-special-error";
 /** Internal marker persisted only inside metadata-route APP_ROUTE cache values. */
 const VINEXT_METADATA_ROUTE_CACHE_HEADER = "x-vinext-metadata-route-cache";
-/** Disabled-by-default client hint describing already-held App Router payload entries. */
-const VINEXT_CLIENT_REUSE_MANIFEST_HEADER = "X-Vinext-Client-Reuse-Manifest";
+/**
+* Hashed identities of the layouts a client navigation already holds, so a
+* render that's never stored can leave them out. Not part of the RSC cache key.
+*/
+const VINEXT_MOUNTED_LAYOUTS_HEADER = "X-Vinext-Mounted-Layouts";
 /**
 * Side-channel signal that an RSC response (HTTP 200) encodes a `redirect()`
 * thrown during render. The header value is the redirect target (path-only
@@ -152,7 +155,8 @@ const FLIGHT_HEADERS = [
 	"next-router-prefetch",
 	"next-hmr-refresh",
 	"next-router-segment-prefetch",
-	"x-vinext-rsc-state-fingerprint"
+	"x-vinext-rsc-state-fingerprint",
+	"x-vinext-mounted-layouts"
 ];
 /**
 * Headers that must be stripped from external requests before any handler
@@ -192,4 +196,4 @@ const VINEXT_INTERNAL_HEADERS = [
 	VINEXT_TRACE_ROUTE_HEADER.toLowerCase()
 ];
 //#endregion
-export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, MIDDLEWARE_SKIP_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ACTION_HEADER, NEXT_CACHE_TAGS_HEADER, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_EXPECTED_WORKER_VERSION_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH, VINEXT_PRERENDER_READINESS_HEADER, VINEXT_PRERENDER_READINESS_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER, VINEXT_PRERENDER_REWRITTEN_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECIAL_ERROR_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_PRERENDER_STATIC_PARAMS_PATH, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_REVALIDATED_CACHE_TAG_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_REVALIDATE_HOST_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER, VINEXT_STALE_TIME_PENDING_HEADER, VINEXT_TIMING_HEADER, VINEXT_TRACE_BUFFERED_BODY_HEADER, VINEXT_TRACE_ERROR_HEADER, VINEXT_TRACE_ROUTE_HEADER, isVinextRscVaryField };
+export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, MIDDLEWARE_SKIP_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ACTION_HEADER, NEXT_CACHE_TAGS_HEADER, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, VINEXT_CACHE_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_EXPECTED_WORKER_VERSION_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_MOUNTED_LAYOUTS_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH, VINEXT_PRERENDER_READINESS_HEADER, VINEXT_PRERENDER_READINESS_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER, VINEXT_PRERENDER_REWRITTEN_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECIAL_ERROR_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_PRERENDER_STATIC_PARAMS_PATH, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_REVALIDATED_CACHE_TAG_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_REVALIDATE_HOST_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER, VINEXT_STALE_TIME_PENDING_HEADER, VINEXT_TIMING_HEADER, VINEXT_TRACE_BUFFERED_BODY_HEADER, VINEXT_TRACE_ERROR_HEADER, VINEXT_TRACE_ROUTE_HEADER, isVinextRscVaryField };

package/dist/server/isr-cache.d.ts

@@ -1,7 +1,7 @@
-import { OnRequestErrorContext } from "./instrumentation.js";
-import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER } from "../utils/protocol-headers.js";
 import { RenderObservation } from "./cache-proof.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+import { OnRequestErrorContext } from "./instrumentation.js";
+import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER } from "../utils/protocol-headers.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { CacheControlMetadata, CacheHandlerValue, CachedAppPageValue, CachedPagesValue, IncrementalCacheValue } from "../shims/cache-handler.js";
 import { getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret } from "./revalidation-request.js";
@@ -68,6 +68,12 @@ export declare function isrSetPrerenderedAppPage(key: string, data: CachedAppPag
 }): Promise<void>;
 /** Coalesce same-key synchronous on-demand revalidations. */
 export declare function coalesceOnDemandRevalidation<T>(key: string, renderFn: () => Promise<T>): Promise<T>;
+/**
+ * Coalesce same-key on-demand revalidations whose render answers with a
+ * Response, or null for no match. Every caller gets its own copy of the one
+ * render's response. `method` is the request method the response answers.
+ */
+export declare function coalesceOnDemandResponse<R extends Response | null>(key: string, method: string, renderFn: () => Promise<R>): Promise<R>;
 /**
  * Trigger a background regeneration for a cache key.
  *

package/dist/server/isr-cache.js

@@ -101,6 +101,31 @@ function coalesceOnDemandRevalidation(key, renderFn) {
 	return promise;
 }
 /**
+* Coalesce same-key on-demand revalidations whose render answers with a
+* Response, or null for no match. Every caller gets its own copy of the one
+* render's response. `method` is the request method the response answers.
+*/
+async function coalesceOnDemandResponse(key, method, renderFn) {
+	const snapshot = await coalesceOnDemandRevalidation(key, async () => {
+		const response = await renderFn();
+		if (!response) return null;
+		const hasBody = method !== "HEAD" && response.status !== 204 && response.status !== 205 && response.status !== 304;
+		if (!hasBody) await response.body?.cancel();
+		return {
+			body: hasBody ? new Uint8Array(await response.arrayBuffer()) : null,
+			headers: [...response.headers.entries()],
+			status: response.status,
+			statusText: response.statusText
+		};
+	});
+	if (!snapshot) return null;
+	return new Response(snapshot.body?.slice() ?? null, {
+		headers: snapshot.headers,
+		status: snapshot.status,
+		statusText: snapshot.statusText
+	});
+}
+/**
 * Trigger a background regeneration for a cache key.
 *
 * If a regeneration for this key is already in progress, this is a no-op.
@@ -247,4 +272,4 @@ function appIsrRouteKey(pathname) {
 	return appIsrCacheKey(pathname, pathname !== "/" && pathname.endsWith("/") ? "route:trailing-slash" : "route");
 }
 //#endregion
-export { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, appIsrCacheKey, appIsrFallbackShellHtmlKey, appIsrFallbackShellKey, appIsrHtmlKey, appIsrRouteKey, appIsrRscKey, buildAppPageCacheValue, buildPagesCacheValue, coalesceOnDemandRevalidation, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret, isrCacheControl, isrCacheKey, isrGet, isrSet, isrSetPrerenderedAppPage, normalizeMountedSlotsHeader, pagesIsrCacheKey, resolveRouteExpireSeconds, triggerBackgroundRegeneration };
+export { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, appIsrCacheKey, appIsrFallbackShellHtmlKey, appIsrFallbackShellKey, appIsrHtmlKey, appIsrRouteKey, appIsrRscKey, buildAppPageCacheValue, buildPagesCacheValue, coalesceOnDemandResponse, coalesceOnDemandRevalidation, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret, isrCacheControl, isrCacheKey, isrGet, isrSet, isrSetPrerenderedAppPage, normalizeMountedSlotsHeader, pagesIsrCacheKey, resolveRouteExpireSeconds, triggerBackgroundRegeneration };

package/dist/server/metadata-route-response.js

@@ -8,16 +8,16 @@ import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { beginRouteCacheability, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete, recordRouteCacheability } from "../shims/cacheability-classification.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl } from "./isr-decision.js";
-import { isrCacheControl } from "./isr-cache.js";
+import { coalesceOnDemandResponse, isrCacheControl } from "./isr-cache.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
 import { isRenderDynamicLatched } from "../shims/internal/headers-state.js";
 import { getActiveDraftModeState, getHeadersContext, hasDraftModeCookieHeader, replaceHeadersContext } from "../shims/headers.js";
-import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
+import { _consumeRequestScopedCacheLife, _isOnDemandRevalidate } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { isValidMetadataImageId, manifestToJson, matchMetadataRoutePattern, robotsToText, sitemapToXml } from "./metadata-routes.js";
-import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
-import { canonicalizeAppPageParams } from "./app-page-segment-state.js";
 import { buildAppRouteCacheValue, buildRouteHandlerCachedResponse } from "./app-route-handler-response.js";
+import { canonicalizeAppPageParams } from "./app-page-segment-state.js";
+import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 import { completeAppRouteHandlerResponse } from "./app-route-handler-execution.js";
@@ -165,7 +165,7 @@ async function captureRenderedMetadataRoute(response, route, cleanPathname) {
 		...observedCacheLife,
 		revalidate: frameworkRevalidate
 	};
-	const cacheable = (response.status < 400 || response.status === 404) && completed && !isRenderDynamicLatched() && !getActiveDraftModeState() && !hasDraftModeCookieHeader() && route.module?.dynamic !== "force-dynamic" && frameworkRevalidate > 0 && !response.headers.has("set-cookie");
+	const cacheable = (_isOnDemandRevalidate() || response.status < 400 || response.status === 404) && completed && !isRenderDynamicLatched() && !getActiveDraftModeState() && !hasDraftModeCookieHeader() && route.module?.dynamic !== "force-dynamic" && frameworkRevalidate > 0 && !response.headers.has("set-cookie");
 	const cacheControl = cacheable ? buildAppRouteMissIsrCacheControl(frameworkRevalidate, cacheLife?.expire) : NEVER_CACHE_CONTROL;
 	if (isUserResponse && !hasUserPolicy) {
 		response = new Response(response.body, {
@@ -231,12 +231,34 @@ async function runMetadataRouteRegeneration(options, route, render, routeKey, pr
 		await closeAfterResponse(requestContext);
 	}
 }
+/** The outer ISR key for a matched metadata route, or null if it's never cached. */
+function getOuterMetadataCacheKey(options, route) {
+	if (!isOuterMetadataCacheEnabled() || !options.isrRouteKey || getActiveDraftModeState() || hasDraftModeCookieHeader() || route.module?.dynamic === "force-dynamic" || route.module?.revalidate === 0) return null;
+	return options.isrRouteKey(options.cleanPathname);
+}
+/**
+* Renders a matched metadata route that wasn't served from the cache, and
+* stores it. Concurrent on-demand revalidations of one entry share a single
+* render, as Next.js batches ResponseCache work by its key and
+* isOnDemandRevalidate.
+*/
+async function renderMetadataRouteMiss(options, route, render, cachedEntry) {
+	const renderAndStore = async () => {
+		const rendered = await render();
+		if (!rendered) return null;
+		await writeMetadataRouteMiss(options, route, rendered, cachedEntry);
+		return rendered.response;
+	};
+	const routeKey = _isOnDemandRevalidate() ? getOuterMetadataCacheKey(options, route) : null;
+	if (routeKey === null || !options.isrSet) return renderAndStore();
+	return coalesceOnDemandResponse(routeKey, "GET", renderAndStore);
+}
 async function readMatchedPrerenderedMetadataRouteResponse(options, route, render) {
-	if (!isOuterMetadataCacheEnabled() || !options.isrGet || !options.isrRouteKey || getActiveDraftModeState() || hasDraftModeCookieHeader() || route.module?.dynamic === "force-dynamic" || route.module?.revalidate === 0) return {
+	const routeKey = getOuterMetadataCacheKey(options, route);
+	if (routeKey === null || !options.isrGet || _isOnDemandRevalidate()) return {
 		cachedEntry: null,
 		response: null
 	};
-	const routeKey = options.isrRouteKey(options.cleanPathname);
 	let cached;
 	try {
 		cached = await options.isrGet(routeKey);
@@ -495,11 +517,8 @@ async function handleMetadataRouteRequest(options) {
 					};
 					const cached = await readMatchedPrerenderedMetadataRouteResponse(options, route, render);
 					if (cached.response) return cached.response;
-					const rendered = await render();
-					if (rendered) {
-						await writeMetadataRouteMiss(options, route, rendered, cached.cachedEntry);
-						return rendered.response;
-					}
+					const response = await renderMetadataRouteMiss(options, route, render, cached.cachedEntry);
+					if (response) return response;
 				}
 				continue;
 			}
@@ -533,9 +552,7 @@ async function handleMetadataRouteRequest(options) {
 			});
 			if (dynamicParamsResponse) return dynamicParamsResponse;
 		}
-		const rendered = await render();
-		await writeMetadataRouteMiss(options, route, rendered, cached.cachedEntry);
-		return rendered.response;
+		return renderMetadataRouteMiss(options, route, render, cached.cachedEntry);
 	}
 	return null;
 }

package/dist/server/multi-stage.d.ts

@@ -1,5 +1,14 @@
 import { CacheabilityRepresentation } from "./cacheability-manifest.js";
 //#region src/server/multi-stage.d.ts
+/**
+ * The origin a shared cache identity names in place of the request's. Next.js
+ * keys its response cache by pathname, so one stored response answers every
+ * host an app serves. `.invalid` never resolves, so no configured domain or
+ * host condition can match it when the identity is replayed.
+ */
+export declare const VINEXT_CACHE_IDENTITY_ORIGIN = "https://cache-identity.vinext.invalid";
+/** Name `origin` in place of a dispatch URL's origin in a shared cache identity. */
+export declare function withCacheIdentityOrigin(requestUrl: string, origin?: string): string;
 /** Whether a response-stage cache must reject a field it did not key itself by. */
 export declare function hasUnsupportedResponseStageVary(headers: Headers, keyedRequestHeaders?: Iterable<string>): boolean;
 /**
@@ -41,26 +50,58 @@ export type VinextResponseStageDispatchOptions = {
    */
   regeneratesStoredEntry?: boolean;
   /**
-   * Query-free identity of a shared App page GET/HEAD dispatch, supplied only
-   * to adapters that declare `responseStageCacheIdentity: "query-free"` and
-   * require completed-response admission. A transport given one partitions
+   * Shared cache identity of an App Router GET/HEAD dispatch, or of a Pages
+   * page the build found static (getStaticProps or none), supplied only to
+   * adapters that declare a `responseStageCacheIdentity` and require
+   * completed-response admission. A transport given one partitions
    * its baseline lookup and stored entry by this request's method and complete
    * URL plus these complete serialized props, instead of the dispatched request
-   * and props, and replays this identity for background regeneration.
+   * and props, and replays this identity for background regeneration, or the
+   * dispatched request and props when `regenerateFromDispatch` is set.
    * Everything else in the contract above still applies.
    *
-   * The identity drops the user query from the URL and `resolvedUrl`, keeping
+   * The identity names `VINEXT_CACHE_IDENTITY_ORIGIN` in place of the
+   * request's origin, in its URL and its `requestOrigin`, so one stored
+   * response answers every host, as Next.js's pathname-keyed response cache
+   * does. That is safe only because completed-response admission refuses a
+   * response whose render used a dynamic API, which every App Router read of
+   * the request's host is. Core omits the identity for bypassed dispatches.
+   *
+   * A Pages page identity instead names the configured i18n domain the
+   * request's host selects, as vinext's Pages ISR key keeps the domain, and
+   * the cache identity origin for every other host. A page without
+   * getStaticProps whose page or `_app` getInitialProps turns out to run is
+   * refused admission, because its props say the entry is shared across
+   * hosts. A getStaticProps page's `_app` getInitialProps shares its entry,
+   * as in Next.js, which keys it by path.
+   *
+   * Under `responseStageCacheIdentity: "query-free"`, an App page identity
+   * also drops the user query from the URL and `resolvedUrl`, keeping
    * framework representation selectors: the `.rsc` suffix, the render mode,
-   * and, for RSC requests only, the one validated `_rsc` value. That is safe only because completed-response
-   * admission refuses a cacheable App page response unless its render proved
-   * it never read `searchParams`. The dispatched request still carries the real
-   * query for the render itself. Core omits the identity when a `next.config`
-   * public cache policy applies (cached per full URL, as Next.js CDN caching
-   * is), and for bypassed, interception, and mounted-slot dispatches.
+   * and, for RSC requests only, the one validated `_rsc` value. That is safe
+   * only because completed-response admission refuses a cacheable App page
+   * response unless its render proved it never read `searchParams`. The
+   * dispatched request still carries the real query for the render itself. A
+   * page identity keeps the query when a `next.config` public cache policy
+   * applies (cached per full URL, as Next.js CDN caching is), and for
+   * interception and mounted-slot dispatches.
    */
   cacheIdentity?: {
     props: unknown;
+    /**
+     * Set when the identity dropped the user query. A transport stores a
+     * page's other part from one render only under such an identity: one
+     * that keeps the query is cached per full URL, and stores its own part.
+     */
+    queryFree?: true;
     request: Request;
+    /**
+     * Regenerate from the dispatched request and props. A getStaticProps
+     * page's custom `_app` getInitialProps receives the request, host
+     * included, so a Pages page regenerates from a real request, as in
+     * Next.js, never from the identity's synthetic origin.
+     */
+    regenerateFromDispatch?: true;
   };
 };
 export type VinextCacheabilityProbeMode = "probe" | "identity";

package/dist/server/multi-stage.js

@@ -1,8 +1,20 @@
 //#region src/server/multi-stage.ts
+/**
+* The origin a shared cache identity names in place of the request's. Next.js
+* keys its response cache by pathname, so one stored response answers every
+* host an app serves. `.invalid` never resolves, so no configured domain or
+* host condition can match it when the identity is replayed.
+*/
+const VINEXT_CACHE_IDENTITY_ORIGIN = "https://cache-identity.vinext.invalid";
+/** Name `origin` in place of a dispatch URL's origin in a shared cache identity. */
+function withCacheIdentityOrigin(requestUrl, origin = VINEXT_CACHE_IDENTITY_ORIGIN) {
+	const url = new URL(requestUrl);
+	return `${origin}${url.pathname}${url.search}`;
+}
 /** Whether a response-stage cache must reject a field it did not key itself by. */
 function hasUnsupportedResponseStageVary(headers, keyedRequestHeaders = []) {
 	const keyedFields = new Set([...keyedRequestHeaders].map((name) => name.trim().toLowerCase()).filter(Boolean));
 	return (headers.get("Vary") ?? "").split(",").map((name) => name.trim().toLowerCase()).filter(Boolean).some((name) => name === "*" || !keyedFields.has(name));
 }
 //#endregion
-export { hasUnsupportedResponseStageVary };
+export { VINEXT_CACHE_IDENTITY_ORIGIN, hasUnsupportedResponseStageVary, withCacheIdentityOrigin };

package/dist/server/navigation-planner.js

@@ -1,9 +1,9 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments } from "../routing/route-pattern.js";
+import { resolveHardNavigationTargetFromRscResponse, resolveRscCompatibilityNavigationDecision } from "./app-rsc-cache-busting.js";
 import { AppElementsWire, compareAppElementsSlotIds } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { resolveHardNavigationTargetFromRscResponse, resolveRscCompatibilityNavigationDecision } from "./app-rsc-cache-busting.js";
 import { resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop } from "./app-browser-rsc-redirect.js";
 import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 import { verifyOperationTokenForCacheReuse } from "./operation-token.js";

package/dist/server/pages-api-route.js

@@ -30,6 +30,17 @@ function isEdgeApiRouteModule(module) {
 function isNodeApiRouteModule(module) {
 	return typeof module.default === "function" && !isEdgeApiRuntime(resolveModuleRuntime(module));
 }
+function withInitialResponseHeaders(response, initialResponseHeaders) {
+	if (!initialResponseHeaders || !initialResponseHeaders.keys().next().value) return response;
+	const headers = new Headers(initialResponseHeaders);
+	for (const [name, value] of response.headers) if (name !== "set-cookie") headers.set(name, value);
+	for (const cookie of response.headers.getSetCookie()) headers.append("Set-Cookie", cookie);
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
 async function handlePagesApiRoute(options) {
 	const run = async () => {
 		const response = await _handlePagesApiRoute(options);
@@ -51,22 +62,10 @@ async function _handlePagesApiRoute(options) {
 				skipTrailingSlashRedirect: options.nextConfig.skipTrailingSlashRedirect
 			} } : void 0);
 			const response = await tracePagesApiHandler(route.pattern, () => handler(nextRequest));
-			if (response instanceof Response) {
-				const finalized = finalizeEdgeApiResponse(response, options.edgeRuntime ?? "worker");
-				if (!options.initialResponseHeaders || !options.initialResponseHeaders.keys().next().value) return finalized;
-				const headers = new Headers(options.initialResponseHeaders);
-				for (const [name, value] of finalized.headers) if (name.toLowerCase() !== "set-cookie") headers.set(name, value);
-				const finalizedCookies = finalized.headers.getSetCookie();
-				for (const cookie of finalizedCookies) headers.append("Set-Cookie", cookie);
-				return new Response(finalized.body, {
-					headers,
-					status: finalized.status,
-					statusText: finalized.statusText
-				});
-			}
+			if (response instanceof Response) return withInitialResponseHeaders(finalizeEdgeApiResponse(response, options.edgeRuntime ?? "worker"), options.initialResponseHeaders);
 			throw new Error("Edge API route did not return a Response");
 		}
-		if (!isNodeApiRouteModule(route.module)) return new Response("API route does not export a default function", { status: 500 });
+		if (!isNodeApiRouteModule(route.module)) return withInitialResponseHeaders(new Response("API route does not export a default function", { status: 500 }), options.initialResponseHeaders);
 		const handler = route.module.default;
 		const query = buildPagesApiQuery(options.url, params);
 		const bodyParserConfig = resolveBodyParserConfig(route.module.config);
@@ -92,8 +91,12 @@ async function _handlePagesApiRoute(options) {
 			if (!res.writableEnded) markVinextStreamedApiResponse(response);
 			return response;
 		};
-		const destroyAfterHandlerError = (error) => {
+		const settleHandlerError = (error) => {
 			const normalizedError = error instanceof Error ? error : new Error(String(error));
+			if (!res.headersSent) return {
+				type: "error",
+				error: normalizedError
+			};
 			res.destroy(normalizedError);
 			throw normalizedError;
 		};
@@ -101,22 +104,28 @@ async function _handlePagesApiRoute(options) {
 			type: "response",
 			response
 		}));
-		const handlerCompletion = Promise.resolve().then(() => tracePagesApiHandler(route.pattern, () => handler(req, res), { recordErrors: options.edgeRuntime !== "node" })).then(() => ({ type: "handler" }), destroyAfterHandlerError);
+		const handlerCompletion = Promise.resolve().then(() => tracePagesApiHandler(route.pattern, () => handler(req, res), { recordErrors: options.edgeRuntime !== "node" })).then(() => ({ type: "handler" }), settleHandlerError);
 		const firstSettled = await Promise.race([responseReady, handlerCompletion]);
 		if (firstSettled.type === "response") {
 			const handlerLifecycle = handlerCompletion.then(completeHandler, (error) => options.reportRequestError?.(error, route.pattern));
 			getRequestExecutionContext()?.waitUntil(handlerLifecycle);
 			return finalizeResponse(firstSettled.response);
 		}
+		if (firstSettled.type === "error") {
+			await options.reportRequestError?.(firstSettled.error, route.pattern);
+			res.statusCode = 500;
+			res.end("Internal Server Error");
+			return finalizeResponse(await responsePromise);
+		}
 		completeHandler();
 		return finalizeResponse(await responsePromise);
 	} catch (error) {
-		if (error instanceof PagesBodyParseError) return new Response(error.message, {
+		if (error instanceof PagesBodyParseError) return withInitialResponseHeaders(new Response(error.message, {
 			status: error.statusCode,
 			statusText: error.message
-		});
+		}), options.initialResponseHeaders);
 		await options.reportRequestError?.(error instanceof Error ? error : new Error(String(error)), route.pattern);
-		return internalServerErrorResponse();
+		return withInitialResponseHeaders(internalServerErrorResponse(), options.initialResponseHeaders);
 	}
 }
 //#endregion

package/dist/server/pages-media-type.d.ts

@@ -9,6 +9,26 @@ export declare class PagesBodyParseError extends Error {
   readonly statusCode: number;
   constructor(message: string, statusCode: number);
 }
-export declare function getMediaType(contentType: string | null | undefined): string;
 export declare function isJsonMediaType(mediaType: string): boolean;
+/** A `TextDecoder`-shaped decoder for one request body. */
+export type PagesBodyDecoder = {
+  decode(input?: Uint8Array, options?: {
+    stream?: boolean;
+  }): string;
+};
+/**
+ * Resolve the media type and body decoder for a Pages API request, matching
+ * Next.js `parseBody()`: a malformed Content-Type is treated as `text/plain`,
+ * the body is decoded with its `charset` (UTF-8 by default), and a charset that
+ * can't be decoded is rejected with `400 Invalid body`.
+ *
+ * Next.js decodes through raw-body with iconv-lite 0.4, which vinext bundles
+ * at the same version. It is loaded only for non-UTF-8 charsets: `TextDecoder`
+ * decodes UTF-8 identically, BOM stripping included, and keeps iconv-lite's
+ * encoding tables out of the startup path.
+ */
+export declare function createPagesBodyDecoder(contentType: string | null | undefined): Promise<{
+  mediaType: string;
+  decoder: PagesBodyDecoder;
+}>;
 //#endregion

package/dist/server/pages-media-type.js

@@ -1,3 +1,5 @@
+import { __toESM } from "../_virtual/_rolldown/runtime.js";
+import { Buffer } from "node:buffer";
 //#region src/server/pages-media-type.ts
 /**
 * Shared media-type helpers and body-parse error for Pages API routes.
@@ -13,12 +15,74 @@ var PagesBodyParseError = class extends Error {
 		this.name = "PagesBodyParseError";
 	}
 };
-function getMediaType(contentType) {
-	const [type] = (contentType ?? "text/plain").split(";");
-	return type?.trim().toLowerCase() || "text/plain";
-}
 function isJsonMediaType(mediaType) {
 	return mediaType === "application/json" || mediaType === "application/ld+json";
 }
+const TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+const PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
+const QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
+function parseContentType(header) {
+	let index = header.indexOf(";");
+	const type = (index === -1 ? header : header.slice(0, index)).trim();
+	if (!TYPE_REGEXP.test(type)) return null;
+	let charset;
+	if (index !== -1) {
+		const paramRegexp = new RegExp(PARAM_REGEXP);
+		paramRegexp.lastIndex = index;
+		let match;
+		while (match = paramRegexp.exec(header)) {
+			if (match.index !== index) return null;
+			index += match[0].length;
+			if (match[1].toLowerCase() !== "charset") continue;
+			const value = match[2];
+			charset = value.startsWith("\"") ? value.slice(1, -1).replace(QESC_REGEXP, "$1") : value;
+		}
+		if (index !== header.length) return null;
+	}
+	return {
+		mediaType: type.toLowerCase(),
+		charset
+	};
+}
+function iconvBodyDecoder(decoder) {
+	return { decode(input, options) {
+		let text = input ? decoder.write(Buffer.from(input.buffer, input.byteOffset, input.byteLength)) : "";
+		if (!options?.stream) text += decoder.end() || "";
+		return text;
+	} };
+}
+/**
+* Resolve the media type and body decoder for a Pages API request, matching
+* Next.js `parseBody()`: a malformed Content-Type is treated as `text/plain`,
+* the body is decoded with its `charset` (UTF-8 by default), and a charset that
+* can't be decoded is rejected with `400 Invalid body`.
+*
+* Next.js decodes through raw-body with iconv-lite 0.4, which vinext bundles
+* at the same version. It is loaded only for non-UTF-8 charsets: `TextDecoder`
+* decodes UTF-8 identically, BOM stripping included, and keeps iconv-lite's
+* encoding tables out of the startup path.
+*/
+async function createPagesBodyDecoder(contentType) {
+	const parsed = contentType && parseContentType(contentType) || {
+		mediaType: "text/plain",
+		charset: void 0
+	};
+	const charset = parsed.charset || "utf-8";
+	if (charset.toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "") === "utf8") return {
+		mediaType: parsed.mediaType,
+		decoder: new TextDecoder()
+	};
+	const iconv = (await import("../deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/lib/index.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1))).default;
+	let decoder;
+	try {
+		decoder = iconv.getDecoder(charset);
+	} catch {
+		throw new PagesBodyParseError("Invalid body", 400);
+	}
+	return {
+		mediaType: parsed.mediaType,
+		decoder: iconvBodyDecoder(decoder)
+	};
+}
 //#endregion
-export { PagesBodyParseError, getMediaType, isJsonMediaType };
+export { PagesBodyParseError, createPagesBodyDecoder, isJsonMediaType };

package/dist/server/pages-node-compat.js

@@ -2,11 +2,11 @@ import { parseCookieHeader } from "../utils/parse-cookie.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT } from "./pages-body-parser-config.js";
-import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
+import { PagesBodyParseError, createPagesBodyDecoder, isJsonMediaType } from "./pages-media-type.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { clearPagesPreviewData, getPagesPreviewState, setPagesDraftMode, setPagesPreviewData } from "./pages-preview.js";
 import { decode } from "node:querystring";
-import { Readable, Writable } from "node:stream";
+import { Readable, Stream, Writable } from "node:stream";
 //#region src/server/pages-node-compat.ts
 const MAX_PAGES_API_BODY_SIZE = DEFAULT_PAGES_API_BODY_SIZE_LIMIT;
 const NO_BODY_RESPONSE_STATUSES = /* @__PURE__ */ new Set([
@@ -26,11 +26,17 @@ function validateAppendedHeader(name, value) {
 		if (INVALID_HEADER_VALUE_CHAR_PATTERN.test(String(item))) throw createNodeTypeError("ERR_INVALID_CHAR", `Invalid character in header content ["${name}"]`);
 	}
 }
-async function readPagesRequestBodyWithLimit(request, maxBytes) {
-	if (!request.body) return "";
-	return readStreamAsTextWithLimit(request.body, maxBytes, () => {
+/** The decoded body, or undefined when the request carried no body bytes. */
+async function readPagesRequestBodyWithLimit(request, maxBytes, decoder) {
+	if (!request.body) return;
+	let byteLength = 0;
+	const text = await readStreamAsTextWithLimit(request.body, maxBytes, () => {
 		throw new PagesBodyParseError("Request body too large", 413);
-	});
+	}, { decode(input, options) {
+		byteLength += input?.byteLength ?? 0;
+		return decoder.decode(input, options);
+	} });
+	return byteLength > 0 ? text : void 0;
 }
 /**
 * Read and parse a Pages Router API request body for the Workers/prod path.
@@ -43,16 +49,16 @@ async function readPagesRequestBodyWithLimit(request, maxBytes) {
 * @see https://nextjs.org/docs/pages/building-your-application/routing/api-routes#custom-config
 */
 async function parsePagesApiBody(request, maxBytes = MAX_PAGES_API_BODY_SIZE) {
+	const { mediaType, decoder } = await createPagesBodyDecoder(request.headers.get("content-type"));
 	if (Number.parseInt(request.headers.get("content-length") || "0", 10) > maxBytes) throw new PagesBodyParseError("Request body too large", 413);
-	let rawBody = "";
+	let rawBody;
 	try {
-		rawBody = await readPagesRequestBodyWithLimit(request, maxBytes);
+		rawBody = await readPagesRequestBodyWithLimit(request, maxBytes, decoder);
 	} catch (err) {
 		if (err instanceof PagesBodyParseError) throw err;
 		throw new PagesBodyParseError("Request body too large", 413);
 	}
-	const mediaType = getMediaType(request.headers.get("content-type"));
-	if (!rawBody) return isJsonMediaType(mediaType) ? {} : mediaType === "application/x-www-form-urlencoded" ? decode(rawBody) : void 0;
+	if (!rawBody) return isJsonMediaType(mediaType) ? {} : mediaType === "application/x-www-form-urlencoded" ? decode("") : rawBody;
 	if (isJsonMediaType(mediaType)) try {
 		return JSON.parse(rawBody);
 	} catch {
@@ -61,24 +67,34 @@ async function parsePagesApiBody(request, maxBytes = MAX_PAGES_API_BODY_SIZE) {
 	if (mediaType === "application/x-www-form-urlencoded") return decode(rawBody);
 	return rawBody;
 }
-async function* requestBodyChunks(request) {
-	if (!request.body || request.bodyUsed) return;
-	const reader = request.body.getReader();
-	try {
-		for (;;) {
-			const { value, done } = await reader.read();
-			if (done) return;
-			yield Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-		}
-	} finally {
-		try {
-			await reader.cancel();
-		} catch {}
-		reader.releaseLock();
-	}
-}
 function createRequestReadable(request) {
-	return Readable.from(requestBodyChunks(request), { objectMode: false });
+	const body = request.bodyUsed ? null : request.body;
+	let reader;
+	return new Readable({
+		read() {
+			if (!body) {
+				this.push(null);
+				return;
+			}
+			reader ??= body.getReader();
+			reader.read().then(({ value, done }) => {
+				if (this.destroyed) return;
+				if (done) {
+					this.push(null);
+					return;
+				}
+				this.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
+			}, (error) => this.destroy(error));
+		},
+		destroy(error, callback) {
+			const cancelled = reader ? reader.cancel(error ?? void 0) : body?.cancel(error ?? void 0);
+			if (!cancelled) {
+				callback(error);
+				return;
+			}
+			cancelled.then(() => callback(error), () => callback(error));
+		}
+	});
 }
 function parsePagesRequestCookies(cookieHeader) {
 	return parseCookieHeader(Array.isArray(cookieHeader) ? cookieHeader.join("; ") : cookieHeader);
@@ -189,6 +205,15 @@ var PagesResponseStream = class extends Writable {
 		this.end(JSON.stringify(data));
 	}
 	send(data) {
+		if (NO_BODY_RESPONSE_STATUSES.has(this.resStatusCode)) {
+			this.end();
+			return;
+		}
+		if (data instanceof Stream) {
+			if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "application/octet-stream";
+			data.pipe(this);
+			return;
+		}
 		if (Buffer.isBuffer(data)) {
 			if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "application/octet-stream";
 			this.resHeaders["content-length"] = String(data.length);