vinext 0.0.38 → 0.0.40

package/dist/server/prod-server.js

@@ -3,16 +3,18 @@ import { applyMiddlewareRequestHeaders, isExternalUrl, matchHeaders, matchRedire
 import { normalizePath } from "./normalize-path.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { manifestFileWithBase } from "../utils/manifest-paths.js";
+import { CONTENT_TYPES, StaticFileCache, etagFromFilenameHash } from "./static-file-cache.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isSafeImageContentType, parseImageParams } from "./image-optimization.js";
+import { computeLazyChunks } from "../utils/lazy-chunks.js";
 import { readPrerenderSecret } from "../build/server-manifest.js";
 import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
-import { computeLazyChunks } from "../index.js";
 import fs from "node:fs";
 import path from "node:path";
+import fsp from "node:fs/promises";
 import { pathToFileURL } from "node:url";
+import zlib from "node:zlib";
 import { createServer } from "node:http";
 import { Readable, pipeline } from "node:stream";
-import zlib from "node:zlib";
 //#region src/server/prod-server.ts
 /**
 * Production server for vinext.
@@ -21,7 +23,7 @@ import zlib from "node:zlib";
 * - Static asset serving from client build output
 * - Pages Router: SSR rendering + API route handling
 * - App Router: RSC/SSR rendering, route handlers, server actions
-* - Gzip/Brotli compression for text-based responses
+* - Zstd/Brotli/Gzip compression for text-based responses
 * - Streaming SSR for App Router
 *
 * Build output for Pages Router:
@@ -62,12 +64,18 @@ const COMPRESSIBLE_TYPES = new Set([
 const COMPRESS_THRESHOLD = 1024;
 /**
 * Parse the Accept-Encoding header and return the best supported encoding.
-* Preference order: br > gzip > deflate > identity.
+* Preference order: zstd > br > gzip > deflate > identity.
+*
+* zstd decompresses ~3-5x faster than brotli at similar compression ratios.
+* Supported in Chrome 123+, Firefox 126+. Safari can decompress but doesn't
+* send zstd in Accept-Encoding, so it transparently falls back to br/gzip.
 */
+const HAS_ZSTD = typeof zlib.createZstdCompress === "function";
 function negotiateEncoding(req) {
 	const accept = req.headers["accept-encoding"];
 	if (!accept || typeof accept !== "string") return null;
 	const lower = accept.toLowerCase();
+	if (HAS_ZSTD && lower.includes("zstd")) return "zstd";
 	if (lower.includes("br")) return "br";
 	if (lower.includes("gzip")) return "gzip";
 	if (lower.includes("deflate")) return "deflate";
@@ -78,6 +86,10 @@ function negotiateEncoding(req) {
 */
 function createCompressor(encoding, mode = "default") {
 	switch (encoding) {
+		case "zstd": return zlib.createZstdCompress({
+			...mode === "streaming" ? { flush: zlib.constants.ZSTD_e_flush } : {},
+			params: { [zlib.constants.ZSTD_c_compressionLevel]: 3 }
+		});
 		case "br": return zlib.createBrotliCompress({
 			...mode === "streaming" ? { flush: zlib.constants.BROTLI_OPERATION_FLUSH } : {},
 			params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 4 }
@@ -134,6 +146,11 @@ function omitHeadersCaseInsensitive(headersRecord, names) {
 	}
 	return filtered;
 }
+function matchesIfNoneMatchHeader(ifNoneMatch, etag) {
+	if (!ifNoneMatch) return false;
+	if (ifNoneMatch === "*") return true;
+	return ifNoneMatch.split(",").map((value) => value.trim()).some((value) => value === etag);
+}
 function stripHeaders(headersRecord, names) {
 	const targets = new Set(names.map((name) => name.toLowerCase()));
 	for (const key of Object.keys(headersRecord)) if (targets.has(key.toLowerCase())) delete headersRecord[key];
@@ -220,33 +237,67 @@ function sendCompressed(req, res, body, contentType, statusCode, extraHeaders =
 		res.end(buf);
 	}
 }
-/** Content-type lookup for static assets. */
-const CONTENT_TYPES = {
-	".js": "application/javascript",
-	".mjs": "application/javascript",
-	".css": "text/css",
-	".html": "text/html",
-	".json": "application/json",
-	".png": "image/png",
-	".jpg": "image/jpeg",
-	".jpeg": "image/jpeg",
-	".gif": "image/gif",
-	".svg": "image/svg+xml",
-	".ico": "image/x-icon",
-	".woff": "font/woff",
-	".woff2": "font/woff2",
-	".ttf": "font/ttf",
-	".eot": "application/vnd.ms-fontobject",
-	".webp": "image/webp",
-	".avif": "image/avif",
-	".map": "application/json",
-	".rsc": "text/x-component"
-};
 /**
 * Try to serve a static file from the client build directory.
-* Returns true if the file was served, false otherwise.
+*
+* When a `StaticFileCache` is provided, lookups are pure in-memory Map.get()
+* with zero filesystem calls. Precompressed .br/.gz/.zst variants (generated at
+* build time) are served directly — no per-request compression needed for
+* hashed assets.
+*
+* Without a cache, falls back to async filesystem probing (still non-blocking,
+* unlike the old sync existsSync/statSync approach).
 */
-function tryServeStatic(req, res, clientDir, pathname, compress, extraHeaders) {
+async function tryServeStatic(req, res, clientDir, pathname, compress, cache, extraHeaders, statusCode) {
+	if (pathname === "/") return false;
+	const responseStatus = statusCode ?? 200;
+	const omitBody = isNoBodyResponseStatus(responseStatus);
+	if (cache) {
+		let lookupPath;
+		if (pathname.includes("%")) {
+			try {
+				lookupPath = decodeURIComponent(pathname);
+			} catch {
+				return false;
+			}
+			if (lookupPath.startsWith("/.vite/") || lookupPath === "/.vite") return false;
+		} else {
+			if (pathname.startsWith("/.vite/") || pathname === "/.vite") return false;
+			lookupPath = pathname;
+		}
+		const entry = cache.lookup(lookupPath);
+		if (!entry) return false;
+		const ifNoneMatch = req.headers["if-none-match"];
+		if (responseStatus === 200 && typeof ifNoneMatch === "string" && matchesIfNoneMatchHeader(ifNoneMatch, entry.etag)) {
+			if (extraHeaders) res.writeHead(304, {
+				...entry.notModifiedHeaders,
+				...extraHeaders
+			});
+			else res.writeHead(304, entry.notModifiedHeaders);
+			res.end();
+			return true;
+		}
+		const rawAe = compress ? req.headers["accept-encoding"] : void 0;
+		const ae = typeof rawAe === "string" ? rawAe.toLowerCase() : void 0;
+		const variant = ae ? ae.includes("zstd") && entry.zst || ae.includes("br") && entry.br || ae.includes("gzip") && entry.gz || entry.original : entry.original;
+		if (extraHeaders) res.writeHead(responseStatus, {
+			...variant.headers,
+			...extraHeaders
+		});
+		else res.writeHead(responseStatus, variant.headers);
+		if (omitBody || req.method === "HEAD") {
+			res.end();
+			return true;
+		}
+		if (variant.buffer) res.end(variant.buffer);
+		else pipeline(fs.createReadStream(variant.path), res, (err) => {
+			if (err) {
+				console.warn(`[vinext] Static file stream error for ${variant.path}:`, err.message);
+				res.destroy(err);
+			}
+		});
+		return true;
+	}
 	const resolvedClient = path.resolve(clientDir);
 	let decodedPathname;
 	try {
@@ -257,44 +308,110 @@ function tryServeStatic(req, res, clientDir, pathname, compress, extraHeaders) {
 	if (decodedPathname.startsWith("/.vite/") || decodedPathname === "/.vite") return false;
 	const staticFile = path.resolve(clientDir, "." + decodedPathname);
 	if (!staticFile.startsWith(resolvedClient + path.sep) && staticFile !== resolvedClient) return false;
-	let resolvedStaticFile = staticFile;
-	if (pathname === "/") return false;
-	if (!fs.existsSync(resolvedStaticFile) || !fs.statSync(resolvedStaticFile).isFile()) {
-		const htmlFallback = staticFile + ".html";
-		if (fs.existsSync(htmlFallback) && fs.statSync(htmlFallback).isFile()) resolvedStaticFile = htmlFallback;
-		else {
-			const indexFallback = path.join(staticFile, "index.html");
-			if (fs.existsSync(indexFallback) && fs.statSync(indexFallback).isFile()) resolvedStaticFile = indexFallback;
-			else return false;
-		}
+	const resolved = await resolveStaticFile(staticFile);
+	if (!resolved) return false;
+	const ext = path.extname(resolved.path);
+	const ct = CONTENT_TYPES[ext] ?? "application/octet-stream";
+	const isHashed = pathname.startsWith("/assets/");
+	const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600";
+	const etag = isHashed && etagFromFilenameHash(resolved.path, ext) || `W/"${resolved.size}-${Math.floor(resolved.mtimeMs / 1e3)}"`;
+	const baseType = ct.split(";")[0].trim();
+	const isCompressible = compress && COMPRESSIBLE_TYPES.has(baseType);
+	const ifNoneMatch = req.headers["if-none-match"];
+	if (responseStatus === 200 && typeof ifNoneMatch === "string" && matchesIfNoneMatchHeader(ifNoneMatch, etag)) {
+		const notModifiedHeaders = {
+			ETag: etag,
+			"Cache-Control": cacheControl,
+			...isCompressible ? { Vary: "Accept-Encoding" } : void 0,
+			...extraHeaders
+		};
+		res.writeHead(304, notModifiedHeaders);
+		res.end();
+		return true;
 	}
-	const ct = CONTENT_TYPES[path.extname(resolvedStaticFile)] ?? "application/octet-stream";
-	const cacheControl = pathname.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "public, max-age=3600";
 	const baseHeaders = {
 		"Content-Type": ct,
 		"Cache-Control": cacheControl,
+		ETag: etag,
 		...extraHeaders
 	};
-	const baseType = ct.split(";")[0].trim();
-	if (compress && COMPRESSIBLE_TYPES.has(baseType)) {
+	if (isCompressible) {
 		const encoding = negotiateEncoding(req);
 		if (encoding) {
-			const fileStream = fs.createReadStream(resolvedStaticFile);
-			const compressor = createCompressor(encoding);
-			res.writeHead(200, {
+			res.writeHead(responseStatus, {
 				...baseHeaders,
 				"Content-Encoding": encoding,
 				Vary: "Accept-Encoding"
 			});
-			pipeline(fileStream, compressor, res, () => {});
+			if (omitBody || req.method === "HEAD") {
+				res.end();
+				return true;
+			}
+			const compressor = createCompressor(encoding);
+			pipeline(fs.createReadStream(resolved.path), compressor, res, (err) => {
+				if (err) {
+					console.warn(`[vinext] Static file stream error for ${resolved.path}:`, err.message);
+					res.destroy(err);
+				}
+			});
 			return true;
 		}
 	}
-	res.writeHead(200, baseHeaders);
-	fs.createReadStream(resolvedStaticFile).pipe(res);
+	res.writeHead(responseStatus, {
+		...baseHeaders,
+		"Content-Length": String(resolved.size)
+	});
+	if (omitBody || req.method === "HEAD") {
+		res.end();
+		return true;
+	}
+	pipeline(fs.createReadStream(resolved.path), res, (err) => {
+		if (err) {
+			console.warn(`[vinext] Static file stream error for ${resolved.path}:`, err.message);
+			res.destroy(err);
+		}
+	});
 	return true;
 }
 /**
+* Resolve the actual file to serve, trying extension-less HTML fallbacks.
+* Returns the resolved path + size + mtime, or null if not found.
+*/
+async function resolveStaticFile(staticFile) {
+	const stat = await statIfFile(staticFile);
+	if (stat) return {
+		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;
+}
+async function statIfFile(filePath) {
+	try {
+		const stat = await fsp.stat(filePath);
+		return stat.isFile() ? {
+			size: stat.size,
+			mtimeMs: stat.mtimeMs
+		} : null;
+	} catch {
+		return null;
+	}
+}
+/**
 * Resolve the host for a request, ignoring X-Forwarded-Host to prevent
 * host header poisoning attacks (open redirects, cache poisoning).
 *
@@ -479,6 +596,7 @@ async function startAppRouterServer(options) {
 	const rscHandler = resolveAppRouterHandler((await import(`${pathToFileURL(rscEntryPath).href}?t=${rscMtime}`)).default);
 	const seededRoutes = await seedMemoryCacheFromPrerender(path.dirname(rscEntryPath));
 	if (seededRoutes > 0) console.log(`[vinext] Seeded ${seededRoutes} pre-rendered route${seededRoutes !== 1 ? "s" : ""} into memory cache`);
+	const staticCache = await StaticFileCache.create(clientDir);
 	const server = createServer(async (req, res) => {
 		const rawUrl = req.url ?? "/";
 		const rawPathname = rawUrl.split("?")[0].replaceAll("\\", "/");
@@ -503,7 +621,7 @@ async function startAppRouterServer(options) {
 				return;
 			}
 		}
-		if (pathname.startsWith("/assets/") && tryServeStatic(req, res, clientDir, pathname, compress)) return;
+		if (pathname.startsWith("/assets/") && await tryServeStatic(req, res, clientDir, pathname, compress, staticCache)) return;
 		if (pathname === "/_vinext/image") {
 			const params = parseImageParams(new URL(rawUrl, "http://localhost"), [...DEFAULT_DEVICE_SIZES, ...DEFAULT_IMAGE_SIZES]);
 			if (!params) {
@@ -521,14 +639,38 @@ async function startAppRouterServer(options) {
 				"X-Content-Type-Options": "nosniff",
 				"Content-Disposition": imageConfig?.contentDispositionType === "attachment" ? "attachment" : "inline"
 			};
-			if (tryServeStatic(req, res, clientDir, params.imageUrl, false, imageSecurityHeaders)) return;
+			if (await tryServeStatic(req, res, clientDir, params.imageUrl, false, staticCache, imageSecurityHeaders)) return;
 			res.writeHead(404);
 			res.end("Image not found");
 			return;
 		}
 		try {
 			const qs = rawUrl.includes("?") ? rawUrl.slice(rawUrl.indexOf("?")) : "";
-			await sendWebResponse(await rscHandler(nodeToWebRequest(req, pathname + qs)), req, res, compress);
+			const response = await rscHandler(nodeToWebRequest(req, pathname + qs));
+			const staticFileSignal = response.headers.get("x-vinext-static-file");
+			if (staticFileSignal) {
+				let staticFilePath = "/";
+				try {
+					staticFilePath = decodeURIComponent(staticFileSignal);
+				} catch {
+					staticFilePath = staticFileSignal;
+				}
+				const staticResponseHeaders = omitHeadersCaseInsensitive(mergeResponseHeaders({}, response), [
+					"x-vinext-static-file",
+					"content-encoding",
+					"content-length",
+					"content-type"
+				]);
+				const served = await tryServeStatic(req, res, clientDir, staticFilePath, compress, staticCache, staticResponseHeaders, response.status);
+				cancelResponseBody(response);
+				if (served) return;
+				await sendWebResponse(new Response("Not Found", {
+					status: 404,
+					headers: toWebHeaders(staticResponseHeaders)
+				}), req, res, compress);
+				return;
+			}
+			await sendWebResponse(response, req, res, compress);
 		} catch (e) {
 			console.error("[vinext] Server error:", e);
 			if (!res.headersSent) {
@@ -590,6 +732,7 @@ async function startPagesRouterServer(options) {
 		const lazyChunks = computeLazyChunks(JSON.parse(fs.readFileSync(buildManifestPath, "utf-8"))).map((file) => manifestFileWithBase(file, assetBase));
 		if (lazyChunks.length > 0) globalThis.__VINEXT_LAZY_CHUNKS__ = lazyChunks;
 	} catch {}
+	const staticCache = await StaticFileCache.create(clientDir);
 	const server = createServer(async (req, res) => {
 		const rawUrl = req.url ?? "/";
 		const rawPagesPathname = rawUrl.split("?")[0].replaceAll("\\", "/");
@@ -640,7 +783,7 @@ async function startPagesRouterServer(options) {
 			return;
 		}
 		const staticLookupPath = stripBasePath(pathname, basePath);
-		if (staticLookupPath.startsWith("/assets/") && tryServeStatic(req, res, clientDir, staticLookupPath, compress)) return;
+		if (staticLookupPath.startsWith("/assets/") && await tryServeStatic(req, res, clientDir, staticLookupPath, compress, staticCache)) return;
 		if (pathname === "/_vinext/image" || staticLookupPath === "/_vinext/image") {
 			const params = parseImageParams(new URL(rawUrl, "http://localhost"), allowedImageWidths);
 			if (!params) {
@@ -658,7 +801,7 @@ async function startPagesRouterServer(options) {
 				"X-Content-Type-Options": "nosniff",
 				"Content-Disposition": pagesImageConfig?.contentDispositionType === "attachment" ? "attachment" : "inline"
 			};
-			if (tryServeStatic(req, res, clientDir, params.imageUrl, false, imageSecurityHeaders)) return;
+			if (await tryServeStatic(req, res, clientDir, params.imageUrl, false, staticCache, imageSecurityHeaders)) return;
 			res.writeHead(404);
 			res.end("Image not found");
 			return;
@@ -769,7 +912,7 @@ async function startPagesRouterServer(options) {
 					else if (!(lk in middlewareHeaders)) middlewareHeaders[lk] = h.value;
 				}
 			}
-			if (staticLookupPath !== "/" && !staticLookupPath.startsWith("/api/") && !staticLookupPath.startsWith("/assets/") && tryServeStatic(req, res, clientDir, staticLookupPath, compress, middlewareHeaders)) return;
+			if (staticLookupPath !== "/" && !staticLookupPath.startsWith("/api/") && !staticLookupPath.startsWith("/assets/") && await tryServeStatic(req, res, clientDir, staticLookupPath, compress, staticCache, middlewareHeaders)) return;
 			if (configRewrites.beforeFiles?.length) {
 				const rewritten = matchRewrite(resolvedPathname, configRewrites.beforeFiles, postMwReqCtx);
 				if (rewritten) {
@@ -861,6 +1004,6 @@ async function startPagesRouterServer(options) {
 	};
 }
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts };
+export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
 
 //# sourceMappingURL=prod-server.js.map