vinext 1.2.1 → 1.3.0

package/dist/server/prod-server.js

@@ -7,11 +7,12 @@ import { notFoundResponse } from "./http-error-responses.js";
 import { getRepeatedSlashRedirect, isOpenRedirectShaped, sendRepeatedSlashRedirect } from "./open-redirect.js";
 import { readStaticFileSignal } from "./static-file-signal.js";
 import { canonicalizeRequestPathname, filterInternalHeaders } from "./request-pipeline.js";
-import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix } from "../utils/asset-prefix.js";
+import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, isAssetPrefixBuildAsset } from "../utils/asset-prefix.js";
 import { StaticFileCache, contentTypeForPath, etagFromFilenameHash } from "./static-file-cache.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
-import { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts } from "./proxy-trust.js";
+import { resolveRequestHost, resolveRequestProtocol, resolveTrustedForwardedHost, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { normalizePath } from "./normalize-path.js";
+import { shouldRestoreLocaleRootTrailingSlash } from "./pages-i18n.js";
 import { buildNextDataNotFoundResponse, encodeUrlParserIgnoredCharacters, isNextDataPathname, normalizeNextDataPagePathname, parseNextDataPathname, shouldAddTrailingSlashToPagesDataPath, urlParserCreatesPagesDataPath } from "./pages-data-route.js";
 import { buildCacheStateHeaders } from "./cache-headers.js";
 import { parseHttpDate } from "./http-date.js";
@@ -378,6 +379,19 @@ function isVinextStreamedHtmlResponse(response) {
 function isVinextStreamedApiResponse(response) {
 	return response.__vinextStreamedApiResponse === true;
 }
+function disablePrerenderKeepAliveTimeout(server, purpose) {
+	if (purpose === "prerender") server.keepAliveTimeout = 0;
+}
+function listen(server, port, host) {
+	return new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(port, host, () => {
+			server.off("error", reject);
+			const addr = server.address();
+			resolve(typeof addr === "object" && addr ? addr.port : port);
+		});
+	});
+}
 function logProdServerStarted(host, port, purpose) {
 	const url = `http://${host}:${port}`;
 	if (purpose === "prerender") {
@@ -925,14 +939,16 @@ async function startProdServer(options = {}) {
 		silent
 	});
 }
