vinext 1.0.0 → 1.1.0

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

@@ -2,9 +2,11 @@ import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
 import { requestContextFromRequest } from "../config/request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { applyMiddlewareRequestHeaders, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, sanitizeDestination } from "../config/config-matchers.js";
+import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
-import { methodNotAllowedResponse, sanitizeMethodNotAllowedHeaders } from "./http-error-responses.js";
+import { VINEXT_PRERENDER_REWRITTEN_HEADER } from "./headers.js";
+import { methodNotAllowedResponse, notFoundStaticAssetResponse, sanitizeMethodNotAllowedHeaders } from "./http-error-responses.js";
 import { cloneRequestWithUrl, normalizeTrailingSlash } from "./request-pipeline.js";
 import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.js";
 import { markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
@@ -13,7 +15,7 @@ import { mergeRewriteQuery } from "../utils/query.js";
 import { buildMiddlewarePrefetchSkipResponse } from "./pages-data-route.js";
 import { setFrameworkRequestRoute } from "./request-tracing.js";
 import { applyConfigHeadersToHeaderRecord } from "./config-headers.js";
-import { mergeHeaders } from "./worker-utils.js";
+import { finalizeMissingStaticAssetResponse, mergeHeaders } from "./worker-utils.js";
 //#region src/server/pages-request-pipeline.ts
 function ruleUsesUnkeyedRequestCondition(rule) {
 	return [...rule.has ?? [], ...rule.missing ?? []].some((condition) => condition.type === "header" || condition.type === "cookie" || condition.type === "host");
@@ -30,12 +32,19 @@ function headersFromRecord(record) {
 	else headers.set(name, value);
 	return headers;
 }
-async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, isDirectBuildAsset = false) {
+async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, basePath = "", assetPathPrefix = "") {
 	const isRetrievalMethod = request.method === "GET" || request.method === "HEAD";
-	if (phase === "direct" && isRetrievalMethod || phase === "direct" && publicFiles !== void 0 && !isDirectBuildAsset && !publicFiles.has(requestPathname) || requestPathname === "/api" || requestPathname.startsWith("/api/")) return false;
+	if (phase === "direct" && isRetrievalMethod || requestPathname === "/api" || requestPathname.startsWith("/api/")) return false;
 	const assetUrl = new URL(request.url);
 	assetUrl.pathname = requestPathname;
 	assetUrl.search = "";
+	const decodedAssetUrl = new URL(assetUrl);
+	try {
+		decodedAssetUrl.pathname = decodeURIComponent(assetUrl.pathname);
+	} catch {
+		return false;
+	}
+	if (!publicFiles.has(assetUrl.pathname) && !publicFiles.has(decodedAssetUrl.pathname) && !isNextStaticPath(decodedAssetUrl.pathname, basePath, assetPathPrefix)) return false;
 	const response = await fetchAsset(isRetrievalMethod ? new Request(assetUrl, request) : new Request(assetUrl, {
 		method: "HEAD",
 		headers: request.headers
@@ -254,10 +263,11 @@ async function runPagesRequest(request, deps) {
 	}
 	const initialFilesystemResult = await serveFilesystemRoute(resolvedPathname, resolvedPathnameIsRequestPathname ? "direct" : "beforeFiles");
 	if (initialFilesystemResult) return initialFilesystemResult;
+	const isMissingBuildAsset = () => isNextStaticPath(resolvedPathname, "", assetPrefixPathname(deps.assetPrefix ?? ""));
 	const isOutsideBasePathUnclaimed = () => basePath && !hadBasePath && !configRewriteFired;
 	const outOfBasePathNotFound = () => ({
 		type: "response",
-		response: new Response("This page could not be found", {
+		response: isMissingBuildAsset() ? notFoundStaticAssetResponse(headersFromRecord(middlewareHeaders)) : new Response("This page could not be found", {
 			status: 404,
 			headers: { "Content-Type": "text/html; charset=utf-8" }
 		})
@@ -375,6 +385,10 @@ async function runPagesRequest(request, deps) {
 			matchedFallbackRewrite = true;
 			if (response.status !== 404) break;
 		}
+		if (!renderPageMatch && response.status === 404 && isMissingBuildAsset()) return {
+			type: "response",
+			response: finalizeMissingStaticAssetResponse(mergeHeaders(response, middlewareHeaders, middlewareStatus), true)
+		};
 		if (response.status === 404 && shouldDeferErrorPageOnMiss && !matchedFallbackRewrite) response = await deps.renderPage(request, resolvedUrl, void 0, stagedHeaders);
 		const matchedPathHeaders = { ...middlewareHeaders };
 		if ((isDataReq || isDataRequest) && deps.hasMiddleware && !renderPageMatch && response.status === 404 && (middlewareStatus === void 0 || middlewareStatus === 200 || middlewareStatus === 404)) {
@@ -392,6 +406,7 @@ async function runPagesRequest(request, deps) {
 			};
 		}
 		if ((isDataReq || isDataRequest) && renderPageMatch && (middlewareStatus ?? response.status) === 200) matchedPathHeaders["x-nextjs-matched-path"] = matchedPathnameForRoute(renderPageMatch?.route.pattern);
+		if (typeof process !== "undefined" && process.env?.VINEXT_PRERENDER === "1") matchedPathHeaders[VINEXT_PRERENDER_REWRITTEN_HEADER] = resolvedUrl === originalResolvedUrl ? "0" : "1";
 		const merged = mergeHeaders(response, matchedPathHeaders, middlewareStatus);
 		if (merged !== response) merged.__vinextStreamedHtmlResponse = response.__vinextStreamedHtmlResponse;
 		return {

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

@@ -6,16 +6,15 @@ 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 { isOpenRedirectShaped } from "./open-redirect.js";
-import { attachRequestCfMetadata, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders } from "./request-pipeline.js";
+import { attachRequestCfMetadata, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.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 { traceFrameworkRequest } from "./request-tracing.js";
 import { resolveResponseStageCachePolicy } from "./config-headers.js";
-import { finalizeMissingStaticAssetResponse } from "./worker-utils.js";
 import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse, isWorkerPrerenderDiscoveryPath } from "./worker-prerender-discovery.js";
@@ -69,7 +68,7 @@ function handleRequestStage(request, env, ctx, dispatchResponseStage) {
 /** Preserve the direct single-entry Worker path without retaining it in request-only builds. */
 function handleRequestStageLocally(request, env, ctx, dispatchResponseStage) {
 	const originalRequest = request;
-	return handleRequest(request, env, ctx, (stageRequest, props, _options, stageEnv, stageCtx) => dispatchResponseStage(stageRequest, stageEnv, stageCtx, props), true, "worker", env?.ASSETS).then((response) => applyCdnResponseIdentityHeaders(response, originalRequest));
+	return handleRequest(request, env, ctx, (stageRequest, props, _options, stageEnv, stageCtx) => dispatchResponseStage(stageRequest, stageEnv, stageCtx, props), true, "worker", ctx?.assets).then((response) => applyCdnResponseIdentityHeaders(response, originalRequest));
 }
 function handleRequest(request, env, platformCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets) {
 	const url = new URL(request.url);
@@ -90,6 +89,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);
 	if (configuredCdnCacheAdapters.hasConfiguredDataCache) registerLazyDataCacheHandler(async () => {
 		(await import("virtual:vinext-cache-adapters")).registerConfiguredCacheAdapters(env);
 	});
@@ -147,7 +147,8 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			requestHost: url.host,
 			stagedHeaders: null
 		}, { cache: "bypass" }, env, ctx);
-		if (isOpenRedirectShaped(pathname)) return new Response("This page could not be found", { status: 404 });
+		const protocolRelativeGuard = guardProtocolRelativeUrl(pathname, url.search);
+		if (protocolRelativeGuard) return protocolRelativeGuard;
 		try {
 			normalizePathnameForRouteMatchStrict(pathname);
 		} catch {
@@ -165,6 +166,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			}
 		}
 		const middlewareRequest = request;
+		const originalRenderUrl = pathname + new URL(request.url).search;
 		const dataNorm = normalizeDataRequest(request);
 		if (dataNorm.notFoundResponse && !vinextConfig?.skipProxyUrlNormalize) return dataNorm.notFoundResponse;
 		const isDataReq = dataNorm.isDataReq;
@@ -184,6 +186,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 		});
 		let speculativeRenderRequest = null;
 		const deps = {
+			assetPrefix: vinextConfig?.assetPrefix,
 			basePath,
 			trailingSlash,
 			i18nConfig,
@@ -227,7 +230,10 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 					kind: "pages-page",
 					protocolVersion: 4,
 					requestHost: new URL(req.url).host,
-					renderOptions: options ?? null,
+					renderOptions: isDataReq ? {
+						...options,
+						originalUrl: originalRenderUrl
+					} : options ?? null,
 					resolvedUrl,
 					stagedHeaders: isSharedStaticPage ? null : [...stagedHeaders ?? new Headers()]
 				});
@@ -287,12 +293,12 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 					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);
 				}
-				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, missingBuildAsset);
+				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix);
 			}
 		};
 		const result = await runPagesRequest(request, deps);
 		if (result.type === "response") {
-			let response = finalizeMissingStaticAssetResponse(result.response, missingBuildAsset);
+			let response = result.response;
 			if (sharedResponseHeaders && sharedOuterPolicyHeaders) reconcileCdnResponseHeadersAfterOuterPolicy(response.headers, sharedOuterPolicyHeaders);
 			if (probeMode && probeRoute && !responseStageDispatched) {
 				const { finalizeRequestStageCacheabilityProbe } = await import("./cacheability-request.js");

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

@@ -16,6 +16,12 @@ export type PrerenderManifestRoute = {
   fallback?: boolean;
   headers?: Record<string, string | string[]>;
   responseStatus?: number;
+  /** Pages source returned notFound, rather than rendering a custom 404 document. */
+  notFound?: true;
+  /** Original Pages redirect props, including client navigation semantics. */
+  redirectProps?: object;
+  /** Pages locale rendered for this public pathname. */
+  locale?: string;
   routeSegments?: string[];
   tags?: string[];
 };

package/dist/server/prerender-manifest.js

@@ -74,7 +74,7 @@ function getPrerenderedConcretePaths(manifest, options) {
 	const paths = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const route of routes) {
-		if (route.status !== "rendered") continue;
+		if (route.status !== "rendered" || route.notFound) continue;
 		const pathname = route.path ?? route.route;
 		if (!options?.includeFallbackShells && isFallbackShellArtifactPath(pathname, route)) continue;
 		if (!options?.includeErrorDocuments && isErrorDocumentRoute(pathname, route)) continue;

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

@@ -2,6 +2,7 @@ import { NextI18nConfig } from "../config/next-config.js";
 import { negotiateEncoding } from "./accept-encoding.js";
 import { StaticFileCache } from "./static-file-cache.js";
 import { resolveRequestHost, trustProxy, trustedHosts } from "./proxy-trust.js";
+import { COMPRESS_THRESHOLD, isCompressibleContentType } from "./response-compression.js";
 import { IncomingMessage, ServerResponse } from "node:http";
 //#region src/server/prod-server.d.ts
 /**
@@ -68,10 +69,6 @@ export type ProdServerOptions = {
   /** Suppress the startup log for internal child-process servers. */
   silent?: boolean;
 };
-/** Content types that benefit from compression. */
-declare const COMPRESSIBLE_TYPES: Set<string>;
-/** Minimum size threshold for compression (in bytes). Below this, compression overhead isn't worth it. */
-declare const COMPRESS_THRESHOLD = 1024;
 /**
  * Merge middleware headers and a Web Response's headers into a single
  * record suitable for Node.js `res.writeHead()`. Uses `getSetCookie()`
@@ -104,15 +101,19 @@ declare function sendCompressed(req: IncomingMessage, res: ServerResponse, body:
  *
  * Without a cache, falls back to async filesystem probing (still non-blocking,
  * unlike the old sync existsSync/statSync approach).
+ *
+ * `extraHeaders` go on every response for the file. `representationHeaders` go
+ * only on responses that carry the file's bytes (200 and 206), never on a 304,
+ * 412, 416 or 405.
  */
-declare function tryServeStatic(req: IncomingMessage, res: ServerResponse, clientDir: string, pathname: string, compress: boolean, cache?: StaticFileCache, extraHeaders?: Record<string, string | string[]>, statusCode?: number): Promise<boolean>;
+declare function tryServeStatic(req: IncomingMessage, res: ServerResponse, clientDir: string, pathname: string, compress: boolean, cache?: StaticFileCache, extraHeaders?: Record<string, string | string[]>, statusCode?: number, representationHeaders?: Record<string, string>): Promise<boolean>;
 /**
  * Convert a Node.js IncomingMessage to a Web Request object.
  *
  * When `urlOverride` is provided, it is used as the path + query string
  * instead of `req.url`.
  */
-declare function nodeToWebRequest(req: IncomingMessage, urlOverride?: string, prerenderSecret?: string, i18nConfig?: NextI18nConfig | null, authorizeOnDemandRevalidate?: (headerValue: string | null) => boolean): Request;
+declare function nodeToWebRequest(req: IncomingMessage, urlOverride?: string, prerenderSecret?: string, i18nConfig?: NextI18nConfig | null, authorizeOnDemandRevalidate?: (headerValue: string | null) => boolean, signal?: AbortSignal): Request;
 /**
  * Stream a Web Response back to a Node.js ServerResponse.
  * Supports streaming compression for SSR responses.
@@ -155,4 +156,4 @@ export declare function resolveAppRouterPrerenderSeeder(entryModule: unknown): A
  */
 export declare function resolveAppRouterAssetPath(pathname: string, assetPathPrefix: string, assetPrefix: string): string | null;
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, trustProxy, trustedHosts, tryServeStatic, waitForNodeResponseCompletion };
+export { COMPRESS_THRESHOLD, isCompressibleContentType, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, trustProxy, trustedHosts, tryServeStatic, waitForNodeResponseCompletion };