vinext 1.0.0-beta.5 → 1.0.0-beta.6

package/dist/build/prerender-paths.js

@@ -9,6 +9,7 @@ import { BLOCKED_PAGES, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { startProdServer } from "../server/prod-server.js";
+import { enterPrerenderPhase } from "./prerender-phase.js";
 import { buildUrlFromParams, resolveParentParams } from "./prerender.js";
 import fs from "node:fs";
 //#region src/build/prerender-paths.ts
@@ -96,15 +97,13 @@ async function shouldStartPathDiscoveryServer(options) {
 	return false;
 }
 async function withPrerenderEndpoints(fn) {
-	const previousPrerenderFlag = process.env.VINEXT_PRERENDER;
+	const restorePrerenderPhase = enterPrerenderPhase();
 	const previousPathDiscoveryFlag = process.env[PRERENDER_PATH_DISCOVERY_ENV];
-	process.env.VINEXT_PRERENDER = "1";
 	process.env[PRERENDER_PATH_DISCOVERY_ENV] = "1";
 	try {
 		return await fn();
 	} finally {
-		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
-		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
+		restorePrerenderPhase();
 		if (previousPathDiscoveryFlag === void 0) delete process.env[PRERENDER_PATH_DISCOVERY_ENV];
 		else process.env[PRERENDER_PATH_DISCOVERY_ENV] = previousPathDiscoveryFlag;
 	}

package/dist/build/prerender-phase.d.ts

@@ -0,0 +1,15 @@
+//#region src/build/prerender-phase.d.ts
+type PrerenderPhaseEnv = {
+  NEXT_PHASE?: string;
+  NODE_ENV?: string;
+  VINEXT_PRERENDER?: string;
+};
+/**
+ * Enter the same process environment phase that Next.js exposes while its
+ * static workers execute application code. The returned cleanup is nest-safe:
+ * direct prerender helpers can run inside the CLI's broader build scope without
+ * overwriting the caller's prior phase when they finish.
+ */
+declare function enterPrerenderPhase(env?: PrerenderPhaseEnv): () => void;
+//#endregion
+export { enterPrerenderPhase };

package/dist/build/prerender-phase.js

@@ -0,0 +1,37 @@
+import { PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
+//#region src/build/prerender-phase.ts
+const activePrerenderPhases = /* @__PURE__ */ new WeakMap();
+/**
+* Enter the same process environment phase that Next.js exposes while its
+* static workers execute application code. The returned cleanup is nest-safe:
+* direct prerender helpers can run inside the CLI's broader build scope without
+* overwriting the caller's prior phase when they finish.
+*/
+function enterPrerenderPhase(env = process.env) {
+	let state = activePrerenderPhases.get(env);
+	if (state) state.depth += 1;
+	else {
+		state = {
+			depth: 1,
+			previousPrerenderFlag: env.VINEXT_PRERENDER,
+			previousNextPhase: env.NEXT_PHASE
+		};
+		activePrerenderPhases.set(env, state);
+	}
+	let restored = false;
+	env.VINEXT_PRERENDER = "1";
+	env.NEXT_PHASE = PHASE_PRODUCTION_BUILD;
+	return () => {
+		if (restored) return;
+		restored = true;
+		state.depth -= 1;
+		if (state.depth > 0) return;
+		activePrerenderPhases.delete(env);
+		if (state.previousPrerenderFlag === void 0) delete env.VINEXT_PRERENDER;
+		else env.VINEXT_PRERENDER = state.previousPrerenderFlag;
+		if (state.previousNextPhase === void 0) delete env.NEXT_PHASE;
+		else env.NEXT_PHASE = state.previousNextPhase;
+	};
+}
+//#endregion
+export { enterPrerenderPhase };

package/dist/build/prerender-server-entry.js

@@ -11,9 +11,9 @@ import { startProdServer } from "../server/prod-server.js";
 * vinext production server on an ephemeral port and reports it to the parent
 * over IPC. The parent then load-balances per-route fetches across the pool.
 *
-* `VINEXT_PRERENDER` / `VINEXT_PRERENDER_OUTDIR` are passed via the fork env so
-* they are set before any module loads (some server modules read the flag at
-* import time).
+* `VINEXT_PRERENDER` / `NEXT_PHASE` / `VINEXT_PRERENDER_OUTDIR` are passed via
+* the fork env so they are set before any module loads (some server and user
+* modules read the phase at import time).
 */
 async function main() {
 	const outDir = process.env.VINEXT_PRERENDER_OUTDIR;

package/dist/build/prerender-server-pool.js

@@ -1,4 +1,5 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import os from "node:os";
@@ -105,6 +106,7 @@ async function startPrerenderServerPool(outDir, size, entry = WORKER_ENTRY) {
 				env: {
 					...process.env,
 					VINEXT_PRERENDER: "1",
+					NEXT_PHASE: PHASE_PRODUCTION_BUILD,
 					VINEXT_PRERENDER_OUTDIR: outDir
 				},
 				stdio: [

package/dist/build/prerender.d.ts

@@ -27,11 +27,15 @@ type PrerenderRouteResult = {
    */
   path?: string;
   /** Which router produced this route. Used by cache seeding. */
-  router: "app" | "pages";
+  router: "app" | "pages" | "metadata";
   /** Response headers that must be replayed with the prerendered artifact. */
-  headers?: Record<string, string>;
+  headers?: Record<string, string | string[]>;
+  /** Original HTTP status for prerendered App Route-style responses. */
+  responseStatus?: number;
   /** Cache tags collected while rendering this route. */
   tags?: string[];
+  /** Raw app-tree segments used to derive App Route implicit tags. */
+  routeSegments?: string[];
   /** Set to true when this is a PPR fallback shell. */
   fallback?: boolean;
 } | {

package/dist/build/prerender.js

@@ -1,7 +1,7 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-matcher.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
-import { NEXT_CACHE_TAGS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER } from "../server/headers.js";
+import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH } from "../server/headers.js";
 import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from "./report.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
 import { NoOpCacheHandler, getCacheHandler, setCacheHandler } from "../shims/cache-handler.js";
@@ -15,9 +15,12 @@ import { navigationRuntimeRscBootstrapExpression } from "../server/app-ssr-strea
 import { encodePrerenderRouteParams, serializePrerenderRouteParamsHeader } from "../server/prerender-route-params.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { createAppPprFallbackShells, markAppPprDynamicFallbackShellHtml } from "../server/app-ppr-fallback-shell.js";
-import { getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
+import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
 import { startProdServer } from "../server/prod-server.js";
 import { prerenderPoolAvailable, resolvePrerenderPoolSize, startPrerenderServerPool } from "./prerender-server-pool.js";
+import { enterPrerenderPhase } from "./prerender-phase.js";
+import { buildAppRouteCacheValue } from "../server/app-route-handler-response.js";
+import { isMetadataResponseCacheable } from "../server/metadata-route-cache-policy.js";
 import fs from "node:fs";
 import os from "node:os";
 //#region src/build/prerender.ts
@@ -265,8 +268,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 	});
 	const previousHandler = getCacheHandler();
 	setCacheHandler(new NoOpCacheHandler());
-	const previousPrerenderFlag = process.env.VINEXT_PRERENDER;
-	process.env.VINEXT_PRERENDER = "1";
+	const restorePrerenderPhase = enterPrerenderPhase();
 	let ownedProdServerHandle = null;
 	let renderPool = null;
 	try {
@@ -497,11 +499,13 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 		});
 		return { routes: results };
 	} finally {
-		if (renderPool) await renderPool.close();
-		setCacheHandler(previousHandler);
-		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
-		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
-		if (ownedProdServerHandle) await new Promise((resolve) => ownedProdServerHandle.server.close(() => resolve()));
+		try {
+			if (renderPool) await renderPool.close();
+			setCacheHandler(previousHandler);
+			if (ownedProdServerHandle) await new Promise((resolve) => ownedProdServerHandle.server.close(() => resolve()));
+		} finally {
+			restorePrerenderPhase();
+		}
 	}
 }
 /**
@@ -530,8 +534,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 	fs.mkdirSync(outDir, { recursive: true });
 	const previousHandler = getCacheHandler();
 	setCacheHandler(new NoOpCacheHandler());
-	const previousPrerenderFlag = process.env.VINEXT_PRERENDER;
-	process.env.VINEXT_PRERENDER = "1";
+	const restorePrerenderPhase = enterPrerenderPhase();
 	const serverDir = path.dirname(rscBundlePath);
 	let rscHandler;
 	let staticParamsMap = {};
@@ -743,14 +746,83 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				isSpeculative: false
 			});
 		}
+		if (metadataRoutes.length > 0) {
+			const response = await fetch(`${baseUrl}${VINEXT_PRERENDER_METADATA_ROUTES_PATH}`, { headers: secretHeaders });
+			const text = await response.text();
+			if (!response.ok) throw new Error(`[vinext] Failed to enumerate prerenderable metadata routes: ${parsePrerenderEndpointError(text)}`);
+			const metadataEntries = JSON.parse(text);
+			if (!Array.isArray(metadataEntries)) throw new Error("[vinext] Invalid prerender metadata route response");
+			const queuedMetadataPaths = /* @__PURE__ */ new Set();
+			for (const metadataEntry of metadataEntries) {
+				if (typeof metadataEntry !== "object" || metadataEntry === null || typeof Reflect.get(metadataEntry, "path") !== "string" || typeof Reflect.get(metadataEntry, "routePattern") !== "string" || !Array.isArray(Reflect.get(metadataEntry, "routeSegments"))) continue;
+				const { path: metadataPath, routePattern, routeSegments } = metadataEntry;
+				if (!metadataPath.startsWith("/") || !routePattern.startsWith("/") || routeSegments.some((segment) => typeof segment !== "string") || queuedMetadataPaths.has(metadataPath)) continue;
+				queuedMetadataPaths.add(metadataPath);
+				urlsToRender.push({
+					kind: "metadata",
+					metadataRouteSegments: routeSegments,
+					urlPath: metadataPath,
+					routePattern,
+					prerenderRouteParams: null,
+					revalidate: false,
+					isSpeculative: false
+				});
+			}
+		}
 		/**
 		* Render a single URL and return its result.
 		* `onProgress` is intentionally not called here; the outer loop calls it
 		* exactly once per URL after this function returns, keeping the callback
 		* at a single, predictable call site.
 		*/
-		async function renderUrl({ urlPath, routePattern, prerenderRouteParams, revalidate, isSpeculative, isFallback }) {
+		async function renderUrl({ kind, metadataRouteSegments, urlPath, routePattern, prerenderRouteParams, revalidate, isSpeculative, isFallback }) {
 			try {
+				if (kind === "metadata") {
+					const request = new Request(`http://localhost${config.basePath ?? ""}${urlPath}`);
+					const response = await runWithHeadersContext(headersContextFromRequest(request), () => rscHandler(request));
+					if (!response.ok) {
+						await response.body?.cancel();
+						return {
+							route: routePattern,
+							status: "error",
+							error: `Metadata route returned ${response.status}`
+						};
+					}
+					const cacheControl = response.headers.get("cache-control") ?? "";
+					if (!isMetadataResponseCacheable(response)) {
+						await response.body?.cancel();
+						return {
+							route: routePattern,
+							status: "skipped",
+							reason: "dynamic"
+						};
+					}
+					const requestCacheLife = readPrerenderCacheLifeHeader(response.headers);
+					const collectedTags = readPrerenderCacheTagsHeader(response.headers);
+					const cacheValue = await buildAppRouteCacheValue(response);
+					cacheValue.headers[VINEXT_METADATA_ROUTE_CACHE_HEADER] = "1";
+					const outputPath = getAppRouteOutputPath(urlPath);
+					const fullPath = path.join(outDir, outputPath);
+					fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+					fs.writeFileSync(fullPath, new Uint8Array(cacheValue.body));
+					const renderedCacheControl = resolveRenderedCacheControl(requestCacheLife ?? {}, cacheControl, config.expireTime);
+					const renderedRevalidate = renderedCacheControl.revalidate ?? false;
+					const renderedStale = resolveClientStaleTimeSeconds(requestCacheLife ?? void 0);
+					return {
+						route: routePattern,
+						...urlPath === routePattern ? {} : { path: urlPath },
+						status: "rendered",
+						outputFiles: [outputPath],
+						revalidate: renderedRevalidate,
+						...typeof renderedRevalidate === "number" ? { expire: renderedCacheControl.expire } : {},
+						...renderedStale === void 0 ? {} : { stale: renderedStale },
+						router: "metadata",
+						headers: cacheValue.headers,
+						responseStatus: cacheValue.status,
+						routeSegments: metadataRouteSegments ?? [],
+						tags: collectedTags
+					};
+				}
 				const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParams);
 				const htmlHeaders = new Headers();
 				if (prerenderRouteParamsHeader !== null) htmlHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
@@ -919,11 +991,13 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 			...outputFiles.length > 0 ? { outputFiles } : {}
 		};
 	} finally {
-		if (renderPool) await renderPool.close();
-		setCacheHandler(previousHandler);
-		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
-		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
-		if (ownedProdServerHandle) await new Promise((resolve) => ownedProdServerHandle.server.close(() => resolve()));
+		try {
+			if (renderPool) await renderPool.close();
+			setCacheHandler(previousHandler);
+			if (ownedProdServerHandle) await new Promise((resolve) => ownedProdServerHandle.server.close(() => resolve()));
+		} finally {
+			restorePrerenderPhase();
+		}
 	}
 }
 function resolveRenderedCacheControl(requestCacheLife, cacheControl, fallbackExpireSeconds) {
@@ -991,7 +1065,9 @@ function writePrerenderIndex(routes, outDir, options) {
 			...typeof r.stale === "number" ? { stale: r.stale } : {},
 			router: r.router,
 			...r.tags && r.tags.length > 0 ? { tags: r.tags } : {},
+			...r.routeSegments ? { routeSegments: r.routeSegments } : {},
 			...r.headers ? { headers: r.headers } : {},
+			...typeof r.responseStatus === "number" ? { responseStatus: r.responseStatus } : {},
 			...r.path ? { path: r.path } : {},
 			...r.fallback ? { fallback: true } : {}
 		};

package/dist/build/run-prerender.js

@@ -3,9 +3,11 @@ import { findDir } from "../utils/project.js";
 import { apiRouter, pagesRouter } from "../routing/pages-router.js";
 import { appRouter } from "../routing/app-router.js";
 import { scanMetadataFiles } from "../server/metadata-routes.js";
+import { PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { rememberCurrentServerEntryImportMtime, startProdServer } from "../server/prod-server.js";
+import { enterPrerenderPhase } from "./prerender-phase.js";
 import { prerenderApp, prerenderPages, writePrerenderIndex } from "./prerender.js";
 import { injectPregeneratedConcretePaths } from "./inject-pregenerated-paths.js";
 import fs from "node:fs";
@@ -104,12 +106,10 @@ async function runPrerender(options) {
 	const appDir = findDir(root, "app", "src/app");
 	const pagesDir = findDir(root, "pages", "src/pages");
 	if (!appDir && !pagesDir) return null;
-	const previousPrerenderFlag = process.env.VINEXT_PRERENDER;
-	process.env.VINEXT_PRERENDER = "1";
 	const manifestDir = path.join(root, "dist", "server");
 	const rscBundlePath = options.rscBundlePath ?? path.join(root, "dist", "server", "index.js");
 	const serverDir = path.dirname(rscBundlePath);
-	const config = options.nextConfig ? { ...options.nextConfig } : { ...await resolveNextConfig(await loadNextConfig(root), root) };
+	const config = options.nextConfig ? { ...options.nextConfig } : { ...await resolveNextConfig(await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root) };
 	const builtBuildId = readBuiltBuildId(serverDir);
 	if (builtBuildId) config.buildId = builtBuildId;
 	const mode = config.output === "export" ? "export" : "default";
@@ -121,6 +121,7 @@ async function runPrerender(options) {
 	const outDir = mode === "export" ? path.join(root, "dist", "client") : path.join(root, "dist", "server", "prerendered-routes");
 	let sharedProdServer = null;
 	let sharedPrerenderSecret;
+	const restorePrerenderPhase = enterPrerenderPhase();
 	try {
 		if (appDir && pagesDir) {
 			sharedProdServer = await startProdServer({
@@ -187,9 +188,11 @@ async function runPrerender(options) {
 			if (result.outputFiles) allOutputFiles.push(...result.outputFiles);
 		}
 	} finally {
-		if (sharedProdServer) await new Promise((resolve) => sharedProdServer.server.close(() => resolve()));
-		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
-		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
+		try {
+			if (sharedProdServer) await new Promise((resolve) => sharedProdServer.server.close(() => resolve()));
+		} finally {
+			restorePrerenderPhase();
+		}
 	}
 	if (allRoutes.length === 0) {
 		progress.finish(0, 0, 0);

package/dist/client/vinext-next-data.d.ts

@@ -6,6 +6,8 @@ type VinextLinkPrefetchRoute = {
   isDynamic: boolean;
   patternParts: string[];
   requiresDynamicNavigationRequest?: boolean;
+  /** The route has dynamic params above its root layout. */
+  hasRootParams?: true;
 };
 /**
  * Pages Router route pattern exposed to the client so the App Router's

package/dist/config/next-config.js

@@ -332,7 +332,11 @@ async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 	const normalizedConfigPath = safeRealpath(path.resolve(configPath));
 	try {
 		const { runnerImport } = await import("vite");
-		const { module: mod } = await runnerImport(configPath, {
+		const virtualConfigId = "virtual:vinext-resolved-next-config";
+		const resolvedVirtualConfigId = `\0${virtualConfigId}`;
+		const configPathLiteral = JSON.stringify(configPath);
+		const phaseLiteral = JSON.stringify(phase);
+		const { module: mod } = await runnerImport(virtualConfigId, {
 			root,
 			logLevel: "error",
 			clearScreen: false,
@@ -351,13 +355,26 @@ async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 					".json"
 				]
 			},
-			plugins: [...isTypeScriptConfig ? [cjsGlobalsInjectorPlugin(configPath)] : [], commonjs({ filter: (id) => {
-				const idPath = id.startsWith("file://") ? fileURLToPath(id) : id.split("?")[0];
-				if (safeRealpath(path.resolve(idPath)) === normalizedConfigPath) return false;
-				return id.includes("node_modules") ? true : void 0;
-			} })]
+			plugins: [
+				{
+					name: "vinext:resolve-next-config-value",
+					resolveId(id) {
+						if (id === virtualConfigId) return resolvedVirtualConfigId;
+					},
+					load(id) {
+						if (id !== resolvedVirtualConfigId) return;
+						return `import * as configModule from ${configPathLiteral};\nconst cjsModule = configModule[${JSON.stringify(VINEXT_CJS_EXPORTS_KEY)}];\nconst cjsInitial = configModule[${JSON.stringify(VINEXT_CJS_INITIAL_KEY)}];\nconst cjsExports = cjsModule && cjsModule.exports;\nconst cjsValue = cjsExports != null && (cjsExports !== cjsInitial || (typeof cjsExports === "object" && Object.keys(cjsExports).length > 0)) ? cjsExports : undefined;\nconst value = cjsValue ?? configModule.default ?? configModule;\nexport default typeof value === "function" ? await value(${phaseLiteral}, { defaultConfig: {} }) : value;\n`;
+					}
+				},
+				...isTypeScriptConfig ? [cjsGlobalsInjectorPlugin(configPath)] : [],
+				commonjs({ filter: (id) => {
+					const idPath = id.startsWith("file://") ? fileURLToPath(id) : id.split("?")[0];
+					if (safeRealpath(path.resolve(idPath)) === normalizedConfigPath) return false;
+					return id.includes("node_modules") ? true : void 0;
+				} })
+			]
 		});
-		return await unwrapConfig(mod, phase);
+		return mod.default;
 	} catch (e) {
 		if (isCjsError(e) && (filename.endsWith(".js") || filename.endsWith(".cjs"))) try {
 			return await loadConfigViaRequire(configPath, root, phase);