-function createNodeExecutionContext(trustedRevalidateOrigin) {
+function createNodeExecutionContext(trustedRevalidateOrigin, { middlewareOrigin, requestSignal } = {}) {
 	return {
 		hostRuntime: "node",
+		requestSignal,
 		waitUntil(promise) {
 			Promise.resolve(promise).catch(() => {});
 		},
 		passThroughOnException() {},
-		trustedRevalidateOrigin
+		trustedRevalidateOrigin,
+		middlewareOrigin
 	};
 }
 /**
@@ -953,8 +969,26 @@ function markPrerenderSpecialError(response, marker) {
 	});
 }
 function resolveTrustedNodeRevalidateOrigin(req, configuredHost, configuredPort) {
+	return `http://${resolveNodeServerHost(req, configuredHost, configuredPort)}`;
+}
+/**
+* The origin middleware runs against. The Host header is client-controlled,
+* so, like Next.js, which builds the middleware URL from its own hostname and
+* port, it never counts as the server's origin. Otherwise a client could send
+* the host of an external middleware rewrite target and turn that rewrite into
+* an internal one, skipping middleware's checks for the target path. A trusted
+* `X-Forwarded-Host` is operator-approved, so it keeps the request origin, and
+* rewrites to that host stay internal.
+*/
+function resolveNodeMiddlewareOrigin(req, requestUrl, configuredHost, configuredPort) {
+	const url = new URL(requestUrl);
+	if (resolveTrustedForwardedHost(req) !== void 0) return url.origin;
+	return `${url.protocol}//${resolveNodeServerHost(req, configuredHost, configuredPort)}`;
+}
+/** The `host:port` this server is reachable at locally. */
+function resolveNodeServerHost(req, configuredHost, configuredPort) {
 	const port = req.socket.localPort ?? configuredPort;
-	return `http://${normalizeInternalFetchHost(configuredHost)}:${port}`;
+	return `${normalizeInternalFetchHost(configuredHost)}:${port}`;
 }
 function normalizeInternalFetchHost(host) {
 	if (!host || host === "0.0.0.0" || host === "::") return "localhost";
@@ -1058,6 +1092,7 @@ function installPagesClientAssets(options) {
 		clientEntry: metadata.clientEntryFile,
 		appBootstrapPreinitModules: metadata.appBootstrapPreinitModules,
 		ssrManifest: Object.keys(ssrManifest).length > 0 ? ssrManifest : void 0,
+		sharedChunks: metadata.sharedChunks,
 		cssGraph: metadata.cssGraph,
 		lazyChunks: metadata.lazyChunks,
 		dynamicPreloads: metadata.dynamicPreloads,
@@ -1154,7 +1189,7 @@ async function startAppRouterServer(options) {
 		const assetLookupPath = sourcePathname !== null ? resolveAppRouterAssetPath(sourcePathname, appAssetPathPrefix, appRouterAssetPrefix) : null;
 		if (assetLookupPath && await serveSource(assetLookupPath)) return;
 		if (sourcePathname !== null) {
-			const sourceResponse = await rscHandler(new Request(sourceUrl, { signal: request.signal }), createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port)));
+			const sourceResponse = await rscHandler(new Request(sourceUrl, { signal: request.signal }), createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port), { middlewareOrigin: resolveNodeMiddlewareOrigin(req, request.url, host, port) }));
 			const sourceSignal = isImageSourceBodyStatus(sourceResponse.status) ? readStaticFileSignal(sourceResponse) : null;
 			cancelResponseBody(sourceResponse, request.signal.reason);
 			if (request.signal.aborted) return;
@@ -1211,8 +1246,12 @@ async function startAppRouterServer(options) {
 			if (clientBuildFile && await tryServeStatic(req, res, clientDir, clientBuildFile, compress, staticCache)) return;
 		}
 		try {
-			const request = nodeToWebRequest(req, rawUrl, prerenderSecret, appRouterI18nConfig, appRouterAuthorizeOnDemandRevalidate, signalFromNodeResponse(res));
-			const ctx = createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port));
+			const signal = signalFromNodeResponse(res);
+			const request = nodeToWebRequest(req, rawUrl, prerenderSecret, appRouterI18nConfig, appRouterAuthorizeOnDemandRevalidate, signal);
+			const ctx = createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port), {
+				middlewareOrigin: resolveNodeMiddlewareOrigin(req, request.url, host, port),
+				requestSignal: signal
+			});
 			const recorded = {};
 			if (purpose === "prerender") ctx.recordPrerenderSpecialError = (marker) => {
 				recorded.marker = marker;
@@ -1282,18 +1321,12 @@ async function startAppRouterServer(options) {
 	const server = createServer((req, res) => {
 		runWithServerEntryRequire(rscEntryRequire, () => handleRequest(req, res));
 	});
-	await new Promise((resolve) => {
-		server.listen(port, host, () => {
-			const addr = server.address();
-			const actualPort = typeof addr === "object" && addr ? addr.port : port;
-			if (!silent) logProdServerStarted(host, actualPort, purpose);
-			resolve();
-		});
-	});
-	const addr = server.address();
+	disablePrerenderKeepAliveTimeout(server, purpose);
+	const actualPort = await listen(server, port, host);
+	if (!silent) logProdServerStarted(host, actualPort, purpose);
 	return {
 		server,
-		port: typeof addr === "object" && addr ? addr.port : port
+		port: actualPort
 	};
 }
 function isPagesServerEntryPageRoute(value) {
@@ -1323,18 +1356,12 @@ async function startPagesRouterServer(options) {
 	const { port, host, purpose, silent } = options;
 	const handler = await createPagesRouterRequestHandler(options);
 	const server = createServer(handler);
-	await new Promise((resolve) => {
-		server.listen(port, host, () => {
-			const addr = server.address();
-			const actualPort = typeof addr === "object" && addr ? addr.port : port;
-			if (!silent) logProdServerStarted(host, actualPort, purpose);
-			resolve();
-		});
-	});
-	const addr = server.address();
+	disablePrerenderKeepAliveTimeout(server, purpose);
+	const actualPort = await listen(server, port, host);
+	if (!silent) logProdServerStarted(host, actualPort, purpose);
 	return {
 		server,
-		port: typeof addr === "object" && addr ? addr.port : port
+		port: actualPort
 	};
 }
 /**
@@ -1481,6 +1508,10 @@ async function createPagesRouterRequestHandler(options) {
 		}
 		try {
 			const hadBasePath = !basePath || hasBasePath(requestPathname, basePath);
+			const restoreLocaleRootTrailingSlash = shouldRestoreLocaleRootTrailingSlash(requestPathname, {
+				trailingSlash,
+				skipProxyUrlNormalize
+			});
 			let configMatchPathname = stripBasePath(requestPathname, basePath);
 			{
 				const strippedPathname = stripBasePath(pathname, basePath);
@@ -1543,6 +1574,8 @@ async function createPagesRouterRequestHandler(options) {
 				duplex: hasBody ? "half" : void 0
 			});
 			const middlewareRequest = isDataReq && skipProxyUrlNormalize ? new Request(new URL(originalRenderUrl, webRequest.url), webRequest) : void 0;
+			const middlewareCtx = createNodeExecutionContext(void 0, { middlewareOrigin: resolveNodeMiddlewareOrigin(req, webRequest.url, host, port) });
+			const runNodeMiddleware = typeof runMiddleware === "function" ? (request, _ctx, opts) => runMiddleware(request, middlewareCtx, opts) : null;
 			const resolvePublicImageSource = async (sourceUrl) => {
 				const rawSourcePathname = sourceUrl.pathname;
 				if (getRepeatedSlashRedirect(rawSourcePathname) || isOpenRedirectShaped(rawSourcePathname)) return null;
@@ -1561,11 +1594,15 @@ async function createPagesRouterRequestHandler(options) {
 					recordCacheability: false,
 					rawSearch: sourceUrl.search,
 					configMatchPathname: strippedSourcePathname,
-					runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, sourceHadBasePath) : null,
+					restoreLocaleRootTrailingSlash: shouldRestoreLocaleRootTrailingSlash(sourceRequestPathname, {
+						trailingSlash,
+						skipProxyUrlNormalize
+					}),
+					runMiddleware: runNodeMiddleware ? wrapMiddlewareWithBasePath(runNodeMiddleware, basePath, sourceHadBasePath) : null,
 					renderPage: null,
 					handleApi: null,
-					serveFilesystemRoute: async (candidate, _stagedHeaders, phase) => {
-						if (isImageOptimizationPath(candidate) || isPagesFilesystemExcludedPath(candidate, phase)) return false;
+					serveFilesystemRoute: async (candidate, _stagedHeaders, phase, _resolvedUrl, _request, candidateHasBasePath) => {
+						if (!candidateHasBasePath && !isAssetPrefixBuildAsset(candidate, pagesAssetPathPrefix) || isImageOptimizationPath(candidate) || isPagesFilesystemExcludedPath(candidate, phase)) return false;
 						const lookupPath = staticCacheLookupPath(candidate);
 						if (lookupPath === null || lookupPath === "/" || !staticCache.lookup(lookupPath)) return false;
 						sourcePath = candidate;
@@ -1595,9 +1632,10 @@ async function createPagesRouterRequestHandler(options) {
 				rawSearch: rawQs,
 				authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
 				configMatchPathname,
+				restoreLocaleRootTrailingSlash,
 				matchPageRoute: matchPageRoute ?? null,
 				matchApiRoute: matchApiRoute ?? null,
-				runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) : null,
+				runMiddleware: runNodeMiddleware ? wrapMiddlewareWithBasePath(runNodeMiddleware, basePath, hadBasePath) : null,
 				renderPage: typeof renderPage === "function" ? (request, resolvedUrl, options, stagedHeaders) => renderPage(request, resolvedUrl, ssrManifest, void 0, stagedHeaders, {
 					...options,
 					originalUrl: originalRenderUrl
@@ -1648,7 +1686,7 @@ async function createPagesRouterRequestHandler(options) {
 						res.end(INVALID_IMAGE_SOURCE_MESSAGE);
 						return true;
 					}
-					if (isPagesFilesystemExcludedPath(requestPathname, phase)) return false;
+					if (!resolvedPathnameHasBasePath && !isAssetPrefixBuildAsset(requestPathname, pagesAssetPathPrefix) || isPagesFilesystemExcludedPath(requestPathname, phase)) return false;
 					return tryServeStatic(req, res, clientDir, requestPathname, compress, staticCache, stagedHeaders);
 				}
 			};

package/dist/server/proxy-trust.d.ts

@@ -35,4 +35,10 @@ export declare function resolveRequestProtocol(source: IncomingMessage | Headers
  * against `request.url`.
  */
 export declare function resolveRequestHost(source: IncomingMessage | Headers, fallback: string): string;
+/**
+ * The `X-Forwarded-Host` value when it matches the `trustedHosts` allow-list,
+ * otherwise undefined. Unlike the raw `Host` header, this host is
+ * operator-approved.
+ */
+export declare function resolveTrustedForwardedHost(source: IncomingMessage | Headers): string | undefined;
 //#endregion

package/dist/server/proxy-trust.js

@@ -42,12 +42,18 @@ function resolveRequestProtocol(source) {
 * against `request.url`.
 */
 function resolveRequestHost(source, fallback) {
+	return resolveTrustedForwardedHost(source) ?? (readHost(source) || fallback);
+}
+/**
+* The `X-Forwarded-Host` value when it matches the `trustedHosts` allow-list,
+* otherwise undefined. Unlike the raw `Host` header, this host is
+* operator-approved.
+*/
+function resolveTrustedForwardedHost(source) {
 	const rawForwarded = readForwardedHost(source);
-	if (rawForwarded && trustedHosts.size > 0) {
-		const forwardedHost = rawForwarded.split(",")[0]?.trim().toLowerCase();
-		if (forwardedHost && trustedHosts.has(forwardedHost)) return forwardedHost;
-	}
-	return readHost(source) || fallback;
+	if (!rawForwarded || trustedHosts.size === 0) return void 0;
+	const forwardedHost = rawForwarded.split(",")[0]?.trim().toLowerCase();
+	return forwardedHost && trustedHosts.has(forwardedHost) ? forwardedHost : void 0;
 }
 function readForwardedProto(source) {
 	if (isWebHeaders(source)) return source.get("x-forwarded-proto") ?? void 0;
@@ -65,4 +71,4 @@ function isWebHeaders(source) {
 	return typeof source.get === "function";
 }
 //#endregion
-export { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts };
+export { resolveRequestHost, resolveRequestProtocol, resolveTrustedForwardedHost, trustProxy, trustedHosts };

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

@@ -143,6 +143,11 @@ export declare function isOriginAllowed(origin: string, allowed: string[]): bool
  *
  * @param headers - The Headers object to modify in place
  */
+/**
+ * Next.js drops each empty middleware Set-Cookie value when it converts
+ * middleware's response headers, so blank values never reach the response.
+ */
+export declare function dropEmptyMiddlewareSetCookie(headers: Headers): void;
 export declare function processMiddlewareHeaders(headers: Headers): void;
 /**
  * Strip internal headers from an inbound request so they cannot be forged by

package/dist/server/request-pipeline.js

@@ -313,7 +313,18 @@ function isOriginAllowed(origin, allowed) {
 *
 * @param headers - The Headers object to modify in place
 */
+/**
+* Next.js drops each empty middleware Set-Cookie value when it converts
+* middleware's response headers, so blank values never reach the response.
+*/
+function dropEmptyMiddlewareSetCookie(headers) {
+	const cookies = headers.getSetCookie();
+	if (!cookies.includes("")) return;
+	headers.delete("set-cookie");
+	for (const cookie of cookies) if (cookie) headers.append("set-cookie", cookie);
+}
 function processMiddlewareHeaders(headers) {
+	dropEmptyMiddlewareSetCookie(headers);
 	const keysToDelete = [];
 	const unconsumedRequestHeaders = getUnconsumedMiddlewareRequestHeaders(headers);
 	for (const key of headers.keys()) if (key.startsWith("x-middleware-") && key !== "x-middleware-cache" && !unconsumedRequestHeaders.has(key)) keysToDelete.push(key);
@@ -433,4 +444,4 @@ function cloneRequestWithUrl(request, url) {
 	return attachRequestCfMetadata(cloned, request);
 }
 //#endregion
-export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, attachRequestCfMetadata, canonicalizeRequestPathname, canonicalizeRequestUrlPathname, cloneRequestWithHeaders, cloneRequestWithUrl, createStaticFileSignal, 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, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, sendRepeatedSlashRedirect, stripBasePath, validateCsrfOrigin, validateServerActionPayload };

package/dist/server/server-reference-loader.js

@@ -1,4 +1,6 @@
 import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { shareIsolatePromise } from "./isolate-shared-promise.js";
 //#region src/server/server-reference-loader.ts
 /**
 * Keep server-reference module evaluation out of the request that first
@@ -21,7 +23,14 @@ const ISOLATED = Symbol.for("vinext.serverReferenceRequire.isolated");
 function isolateServerReferenceLoads() {
 	const load = globalThis.__vite_rsc_server_require__;
 	if (typeof load !== "function" || ISOLATED in load) return;
-	const isolated = (id) => runOutsideRequestScopes(() => load(id));
+	const started = /* @__PURE__ */ new WeakSet();
+	const isolated = (id) => {
+		const ctx = getRequestExecutionContext();
+		const loaded = runOutsideRequestScopes(() => load(id));
+		if (!(loaded instanceof Promise) || started.has(loaded)) return loaded;
+		started.add(loaded);
+		return shareIsolatePromise(loaded, ctx);
+	};
 	Object.defineProperty(isolated, ISOLATED, { value: true });
 	globalThis.__vite_rsc_server_require__ = isolated;
 }

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

@@ -178,6 +178,15 @@ var StaticFileCache = class StaticFileCache {
 		return this.entries.get(pathname);
 	}
 };
+const MANAGED_CHUNKS_SEGMENT = `${ASSET_PREFIX_URL_DIR}/chunks/`;
+const MANAGED_CSS_SEGMENT = `${ASSET_PREFIX_URL_DIR}/css/`;
+const MANAGED_WORKERS_SEGMENT = `${ASSET_PREFIX_URL_DIR}/workers/`;
+const MANAGED_MEDIA_SEGMENT = `${ASSET_PREFIX_URL_DIR}/media/`;
+const HASH_ONLY_BASENAME_RE = /^[A-Za-z0-9_-]{8}$/;
+const WORKER_BASENAME_RE = /^[0-9a-f]{8}-[A-Za-z0-9_-]{8}$/;
+function isInManagedDir(normalizedPath, segment) {
+	return normalizedPath.startsWith(segment) || normalizedPath.includes(`/${segment}`);
+}
 /**
 * Extract a stable weak ETag from a Vite hashed filename (e.g. `app-DqZc3R4n.js`).
 * The hash is a content hash computed by the bundler — deterministic across
@@ -190,14 +199,17 @@ var StaticFileCache = class StaticFileCache {
 */
 function etagFromFilenameHash(relativePath, ext) {
 	const basename = path.basename(relativePath, ext);
+	if (basename.length === 8 && HASH_ONLY_BASENAME_RE.test(basename)) {
+		const normalizedPath = toSlash(relativePath);
+		if (isInManagedDir(normalizedPath, MANAGED_CHUNKS_SEGMENT) || isInManagedDir(normalizedPath, MANAGED_CSS_SEGMENT)) return `W/"${basename}"`;
+	}
+	if (basename.length === 17 && WORKER_BASENAME_RE.test(basename) && isInManagedDir(toSlash(relativePath), MANAGED_WORKERS_SEGMENT)) return `W/"${basename}"`;
 	const lastDash = basename.lastIndexOf("-");
 	if (lastDash !== -1 && lastDash !== basename.length - 1) {
 		const suffix = basename.slice(lastDash + 1);
 		if (suffix.length >= 6 && suffix.length <= 12 && /^[A-Za-z0-9_-]+$/.test(suffix)) return `W/"${suffix}"`;
 	}
-	const normalizedPath = toSlash(relativePath);
-	const managedMediaSegment = `${ASSET_PREFIX_URL_DIR}/media/`;
-	if (normalizedPath.startsWith(managedMediaSegment) || normalizedPath.includes(`/${managedMediaSegment}`)) {
+	if (isInManagedDir(toSlash(relativePath), MANAGED_MEDIA_SEGMENT)) {
 		const lastDot = basename.lastIndexOf(".");
 		if (lastDot !== -1) {
 			const suffix = basename.slice(lastDot + 1);

package/dist/server/worker-utils.js

@@ -108,7 +108,7 @@ async function resolveStaticAssetSignal(signalResponse, options) {
 * overrides, so a removed `Range` or replaced validator reaches the asset fetch.
 */
 function createStaticAssetRequest(assetPath, sourceRequest, headers = null) {
-	const assetUrl = new URL(assetPath, sourceRequest.url);
+	const assetUrl = new URL(assetPath.replace(/[?#]/g, (character) => encodeURIComponent(character)), sourceRequest.url);
 	if (sourceRequest.method === "GET" || sourceRequest.method === "HEAD") return headers ? new Request(new Request(assetUrl, sourceRequest), { headers }) : new Request(assetUrl, sourceRequest);
 	return new Request(assetUrl, {
 		method: sourceRequest.method,

package/dist/shims/cache-handler.js

@@ -1,3 +1,4 @@
+import { shareIsolatePromise } from "../server/isolate-shared-promise.js";
 import { readCacheControlNumberField, readCacheControlRevalidateField } from "../utils/cache-control-metadata.js";
 //#region src/shims/cache-handler.ts
 var NoOpCacheHandler = class {
@@ -167,7 +168,7 @@ var LazyDataCacheHandler = class {
 		this.load = load;
 	}
 	resolve() {
-		return this.resolved ??= this.load().then(() => {
+		return this.resolved ??= shareIsolatePromise(this.load().then(() => {
 			const registered = globalHandlers[HANDLER_KEY];
 			if (registered && registered !== this) {
 				this.loadedHandler = registered;
@@ -179,7 +180,7 @@ var LazyDataCacheHandler = class {
 			delete globalHandlers[LAZY_HANDLER_KEY];
 			this.loadedHandler = fallback;
 			return fallback;
-		});
+		}));
 	}
 	async get(key, ctx) {
 		return (await this.resolve()).get(key, ctx);

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

@@ -23,9 +23,19 @@ export type UnstableCacheObservation = Readonly<{
 export type CacheLifeSink = {
   cacheLife: CacheLifeConfig | null;
 };
+type TagInvalidationDurations = {
+  expire?: number;
+} | undefined;
+/** A CDN purge waiting for the request boundary, after its data-cache invalidation. */
+export type PendingCdnTagInvalidation = Readonly<{
+  tag: string;
+  durations: TagInvalidationDurations;
+  dataInvalidation: Promise<void>;
+}>;
 export type CacheState = {
   actionRevalidationKind: ActionRevalidationKind;
   cacheLifeSink: CacheLifeSink | null;
+  pendingCdnTagInvalidations: PendingCdnTagInvalidation[];
   pendingRevalidatedTags: Set<string>;
   pendingRevalidations: Set<Promise<void>>;
   requestScopedCacheLife: CacheLifeConfig | null;
@@ -56,9 +66,36 @@ export declare function _hasPendingRevalidatedTag(tags: readonly string[]): bool
  */
 export declare function _queuePendingRevalidation(promise: Promise<void>): boolean;
 /**
- * Await and clear every cache invalidation queued in the current request.
- * Clearing before awaiting also lets a later drain observe work enqueued by
- * an async continuation while this batch is settling.
+ * Defer the CDN purge for `tag` to the current Server Action or Route Handler
+ * boundary, so the request sends one adapter call per cacheLife profile like
+ * Next.js' `executeRevalidates`. Edge purges are rate limited (Workers Cache
+ * allows 5 requests a minute per account), so per-call purges run out fast.
+ *
+ * Only those two phases defer: their executors always drain before the
+ * request finishes. Once the response has closed, `after()` callbacks run
+ * past the last drain, so they purge immediately too. Everywhere else returns
+ * false and the caller purges immediately.
+ *
+ * @internal
+ */
+export declare function _queuePendingCdnTagInvalidation(tag: string, durations: TagInvalidationDurations, dataInvalidation: Promise<void>): boolean;
+/**
+ * Ask the CDN adapter to invalidate `tags`, logging rather than rethrowing a
+ * failure. The data cache is already invalidated by then, so a failed edge
+ * purge leaves edge-cached responses stale until they expire, and failing the
+ * request would not change that. It would only report a committed Server
+ * Action write as a failure.
+ *
+ * @internal
+ */
+export declare function _revalidateCdnTags(tags: string | string[], durations?: {
+  expire?: number;
+}): Promise<void>;
+/**
+ * Await and clear every cache invalidation queued in the current request,
+ * then send the deferred CDN purges in batches. Clearing before awaiting also
+ * lets a later drain observe work enqueued by an async continuation while
+ * this batch is settling.
  *
  * @internal
  */

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

@@ -1,5 +1,6 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+import { getCdnCacheAdapter } from "./cdn-cache.js";
 import { getHeadersAccessPhase } from "./internal/headers-state.js";
 import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
 //#region src/shims/cache-request-state.ts
@@ -48,6 +49,7 @@ const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
 const fallbackState = globalState[FALLBACK_KEY] ??= {
 	actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
 	cacheLifeSink: null,
+	pendingCdnTagInvalidations: [],
 	pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 	pendingRevalidations: /* @__PURE__ */ new Set(),
 	requestScopedCacheLife: null,
@@ -69,6 +71,7 @@ function _runWithCacheState(fn) {
 	const state = {
 		actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
 		cacheLifeSink: null,
+		pendingCdnTagInvalidations: [],
 		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 		pendingRevalidations: /* @__PURE__ */ new Set(),
 		requestScopedCacheLife: null,
@@ -128,9 +131,69 @@ function _queuePendingRevalidation(promise) {
 	return true;
 }
 /**
-* Await and clear every cache invalidation queued in the current request.
-* Clearing before awaiting also lets a later drain observe work enqueued by
-* an async continuation while this batch is settling.
+* Defer the CDN purge for `tag` to the current Server Action or Route Handler
+* boundary, so the request sends one adapter call per cacheLife profile like
+* Next.js' `executeRevalidates`. Edge purges are rate limited (Workers Cache
+* allows 5 requests a minute per account), so per-call purges run out fast.
+*
+* Only those two phases defer: their executors always drain before the
+* request finishes. Once the response has closed, `after()` callbacks run
+* past the last drain, so they purge immediately too. Everywhere else returns
+* false and the caller purges immediately.
+*
+* @internal
+*/
+function _queuePendingCdnTagInvalidation(tag, durations, dataInvalidation) {
+	const phase = getHeadersAccessPhase();
+	if (phase !== "action" && phase !== "route-handler") return false;
+	if (isInsideUnifiedScope() && getRequestContext().afterContext.responseClosed) return false;
+	getCacheState().pendingCdnTagInvalidations.push({
+		tag,
+		durations,
+		dataInvalidation
+	});
+	return true;
+}
+/**
+* Ask the CDN adapter to invalidate `tags`, logging rather than rethrowing a
+* failure. The data cache is already invalidated by then, so a failed edge
+* purge leaves edge-cached responses stale until they expire, and failing the
+* request would not change that. It would only report a committed Server
+* Action write as a failure.
+*
+* @internal
+*/
+async function _revalidateCdnTags(tags, durations) {
+	try {
+		await getCdnCacheAdapter().revalidateTag(tags, durations);
+	} catch (error) {
+		console.error("[vinext] CDN cache invalidation failed; edge-cached responses may stay stale until they expire:", error);
+	}
+}
+async function flushCdnTagInvalidations(invalidations) {
+	if (invalidations.length === 0) return;
+	const settled = await Promise.allSettled(invalidations.map(({ dataInvalidation }) => dataInvalidation));
+	const batches = /* @__PURE__ */ new Map();
+	invalidations.forEach(({ tag, durations }, index) => {
+		if (settled[index].status === "rejected") return;
+		const key = durations === void 0 ? "" : JSON.stringify(durations);
+		let batch = batches.get(key);
+		if (!batch) {
+			batch = {
+				durations,
+				tags: /* @__PURE__ */ new Set()
+			};
+			batches.set(key, batch);
+		}
+		batch.tags.add(tag);
+	});
+	await Promise.all([...batches.values()].map(({ durations, tags }) => _revalidateCdnTags([...tags], durations)));
+}
+/**
+* Await and clear every cache invalidation queued in the current request,
+* then send the deferred CDN purges in batches. Clearing before awaiting also
+* lets a later drain observe work enqueued by an async continuation while
+* this batch is settling.
 *
 * @internal
 */
@@ -138,14 +201,16 @@ async function _drainPendingRevalidations() {
 	const state = getCacheState();
 	let didReject = false;
 	let firstRejection;
-	while (state.pendingRevalidations.size > 0) {
+	while (state.pendingRevalidations.size > 0 || state.pendingCdnTagInvalidations.length > 0) {
 		const pending = [...state.pendingRevalidations];
 		state.pendingRevalidations.clear();
+		const cdnInvalidations = state.pendingCdnTagInvalidations.splice(0);
 		const results = await Promise.allSettled(pending);
 		for (const result of results) if (result.status === "rejected" && !didReject) {
 			didReject = true;
 			firstRejection = result.reason;
 		}
+		await flushCdnTagInvalidations(cdnInvalidations);
 	}
 	if (didReject) throw firstRejection;
 }
@@ -220,4 +285,4 @@ 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, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _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, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry };