vinext 1.3.1 → 1.4.0

package/dist/server/pages-page-handler.js

@@ -13,8 +13,8 @@ import { beginRouteCacheability, isRouteCacheabilityIdentityProbe, isRouteCachea
 import { BROWSER_REVALIDATE_CACHE_CONTROL, NEVER_CACHE_CONTROL, STATIC_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy, hasExplicitNonCacheableResponsePolicy, isCdnResponsePolicyHeader, shouldUseNextDeployCacheControl } from "./cache-control.js";
 import { buildMissIsrCacheControl } from "./isr-decision.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
-import { coalesceOnDemandRevalidation, isrGet, isrSet, pagesIsrCacheKey, triggerBackgroundRegeneration } from "./isr-cache.js";
-import { ensureFetchPatch } from "../shims/fetch-cache.js";
+import { coalesceOnDemandResponse, isrGet, isrSet, pagesIsrCacheKey, triggerBackgroundRegeneration } from "./isr-cache.js";
+import { ensureFetchPatch, setCurrentFetchDraftMode } from "../shims/fetch-cache.js";
 import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
@@ -258,23 +258,10 @@ function createPagesPageHandler(opts) {
 		const isStaticPropsRender = isStaticPropsRoute && typeof pageModule.getServerSideProps !== "function";
 		if (!options?.__skipOnDemandCoalesce && !options?.__forcedRoute && !cacheIdentityDiverges && isStaticPropsRoute && isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate"))) {
 			const cacheKey = pageIsrCacheKey("pages", routeUrl.split("?")[0]);
-			const snapshot = await coalesceOnDemandRevalidation(cacheKey, async () => {
-				const response = await renderPage(request, url, manifest, middlewareHeaders, {
-					...options,
-					__skipOnDemandCoalesce: true
-				}, initialResponseHeaders);
-				return {
-					body: request.method === "HEAD" || response.status === 204 || response.status === 304 ? null : new Uint8Array(await response.arrayBuffer()),
-					headers: [...response.headers.entries()],
-					status: response.status,
-					statusText: response.statusText
-				};
-			});
-			return new Response(snapshot.body?.slice() ?? null, {
-				headers: snapshot.headers,
-				status: snapshot.status,
-				statusText: snapshot.statusText
-			});
+			return coalesceOnDemandResponse(cacheKey, request.method, () => renderPage(request, url, manifest, middlewareHeaders, {
+				...options,
+				__skipOnDemandCoalesce: true
+			}, initialResponseHeaders));
 		}
 		const routePattern = patternToNextFormat(route.pattern);
 		const renderStatusCode = renderStatusCodeOverride ?? (routePattern === "/404" ? 404 : void 0);
@@ -283,7 +270,10 @@ function createPagesPageHandler(opts) {
 		const renderRouteUrl = isStaticPropsRender && isStatusPageIdentity ? resolvePagesStatusPageRenderPath(statusPagePathname, vinextConfig.trailingSlash, originalRequestUrl.pathname) : isStaticPropsRender ? routeUrl.split("?")[0] : routeUrl;
 		const routerAsPathSource = isStaticPropsRender ? renderRouteUrl : renderAsPath ?? renderRouteUrl;
 		const routerAsPath = i18nConfig ? extractLocaleFromUrl(routerAsPathSource, i18nConfig, locale).url : routerAsPathSource;
-		const uCtx = createRequestContext({ executionContext: getRequestExecutionContext() });
+		const uCtx = createRequestContext({
+			executionContext: getRequestExecutionContext(),
+			isOnDemandRevalidate: isOnDemandRevalidateRequest(request.headers.get(PRERENDER_REVALIDATE_HEADER))
+		});
 		let pageReqRes = null;
 		const pageResponseSent = () => pageReqRes?.res.headersSent === true;
 		const sendsEarly = isStaticPropsRoute && !isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate"));
@@ -322,6 +312,7 @@ function createPagesPageHandler(opts) {
 					shouldClear: false
 				};
 				const previewData = preview.data;
+				setCurrentFetchDraftMode(previewData !== false);
 				const pagesNextData = {
 					...pagesReadiness,
 					...previewData === false ? {} : { isPreview: true }

package/dist/server/pages-request-pipeline.d.ts

@@ -84,6 +84,14 @@ export type PagesPipelineDeps = {
   dataNotFoundResponse?: Response | null;
   renderPage?: ((request: Request, resolvedUrl: string, options?: PagesRenderOptions, stagedHeaders?: Headers) => Promise<Response>) | null;
   handleApi?: ((request: Request, apiUrl: string, ctx: unknown, stagedHeaders: Headers) => Promise<Response>) | null;
+  /**
+   * `handleApi` installs the staged headers on the handler's `res` before user
+   * code runs, as Next.js does, so its response already reflects any header the
+   * handler replaced and only middleware's status is applied here.
+   * Workers leaves this unset: its response stage strips the inherited cookies
+   * so they are not stored, and this merge adds them back.
+   */
+  handleApiAppliesStagedHeaders?: boolean;
   /**
    * Optional override for proxying external rewrite destinations.
    * When supplied, the pipeline calls this instead of proxyExternalRequest(currentRequest, url).

package/dist/server/pages-request-pipeline.js

@@ -14,8 +14,8 @@ import { buildMiddlewarePrefetchSkipResponse } from "./pages-data-route.js";
 import { markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import { mergeRewriteQuery } from "../utils/query.js";
-import { withExternalRewriteResponseHeaders } from "./middleware-response-headers.js";
 import { setFrameworkRequestRoute } from "./request-tracing.js";
+import { withExternalRewriteResponseHeaders } from "./middleware-response-headers.js";
 import { applyConfigHeadersToHeaderRecord } from "./config-headers.js";
 import { finalizeMissingStaticAssetResponse, mergeHeaders } from "./worker-utils.js";
 //#region src/server/pages-request-pipeline.ts
@@ -310,7 +310,7 @@ async function runPagesRequest(request, deps) {
 				apiRequest = cloneRequestWithUrl(request, apiRequestUrl.toString());
 			}
 			const response = await deps.handleApi(apiRequest, apiLookupUrl, deps.ctx ?? null, headersFromRecord(middlewareHeaders));
-			const merged = mergeHeaders(response, middlewareHeaders, middlewareStatus);
+			const merged = mergeHeaders(response, deps.handleApiAppliesStagedHeaders ? {} : middlewareHeaders, middlewareStatus);
 			if (merged !== response) merged.__vinextStreamedApiResponse = response.__vinextStreamedApiResponse;
 			return {
 				type: "response",

package/dist/server/pages-request-stage-entry.js

@@ -3,7 +3,7 @@ import { requestContextFromRequest } from "../config/request-context.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_EXPECTED_WORKER_VERSION_HEADER } from "./headers.js";
 import { notFoundStaticAssetResponse } from "./http-error-responses.js";
-import { attachRequestCfMetadata, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.js";
+import { attachRequestCfMetadata, cloneRequestWithUrl, filterInternalHeaders, guardProtocolRelativeUrl, haveSameHeaders, withRequestHeaders } from "./request-pipeline.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
@@ -22,7 +22,8 @@ import { resolveClientBuildFile } from "./client-build-files.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse, isWorkerPrerenderDiscoveryPath } from "./worker-prerender-discovery.js";
 import { getPagesResponseStageCacheDisposition } from "./pages-response-stage.js";
-import "./worker-stages.js";
+import { adapterUsesSharedCacheIdentity, pagesCacheIdentityOrigin, pagesPageSharesAcrossHosts } from "./shared-cache-identity.js";
+import { createSharedPagesPageCacheIdentity } from "./worker-stages.js";
 import { consumePagesResponseStagePolicyOwner, prependResponseStageAdditiveHeaders, withResponseStageVary, withoutResponseStageVary } from "./response-stage-policy.js";
 import * as configuredCdnCacheAdapters from "virtual:vinext-cdn-cache-adapter";
 import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
@@ -34,11 +35,6 @@ import * as pagesEntry from "virtual:vinext-pages-request-entry";
 * The public pages-router-entry delegates here. Multi-stage hosts import the
 * named request handler directly and provide their response-stage dispatcher.
 */
-function haveSameHeaders(first, second) {
-	const firstEntries = [...first];
-	const secondEntries = [...second];
-	return firstEntries.length === secondEntries.length && firstEntries.every(([name, value], index) => name === secondEntries[index]?.[0] && value === secondEntries[index]?.[1]);
-}
 function captureOuterResponsePolicyHeaders(stagedHeaders, transportedPolicyHeaders) {
 	return captureCdnResponsePolicyOverrides(stagedHeaders, new Headers(transportedPolicyHeaders ?? []));
 }
@@ -151,7 +147,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			const expectedWorkerVersion = request.headers.get(VINEXT_EXPECTED_WORKER_VERSION_HEADER);
 			if (expectedWorkerVersion) filteredHeaders.set(VINEXT_EXPECTED_WORKER_VERSION_HEADER, expectedWorkerVersion);
 		}
-		request = cloneRequestWithHeaders(request, filteredHeaders);
+		request = withRequestHeaders(request, filteredHeaders);
 		const url = new URL(request.url);
 		let pathname = url.pathname;
 		if (ctx.isPrerenderPathDiscovery && isWorkerPrerenderDiscoveryPath(pathname)) return trackedDispatchResponseStage(request, {
@@ -162,7 +158,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 				resolvedRoutePathname: pathname
 			},
 			kind: "pages-prerender-discovery",
-			protocolVersion: 5,
+			protocolVersion: 6,
 			requestHost: url.host,
 			stagedHeaders: null
 		}, { cache: "bypass" }, env, ctx);
@@ -247,6 +243,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 					stagedHeaders
 				});
 				const isSharedStaticPage = cache === "shared" && matchedPage?.route.dataKind === "static";
+				const sharedAcrossHosts = (cache === "shared" || probeMode !== null) && pagesPageSharesAcrossHosts(matchedPage?.route) && adapterUsesSharedCacheIdentity();
 				const transportedPolicyHeaders = isSharedStaticPage ? withoutResponseStageVary(responseStagePolicyHeaders) : withResponseStageVary(responseStagePolicyHeaders, stagedHeaders?.get("Vary"));
 				const responseStageProps = () => ({
 					buildId: pagesEntry.buildId,
@@ -257,17 +254,22 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						resolvedRoutePathname: new URL(resolvedUrl, req.url).pathname
 					},
 					kind: "pages-page",
-					protocolVersion: 5,
+					protocolVersion: 6,
 					requestHost: new URL(req.url).host,
 					renderOptions: isDataReq ? {
 						...options,
 						originalUrl: originalRenderUrl
 					} : options ?? null,
 					resolvedUrl,
+					sharedAcrossHosts,
 					stagedHeaders: isSharedStaticPage ? null : [...stagedHeaders ?? new Headers()]
 				});
 				const isHeadRequest = req.method.toUpperCase() === "HEAD";
