vinext 1.3.0 → 1.4.0

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.d.ts

@@ -8,4 +8,5 @@ type PagesWorkerExecutionContext = ExecutionContextLike & {
 };
 export declare function renderPagesResponse(request: Request, env: PagesWorkerEnv | undefined, platformCtx: PagesWorkerExecutionContext | undefined, props: WorkerResponseStageProps, stagedHeaders?: Headers, dispatchRequestStage?: VinextRequestStageTransport, dispatchOptions?: VinextResponseStageDispatchOptions): Promise<Response>;
 export declare function handleResponseStage(request: Request, env: PagesWorkerEnv | undefined, ctx: PagesWorkerExecutionContext | undefined, props: WorkerResponseStageProps, dispatchRequestStage: VinextRequestStageTransport, options: VinextResponseStageDispatchOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

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/pages-route-data-kind.d.ts

@@ -15,4 +15,5 @@ type AppComponent = {
 } | null;
 /** Classify loaded Pages modules after HOCs and re-exports have been evaluated. */
 export declare function getRuntimePagesDataKind(pageModule: PagesModule, appComponent: AppComponent): RuntimePagesDataKind;
-//#endregion
+//#endregion
+export {};

package/dist/server/prerender-cache-life-header.d.ts

@@ -7,4 +7,5 @@ type PrerenderCacheLife = {
 };
 export declare function applyPrerenderCacheLifeHeader(headers: Headers, requestCacheLife: PrerenderCacheLife | null | undefined): void;
 export declare function applyPrerenderCacheTagsHeader(headers: Headers, cacheTags: readonly string[]): void;
-//#endregion
+//#endregion
+export {};

package/dist/server/prerender-route-params.d.ts

@@ -26,4 +26,5 @@ export declare function readTrustedPrerenderStateFromHeaders(headers: Headers, e
 export declare function readTrustedPrerenderRouteParams(request: Request): PrerenderRouteParamsPayload | null;
 export declare function matchPrerenderRouteParamsPayload(payload: PrerenderRouteParamsPayload | null, routePattern: string, params: PrerenderRouteParams): PrerenderRouteParamsRouteMatch | null;
 export declare function encodePrerenderRouteParams(pattern: string, params: PrerenderRouteParams, fallbackParamNames?: readonly string[]): PrerenderRouteParamsPayload | null;
-//#endregion
+//#endregion
+export {};

package/dist/server/prod-server.js

@@ -31,7 +31,6 @@ import { readPrerenderSecret, readServerCompress } from "../build/server-manifes
 import { readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { resolveClientBuildFile } from "./client-build-files.js";
 import { registerPrerenderCloudflareLoader } from "../build/prerender-cloudflare-loader.js";
-import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
 import { negotiateEncoding, parseAcceptedEncodings, selectContentEncoding } from "./accept-encoding.js";
 import { COMPRESS_THRESHOLD, hasNoTransform, isCompressibleContentType, parseContentLengthHeader, resolveResponseCompression } from "./response-compression.js";
 import { ifRangeAllowsRange, parseByteRange } from "./http-range.js";
@@ -329,6 +328,7 @@ function installClientBuildManifestGlobals(clientDir, assetBase, assetPrefix, cr
 	});
 	setPagesClientAssets({
 		appBootstrapPreinitModules: metadata.appBootstrapPreinitModules,
+		appRouteManifestModule: metadata.appRouteManifestModule,
 		lazyChunks: metadata.lazyChunks,
 		dynamicPreloads: metadata.dynamicPreloads,
 		crossOrigin
@@ -904,6 +904,7 @@ function waitForNodeResponseCompletion(res) {
 */
 async function startProdServer(options = {}) {
 	installSocketErrorBackstop({ runningServer: options.purpose !== "prerender" });
+	if (options.purpose !== "prerender" && !process.env.NODE_ENV) Reflect.set(process.env, "NODE_ENV", "production");
 	const { port = process.env.PORT ? parseInt(process.env.PORT) : 3e3, host = "0.0.0.0", outDir = path.resolve("dist"), rscEntryPath: explicitRscEntryPath, serverDir: explicitServerDir, serverEntryPath: explicitServerEntryPath, noCompression = false, purpose, silent = false } = options;
 	if (purpose === "prerender") registerPrerenderCloudflareLoader();
 	const compress = !noCompression;
@@ -1007,15 +1008,19 @@ function resolveAppRouterHandler(entry) {
 	console.error("[vinext] App Router entry must export either a default handler function or a Worker-style default export with fetch()");
 	process.exit(1);
 }
+async function seedMemoryCacheFromPrerenderFallback(serverDir) {
+	const { seedMemoryCacheFromPrerender } = await import("./seed-cache.js");
+	return seedMemoryCacheFromPrerender(serverDir);
+}
 function isAppRouterPrerenderSeederExport(value) {
 	return typeof value === "function";
 }
 function resolveAppRouterPrerenderSeeder(entryModule) {
-	if (typeof entryModule !== "object" || entryModule === null) return seedMemoryCacheFromPrerender;
+	if (typeof entryModule !== "object" || entryModule === null) return seedMemoryCacheFromPrerenderFallback;
 	const seedExport = Object.getOwnPropertyDescriptor(entryModule, "seedMemoryCacheFromPrerender")?.value;
 	if (!isAppRouterPrerenderSeederExport(seedExport)) {
 		if (process.env.NEXT_PRIVATE_DEBUG_CACHE) console.debug("[vinext] ISR: using fallback prerender cache seeder");
-		return seedMemoryCacheFromPrerender;
+		return seedMemoryCacheFromPrerenderFallback;
 	}
 	if (process.env.NEXT_PRIVATE_DEBUG_CACHE) console.debug("[vinext] ISR: using App Router entry prerender cache seeder");
 	return async (serverDir) => {
@@ -1091,6 +1096,7 @@ function installPagesClientAssets(options) {
 	setPagesClientAssets({
 		clientEntry: metadata.clientEntryFile,
 		appBootstrapPreinitModules: metadata.appBootstrapPreinitModules,
+		appRouteManifestModule: metadata.appRouteManifestModule,
 		ssrManifest: Object.keys(ssrManifest).length > 0 ? ssrManifest : void 0,
 		sharedChunks: metadata.sharedChunks,
 		cssGraph: metadata.cssGraph,
@@ -1640,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-log.d.ts

@@ -31,4 +31,5 @@ export declare function logRequest({ method, url, status, totalMs, compileMs, re
  * Returns `performance.now()` - a high-resolution monotonic timestamp.
  */
 export declare function now(): number;
-//#endregion
+//#endregion
+export {};

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/request-tracing.d.ts

@@ -19,4 +19,5 @@ export declare function clearFrameworkRequestError(response: Response): Response
 export declare function attachFrameworkRequestError(response: Response, error: unknown): Response;
 export declare function consumeFrameworkRequestRoute(response: Response): Response;
 export declare function traceFrameworkRequest<T>(input: RequestTraceInput<T>): Promise<T>;
-//#endregion
+//#endregion
+export {};

package/dist/server/request-tracing.js

@@ -1,8 +1,8 @@
 import { getOrCreateAls } from "../shims/internal/als-registry.js";
 import { isFullyBufferedBody, markFullyBufferedBody, preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { VINEXT_TRACE_BUFFERED_BODY_HEADER, VINEXT_TRACE_ERROR_HEADER, VINEXT_TRACE_ROUTE_HEADER } from "./headers.js";
 import { frameworkTracer } from "./tracer.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { getResponseStartCompletion } from "./response-start-tracing.js";
 //#region src/server/request-tracing.ts
 const activeRequestTrace = getOrCreateAls("vinext.requestTracing.als");

package/dist/server/response-start-tracing.js

@@ -1,4 +1,5 @@
 import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { observeStreamConsumption } from "./defer-until-stream-consumed.js";
 import { frameworkTracer } from "./tracer.js";
 import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
 //#region src/server/response-start-tracing.ts
@@ -13,37 +14,14 @@ function createResponseStartSpanDescriptor() {
 	};
 }
 function traceResponseStartStream(stream, onSettled) {
-	const reader = stream.getReader();
 	const runInTraceContext = frameworkTracer.captureActiveContext();
-	let started = false;
-	return new ReadableStream({
-		async pull(controller) {
-			try {
-				const result = await reader.read();
-				if (result.done) {
-					onSettled();
-					controller.close();
-					return;
-				}
-				if (!started) {
-					started = true;
-					runInTraceContext(() => frameworkTracer.trace(createResponseStartSpanDescriptor(), () => void 0));
-					onSettled();
-				}
-				controller.enqueue(result.value);
-			} catch (error) {
-				onSettled();
-				controller.error(error);
-			}
+	return observeStreamConsumption(stream, {
+		onStart() {
+			runInTraceContext(() => frameworkTracer.trace(createResponseStartSpanDescriptor(), () => void 0));
+			onSettled();
 		},
-		async cancel(reason) {
-			try {
-				await reader.cancel(reason);
-			} finally {
-				onSettled();
-			}
-		}
-	}, { highWaterMark: 0 });
+		onFlush: onSettled
+	});
 }
 function traceResponseStartWithCompletion(response) {
 	const existing = tracedResponses.get(response);

package/dist/server/rsc-render-stream.d.ts

@@ -0,0 +1,4 @@
+//#region src/server/rsc-render-stream.d.ts
+export type RscRawRenderer = (model: unknown, options?: unknown) => ReadableStream<Uint8Array>;
+export declare function createRscRenderer(render: RscRawRenderer): RscRawRenderer;
+//#endregion

package/dist/server/rsc-render-stream.js

@@ -0,0 +1,25 @@
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import { createRenderStreamCancellation } from "./app-render-abort-error.js";
+//#region src/server/rsc-render-stream.ts
+const noop = () => {};
+function createRscRenderer(render) {
+	return (model, options) => {
+		const cancellation = createRenderStreamCancellation();
+		return deferUntilStreamConsumed(render(model, ignoreCancellationErrors(options, cancellation)), noop, void 0, cancellation.record);
+	};
+}
+/** A consumer cancelling the payload is not a render failure. */
+function ignoreCancellationErrors(options, cancellation) {
+	if (!options || typeof options !== "object") return options;
+	const onError = Reflect.get(options, "onError");
+	if (typeof onError !== "function") return options;
+	return {
+		...options,
+		onError(error, ...rest) {
+			if (cancellation.isReason(error)) return void 0;
+			return Reflect.apply(onError, options, [error, ...rest]);
+		}
+	};
+}
+//#endregion
+export { createRscRenderer };

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

@@ -30,4 +30,5 @@ type PrerenderCacheSeedOptions = {
  * @returns The number of routes seeded (0 if no manifest or no renderable routes).
  */
 export declare function seedMemoryCacheFromPrerender(serverDir: string, options?: PrerenderCacheSeedOptions): Promise<number>;
-//#endregion
+//#endregion
+export {};

package/dist/server/seed-cache.js

@@ -2,8 +2,8 @@ import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { appIsrCacheKey, appIsrFallbackShellKey, isrSet, isrSetPrerenderedAppPage } from "./isr-cache.js";
 import { addPregeneratedConcretePath, addPregeneratedRoute, clearPregeneratedConcretePaths, normalizePregeneratedPathname } from "./pregenerated-concrete-paths.js";
 import { getRenderedAppRoutes, getRenderedMetadataRoutes, isFallbackShellArtifactPath, readPrerenderManifest } from "./prerender-manifest.js";
-import { buildAppPageCacheTags, buildAppRouteCacheTags } from "./app-page-cache.js";
 import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
+import { buildAppPageCacheTags, buildAppRouteCacheTags } from "./app-page-cache.js";
 import fs from "node:fs";
 //#region src/server/seed-cache.ts
 /**

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/static-file-cache.d.ts

@@ -66,4 +66,5 @@ export declare class StaticFileCache {
  * so the caller can fall back to mtime-based ETags.
  */
 export declare function etagFromFilenameHash(relativePath: string, ext: string): string | null;
-//#endregion
+//#endregion
+export {};

package/dist/server/static-file-cache.js

@@ -37,6 +37,7 @@ const CONTENT_TYPES = {
 	".mp4": "video/mp4",
 	".ogg": "audio/ogg",
 	".ogv": "video/ogg",
+	".otf": "font/otf",
 	".pdf": "application/pdf",
 	".png": "image/png",
 	".rsc": "text/x-component",

package/dist/server/worker-revalidation-context.d.ts

@@ -9,4 +9,5 @@ type PlatformExecutionContext = Partial<ExecutionContextLike> & VinextRequestSta
  * on the normal header-scrubbing path.
  */
 export declare function createWorkerRevalidationContext(base: PlatformExecutionContext | undefined, handleInternalRequest: (request: Request, ctx: ExecutionContextLike) => Promise<Response>, defaultHostRuntime?: "node" | "worker"): ExecutionContextLike;
-//#endregion
+//#endregion
+export {};

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,5 +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
+//#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/app.d.ts

@@ -34,4 +34,5 @@ export default class App<P = any, CP = any, S = any> extends React.Component<P &
   static getInitialProps: typeof appGetInitialProps;
   render(): React.ReactElement;
 }
-//#endregion
+//#endregion
+export {};

package/dist/shims/cache-callable-runtime.d.ts

@@ -12,4 +12,5 @@ export declare function registerCachedFunction<TArgs extends unknown[], TResult>
 }): (...args: TArgs) => Promise<TResult>;
 /** Replay the persisted payload without re-reading or re-encoding caller objects. */
 export declare function invokeCacheFunction(invocation: VinextCacheFunctionInvocation, loadServerAction: (id: string) => Promise<unknown>): Promise<void>;
-//#endregion
+//#endregion
+export {};

package/dist/shims/cache-handler.d.ts

@@ -96,7 +96,7 @@ type MemoryCacheHandlerOptions = Pick<CacheHandlerContext, "maxMemoryCacheSize">
 };
 export declare class MemoryCacheHandler implements CacheHandler {
   private store;
-  private tagRevalidatedAt;
+  private tagsManifest;
   private readonly maxMemoryCacheSize;
   private currentMemoryCacheSize;
   constructor(options?: number | MemoryCacheHandlerOptions);
@@ -106,7 +106,11 @@ export declare class MemoryCacheHandler implements CacheHandler {
   private evictLeastRecentlyUsed;
   get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
   set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
-  revalidateTag(tags: string | string[]): Promise<void>;
+  revalidateTag(tags: string | string[], durations?: {
+    expire?: number;
+  }): Promise<void>;
+  private isTagExpired;
+  private isTagStale;
   resetRequestCache(): void;
 }
 export declare function configureMemoryCacheHandler(options?: MemoryCacheHandlerOptions): void;
@@ -121,4 +125,5 @@ export declare function registerLazyDataCacheHandler(load: () => Promise<void>):
 export declare function getDataCacheHandler(): CacheHandler;
 export declare function setCacheHandler(handler: CacheHandler): void;
 export declare function getCacheHandler(): CacheHandler;
-//#endregion
+//#endregion
+export {};