vinext 1.4.1 → 1.4.3

package/dist/server/pages-i18n.js

@@ -8,6 +8,19 @@ function readHeader(headers, name) {
 	return direct;
 }
 const normalizeHostname = normalizeDomainHostname;
+const LOCALE_REDIRECT = Symbol.for("vinext.pages-locale-redirect");
+/**
+* Mark a locale-detection redirect. Next.js answers it before next.config
+* headers are staged, so it goes out without them. The global symbol crosses
+* the App Router / Pages Router module graph boundary.
+*/
+function markLocaleRedirect(response) {
+	if (!isLocaleRedirect(response)) Object.defineProperty(response, LOCALE_REDIRECT, { value: true });
+	return response;
+}
+function isLocaleRedirect(response) {
+	return LOCALE_REDIRECT in response;
+}
 /**
 * Return the configured locale that the first pathname segment names, compared
 * case-insensitively (`/EN/about` -> `"en"`), or `undefined` when there is none.
@@ -259,4 +272,4 @@ function resolvePagesI18nRequest(url, i18nConfig, headers, hostname, basePath =
 	};
 }
 //#endregion
-export { detectDomainLocale, detectLocaleFromAcceptLanguage, detectPathnameLocale, extractLocaleFromUrl, getLocaleRedirect, normalizeDefaultLocalePathname, parseCookieLocaleFromHeader, resolvePagesI18nRequest, shouldRestoreLocaleRootTrailingSlash, stripI18nLocaleForApiRoute };
+export { detectDomainLocale, detectLocaleFromAcceptLanguage, detectPathnameLocale, extractLocaleFromUrl, getLocaleRedirect, isLocaleRedirect, markLocaleRedirect, normalizeDefaultLocalePathname, parseCookieLocaleFromHeader, resolvePagesI18nRequest, shouldRestoreLocaleRootTrailingSlash, stripI18nLocaleForApiRoute };

package/dist/server/pages-node-compat.js

@@ -201,10 +201,14 @@ var PagesResponseStream = class extends Writable {
 		return this;
 	}
 	json(data) {
-		this.resHeaders["content-type"] = "application/json";
+		this.resHeaders["content-type"] = "application/json; charset=utf-8";
 		this.end(JSON.stringify(data));
 	}
 	send(data) {
+		if (data === null || data === void 0) {
+			this.end();
+			return;
+		}
 		if (NO_BODY_RESPONSE_STATUSES.has(this.resStatusCode)) {
 			this.end();
 			return;
@@ -220,8 +224,8 @@ var PagesResponseStream = class extends Writable {
 			this.end(data);
 			return;
 		}
-		if (typeof data === "object" && data !== null) {
-			this.resHeaders["content-type"] = "application/json";
+		if (typeof data === "object" || typeof data === "number" || typeof data === "boolean") {
+			this.resHeaders["content-type"] = "application/json; charset=utf-8";
 			this.end(JSON.stringify(data));
 			return;
 		}

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

@@ -5,7 +5,7 @@ import { NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, VINEXT_CACHE_HEADER,
 import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { extractLocaleFromUrl, resolvePagesI18nRequest } from "./pages-i18n.js";
+import { extractLocaleFromUrl, markLocaleRedirect, resolvePagesI18nRequest } from "./pages-i18n.js";
 import { buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, normalizePagesDataRequest, parseNextDataPathname } from "./pages-data-route.js";
 import { reportRequestError } from "./instrumentation.js";
 import { logRequestError } from "./request-error-log.js";
@@ -154,7 +154,7 @@ function createPagesPageHandler(opts) {
 		const originalRequestPathAndSearch = originalRequestUrl.pathname + originalRequestUrl.search;
 		let dataRequestPathname = null;
 		let dataRequestSearch = "";
-		const initialDataNorm = normalizePagesDataRequest(request, buildId, vinextConfig.basePath, hasMiddleware && vinextConfig.trailingSlash);
+		const initialDataNorm = normalizePagesDataRequest(request, buildId, "", hasMiddleware && vinextConfig.trailingSlash);
 		if (!isDataReq) {
 			if (initialDataNorm.notFoundResponse) return initialDataNorm.notFoundResponse;
 			if (initialDataNorm.isDataReq) {
@@ -195,10 +195,10 @@ function createPagesPageHandler(opts) {
 		const currentDefaultLocale = i18nConfig ? localeInfo.domainLocale ? localeInfo.domainLocale.defaultLocale : i18nConfig.defaultLocale : void 0;
 		const domainLocales = i18nConfig ? i18nConfig.domains : void 0;
 		const pageIsrCacheKey = isrCacheKeyForRequest(i18nConfig ? localeInfo.domainLocale ? JSON.stringify([String(localeInfo.domainLocale.domain).toLowerCase(), locale]) : "locale:" + String(locale) : null);
-		if (localeInfo.redirectUrl) return new Response(null, {
+		if (localeInfo.redirectUrl) return markLocaleRedirect(new Response(null, {
 			status: 307,
 			headers: { Location: localeInfo.redirectUrl }
-		});
+		}));
 		let match = options && options.__forcedRoute ? {
 			route: options.__forcedRoute,
 			params: {}

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

@@ -15,6 +15,14 @@ type PageRouteMatch = {
     dataKind?: PagesRouteDataKind;
   };
 };
+/**
+ * Whether a filesystem route may serve `requestPathname` from the client
+ * build directory. Like Next.js, only a public file or a build asset resolves
+ * there: the directory also holds build metadata and private artifacts. A
+ * direct GET/HEAD reaches this route only for a public file, since servers
+ * answer existing build assets before middleware.
+ */
+export declare function isServableFilesystemRoute(requestPathname: string, phase: FilesystemRoutePhase, method: string, publicFiles: ReadonlySet<string>, basePath?: string, assetPathPrefix?: string, pathnameHasBasePath?: boolean): boolean;
 export declare function fetchWorkerFilesystemRoute(request: Request, requestPathname: string, phase: FilesystemRoutePhase, fetchAsset: (request: Request) => Promise<Response>, publicFiles: ReadonlySet<string>, basePath?: string, assetPathPrefix?: string, pathnameHasBasePath?: boolean): Promise<Response | false>;
 export type MiddlewareResult = {
   continue: boolean;
@@ -77,6 +85,7 @@ export type PagesPipelineDeps = {
   runMiddleware?: ((request: Request, ctx: unknown, opts: {
     isDataRequest: boolean;
     isStaleDataRequest?: boolean;
+    restoreLocaleRootTrailingSlash?: boolean;
   }) => Promise<MiddlewareResult>) | null;
   /** Original URL presented to middleware when URL normalization is disabled. */
   middlewareRequest?: Request;

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

@@ -1,7 +1,7 @@
 import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
 import { requestContextFromRequest } from "../config/request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
-import { addBasePathToPathname } from "../utils/base-path.js";
+import { restoreBasePath } from "../utils/base-path.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";
@@ -14,10 +14,12 @@ import { buildMiddlewarePrefetchSkipResponse } from "./pages-data-route.js";
 import { markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import { mergeRewriteQuery } from "../utils/query.js";
+import { isImageOptimizationPath } from "./image-optimization.js";
 import { setFrameworkRequestRoute } from "./request-tracing.js";
 import { withExternalRewriteResponseHeaders } from "./middleware-response-headers.js";
 import { applyConfigHeadersToHeaderRecord } from "./config-headers.js";
-import { finalizeMissingStaticAssetResponse, mergeHeaders } from "./worker-utils.js";
+import { finalizeMissingStaticAssetResponse, mergeHeaders, mergeStaticFileHeaders } from "./worker-utils.js";
+import { publicFileRouteKey } from "../utils/public-file-path.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");
@@ -34,24 +36,41 @@ function headersFromRecord(record) {
 	else headers.set(name, value);
 	return headers;
 }
-async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, basePath = "", assetPathPrefix = "", pathnameHasBasePath = true) {
-	const isRetrievalMethod = request.method === "GET" || request.method === "HEAD";
-	const assetUrl = new URL(request.url);
+/**
+* Whether a filesystem route may serve `requestPathname` from the client
+* build directory. Like Next.js, only a public file or a build asset resolves
+* there: the directory also holds build metadata and private artifacts. A
+* direct GET/HEAD reaches this route only for a public file, since servers
+* answer existing build assets before middleware.
+*/
+function isServableFilesystemRoute(requestPathname, phase, method, publicFiles, basePath = "", assetPathPrefix = "", pathnameHasBasePath = true) {
+	const assetUrl = new URL("http://localhost");
 	assetUrl.pathname = requestPathname;
-	assetUrl.search = "";
 	const decodedAssetUrl = new URL(assetUrl);
 	let publicFileKey;
+	let servedPathname;
+	let servedFileKey;
 	try {
 		decodedAssetUrl.pathname = decodeURIComponent(assetUrl.pathname);
 		publicFileKey = normalizePathnameForRouteMatchStrict(assetUrl.pathname);
+		servedPathname = decodeURIComponent(requestPathname);
+		servedFileKey = publicFileRouteKey(servedPathname);
 	} catch {
 		return false;
 	}
-	if (!pathnameHasBasePath && !isAssetPrefixBuildAsset(decodedAssetUrl.pathname, assetPathPrefix)) return false;
-	const isPublicFile = pathnameHasBasePath && publicFiles.has(publicFileKey);
+	const decodedPathname = decodedAssetUrl.pathname;
+	if (!pathnameHasBasePath && !isAssetPrefixBuildAsset(decodedPathname, assetPathPrefix)) return false;
+	const isPublicFile = pathnameHasBasePath && publicFiles.has(publicFileKey) && publicFiles.has(servedFileKey);
 	if (!isPublicFile && (requestPathname === "/api" || requestPathname.startsWith("/api/"))) return false;
-	if (phase === "direct" && isRetrievalMethod && !isPublicFile) return false;
-	if (!isPublicFile && !isNextStaticPath(decodedAssetUrl.pathname, basePath, assetPathPrefix)) return false;
+	if (phase === "direct" && (method === "GET" || method === "HEAD") && !isPublicFile) return false;
+	return isPublicFile || isNextStaticPath(decodedPathname, basePath, assetPathPrefix) && isNextStaticPath(servedPathname, basePath, assetPathPrefix);
+}
+async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, basePath = "", assetPathPrefix = "", pathnameHasBasePath = true) {
+	const isRetrievalMethod = request.method === "GET" || request.method === "HEAD";
+	const assetUrl = new URL(request.url);
+	assetUrl.pathname = requestPathname;
+	assetUrl.search = "";
+	if (!isServableFilesystemRoute(requestPathname, phase, request.method, publicFiles, basePath, assetPathPrefix, pathnameHasBasePath)) return false;
 	const response = await fetchAsset(isRetrievalMethod ? new Request(assetUrl, request) : new Request(assetUrl, {
 		method: "HEAD",
 		headers: request.headers
@@ -80,7 +99,7 @@ function wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) {
 	if (!hadBasePath || !basePath) return runMiddleware;
 	return (request, ctx, opts) => {
 		const mwUrl = new URL(request.url);
-		mwUrl.pathname = addBasePathToPathname(mwUrl.pathname, basePath);
+		mwUrl.pathname = restoreBasePath(mwUrl.pathname, basePath);
 		return runMiddleware(cloneRequestWithUrl(request, mwUrl.toString()), ctx, opts);
 	};
 }
@@ -166,7 +185,7 @@ async function runPagesRequest(request, deps) {
 		const served = await deps.serveFilesystemRoute(requestPathname, middlewareHeaders, phase, resolvedUrl, request, resolvedPathnameHasBasePath);
 		if (served instanceof Response) {
 			const isStaticMethodNotAllowed = served.status === 405 && served.headers.get("allow") === "GET, HEAD";
-			const response = mergeHeaders(served, middlewareHeaders, isStaticMethodNotAllowed || !served.ok || served.status === 206 ? void 0 : middlewareStatus);
+			const response = (resolvedPathnameHasBasePath && isImageOptimizationPath(requestPathname) ? mergeHeaders : mergeStaticFileHeaders)(served, middlewareHeaders, isStaticMethodNotAllowed || !served.ok || served.status === 206 ? void 0 : middlewareStatus);
 			if (isStaticMethodNotAllowed) sanitizeMethodNotAllowedHeaders(response.headers, "GET, HEAD");
 			return {
 				type: "response",
@@ -178,7 +197,8 @@ async function runPagesRequest(request, deps) {
 	if (!isOnDemandRevalidate && typeof deps.runMiddleware === "function") {
 		const result = await deps.runMiddleware(deps.middlewareRequest ?? request, deps.ctx ?? null, {
 			isDataRequest,
-			isStaleDataRequest: isDataRequest && !!deps.dataNotFoundResponse
+			isStaleDataRequest: isDataRequest && !!deps.dataNotFoundResponse,
+			restoreLocaleRootTrailingSlash: deps.restoreLocaleRootTrailingSlash
 		});
 		if (deps.recordCacheability !== false && result.pathnameEligible) markRouteCacheabilityDynamic("middleware can match this pathname");
 		if (result.waitUntilPromises && result.waitUntilPromises.length > 0) {
@@ -306,7 +326,7 @@ async function runPagesRequest(request, deps) {
 			let apiRequest = request;
 			if (basePath && hadBasePath) {
 				const apiRequestUrl = new URL(request.url);
-				apiRequestUrl.pathname = addBasePathToPathname(apiRequestUrl.pathname, basePath);
+				apiRequestUrl.pathname = restoreBasePath(apiRequestUrl.pathname, basePath);
 				apiRequest = cloneRequestWithUrl(request, apiRequestUrl.toString());
 			}
 			const response = await deps.handleApi(apiRequest, apiLookupUrl, deps.ctx ?? null, headersFromRecord(middlewareHeaders));
@@ -464,4 +484,4 @@ async function runPagesRequest(request, deps) {
 	};
 }
 //#endregion
-export { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath };
+export { fetchWorkerFilesystemRoute, isServableFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath };

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

@@ -69,10 +69,13 @@ const configRewrites = vinextConfig?.rewrites ?? {
 const configHeaders = vinextConfig?.headers ?? [];
 const imageConfig = vinextConfig?.images ? {
 	qualities: vinextConfig.images.qualities,
+	localPatterns: vinextConfig.images.localPatterns,
 	dangerouslyAllowSVG: vinextConfig.images.dangerouslyAllowSVG,
 	dangerouslyAllowLocalIP: vinextConfig.images.dangerouslyAllowLocalIP,
 	contentDispositionType: vinextConfig.images.contentDispositionType,
-	contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy
+	contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy,
+	minimumCacheTTL: vinextConfig.images.minimumCacheTTL,
+	maximumResponseBody: vinextConfig.images.maximumResponseBody
 } : void 0;
 /**
 * Whether the request stage serves this request as a client build file
@@ -383,7 +386,10 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			});
 			if (sourceResult.type !== "response") return null;
 			await sourceResult.response.body?.cancel().catch(() => {});
-			if (isImageSourceBodyStatus(sourceResult.response.status)) return sourceAsset;
+			if (isImageSourceBodyStatus(sourceResult.response.status) && sourceAsset !== null) {
+				const { withStagedCacheControl } = await import("./worker-image-optimization.js");
+				return withStagedCacheControl(sourceAsset, sourceResult.response.headers.get("Cache-Control"));
+			}
 			await sourceAsset?.body?.cancel().catch(() => {});
 			return null;
 		};

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

@@ -1,10 +1,12 @@
 import { VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM } from "./headers.js";
+import { notFoundResponse } from "./http-error-responses.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl, stripRequestUrlFragment } 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 { isSrvxAbsoluteFormTarget } from "./srvx-request-target.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";
@@ -52,6 +54,7 @@ async function handleSingleStageRequest(request, env, platformCtx) {
 	return finalize ? finalize(response, ctx) : response;
 }
 var pages_router_entry_default = { fetch(request, env, ctx) {
+	if (isSrvxAbsoluteFormTarget(request)) return Promise.resolve(notFoundResponse());
 	const strippedRequest = stripRequestUrlFragment(request);
 	const handle = () => handleSingleStageRequest(strippedRequest, env, ctx);
 	return ctx && typeof ctx.waitUntil === "function" ? runWithExecutionContext(ctx, handle) : handle();

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

@@ -90,7 +90,7 @@ declare function mergeWebResponse(middlewareHeaders: Record<string, string | str
  * Send a compressed response if the content type is compressible and the
  * client supports compression. Otherwise send uncompressed.
  */
-declare function sendCompressed(req: IncomingMessage, res: ServerResponse, body: string | Buffer, contentType: string, statusCode: number, extraHeaders?: Record<string, string | string[]>, compress?: boolean, statusText?: string): void;
+declare function sendCompressed(req: IncomingMessage, res: ServerResponse, body: string | Buffer, contentType: string | undefined, statusCode: number, extraHeaders?: Record<string, string | string[]>, compress?: boolean, statusText?: string): void;
 /**
  * Try to serve a static file from the client build directory.
  *

package/dist/server/prod-server.js

@@ -7,7 +7,7 @@ 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, isAssetPrefixBuildAsset } from "../utils/asset-prefix.js";
+import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix } from "../utils/asset-prefix.js";
 import { StaticFileCache, contentTypeForPath, etagFromFilenameHash, staticFileCacheControl } from "./static-file-cache.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { resolveRequestHost, resolveRequestProtocol, resolveTrustedForwardedHost, trustProxy, trustedHosts } from "./proxy-trust.js";
@@ -19,13 +19,13 @@ import { parseHttpDate } from "./http-date.js";
 import { evaluateStaticPreconditions } from "./http-conditional.js";
 import { setPagesClientAssets } from "./pages-client-assets.js";
 import { signalFromNodeResponse } from "./node-response-signal.js";
-import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_RESPONSE_CACHE_STATE, INVALID_IMAGE_SOURCE_MESSAGE, MUTABLE_IMAGE_SOURCE_CACHE_CONTROL, isImageOptimizationPath, isImageSourceBodyStatus, isSafeImageContentType, parseImageParams, readImageOptimizationSignal } from "./image-optimization.js";
+import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_RESPONSE_CACHE_STATE, IMAGE_TYPE_NOT_ALLOWED_MESSAGE, INVALID_IMAGE_SOURCE_MESSAGE, isImageOptimizationPath, isImageSourceBodyStatus, isSafeImageContentType, parseImageParams, readImageOptimizationSignal, sourceImageCacheControl } from "./image-optimization.js";
 import { installSocketErrorBackstop } from "./socket-error-backstop.js";
 import { collectInlineCssManifest } from "../build/inline-css.js";
 import { readTrustedRevalidationHostname } from "./revalidation-host.js";
 import { traceFrameworkRequest } from "./request-tracing.js";
 import { mergeHeaders } from "./worker-utils.js";
-import { runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
+import { isServableFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
 import { computeClientRuntimeMetadata } from "../utils/client-runtime-metadata.js";
 import { readPrerenderSecret, readServerCompress } from "../build/server-manifest.js";
 import { readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
@@ -270,6 +270,7 @@ const OMIT_STATIC_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
 	"content-type",
 	VINEXT_PRERENDER_SPECIAL_ERROR_HEADER
 ]);
+const IMAGE_ERROR_SIGNAL_HEADERS = ["content-type", "content-encoding"];
 function omitHeadersCaseInsensitive(headersRecord, targets) {
 	const filtered = {};
 	for (const [key, value] of Object.entries(headersRecord)) {
@@ -338,6 +339,7 @@ function installClientBuildManifestGlobals(clientDir, assetBase, assetPrefix, cr
 	});
 	setPagesClientAssets({
 		appBootstrapPreinitModules: metadata.appBootstrapPreinitModules,
+		appBootstrapPreloadModules: metadata.appBootstrapPreloadModules,
 		appRouteManifestModule: metadata.appRouteManifestModule,
 		lazyChunks: metadata.lazyChunks,
 		dynamicPreloads: metadata.dynamicPreloads,
@@ -443,7 +445,7 @@ function sendCompressed(req, res, body, contentType, statusCode, extraHeaders =
 	if (encoding !== "identity") {
 		writeHead(mergeVaryHeader({
 			...headersWithoutBodyHeaders,
-			"Content-Type": contentType,
+			...contentType !== void 0 && { "Content-Type": contentType },
 			"Content-Encoding": encoding
 		}, "Accept-Encoding"));
 		const compressor = createCompressor(encoding);
@@ -452,7 +454,7 @@ function sendCompressed(req, res, body, contentType, statusCode, extraHeaders =
 	} else {
 		const identityHeaders = {
 			...headersWithoutBodyHeaders,
-			"Content-Type": contentType,
+			...contentType !== void 0 && { "Content-Type": contentType },
 			"Content-Length": String(buf.length)
 		};
 		writeHead(varyByEncoding ? mergeVaryHeader(identityHeaders, "Accept-Encoding") : identityHeaders);
@@ -476,20 +478,18 @@ function staticCacheLookupPath(pathname) {
 }
 /**
 * Give a Node image passthrough Next.js's image Cache-Control instead of the
-* public-file default: a hashed build asset keeps its immutable default, and
-* any other source is revalidated after the default `images.minimumCacheTTL`.
+* public-file default: a build asset keeps its immutable default, and a public
+* file, whatever its path, is revalidated after `images.minimumCacheTTL`, or
+* after the max-age a direct request for it gets (from middleware or
+* `headers()`, else the public-file default) when that is longer.
 */
-function withImageSourceCacheControl(headers, sourcePath) {
-	if (sourcePath.includes(`/_next/static/`)) return headers;
+function withImageSourceCacheControl(headers, publicFileCacheControl, config) {
+	if (publicFileCacheControl === void 0) return headers;
 	return {
 		...headers,
-		"Cache-Control": MUTABLE_IMAGE_SOURCE_CACHE_CONTROL
+		"Cache-Control": sourceImageCacheControl(false, publicFileCacheControl ?? staticFileCacheControl(false), config)
 	};
 }
-/** Pathnames the Pages Router serves from routes rather than the client directory. */
-function isPagesFilesystemExcludedPath(pathname, phase) {
-	return pathname === "/" || pathname === "/api" || pathname.startsWith("/api/") || phase === "direct" && pathname.startsWith(`/_next/static/`);
-}
 /**
 * Try to serve a static file from the client build directory.
 *
@@ -782,32 +782,14 @@ function pipeStaticFileRange(filePath, range, res) {
 		}
 	});
 }
-/**
-* Resolve the actual file to serve, trying extension-less HTML fallbacks.
-* Returns the resolved path + size + mtime, or null if not found.
-*/
+/** Returns the file's path + size + mtime, or null if it is not a regular file. */
 async function resolveStaticFile(staticFile) {
 	const stat = await statIfFile(staticFile);
-	if (stat) return {
+	return stat ? {
 		path: staticFile,
 		size: stat.size,
 		mtimeMs: stat.mtimeMs
-	};
-	const htmlFallback = staticFile + ".html";
-	const htmlStat = await statIfFile(htmlFallback);
-	if (htmlStat) return {
-		path: htmlFallback,
-		size: htmlStat.size,
-		mtimeMs: htmlStat.mtimeMs
-	};
-	const indexFallback = path.join(staticFile, "index.html");
-	const indexStat = await statIfFile(indexFallback);
-	if (indexStat) return {
-		path: indexFallback,
-		size: indexStat.size,
-		mtimeMs: indexStat.mtimeMs
-	};
-	return null;
+	} : null;
 }
 async function statIfFile(filePath) {
 	try {
@@ -1128,6 +1110,7 @@ function installPagesClientAssets(options) {
 	setPagesClientAssets({
 		clientEntry: metadata.clientEntryFile,
 		appBootstrapPreinitModules: metadata.appBootstrapPreinitModules,
+		appBootstrapPreloadModules: metadata.appBootstrapPreloadModules,
 		appRouteManifestModule: metadata.appRouteManifestModule,
 		ssrManifest: Object.keys(ssrManifest).length > 0 ? ssrManifest : void 0,
 		sharedChunks: metadata.sharedChunks,
@@ -1195,18 +1178,25 @@ async function startAppRouterServer(options) {
 	if (seededRoutes > 0) console.log(`[vinext] Seeded ${seededRoutes} pre-rendered route${seededRoutes !== 1 ? "s" : ""} into memory cache`);
 	const staticCache = await StaticFileCache.create(clientDir);
 	const serveImageOptimization = async (req, res, request, signal) => {
-		const stagedHeaders = omitHeadersCaseInsensitive(mergeResponseHeaders({}, new Response(null, { headers: signal.middlewareHeaders })), OMIT_STATIC_RESPONSE_HEADERS);
+		const signalHeaders = mergeResponseHeaders({}, new Response(null, { headers: signal.middlewareHeaders }));
+		const stagedHeaders = omitHeadersCaseInsensitive(signalHeaders, OMIT_STATIC_RESPONSE_HEADERS);
 		for (const [name, value] of Object.entries(stagedHeaders)) res.setHeader(name, value);
+		const sendBadRequest = (body) => {
+			for (const name of IMAGE_ERROR_SIGNAL_HEADERS) {
+				const value = signalHeaders[name];
+				if (value !== void 0) res.setHeader(name, value);
+			}
+			res.writeHead(400);
+			res.end(body);
+		};
 		const parsedUrl = new URL(`/${signal.search}`, "http://localhost");
-		const params = parseImageParams(parsedUrl, appImageAllowedWidths, imageConfig?.qualities);
+		const params = parseImageParams(parsedUrl, appImageAllowedWidths, imageConfig?.qualities, { localPatterns: imageConfig?.localPatterns });
 		if (!params) {
-			res.writeHead(400);
-			res.end("Bad Request");
+			sendBadRequest("Bad Request");
 			return;
 		}
 		const sendUnsafeContentType = () => {
-			res.writeHead(400);
-			res.end("The requested resource is not an allowed image type");
+			sendBadRequest(IMAGE_TYPE_NOT_ALLOWED_MESSAGE);
 		};
 		const isSafeSourcePath = (sourcePath) => isSafeImageContentType(contentTypeForPath(sourcePath), imageConfig?.dangerouslyAllowSVG);
 		const imageSecurityHeaders = {
@@ -1214,7 +1204,7 @@ async function startAppRouterServer(options) {
 			"X-Content-Type-Options": "nosniff",
 			"Content-Disposition": imageConfig?.contentDispositionType === "attachment" ? "attachment" : "inline"
 		};
-		const serveSource = (sourcePath) => tryServeStatic(req, res, clientDir, sourcePath, false, staticCache, withImageSourceCacheControl(imageSecurityHeaders, sourcePath), void 0, IMAGE_REPRESENTATION_HEADERS);
+		const serveSource = (sourcePath, publicFileCacheControl) => tryServeStatic(req, res, clientDir, sourcePath, false, staticCache, withImageSourceCacheControl(imageSecurityHeaders, publicFileCacheControl, imageConfig), void 0, IMAGE_REPRESENTATION_HEADERS);
 		const sourceUrl = new URL(params.imageUrl, request.url);
 		let sourcePathname = null;
 		try {
@@ -1240,11 +1230,10 @@ async function startAppRouterServer(options) {
 					sendUnsafeContentType();
 					return;
 				}
-				if (await serveSource(sourcePath)) return;
+				if (await serveSource(sourcePath, sourceResponse.headers.get("Cache-Control"))) return;
 			}
 		}
-		res.writeHead(400);
-		res.end(INVALID_IMAGE_SOURCE_MESSAGE);
+		sendBadRequest(INVALID_IMAGE_SOURCE_MESSAGE);
 	};
 	const clientBuildFiles = new Set(Array.isArray(rscModule.__clientBuildFiles) ? rscModule.__clientBuildFiles : []);
 	const handleRequestImpl = async (req, res) => {
@@ -1433,6 +1422,8 @@ async function createPagesRouterRequestHandler(options) {
 	const ensureInstrumentation = typeof serverEntry.__ensureInstrumentation === "function" ? () => serverEntry.__ensureInstrumentation() : () => void 0;
 	const hasMiddleware = serverEntry.hasMiddleware === true;
 	const pageRoutes = readPagesServerEntryPageRoutes(serverEntry.pageRoutes);
+	const publicFiles = serverEntry.publicFiles instanceof Set ? serverEntry.publicFiles : /* @__PURE__ */ new Set();
+	const clientBuildFiles = serverEntry.clientBuildFiles instanceof Set ? serverEntry.clientBuildFiles : /* @__PURE__ */ new Set();
 	const prerenderSecret = readPrerenderSecret(path.dirname(serverEntryPath));
 	const compress = compressOption && readServerCompress(serverDir);
 	const basePath = vinextConfig?.basePath ?? "";
@@ -1455,8 +1446,11 @@ async function createPagesRouterRequestHandler(options) {
 		dangerouslyAllowSVG: vinextConfig.images.dangerouslyAllowSVG,
 		dangerouslyAllowLocalIP: vinextConfig.images.dangerouslyAllowLocalIP,
 		qualities: vinextConfig.images.qualities,
+		localPatterns: vinextConfig.images.localPatterns,
 		contentDispositionType: vinextConfig.images.contentDispositionType,
-		contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy
+		contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy,
+		minimumCacheTTL: vinextConfig.images.minimumCacheTTL,
+		maximumResponseBody: vinextConfig.images.maximumResponseBody
 	} : void 0;
 	const ssrManifest = installPagesClientAssets({
 		clientDir,
@@ -1546,6 +1540,10 @@ async function createPagesRouterRequestHandler(options) {
 		if (pagesAssetLookup) {
 			if (await tryServeStatic(req, res, clientDir, pagesAssetLookup, compress, staticCache)) return;
 		}
+		if (req.method === "GET" || req.method === "HEAD") {
+			const clientBuildFile = resolveClientBuildFile(rawPagesPathname, basePath, clientBuildFiles);
+			if (clientBuildFile && await tryServeStatic(req, res, clientDir, clientBuildFile, compress, staticCache)) return;
+		}
 		try {
 			const hadBasePath = !basePath || hasBasePath(requestPathname, basePath);
 			const restoreLocaleRootTrailingSlash = shouldRestoreLocaleRootTrailingSlash(requestPathname, {
@@ -1616,6 +1614,7 @@ async function createPagesRouterRequestHandler(options) {
 			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;
+			/** The public file a source resolves to, with the Cache-Control staged for it. */
 			const resolvePublicImageSource = async (sourceUrl) => {
 				const rawSourcePathname = sourceUrl.pathname;
 				if (getRepeatedSlashRedirect(rawSourcePathname) || isOpenRedirectShaped(rawSourcePathname)) return null;
@@ -1623,7 +1622,7 @@ async function createPagesRouterRequestHandler(options) {
 				const sourceHadBasePath = !basePath || hasBasePath(sourceRequestPathname, basePath);
 				const strippedSourcePathname = stripBasePath(sourceRequestPathname, basePath);
 				if (isNextDataPathname(strippedSourcePathname)) return null;
-				let sourcePath = null;
+				let source = null;
 				const result = await runPagesRequest(new Request(new URL(strippedSourcePathname + sourceUrl.search, sourceUrl), { signal: webRequest.signal }), {
 					...deps,
 					hadBasePath: sourceHadBasePath,
@@ -1641,17 +1640,20 @@ async function createPagesRouterRequestHandler(options) {
 					runMiddleware: runNodeMiddleware ? wrapMiddlewareWithBasePath(runNodeMiddleware, basePath, sourceHadBasePath) : null,
 					renderPage: null,
 					handleApi: null,
-					serveFilesystemRoute: async (candidate, _stagedHeaders, phase, _resolvedUrl, _request, candidateHasBasePath) => {
-						if (!candidateHasBasePath && !isAssetPrefixBuildAsset(candidate, pagesAssetPathPrefix) || isImageOptimizationPath(candidate) || isPagesFilesystemExcludedPath(candidate, phase)) return false;
+					serveFilesystemRoute: async (candidate, stagedHeaders, phase, _resolvedUrl, sourceRequest, candidateHasBasePath) => {
+						if (isImageOptimizationPath(candidate) || !isServableFilesystemRoute(candidate, phase, sourceRequest.method, publicFiles, basePath, pagesAssetPathPrefix, candidateHasBasePath)) return false;
 						const lookupPath = staticCacheLookupPath(candidate);
 						if (lookupPath === null || lookupPath === "/" || !staticCache.lookup(lookupPath)) return false;
-						sourcePath = candidate;
+						source = {
+							path: candidate,
+							cacheControl: readHeaderCaseInsensitive(stagedHeaders, "cache-control") ?? null
+						};
 						return new Response(null);
 					}
 				});
 				if (result.type !== "response") return null;
 				cancelResponseBody(result.response);
-				return isImageSourceBodyStatus(result.response.status) ? sourcePath : null;
+				return isImageSourceBodyStatus(result.response.status) ? source : null;
 			};
 			const deps = {
 				assetPrefix,
@@ -1685,11 +1687,11 @@ async function createPagesRouterRequestHandler(options) {
 					return handleApi(request, apiUrl, createNodeExecutionContext(), resolveTrustedNodeRevalidateOrigin(req, host, port), "node", stagedHeaders);
 				} : null,
 				handleApiAppliesStagedHeaders: true,
-				serveFilesystemRoute: async (requestPathname, stagedHeaders, phase, resolvedUrl, _request, resolvedPathnameHasBasePath) => {
+				serveFilesystemRoute: async (requestPathname, stagedHeaders, phase, resolvedUrl, filesystemRequest, resolvedPathnameHasBasePath) => {
 					if (resolvedPathnameHasBasePath && isImageOptimizationPath(requestPathname)) {
 						for (const [name, value] of Object.entries(stagedHeaders)) res.setHeader(name, value);
 						const parsedUrl = new URL(resolvedUrl, "http://localhost");
-						const params = parseImageParams(parsedUrl, allowedImageWidths, pagesImageConfig?.qualities);
+						const params = parseImageParams(parsedUrl, allowedImageWidths, pagesImageConfig?.qualities, { localPatterns: pagesImageConfig?.localPatterns });
 						if (!params) {
 							res.writeHead(400);
 							res.end("Bad Request");
@@ -1697,7 +1699,7 @@ async function createPagesRouterRequestHandler(options) {
 						}
 						const sendUnsafeContentType = () => {
 							res.writeHead(400);
-							res.end("The requested resource is not an allowed image type");
+							res.end(IMAGE_TYPE_NOT_ALLOWED_MESSAGE);
 						};
 						const isSafeSourcePath = (sourcePath) => isSafeImageContentType(contentTypeForPath(sourcePath), pagesImageConfig?.dangerouslyAllowSVG);
 						const imageSecurityHeaders = {
@@ -1705,7 +1707,7 @@ async function createPagesRouterRequestHandler(options) {
 							"X-Content-Type-Options": "nosniff",
 							"Content-Disposition": pagesImageConfig?.contentDispositionType === "attachment" ? "attachment" : "inline"
 						};
-						const serveSource = (sourcePath) => tryServeStatic(req, res, clientDir, sourcePath, false, staticCache, withImageSourceCacheControl(imageSecurityHeaders, sourcePath), void 0, IMAGE_REPRESENTATION_HEADERS);
+						const serveSource = (sourcePath, publicFileCacheControl) => tryServeStatic(req, res, clientDir, sourcePath, false, staticCache, withImageSourceCacheControl(imageSecurityHeaders, publicFileCacheControl, pagesImageConfig), void 0, IMAGE_REPRESENTATION_HEADERS);
 						const sourceUrl = new URL(params.imageUrl, webRequest.url);
 						let sourcePathname = null;
 						try {
@@ -1715,22 +1717,22 @@ async function createPagesRouterRequestHandler(options) {
 							sendUnsafeContentType();
 							return true;
 						}
-						const assetLookupPath = sourcePathname !== null ? resolveAppRouterAssetPath(sourcePathname, pagesAssetPathPrefix, assetPrefix) : null;
+						const assetLookupPath = sourcePathname !== null ? resolveAppRouterAssetPath(sourcePathname, pagesAssetPathPrefix, assetPrefix) ?? resolveClientBuildFile(sourceUrl.pathname, basePath, clientBuildFiles) : null;
 						if (assetLookupPath && await serveSource(assetLookupPath)) return true;
-						const sourcePath = sourcePathname !== null ? await resolvePublicImageSource(sourceUrl) : null;
+						const source = sourcePathname !== null ? await resolvePublicImageSource(sourceUrl) : null;
 						if (webRequest.signal.aborted) return true;
-						if (sourcePath !== null) {
-							if (!isSafeSourcePath(staticCacheLookupPath(sourcePath) ?? sourcePath)) {
+						if (source !== null) {
+							if (!isSafeSourcePath(staticCacheLookupPath(source.path) ?? source.path)) {
 								sendUnsafeContentType();
 								return true;
 							}
-							if (await serveSource(sourcePath)) return true;
+							if (await serveSource(source.path, source.cacheControl)) return true;
 						}
 						res.writeHead(400);
 						res.end(INVALID_IMAGE_SOURCE_MESSAGE);
 						return true;
 					}
-					if (!resolvedPathnameHasBasePath && !isAssetPrefixBuildAsset(requestPathname, pagesAssetPathPrefix) || isPagesFilesystemExcludedPath(requestPathname, phase)) return false;
+					if (!isServableFilesystemRoute(requestPathname, phase, filesystemRequest.method, publicFiles, basePath, pagesAssetPathPrefix, resolvedPathnameHasBasePath)) return false;
 					return tryServeStatic(req, res, clientDir, requestPathname, compress, staticCache, stagedHeaders);
 				}
 			};
@@ -1750,7 +1752,7 @@ async function createPagesRouterRequestHandler(options) {
 				}
 				const responseBody = await bufferResponseBodyUntilAborted(response, webRequest.signal);
 				if (!responseBody) return;
-				const ct = response.headers.get("content-type") ?? result.defaultContentType;
+				const ct = response.headers.get("content-type") ?? (responseBody.length > 0 ? result.defaultContentType : void 0);
 				const responseHeaders = {};
 				response.headers.forEach((v, k) => {
 					if (k === "set-cookie") return;

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

@@ -16,6 +16,11 @@ import { getRepeatedSlashRedirect, isOpenRedirectShaped, sendRepeatedSlashRedire
 export declare function canonicalizeRequestPathname(pathname: string): string;
 /** Canonicalize only the pathname portion while preserving the raw query. */
 export declare function canonicalizeRequestUrlPathname(url: string): string;
+/**
+ * Whether the pathname has a segment the URL parser resolves as `.` or `..`,
+ * literally or percent-encoded. Such a pathname changes when it becomes a URL.
+ */
+export declare function hasUrlParserDotSegment(pathname: string): boolean;
 /**
  * Shared request pipeline utilities.
  *