-				const responsePromise = trackedDispatchResponseStage(stageRequest, responseStageProps(), { cache }, env, ctx).then((response) => {
+				const props = responseStageProps();
+				const responsePromise = trackedDispatchResponseStage(stageRequest, props, cache === "shared" && sharedAcrossHosts ? {
+					cache,
+					cacheIdentity: createSharedPagesPageCacheIdentity(stageRequest, props, pagesCacheIdentityOrigin(stageRequest.url, i18nConfig))
+				} : { cache }, env, ctx).then((response) => {
 					const consumed = consumePagesResponseStagePolicyOwner(response);
 					if (cache === "shared") {
 						if (isSharedStaticPage && stagedHeaders) prependResponseStageAdditiveHeaders(consumed.response.headers, stagedHeaders);
@@ -297,7 +299,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						resolvedRoutePathname: new URL(apiUrl, req.url).pathname
 					},
 					kind: "pages-api",
-					protocolVersion: 5,
+					protocolVersion: 6,
 					requestHost: new URL(req.url).host,
 					stagedHeaders: [...stagedHeaders]
 				});

package/dist/server/pages-response-stage-entry.js

@@ -1,7 +1,7 @@
 import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
 import "../shims/unified-request-context.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
-import { beginRouteCacheability } from "../shims/cacheability-classification.js";
+import { beginRouteCacheability, markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
 import { validateCdnRequest } from "./cache-control.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
@@ -57,6 +57,12 @@ async function renderPagesResponse(request, env, platformCtx, props, stagedHeade
 		...ctx,
 		isStoredEntryRegeneration: true
 	};
+	let runtimeDataKind;
+	const runtimeDataKindIsRequestTime = () => {
+		if (props.kind !== "pages-page") return false;
+		runtimeDataKind ??= pagesEntry.getRuntimePageDataKind(props.resolvedUrl, request);
+		return runtimeDataKind === "server" || runtimeDataKind === "initial";
+	};
 	const render = async (cacheabilityContext) => {
 		if (props.kind === "pages-prerender-discovery") {
 			const readinessResponse = createWorkerPrerenderReadinessResponse(cacheabilityContext, request);
@@ -77,6 +83,7 @@ async function renderPagesResponse(request, env, platformCtx, props, stagedHeade
 			});
 		}
 		if (typeof pagesEntry.renderPage !== "function") return new Response("This page could not be found", { status: 404 });
+		if (props.sharedAcrossHosts && runtimeDataKindIsRequestTime()) runWithExecutionContext(cacheabilityContext, () => markRouteCacheabilityDynamic("getInitialProps render shares a cache entry across hosts"));
 		return stripStreamedHtmlContentLength(await pagesEntry.renderPage(request, props.resolvedUrl, null, cacheabilityContext, renderHeaders, props.renderOptions ?? void 0, initialResponseHeaders));
 	};
 	const handle = async (cacheabilityContext) => stripInheritedResponseStageCookies(await render(cacheabilityContext), renderHeaders);
@@ -94,9 +101,8 @@ async function renderPagesResponse(request, env, platformCtx, props, stagedHeade
 		resolvedRoutePathname: props.cacheability.resolvedRoutePathname
 	}, handle);
 	if (props.kind !== "pages-page") return response;
-	const runtimeDataKind = pagesEntry.getRuntimePageDataKind(props.resolvedUrl, request);
 	const headers = new Headers(response.headers);
-	headers.set(PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER, runtimeDataKind === "server" || runtimeDataKind === "initial" ? "request-time" : "static");
+	headers.set(PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER, runtimeDataKindIsRequestTime() ? "request-time" : "static");
 	return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
 		headers,
 		status: response.status,

package/dist/server/prod-server.js

@@ -1646,7 +1646,11 @@ async function createPagesRouterRequestHandler(options) {
 					...options,
 					originalUrl: originalRenderUrl
 				}, stagedHeaders?.has("Cache-Control") ? new Headers({ "Cache-Control": stagedHeaders.get("Cache-Control") }) : void 0) : null,
