vinext 1.1.0 → 1.2.1

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

@@ -1,21 +1,24 @@
 import { VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
 import { requestContextFromRequest } from "../config/request-context.js";
-import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
-import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
-import { runWithExecutionContext } from "../shims/request-context.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 { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
+import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
+import { runWithExecutionContext } from "../shims/request-context.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { isNextDataPathname } from "./pages-data-route.js";
 import { getExplicitCdnCacheAdapter } from "../shims/cdn-cache-state.js";
 import { CACHEABILITY_REQUEST_STATE } from "../shims/cacheability-classification.js";
 import { applyCdnResponseIdentityHeaders, captureCdnResponsePolicyOverrides, reconcileCdnResponseHeadersAfterOuterPolicy, validateCdnRequest } from "./cache-control.js";
 import { registerLazyDataCacheHandler } from "../shims/cache-handler.js";
-import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
+import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleConfiguredImageOptimization, isImageOptimizationPath, isImageSourceBodyStatus } from "./image-optimization.js";
 import { traceFrameworkRequest } from "./request-tracing.js";
 import { resolveResponseStageCachePolicy } from "./config-headers.js";
+import { createStaticAssetRequest } from "./worker-utils.js";
 import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
+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";
@@ -39,12 +42,13 @@ function haveSameHeaders(first, second) {
 function captureOuterResponsePolicyHeaders(stagedHeaders, transportedPolicyHeaders) {
 	return captureCdnResponsePolicyOverrides(stagedHeaders, new Headers(transportedPolicyHeaders ?? []));
 }
-const { authorizeOnDemandRevalidate, hasMiddleware, hasRequestAwareDocument, matchApiRoute, matchPageRoute, normalizeDataRequest, publicFiles, runMiddleware, vinextConfig } = pagesEntry;
+const { authorizeOnDemandRevalidate, hasMiddleware, hasRequestAwareDocument, matchApiRoute, matchPageRoute, normalizeDataRequest, publicFiles, clientBuildFiles, runMiddleware, vinextConfig } = pagesEntry;
 const pagesRequestStageBuildId = pagesEntry.buildId ?? null;
 const pagesRequestStagePrerenderSecret = pagesEntry.prerenderSecret ?? null;
 const basePath = vinextConfig?.basePath ?? "";
 const assetPathPrefix = assetPrefixPathname(vinextConfig?.assetPrefix ?? "");
 const trailingSlash = vinextConfig?.trailingSlash ?? false;
+const skipTrailingSlashRedirect = vinextConfig?.skipTrailingSlashRedirect ?? false;
 const i18nConfig = vinextConfig?.i18n ?? null;
 const configRedirects = vinextConfig?.redirects ?? [];
 const configRewrites = vinextConfig?.rewrites ?? {
@@ -60,6 +64,17 @@ const imageConfig = vinextConfig?.images ? {
 	contentDispositionType: vinextConfig.images.contentDispositionType,
 	contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy
 } : void 0;
+/**
+* Whether the request stage serves this request as a client build file
+* outside `_next/static`. Such responses resolve no route, so the Worker
+* keeps their ASSETS cache policy out of route cacheability admission.
+*/
+function isPagesClientBuildFileRequest(request, env, ctx) {
+	return (request.method === "GET" || request.method === "HEAD") && resolveAssetFetcher(ctx?.assets, env, "worker") !== void 0 && resolveClientBuildFile(new URL(request.url).pathname, basePath, clientBuildFiles) !== null;
+}
+function resolveAssetFetcher(assets, env, defaultHostRuntime) {
+	return assets ?? getExplicitCdnCacheAdapter()?.assets ?? (defaultHostRuntime === "worker" ? env?.ASSETS : void 0);
+}
 /** Run the request-time stage with a host-owned response dispatcher. */
 function handleRequestStage(request, env, ctx, dispatchResponseStage) {
 	const originalRequest = request;
@@ -89,7 +104,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 	let sharedOuterPolicyHeaders = null;
 	let ctx = createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets), defaultHostRuntime);
 	configuredCdnCacheAdapters.registerConfiguredCacheAdapters(env);
-	assets ??= getExplicitCdnCacheAdapter()?.assets ?? (defaultHostRuntime === "worker" ? env?.ASSETS : void 0);
+	assets = resolveAssetFetcher(assets, env, defaultHostRuntime);
 	if (configuredCdnCacheAdapters.hasConfiguredDataCache) registerLazyDataCacheHandler(async () => {
 		(await import("virtual:vinext-cache-adapters")).registerConfiguredCacheAdapters(env);
 	});
@@ -113,7 +128,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 				probeRoute = readWorkerCacheabilityProbeRoute(request);
 				const probeUrl = new URL(request.url);
 				probeUrl.searchParams.delete(VINEXT_CACHEABILITY_PROBE_QUERY_PARAM);
-				request = new Request(probeUrl, request);
+				request = cloneRequestWithUrl(request, probeUrl.href);
 			}
 		}
 		let responseStageDispatched = false;
@@ -143,7 +158,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 				resolvedRoutePathname: pathname
 			},
 			kind: "pages-prerender-discovery",
-			protocolVersion: 4,
+			protocolVersion: 5,
 			requestHost: url.host,
 			stagedHeaders: null
 		}, { cache: "bypass" }, env, ctx);
@@ -154,6 +169,10 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 		} catch {
 			return new Response("Bad Request", { status: 400 });
 		}
+		if (assets && (request.method === "GET" || request.method === "HEAD")) {
+			const clientBuildFile = resolveClientBuildFile(pathname, basePath, clientBuildFiles);
+			if (clientBuildFile) return await assets.fetch(createStaticAssetRequest(clientBuildFile, request));
+		}
 		const missingBuildAsset = isNextStaticPath(pathname, basePath, assetPathPrefix);
 		const hadBasePath = !basePath || hasBasePath(pathname, basePath);
 		{
@@ -189,6 +208,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			assetPrefix: vinextConfig?.assetPrefix,
 			basePath,
 			trailingSlash,
+			skipTrailingSlashRedirect,
 			i18nConfig,
 			configRedirects,
 			configRewrites,
@@ -228,7 +248,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						resolvedRoutePathname: new URL(resolvedUrl, req.url).pathname
 					},
 					kind: "pages-page",
-					protocolVersion: 4,
+					protocolVersion: 5,
 					requestHost: new URL(req.url).host,
 					renderOptions: isDataReq ? {
 						...options,
@@ -268,7 +288,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						resolvedRoutePathname: new URL(apiUrl, req.url).pathname
 					},
 					kind: "pages-api",
-					protocolVersion: 4,
+					protocolVersion: 5,
 					requestHost: new URL(req.url).host,
 					stagedHeaders: [...stagedHeaders]
 				});
@@ -285,17 +305,56 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 					return response;
 				}) : dispatched;
 			},
-			serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase, resolvedUrl) => {
+			serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase, resolvedUrl, filesystemRequest, resolvedPathnameHasBasePath) => {
 				if (!assets) return false;
-				if (isImageOptimizationPath(requestPathname)) {
+				if (resolvedPathnameHasBasePath && isImageOptimizationPath(requestPathname)) {
 					const imageUrl = new URL(resolvedUrl, request.url);
-					const imageRequest = new Request(imageUrl, request);
+					const imageRequest = cloneRequestWithUrl(request, imageUrl.href);
 					const allowedWidths = [...vinextConfig?.images?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...vinextConfig?.images?.imageSizes ?? DEFAULT_IMAGE_SIZES];
-					return handleConfiguredImageOptimization(imageRequest, (assetPath) => Promise.resolve(assets.fetch(new Request(new URL(assetPath, request.url)))), allowedWidths, imageConfig);
+					const { fetchWorkerImageSource } = await import("./worker-image-optimization.js");
+					return handleConfiguredImageOptimization(imageRequest, (sourceUrl, sourceImageRequest) => fetchWorkerImageSource(sourceUrl, sourceImageRequest, {
+						assets,
+						basePath,
+						assetPathPrefix,
+						clientBuildFiles,
+						fetchPublicFile: (sourceRequest) => resolvePublicImageSource(sourceRequest, assets)
+					}), allowedWidths, imageConfig);
 				}
-				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix);
+				return fetchWorkerFilesystemRoute(filesystemRequest, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix, hadBasePath);
 			}
 		};
+		const resolvePublicImageSource = async (sourceRequest, sourceAssets) => {
+			const sourceUrl = new URL(sourceRequest.url);
+			if (guardProtocolRelativeUrl(sourceUrl.pathname, sourceUrl.search)) return null;
+			const sourceHadBasePath = !basePath || hasBasePath(sourceUrl.pathname, basePath);
+			const sourcePathname = stripBasePath(sourceUrl.pathname, basePath);
+			if (isNextDataPathname(sourcePathname)) return null;
+			let sourceAsset = null;
+			const sourceResult = await runPagesRequest(attachRequestCfMetadata(new Request(new URL(sourcePathname + sourceUrl.search, sourceUrl), { signal: sourceRequest.signal }), sourceRequest), {
+				...deps,
+				hadBasePath: sourceHadBasePath,
+				isDataReq: false,
+				isDataRequest: false,
+				middlewareRequest: void 0,
+				dataNotFoundResponse: null,
+				recordCacheability: false,
+				runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, sourceHadBasePath) : null,
+				renderPage: null,
+				handleApi: null,
+				serveFilesystemRoute: async (candidate, _stagedHeaders, phase, _resolvedUrl, filesystemRequest) => {
+					if (isImageOptimizationPath(candidate)) return false;
+					const asset = await fetchWorkerFilesystemRoute(filesystemRequest, candidate, phase, (assetRequest) => Promise.resolve(sourceAssets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix, sourceHadBasePath);
+					if (asset === false) return false;
+					sourceAsset = asset;
+					return new Response(null);
+				}
+			});
+			if (sourceResult.type !== "response") return null;
+			await sourceResult.response.body?.cancel().catch(() => {});
+			if (isImageSourceBodyStatus(sourceResult.response.status)) return sourceAsset;
+			await sourceAsset?.body?.cancel().catch(() => {});
+			return null;
+		};
 		const result = await runPagesRequest(request, deps);
 		if (result.type === "response") {
 			let response = result.response;
@@ -317,4 +376,4 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 	}
 }
 //#endregion
-export { handleRequestStage, handleRequestStageLocally, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret };
+export { handleRequestStage, handleRequestStageLocally, isPagesClientBuildFileRequest, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret };

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

@@ -53,6 +53,10 @@ async function renderPagesResponse(request, env, platformCtx, props, stagedHeade
 		...ctx,
 		isPrerenderPathDiscovery: true
 	};
+	else if (props.kind === "pages-page" && dispatchOptions.regeneratesStoredEntry === true) ctx = {
+		...ctx,
+		isStoredEntryRegeneration: true
+	};
 	const render = async (cacheabilityContext) => {
 		if (props.kind === "pages-prerender-discovery") {
 			const readinessResponse = createWorkerPrerenderReadinessResponse(cacheabilityContext, request);

package/dist/server/pages-revalidate.js

@@ -1,11 +1,11 @@
 import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
-import { getRequestExecutionContext } from "../shims/request-context.js";
 import { VINEXT_REVALIDATED_CACHE_TAG_HEADER } from "./headers.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 import { normalizeDomainHostname } from "../utils/domain-locale.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { getRevalidateSecret, isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import "./isr-cache.js";
-import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 //#region src/server/pages-revalidate.ts
 async function performOnDemandRevalidate(source, urlPath, opts = {}, trustedOrigin, allowedRevalidateHeaderKeys = [], dev = false) {
 	if (typeof urlPath !== "string" || !urlPath.startsWith("/")) throw new Error(`Invalid urlPath provided to revalidate(), must be a path e.g. /blog/post-1, received ${urlPath}`);
@@ -29,7 +29,7 @@ async function performOnDemandRevalidate(source, urlPath, opts = {}, trustedOrig
 	const res = await fetchRevalidateTarget(target, headers, dispatchRevalidate);
 	if (!((res.headers.get("x-vercel-cache") ?? res.headers.get("x-nextjs-cache"))?.toUpperCase() === "REVALIDATED" || res.status === 200 || res.status === 404 && opts.unstable_onlyGenerated === true)) throw new Error(`Failed to revalidate ${urlPath}: ${res.status}`);
 	const regeneratedTag = res.headers.get(VINEXT_REVALIDATED_CACHE_TAG_HEADER);
-	if (regeneratedTag) await getCdnCacheAdapter().revalidateTag(regeneratedTag);
+	if (regeneratedTag) await getCdnCacheAdapter().revalidateTag(decodeURIComponent(regeneratedTag));
 }
 function readSourceHeader(source, key) {
 	if (isWebHeaders(source)) return source.get(key) ?? void 0;

package/dist/server/pages-router-entry.js

@@ -1,11 +1,11 @@
-import { runWithExecutionContext } from "../shims/request-context.js";
 import { VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM } from "./headers.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
+import { runWithExecutionContext } from "../shims/request-context.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { validateCdnRequest } from "./cache-control.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
-import { handleRequestStageLocally, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret } from "./pages-request-stage-entry.js";
+import { handleRequestStageLocally, isPagesClientBuildFileRequest, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret } from "./pages-request-stage-entry.js";
 import { renderPagesResponse } from "./pages-response-stage-entry.js";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 import { __ensureInstrumentation } from "virtual:vinext-pages-request-entry";
@@ -23,8 +23,9 @@ async function handleSingleStageRequest(request, env, platformCtx) {
 		if (readinessResponse.status === 204) await Promise.all([__ensureInstrumentation(), __ensureInstrumentation$1()]);
 		return await validateCdnRequest(request) ?? readinessResponse;
 	}
+	const isClientBuildFile = isPagesClientBuildFileRequest(request, env, ctx);
 	let finalize;
-	if (request.headers.has("X-Vinext-Cacheability-Probe")) {
+	if (!isClientBuildFile && request.headers.has("X-Vinext-Cacheability-Probe")) {
 		const cacheability = await import("./cacheability-request.js");
 		const probeContext = cacheability.createWorkerCacheabilityContext(ctx, request, pagesRequestStagePrerenderSecret, adapter.responseVary);
 		if (probeContext !== ctx) {
@@ -39,7 +40,7 @@ async function handleSingleStageRequest(request, env, platformCtx) {
 		}
 	}
 	const requiresCompletedResponseAdmission = adapter.requiresCompletedResponseAdmission === true;
-	if (!finalize && (__cacheabilityManifest || requiresCompletedResponseAdmission)) {
+	if (!finalize && !isClientBuildFile && (__cacheabilityManifest || requiresCompletedResponseAdmission)) {
 		const cacheability = await import("./cacheability-request.js");
 		const admissionContext = cacheability.createWorkerCacheabilityAdmissionContext(ctx, request, __cacheabilityManifest, pagesRequestStageBuildId, requiresCompletedResponseAdmission, adapter.responseVary);
 		if (admissionContext !== ctx) {

package/dist/server/prerender-manifest.d.ts

@@ -32,7 +32,6 @@ export type PrerenderManifest = {
   pregeneratedConcretePaths?: Array<[string, string[]]>;
 };
 export type PrerenderedPathSelectionOptions = {
-  includeFallbackShells?: boolean;
   includeErrorDocuments?: boolean;
 };
 export declare function readPrerenderManifest(manifestPath: string): PrerenderManifest | null;
@@ -58,8 +57,9 @@ export declare function buildPregeneratedConcretePathTable(manifest: PrerenderMa
  * This intentionally includes both App Router and Pages Router entries because
  * deploy-time cache warmup should exercise the same URLs the prerender phase
  * proved are statically renderable. PPR fallback-shell placeholder artifacts
- * and known error documents are excluded by default so warmup does not request
- * synthetic bracket paths or treat a healthy 404 response as a failed warmup.
+ * are always excluded, and known error documents by default, so warmup does not
+ * request synthetic bracket paths or treat a healthy 404 response as a failed
+ * warmup.
  */
 export declare function getPrerenderedConcretePaths(manifest: PrerenderManifest, options?: PrerenderedPathSelectionOptions): string[];
 //#endregion

package/dist/server/prerender-manifest.js

@@ -65,8 +65,9 @@ function buildPregeneratedConcretePathTable(manifest) {
 * This intentionally includes both App Router and Pages Router entries because
 * deploy-time cache warmup should exercise the same URLs the prerender phase
 * proved are statically renderable. PPR fallback-shell placeholder artifacts
-* and known error documents are excluded by default so warmup does not request
-* synthetic bracket paths or treat a healthy 404 response as a failed warmup.
+* are always excluded, and known error documents by default, so warmup does not
+* request synthetic bracket paths or treat a healthy 404 response as a failed
+* warmup.
 */
 function getPrerenderedConcretePaths(manifest, options) {
 	const routes = manifest.routes;
@@ -76,7 +77,7 @@ function getPrerenderedConcretePaths(manifest, options) {
 	for (const route of routes) {
 		if (route.status !== "rendered" || route.notFound) continue;
 		const pathname = route.path ?? route.route;
-		if (!options?.includeFallbackShells && isFallbackShellArtifactPath(pathname, route)) continue;
+		if (isFallbackShellArtifactPath(pathname, route)) continue;
 		if (!options?.includeErrorDocuments && isErrorDocumentRoute(pathname, route)) continue;
 		if (seen.has(pathname)) continue;
 		seen.add(pathname);

package/dist/server/prerender-work-unit-setup.js

@@ -1,3 +1,4 @@
+import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { workUnitAsyncStorage } from "../shims/internal/work-unit-async-storage.js";
 import { isRouteCacheabilityProbe } from "../shims/cacheability-classification.js";
 import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
@@ -15,6 +16,9 @@ import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
 *
 */
 function runWithPrerenderWorkUnit(fn, options) {
+	return runInWorkStoreScope(() => runWithWorkUnit(fn, options));
+}
+function runWithWorkUnit(fn, options) {
 	if (process.env.VINEXT_PRERENDER === "1" || isRouteCacheabilityProbe()) {
 		if (options?.cacheComponents !== true) return workUnitAsyncStorage.run({ type: "prerender-legacy" }, fn);
 		return runWithPrerenderWorkUnitOwner(fn, options);

package/dist/server/prod-server.d.ts

@@ -155,5 +155,17 @@ export declare function resolveAppRouterPrerenderSeeder(entryModule: unknown): A
  *    route through; the on-disk path is just `_next/static/...`.
  */
 export declare function resolveAppRouterAssetPath(pathname: string, assetPathPrefix: string, assetPrefix: string): string | null;
+/**
+ * Create the Pages Router request handler for `vite preview`. Vite's preview
+ * middleware (proxy, compression, `base`, static files) runs first, so this
+ * handles only the requests Vite doesn't serve and leaves compression to Vite.
+ * Resolves to null when the build has no Pages Router server entry.
+ */
+export declare function createPagesPreviewHandler(options: {
+  clientDir: string;
+  serverDir: string;
+  host: string;
+  port: number;
+}): Promise<((req: IncomingMessage, res: ServerResponse) => void) | null>;
 //#endregion
 export { COMPRESS_THRESHOLD, isCompressibleContentType, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, trustProxy, trustedHosts, tryServeStatic, waitForNodeResponseCompletion };