-				handleApi: typeof handleApi === "function" ? (request, apiUrl) => handleApi(request, apiUrl, createNodeExecutionContext(), resolveTrustedNodeRevalidateOrigin(req, host, port), "node") : null,
+				handleApi: typeof handleApi === "function" ? (request, apiUrl, _ctx, stagedHeaders) => {
+					stagedHeaders.delete("Content-Length");
+					return handleApi(request, apiUrl, createNodeExecutionContext(), resolveTrustedNodeRevalidateOrigin(req, host, port), "node", stagedHeaders);
+				} : null,
+				handleApiAppliesStagedHeaders: true,
 				serveFilesystemRoute: async (requestPathname, stagedHeaders, phase, resolvedUrl, _request, resolvedPathnameHasBasePath) => {
 					if (resolvedPathnameHasBasePath && isImageOptimizationPath(requestPathname)) {
 						for (const [name, value] of Object.entries(stagedHeaders)) res.setHeader(name, value);

package/dist/server/request-pipeline.d.ts

@@ -181,6 +181,12 @@ export declare function attachRequestCfMetadata(target: Request, source: Request
  * a RequestInit with best-effort metadata.
  */
 export declare function cloneRequestWithHeaders(request: Request, headers: Headers): Request;
+export declare function haveSameHeaders(first: Headers, second: Headers): boolean;
+/**
+ * `cloneRequestWithHeaders`, except that a native request whose headers
+ * already match is returned as is, so its body stays where it is.
+ */
+export declare function withRequestHeaders(request: Request, headers: Headers): Request;
 /**
  * Clone a Request while overriding the URL, preserving headers and metadata
  * when possible.

package/dist/server/request-pipeline.js

@@ -407,6 +407,26 @@ function cloneRequestWithHeaders(request, headers) {
 	}
 	return attachRequestCfMetadata(cloned, request);
 }
+function haveSameHeaders(first, second) {
+	const firstEntries = [...first];
+	const secondEntries = [...second];
+	return firstEntries.length === secondEntries.length && firstEntries.every(([name, value], index) => name === secondEntries[index]?.[0] && value === secondEntries[index]?.[1]);
+}
+function isNativeRequest(request) {
+	try {
+		Reflect.get(Request.prototype, "url", request);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* `cloneRequestWithHeaders`, except that a native request whose headers
+* already match is returned as is, so its body stays where it is.
+*/
+function withRequestHeaders(request, headers) {
+	return isNativeRequest(request) && haveSameHeaders(headers, request.headers) ? request : cloneRequestWithHeaders(request, headers);
+}
 /**
 * Clone a Request while overriding the URL, preserving headers and metadata
 * when possible.
@@ -444,4 +464,4 @@ function cloneRequestWithUrl(request, url) {
 	return attachRequestCfMetadata(cloned, request);
 }
 //#endregion
-export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, attachRequestCfMetadata, canonicalizeRequestPathname, canonicalizeRequestUrlPathname, cloneRequestWithHeaders, cloneRequestWithUrl, createStaticFileSignal, dropEmptyMiddlewareSetCookie, filterInternalHeaders, getRepeatedSlashRedirect, guardProtocolRelativeUrl, hasBasePath, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, sendRepeatedSlashRedirect, stripBasePath, validateCsrfOrigin, validateServerActionPayload };
+export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, attachRequestCfMetadata, canonicalizeRequestPathname, canonicalizeRequestUrlPathname, cloneRequestWithHeaders, cloneRequestWithUrl, createStaticFileSignal, dropEmptyMiddlewareSetCookie, filterInternalHeaders, getRepeatedSlashRedirect, guardProtocolRelativeUrl, hasBasePath, haveSameHeaders, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, sendRepeatedSlashRedirect, stripBasePath, validateCsrfOrigin, validateServerActionPayload, withRequestHeaders };

package/dist/server/shared-cache-identity.d.ts

@@ -0,0 +1,23 @@
+import { NextI18nConfig } from "../config/next-config.js";
+//#region src/server/shared-cache-identity.d.ts
+/** The core cache identity the configured adapter keys shared dispatches by, if any. */
+export declare function adapterSharedCacheIdentity(): "host-free" | "query-free" | null;
+/** Whether the configured adapter keys shared dispatches by a core cache identity. */
+export declare function adapterUsesSharedCacheIdentity(): boolean;
+/**
+ * Whether a Pages page's response is one for every host, as Next.js serves a
+ * getStaticProps page and an automatically static page. A page without data
+ * functions is rendered per request when its getInitialProps or a custom
+ * _app's runs, and may read the host, so it keeps the host in its key.
+ */
+export declare function pagesPageSharesAcrossHosts(route: {
+  dataKind?: string;
+  runsInitialProps?: boolean;
+} | null | undefined): boolean;
+/**
+ * The origin a shared Pages page identity names. A static Pages render reads
+ * the host only to select a configured i18n domain, so the identity keeps that
+ * domain, as vinext's Pages ISR key does, and every other host shares one entry.
+ */
+export declare function pagesCacheIdentityOrigin(requestUrl: string, i18nConfig: NextI18nConfig | null | undefined): string;
+//#endregion

package/dist/server/shared-cache-identity.js

@@ -0,0 +1,36 @@
+import { detectDomainLocale, normalizeDomainHostname } from "../utils/domain-locale.js";
+import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
+import { VINEXT_CACHE_IDENTITY_ORIGIN } from "./multi-stage.js";
+//#region src/server/shared-cache-identity.ts
+/** The core cache identity the configured adapter keys shared dispatches by, if any. */
+function adapterSharedCacheIdentity() {
+	const adapter = getCdnCacheAdapter();
+	if (adapter.requiresCompletedResponseAdmission !== true) return null;
+	return adapter.responseStageCacheIdentity ?? null;
+}
+/** Whether the configured adapter keys shared dispatches by a core cache identity. */
+function adapterUsesSharedCacheIdentity() {
+	return adapterSharedCacheIdentity() !== null;
+}
+/**
+* Whether a Pages page's response is one for every host, as Next.js serves a
+* getStaticProps page and an automatically static page. A page without data
+* functions is rendered per request when its getInitialProps or a custom
+* _app's runs, and may read the host, so it keeps the host in its key.
+*/
+function pagesPageSharesAcrossHosts(route) {
+	if (route?.dataKind === "static") return true;
+	return route?.dataKind === "none" && route.runsInitialProps !== true;
+}
+/**
+* The origin a shared Pages page identity names. A static Pages render reads
+* the host only to select a configured i18n domain, so the identity keeps that
+* domain, as vinext's Pages ISR key does, and every other host shares one entry.
+*/
+function pagesCacheIdentityOrigin(requestUrl, i18nConfig) {
+	const domainLocale = detectDomainLocale(i18nConfig?.domains, new URL(requestUrl).hostname);
+	if (!domainLocale) return VINEXT_CACHE_IDENTITY_ORIGIN;
+	return `${domainLocale.http ? "http" : "https"}://${normalizeDomainHostname(domainLocale.domain)}`;
+}
+//#endregion
+export { adapterSharedCacheIdentity, adapterUsesSharedCacheIdentity, pagesCacheIdentityOrigin, pagesPageSharesAcrossHosts };

package/dist/server/worker-stages.d.ts

@@ -1,7 +1,7 @@
-import { VinextResponseStageCacheability, VinextResponseStageTransport } from "./multi-stage.js";
+import { VinextResponseStageCacheability, VinextResponseStageDispatchOptions, VinextResponseStageTransport } from "./multi-stage.js";
 import { PagesRenderOptions } from "./pages-request-pipeline.js";
 //#region src/server/worker-stages.d.ts
-export declare const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 5;
+export declare const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 6;
 export declare const PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER = "x-vinext-pages-response-stage-policy-owner";
 export type PagesResponseStagePolicyOwner = "request-time" | "static";
 type PagesResponseStageEnvelope = {
@@ -14,10 +14,16 @@ type PagesResponseStageEnvelope = {
   stagedHeaders: Array<[string, string]> | null;
 };
 /** Serializable Pages page render delegated to a cacheable Worker stage. */
-type PagesPageResponseStageProps = PagesResponseStageEnvelope & {
+export type PagesPageResponseStageProps = PagesResponseStageEnvelope & {
   kind: "pages-page";
   renderOptions: PagesRenderOptions | null;
   resolvedUrl: string;
+  /**
+   * The shared cache entry answers every host, as Next.js keys a static page
+   * by its path, so a getInitialProps render of a page without
+   * getStaticProps, which reads the request, is not stored.
+   */
+  sharedAcrossHosts: boolean;
 };
 /** Serializable Pages API dispatch delegated to a cacheable Worker stage. */
 type PagesApiResponseStageProps = PagesResponseStageEnvelope & {
@@ -39,6 +45,13 @@ export type WorkerResponseStageProps = PagesApiResponseStageProps | PagesPageRes
  * response as Next.js.
  */
 export type DispatchWorkerResponseStage = VinextResponseStageTransport<WorkerResponseStageProps>;
+type PagesPageResponseStageCacheIdentity = NonNullable<VinextResponseStageDispatchOptions["cacheIdentity"]>;
+/**
+ * Build the cache identity of a shared Pages page dispatch: the dispatched
+ * request and props under `origin`, so every host that names it shares one
+ * entry.
+ */
+export declare function createSharedPagesPageCacheIdentity(request: Request, props: PagesPageResponseStageProps, origin: string): PagesPageResponseStageCacheIdentity;
 export declare function isPagesResponseStageProps(value: unknown): value is WorkerResponseStageProps;
 //#endregion
 export {};

package/dist/server/worker-stages.js

@@ -1,6 +1,25 @@
+import { withCacheIdentityOrigin } from "./multi-stage.js";
 //#region src/server/worker-stages.ts
-const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 5;
+const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 6;
 const PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER = "x-vinext-pages-response-stage-policy-owner";
+/**
+* Build the cache identity of a shared Pages page dispatch: the dispatched
+* request and props under `origin`, so every host that names it shares one
+* entry.
+*/
+function createSharedPagesPageCacheIdentity(request, props, origin) {
+	return {
+		props: {
+			...props,
+			requestHost: new URL(origin).host
+		},
+		regenerateFromDispatch: true,
+		request: new Request(withCacheIdentityOrigin(request.url, origin), {
+			headers: new Headers(request.headers),
+			method: request.method
+		})
+	};
+}
 function isSerializedHeaders(value) {
 	return Array.isArray(value) && value.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && typeof entry[1] === "string");
 }
@@ -12,14 +31,14 @@ function isResponseStageCacheability(value) {
 function isPagesResponseStageProps(value) {
 	if (!value || typeof value !== "object") return false;
 	const props = value;
-	if (props.protocolVersion !== 5 || props.buildId !== null && typeof props.buildId !== "string" || !isResponseStageCacheability(props.cacheability) || typeof props.requestHost !== "string" || props.requestHost.length === 0 || props.stagedHeaders !== null && !isSerializedHeaders(props.stagedHeaders)) return false;
+	if (props.protocolVersion !== 6 || props.buildId !== null && typeof props.buildId !== "string" || !isResponseStageCacheability(props.cacheability) || typeof props.requestHost !== "string" || props.requestHost.length === 0 || props.stagedHeaders !== null && !isSerializedHeaders(props.stagedHeaders)) return false;
 	if (props.kind === "pages-api") return typeof props.apiUrl === "string";
 	if (props.kind === "pages-prerender-discovery") return true;
-	if (props.kind !== "pages-page" || typeof props.resolvedUrl !== "string") return false;
+	if (props.kind !== "pages-page" || typeof props.resolvedUrl !== "string" || typeof props.sharedAcrossHosts !== "boolean") return false;
 	if (props.renderOptions === null) return true;
 	if (!props.renderOptions || typeof props.renderOptions !== "object") return false;
 	const options = props.renderOptions;
 	return (options.isDataReq === void 0 || typeof options.isDataReq === "boolean") && (options.renderErrorPageOnMiss === void 0 || typeof options.renderErrorPageOnMiss === "boolean") && (options.originalUrl === void 0 || typeof options.originalUrl === "string");
 }
 //#endregion
-export { PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER, PAGES_RESPONSE_STAGE_PROTOCOL_VERSION, isPagesResponseStageProps };
+export { PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER, PAGES_RESPONSE_STAGE_PROTOCOL_VERSION, createSharedPagesPageCacheIdentity, isPagesResponseStageProps };

package/dist/shims/cache-handler.js

@@ -1,5 +1,5 @@
 import { shareIsolatePromise } from "../server/isolate-shared-promise.js";
-import { readCacheControlNumberField, readCacheControlRevalidateField } from "../utils/cache-control-metadata.js";
+import { readCacheControlNumberField, readCacheControlRevalidateField, readCacheTimestamp } from "../utils/cache-control-metadata.js";
 //#region src/shims/cache-handler.ts
 var NoOpCacheHandler = class {
 	async get(_key, _ctx) {
@@ -122,7 +122,7 @@ var MemoryCacheHandler = class {
 		if (data && "revalidate" in data && typeof data.revalidate === "number") effectiveRevalidate = data.revalidate;
 		else if (data && "revalidate" in data && data.revalidate === false) effectiveRevalidate ??= false;
 		if (effectiveRevalidate === 0) return;
-		const now = Date.now();
+		const now = readCacheTimestamp(ctx, Date.now());
 		const revalidateAt = typeof effectiveRevalidate === "number" && effectiveRevalidate > 0 ? now + effectiveRevalidate * 1e3 : null;
 		const expireAt = typeof effectiveExpire === "number" && effectiveExpire > 0 ? now + effectiveExpire * 1e3 : null;
 		const cacheControl = typeof effectiveRevalidate === "number" || effectiveRevalidate === false ? {

package/dist/shims/cache-request-state.d.ts

@@ -8,21 +8,6 @@ export type CacheLifeConfig = {
 export declare const cacheLifeProfiles: Record<string, CacheLifeConfig>;
 export type UnstableCacheRevalidationMode = "foreground" | "background";
 export type ActionRevalidationKind = 0 | 1 | 2;
-export type UnstableCacheObservation = Readonly<{
-  kind: "unstable_cache";
-  keyHash: string;
-  revalidate: number | false | null;
-  tagCount: number;
-  tagHash: string | null;
-}>;
-/**
- * Collects the cacheLife claims made anywhere below the scope that installed
- * it, including nested scopes that reset `requestScopedCacheLife`. Shallow
- * scope clones share it by reference.
- */
-export type CacheLifeSink = {
-  cacheLife: CacheLifeConfig | null;
-};
 type TagInvalidationDurations = {
   expire?: number;
 } | undefined;
@@ -34,12 +19,17 @@ export type PendingCdnTagInvalidation = Readonly<{
 }>;
 export type CacheState = {
   actionRevalidationKind: ActionRevalidationKind;
-  cacheLifeSink: CacheLifeSink | null;
+  /**
+   * The request is an authorized on-demand revalidation (`res.revalidate()`).
+   * Like Next.js's `workStore.isOnDemandRevalidate`, the data caches then skip
+   * their reads but still execute and store fresh results. Set once when the
+   * request context is created; nested scopes inherit it.
+   */
+  isOnDemandRevalidate: boolean;
   pendingCdnTagInvalidations: PendingCdnTagInvalidation[];
   pendingRevalidatedTags: Set<string>;
   pendingRevalidations: Set<Promise<void>>;
   requestScopedCacheLife: CacheLifeConfig | null;
-  unstableCacheObservations: Map<string, UnstableCacheObservation>;
   unstableCacheRevalidation: UnstableCacheRevalidationMode;
 };
 export declare const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
@@ -47,6 +37,15 @@ export declare const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
 export declare function _runWithCacheState<T>(fn: () => Promise<T>): Promise<T>;
 export declare function _runWithCacheState<T>(fn: () => T | Promise<T>): T | Promise<T>;
 export declare function _initRequestScopedCacheState(): void;
+/**
+ * Whether the current request is an authorized on-demand revalidation, so the
+ * data caches must skip their reads (not their writes). Mirrors Next.js's
+ * `workStore.isOnDemandRevalidate` checks in use-cache-wrapper, patch-fetch
+ * and unstable-cache.
+ *
+ * @internal
+ */
+export declare function _isOnDemandRevalidate(): boolean;
 export declare function markActionRevalidation(kind: ActionRevalidationKind): void;
 export declare function getAndClearActionRevalidationKind(): ActionRevalidationKind;
 /** @internal */
@@ -114,11 +113,9 @@ export declare function _captureRequestScopedCacheLifeAccessors(): {
   consume: () => CacheLifeConfig | null;
   peek: () => CacheLifeConfig | null;
 };
-export declare function recordUnstableCacheObservation(observation: UnstableCacheObservation): void;
-export declare function _peekUnstableCacheObservations(): UnstableCacheObservation[];
 /**
  * Run `fn` with the request's cache settings, including its revalidation mode,
- * but its own record of cache lives and unstable_cache observations, so work
+ * but its own record of cache lives, so work
  * done on the request's behalf after the fact leaves the request untouched.
  */
 export declare function runWithDetachedCacheObservations<T>(fn: () => Promise<T>): Promise<T>;

package/dist/shims/cache-request-state.js

@@ -48,12 +48,11 @@ const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
 const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
 const fallbackState = globalState[FALLBACK_KEY] ??= {
 	actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
-	cacheLifeSink: null,
+	isOnDemandRevalidate: false,
 	pendingCdnTagInvalidations: [],
 	pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 	pendingRevalidations: /* @__PURE__ */ new Set(),
 	requestScopedCacheLife: null,
-	unstableCacheObservations: /* @__PURE__ */ new Map(),
 	unstableCacheRevalidation: "foreground"
 };
 function getCacheState() {
@@ -63,19 +62,16 @@ function getCacheState() {
 function _runWithCacheState(fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((context) => {
 		context.actionRevalidationKind = ACTION_DID_NOT_REVALIDATE;
-		context.cacheLifeSink = null;
 		context.requestScopedCacheLife = null;
-		context.unstableCacheObservations = /* @__PURE__ */ new Map();
 		context.unstableCacheRevalidation = "foreground";
 	}, fn);
 	const state = {
 		actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
-		cacheLifeSink: null,
+		isOnDemandRevalidate: false,
 		pendingCdnTagInvalidations: [],
 		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 		pendingRevalidations: /* @__PURE__ */ new Set(),
 		requestScopedCacheLife: null,
-		unstableCacheObservations: /* @__PURE__ */ new Map(),
 		unstableCacheRevalidation: "foreground"
 	};
 	return cacheAls.run(state, fn);
@@ -84,7 +80,17 @@ function _initRequestScopedCacheState() {
 	const state = getCacheState();
 	state.actionRevalidationKind = ACTION_DID_NOT_REVALIDATE;
 	state.requestScopedCacheLife = null;
-	state.unstableCacheObservations = /* @__PURE__ */ new Map();
+}
+/**
+* Whether the current request is an authorized on-demand revalidation, so the
+* data caches must skip their reads (not their writes). Mirrors Next.js's
+* `workStore.isOnDemandRevalidate` checks in use-cache-wrapper, patch-fetch
+* and unstable-cache.
+*
+* @internal
+*/
+function _isOnDemandRevalidate() {
+	return getCacheState().isOnDemandRevalidate === true;
 }
 function markActionRevalidation(kind) {
 	if (getHeadersAccessPhase() !== "action") return;
@@ -224,7 +230,6 @@ function mergeCacheLife(current, config) {
 function _setRequestScopedCacheLife(config) {
 	const state = getCacheState();
 	state.requestScopedCacheLife = mergeCacheLife(state.requestScopedCacheLife, config);
-	if (state.cacheLifeSink) state.cacheLifeSink.cacheLife = mergeCacheLife(state.cacheLifeSink.cacheLife, config);
 }
 function _peekRequestScopedCacheLife() {
 	const config = getCacheState().requestScopedCacheLife;
@@ -257,32 +262,22 @@ function _captureRequestScopedCacheLifeAccessors() {
 		}
 	};
 }
-function recordUnstableCacheObservation(observation) {
-	getCacheState().unstableCacheObservations.set(observation.keyHash, observation);
-}
-function _peekUnstableCacheObservations() {
-	return [...getCacheState().unstableCacheObservations.values()].sort((a, b) => a.keyHash.localeCompare(b.keyHash));
-}
 /**
 * Run `fn` with the request's cache settings, including its revalidation mode,
-* but its own record of cache lives and unstable_cache observations, so work
+* but its own record of cache lives, so work
 * done on the request's behalf after the fact leaves the request untouched.
 */
 function runWithDetachedCacheObservations(fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((context) => {
-		context.cacheLifeSink = null;
 		context.requestScopedCacheLife = null;
-		context.unstableCacheObservations = /* @__PURE__ */ new Map();
 	}, fn);
 	return cacheAls.run({
 		...getCacheState(),
-		cacheLifeSink: null,
-		requestScopedCacheLife: null,
-		unstableCacheObservations: /* @__PURE__ */ new Map()
+		requestScopedCacheLife: null
 	}, fn);
 }
 function shouldServeStaleUnstableCacheEntry() {
 	return getCacheState().unstableCacheRevalidation === "background";
 }
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _isOnDemandRevalidate, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry };