vinext 0.2.1 → 1.0.0-beta.1

package/dist/build/module-dependency-cache.js

@@ -0,0 +1,13 @@
+//#region src/build/module-dependency-cache.ts
+function createModuleDependencyCache(collect) {
+	const cache = /* @__PURE__ */ new Map();
+	return function getModuleDependencies(moduleId) {
+		const cached = cache.get(moduleId);
+		if (cached) return cached;
+		const pending = collect(moduleId);
+		cache.set(moduleId, pending);
+		return pending;
+	};
+}
+//#endregion
+export { createModuleDependencyCache };

package/dist/build/next-client-runtime-manifests.js

@@ -1,5 +1,5 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/build/next-client-runtime-manifests.ts
 function normalizeRewriteForClientManifest(rewrite) {
 	if (rewrite.destination.startsWith("/")) return {

package/dist/build/pages-client-assets-module.js

@@ -1,5 +1,5 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/build/pages-client-assets-module.ts
 const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
 const pagesClientAssetsByBuildSession = /* @__PURE__ */ new Map();

package/dist/build/precompress.js

@@ -1,6 +1,6 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { ASSET_PREFIX_URL_DIR } from "../utils/asset-prefix.js";
-import path from "node:path";
-import fs from "node:fs/promises";
+import fsp from "node:fs/promises";
 import os from "node:os";
 import zlib from "node:zlib";
 import { promisify } from "node:util";
@@ -20,7 +20,7 @@ const brotliCompress = promisify(zlib.brotliCompress);
 const gzip = promisify(zlib.gzip);
 const zstdCompress = typeof zlib.zstdCompress === "function" ? promisify(zlib.zstdCompress) : null;
 /** File extensions worth compressing (text-based, not already compressed). */
-const COMPRESSIBLE_EXTENSIONS = new Set([
+const COMPRESSIBLE_EXTENSIONS = /* @__PURE__ */ new Set([
 	".js",
 	".mjs",
 	".css",
@@ -46,7 +46,7 @@ const CONCURRENCY = Math.min(os.availableParallelism(), 8);
 async function* walkFiles(dir, base = dir) {
 	let entries;
 	try {
-		entries = await fs.readdir(dir, { withFileTypes: true });
+		entries = await fsp.readdir(dir, { withFileTypes: true });
 	} catch {
 		return;
 	}
@@ -89,13 +89,13 @@ async function precompressAssets(clientDir, options = {}) {
 	for (let i = 0; i < filePaths.length; i += CONCURRENCY) {
 		const chunk = filePaths.slice(i, i + CONCURRENCY);
 		await Promise.all(chunk.map(async (fullPath) => {
-			const content = await fs.readFile(fullPath);
+			const content = await fsp.readFile(fullPath);
 			if (content.length < MIN_SIZE) return;
 			const compressions = [brotliCompress(content, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 5 } }), gzip(content, { level: 8 })];
 			if (zstdCompress) compressions.push(zstdCompress(content, { params: { [zlib.constants.ZSTD_c_compressionLevel]: 8 } }));
 			const [brContent, gzContent, zstdContent] = await Promise.all(compressions);
-			const writes = [fs.writeFile(fullPath + ".br", brContent), fs.writeFile(fullPath + ".gz", gzContent)];
-			if (zstdContent) writes.push(fs.writeFile(fullPath + ".zst", zstdContent));
+			const writes = [fsp.writeFile(fullPath + ".br", brContent), fsp.writeFile(fullPath + ".gz", gzContent)];
+			if (zstdContent) writes.push(fsp.writeFile(fullPath + ".zst", zstdContent));
 			await Promise.all(writes);
 			result.filesCompressed++;
 			result.totalOriginalBytes += content.length;

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

@@ -0,0 +1,23 @@
+import { ResolvedNextConfig } from "../config/next-config.js";
+import { VinextRouteRootConfig } from "../config/prerender.js";
+
+//#region src/build/prerender-paths.d.ts
+type PrerenderPathManifest = {
+  buildId?: string;
+  trailingSlash?: boolean;
+  paths: string[];
+};
+declare const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";
+declare const PRERENDER_PATHS_MANIFEST = "vinext-prerender-paths.json";
+type EmitPrerenderPathManifestOptions = {
+  root: string; /** Fully resolved Next.js config. Loaded from disk when omitted. */
+  nextConfig?: ResolvedNextConfig;
+  appDir?: string | null;
+  pagesDir?: string | null;
+  routeRootConfig?: VinextRouteRootConfig | null;
+  pagesBundlePath?: string;
+  rscBundlePath?: string;
+};
+declare function emitPrerenderPathManifest(options: EmitPrerenderPathManifestOptions): Promise<PrerenderPathManifest | null>;
+//#endregion
+export { PRERENDER_PATHS_MANIFEST, PRERENDER_PATH_DISCOVERY_ENV, PrerenderPathManifest, emitPrerenderPathManifest };

package/dist/build/prerender-paths.js

@@ -0,0 +1,291 @@
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { findDir } from "../utils/project.js";
+import { apiRouter, pagesRouter } from "../routing/pages-router.js";
+import { VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
+import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath, hasNamedExport } from "./report.js";
+import { appRouter } from "../routing/app-router.js";
+import { normalizeStaticPathsEntry } from "../routing/route-pattern.js";
+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 { buildUrlFromParams, resolveParentParams } from "./prerender.js";
+import fs from "node:fs";
+//#region src/build/prerender-paths.ts
+const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";
+const PRERENDER_PATHS_MANIFEST = "vinext-prerender-paths.json";
+const PATH_DISCOVERY_FETCH_TIMEOUT_MS = 3e4;
+function readBuiltBuildId(serverDir) {
+	try {
+		const buildId = fs.readFileSync(path.join(serverDir, "BUILD_ID"), "utf-8").trim();
+		return buildId.length > 0 ? buildId : null;
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+function addPath(paths, seen, pathname) {
+	if (seen.has(pathname)) return;
+	seen.add(pathname);
+	paths.push(pathname);
+}
+function warnDiscoveryFailure(route, error) {
+	const message = error instanceof Error ? error.message : String(error);
+	console.warn(`[vinext] Warning: failed to discover warmup path(s) for ${route}: ${message}`);
+}
+async function fetchDiscoveryEndpoint(url, headers) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), PATH_DISCOVERY_FETCH_TIMEOUT_MS);
+	try {
+		const res = await fetch(url, {
+			headers,
+			signal: controller.signal
+		});
+		const text = await res.text();
+		if (!res.ok || text === "null") return null;
+		return text;
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") throw new Error(`path discovery timed out after ${PATH_DISCOVERY_FETCH_TIMEOUT_MS}ms`);
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+function fileHasNamedExport(filePath, name) {
+	if (!filePath) return false;
+	try {
+		return hasNamedExport(fs.readFileSync(filePath, "utf-8"), name);
+	} catch {
+		return false;
+	}
+}
+function resolveConfiguredRouteDirs(root, routeRootConfig) {
+	if (!routeRootConfig) return {
+		appDir: findDir(root, "app", "src/app"),
+		pagesDir: findDir(root, "pages", "src/pages")
+	};
+	let baseDir;
+	if (routeRootConfig.appDir) {
+		baseDir = path.isAbsolute(routeRootConfig.appDir) ? routeRootConfig.appDir : path.resolve(root, routeRootConfig.appDir);
+		baseDir = toSlash(baseDir);
+	} else {
+		const hasRootApp = fs.existsSync(path.join(root, "app"));
+		const hasRootPages = fs.existsSync(path.join(root, "pages"));
+		const hasSrcApp = fs.existsSync(path.join(root, "src", "app"));
+		const hasSrcPages = fs.existsSync(path.join(root, "src", "pages"));
+		baseDir = hasRootApp || hasRootPages ? root : hasSrcApp || hasSrcPages ? path.join(root, "src") : root;
+	}
+	const appDir = path.join(baseDir, "app");
+	const pagesDir = path.join(baseDir, "pages");
+	return {
+		appDir: !routeRootConfig.disableAppRouter && fs.existsSync(appDir) ? appDir : null,
+		pagesDir: fs.existsSync(pagesDir) ? pagesDir : null
+	};
+}
+function appRouteMayHaveGenerateStaticParams(route) {
+	if (fileHasNamedExport(route.pagePath, "generateStaticParams")) return true;
+	return route.layouts.some((layoutPath) => fileHasNamedExport(layoutPath, "generateStaticParams"));
+}
+async function shouldStartPathDiscoveryServer(options) {
+	if (options.appDir) {
+		if ((await appRouter(options.appDir, options.pageExtensions)).some((route) => route.isDynamic && appRouteMayHaveGenerateStaticParams(route))) return true;
+	}
+	if (options.pagesDir) {
+		if ((await pagesRouter(options.pagesDir, options.pageExtensions)).some((route) => route.isDynamic && fileHasNamedExport(route.filePath, "getStaticPaths"))) return true;
+	}
+	return false;
+}
+async function withPrerenderEndpoints(fn) {
+	const previousPrerenderFlag = process.env.VINEXT_PRERENDER;
+	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;
+		if (previousPathDiscoveryFlag === void 0) delete process.env[PRERENDER_PATH_DISCOVERY_ENV];
+		else process.env[PRERENDER_PATH_DISCOVERY_ENV] = previousPathDiscoveryFlag;
+	}
+}
+async function collectPagesPaths(options) {
+	const [pageRoutes, apiRoutes] = await Promise.all([pagesRouter(options.pagesDir, options.pageExtensions), apiRouter(options.pagesDir, options.pageExtensions)]);
+	const apiPatterns = new Set(apiRoutes.map((route) => route.pattern));
+	const paths = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const route of pageRoutes) {
+		if (apiPatterns.has(route.pattern)) continue;
+		if (BLOCKED_PAGES.includes(route.pattern)) continue;
+		if (route.pattern === "/404" || route.pattern === "/500" || route.pattern === "/_error") continue;
+		const { type } = classifyPagesRoute(route.filePath);
+		if (type === "api" || type === "ssr") continue;
+		if (!route.isDynamic) {
+			addPath(paths, seen, route.pattern);
+			continue;
+		}
+		if (!fileHasNamedExport(route.filePath, "getStaticPaths")) continue;
+		if (!options.baseUrl) continue;
+		try {
+			const search = new URLSearchParams({ pattern: route.pattern });
+			const text = await fetchDiscoveryEndpoint(`${options.baseUrl}/__vinext/prerender/pages-static-paths?${search}`, options.secretHeaders);
+			if (text === null) continue;
+			const pathsResult = JSON.parse(text);
+			for (const item of pathsResult.paths ?? []) {
+				const normalized = normalizeStaticPathsEntry(item, route.pattern);
+				if ("error" in normalized) throw new Error(normalized.error);
+				addPath(paths, seen, buildUrlFromParams(route.pattern, normalized.params));
+			}
+		} catch (error) {
+			warnDiscoveryFailure(route.pattern, error);
+		}
+	}
+	return paths;
+}
+async function collectAppPaths(options) {
+	const routes = await appRouter(options.appDir, options.pageExtensions);
+	const paths = [];
+	const seen = /* @__PURE__ */ new Set();
+	const staticParamsCache = /* @__PURE__ */ new Map();
+	const staticParamsMap = new Proxy({}, {
+		get(_target, pattern) {
+			return async ({ params }) => {
+				if (!options.baseUrl) return null;
+				const cacheKey = `${pattern}\0${JSON.stringify(params)}`;
+				const cached = staticParamsCache.get(cacheKey);
+				if (cached !== void 0) return cached;
+				const request = (async () => {
+					const search = new URLSearchParams({ pattern });
+					if (Object.keys(params).length > 0) search.set("parentParams", JSON.stringify(params));
+					const text = await fetchDiscoveryEndpoint(`${options.baseUrl}/__vinext/prerender/static-params?${search}`, options.secretHeaders);
+					if (text === null) return null;
+					return JSON.parse(text);
+				})();
+				request.catch(() => staticParamsCache.delete(cacheKey));
+				staticParamsCache.set(cacheKey, request);
+				return request;
+			};
+		},
+		has() {
+			return false;
+		}
+	});
+	for (const route of routes) {
+		const renderEntryPath = getAppRouteRenderEntryPath(route);
+		if (!renderEntryPath) continue;
+		const { type } = classifyAppRoute(renderEntryPath, route.routePath, route.isDynamic);
+		if (type === "api") continue;
+		if (type === "ssr" && !route.isDynamic) continue;
+		if (!route.isDynamic) {
+			addPath(paths, seen, route.pattern);
+			continue;
+		}
+		if (!appRouteMayHaveGenerateStaticParams(route)) continue;
+		try {
+			const generateStaticParams = staticParamsMap[route.pattern];
+			if (typeof generateStaticParams !== "function") continue;
+			const parentParamSets = await resolveParentParams(route, staticParamsMap);
+			let paramSets;
+			if (parentParamSets.length > 0) {
+				paramSets = [];
+				for (const parentParams of parentParamSets) {
+					const childResults = await generateStaticParams({ params: parentParams });
+					if (childResults === null) {
+						paramSets = null;
+						break;
+					}
+					if (Array.isArray(childResults)) for (const childParams of childResults) paramSets.push({
+						...parentParams,
+						...childParams
+					});
+				}
+			} else {
+				const results = await generateStaticParams({ params: {} });
+				paramSets = Array.isArray(results) || results === null ? results : [];
+			}
+			if (!paramSets?.length) continue;
+			for (const params of paramSets) {
+				if (params === null || params === void 0) continue;
+				addPath(paths, seen, buildUrlFromParams(route.pattern, params));
+			}
+		} catch (error) {
+			warnDiscoveryFailure(route.pattern, error);
+		}
+	}
+	return paths;
+}
+async function startPathDiscoveryServer(options) {
+	return startProdServer({
+		port: 0,
+		host: "127.0.0.1",
+		outDir: options.pagesBundlePath ? path.dirname(path.dirname(options.pagesBundlePath)) : path.dirname(options.serverDir),
+		rscEntryPath: options.rscBundlePath,
+		serverEntryPath: options.pagesBundlePath,
+		noCompression: true,
+		purpose: "prerender"
+	});
+}
+async function emitPrerenderPathManifest(options) {
+	const { root } = options;
+	const configuredRouteDirs = resolveConfiguredRouteDirs(root, options.routeRootConfig);
+	const appDir = options.appDir !== void 0 ? options.appDir : configuredRouteDirs.appDir;
+	const pagesDir = options.pagesDir !== void 0 ? options.pagesDir : configuredRouteDirs.pagesDir;
+	if (!appDir && !pagesDir) return null;
+	const defaultRscBundlePath = options.routeRootConfig?.rscOutDir ? path.join(path.resolve(root, options.routeRootConfig.rscOutDir), "index.js") : path.join(root, "dist", "server", "index.js");
+	const rscBundlePath = options.rscBundlePath ?? defaultRscBundlePath;
+	const pagesBundlePath = options.pagesBundlePath ?? path.join(root, "dist", "server", "entry.js");
+	const bundleServerDir = fs.existsSync(rscBundlePath) ? path.dirname(rscBundlePath) : path.dirname(pagesBundlePath);
+	const manifestDir = path.join(root, "dist", "server");
+	const config = options.nextConfig ? { ...options.nextConfig } : { ...await resolveNextConfig(await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root) };
+	const builtBuildId = readBuiltBuildId(manifestDir) ?? readBuiltBuildId(bundleServerDir);
+	if (builtBuildId) config.buildId = builtBuildId;
+	const paths = [];
+	const seen = /* @__PURE__ */ new Set();
+	await withPrerenderEndpoints(async () => {
+		let prodServer = null;
+		if (await shouldStartPathDiscoveryServer({
+			appDir,
+			pagesDir,
+			pageExtensions: config.pageExtensions
+		})) try {
+			prodServer = await startPathDiscoveryServer({
+				serverDir: bundleServerDir,
+				pagesBundlePath: !appDir && pagesDir ? pagesBundlePath : void 0,
+				rscBundlePath: appDir ? rscBundlePath : void 0
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			console.warn(`[vinext] Warning: failed to start prerender path discovery server: ${message}`);
+		}
+		const baseUrl = prodServer ? `http://127.0.0.1:${prodServer.port}` : null;
+		const prerenderSecret = readPrerenderSecret(bundleServerDir) ?? readPrerenderSecret(manifestDir);
+		const secretHeaders = prerenderSecret ? { [VINEXT_PRERENDER_SECRET_HEADER]: prerenderSecret } : {};
+		try {
+			if (appDir) for (const pathname of await collectAppPaths({
+				appDir,
+				baseUrl,
+				pageExtensions: config.pageExtensions,
+				secretHeaders
+			})) addPath(paths, seen, pathname);
+			if (pagesDir) for (const pathname of await collectPagesPaths({
+				baseUrl,
+				pagesDir,
+				pageExtensions: config.pageExtensions,
+				secretHeaders
+			})) addPath(paths, seen, pathname);
+		} finally {
+			if (prodServer) await new Promise((resolve) => prodServer.server.close(() => resolve()));
+		}
+	});
+	const manifest = {
+		buildId: config.buildId,
+		trailingSlash: config.trailingSlash,
+		paths
+	};
+	fs.mkdirSync(manifestDir, { recursive: true });
+	fs.writeFileSync(path.join(manifestDir, PRERENDER_PATHS_MANIFEST), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+	console.log(`  Discovered ${paths.length} CDN warmup path(s).`);
+	return manifest;
+}
+//#endregion
+export { PRERENDER_PATHS_MANIFEST, PRERENDER_PATH_DISCOVERY_ENV, emitPrerenderPathManifest };

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

@@ -1,5 +1,5 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import fs from "node:fs";
-import path from "node:path";
 import { fileURLToPath } from "node:url";
 import os from "node:os";
 import { fork } from "node:child_process";
@@ -50,7 +50,7 @@ const APPROX_BYTES_PER_WORKER = 768 * 1024 * 1024;
 const WORKER_READY_TIMEOUT_MS = 6e4;
 /** Best-effort close timeout so build cleanup is not blocked forever by a wedged child. */
 const WORKER_CLOSE_TIMEOUT_MS = 5e3;
-const PRERENDER_WORKER_TRANSPORT_ERROR_CODES = new Set([
+const PRERENDER_WORKER_TRANSPORT_ERROR_CODES = /* @__PURE__ */ new Set([
 	"ECONNREFUSED",
 	"ECONNRESET",
 	"EPIPE",

package/dist/build/prerender.d.ts

@@ -135,6 +135,17 @@ type PrerenderAppOptionsInternal = PrerenderAppOptions & {
  * all '<' and '>' in the embedded JSON, preventing false </script> matches.
  */
 declare function extractRscPayloadFromPrerenderedHtml(html: string): Uint8Array | null;
+/**
+ * Build a URL path from a route pattern and params.
+ * "/posts/:id" + { id: "42" } → "/posts/42"
+ * "/docs/:slug+" + { slug: ["a", "b"] } → "/docs/a/b"
+ *
+ * Throws a descriptive error rather than a cryptic `Cannot read properties of
+ * undefined` if `params` itself is missing or required keys are absent — the
+ * caller (prerenderPages / prerenderApp) catches this and surfaces it as a
+ * per-route error result.
+ */
+declare function buildUrlFromParams(pattern: string, params: Record<string, string | string[]> | undefined | null): string;
 /** Map of route patterns to generateStaticParams functions (or null/undefined). */
 type StaticParamsMap = Record<string, ((opts: {
   params: Record<string, string | string[]>;
@@ -207,4 +218,4 @@ declare function writePrerenderIndex(routes: PrerenderRouteResult[], outDir: str
   trailingSlash?: boolean;
 }): void;
 //#endregion
-export { PrerenderResult, PrerenderRouteResult, StaticParamsMap, extractRscPayloadFromPrerenderedHtml, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };
+export { PrerenderResult, PrerenderRouteResult, StaticParamsMap, buildUrlFromParams, extractRscPayloadFromPrerenderedHtml, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };

package/dist/build/prerender.js

@@ -1,3 +1,4 @@
+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 { VINEXT_PRERENDER_CACHE_LIFE_HEADER } from "../server/headers.js";
@@ -17,7 +18,6 @@ import { getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths
 import { startProdServer } from "../server/prod-server.js";
 import { prerenderPoolAvailable, resolvePrerenderPoolSize, startPrerenderServerPool } from "./prerender-server-pool.js";
 import fs from "node:fs";
-import path from "node:path";
 import os from "node:os";
 //#region src/build/prerender.ts
 /**
@@ -1000,4 +1000,4 @@ function writePrerenderIndex(routes, outDir, options) {
 	fs.writeFileSync(path.join(outDir, "vinext-prerender.json"), JSON.stringify(index, null, 2), "utf-8");
 }
 //#endregion
-export { extractRscPayloadFromPrerenderedHtml, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };
+export { buildUrlFromParams, extractRscPayloadFromPrerenderedHtml, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };

package/dist/build/preview-credentials.d.ts

@@ -0,0 +1,11 @@
+//#region src/build/preview-credentials.d.ts
+type PreviewBuildCredentials = {
+  id: string;
+  signingKey: string;
+  encryptionKey: string;
+};
+declare function createPreviewBuildCredentials(): PreviewBuildCredentials;
+declare function getPreviewBuildCredentials(): PreviewBuildCredentials | undefined;
+declare function runWithPreviewBuildCredentials<T>(callback: () => T): T;
+//#endregion
+export { PreviewBuildCredentials, createPreviewBuildCredentials, getPreviewBuildCredentials, runWithPreviewBuildCredentials };

package/dist/build/preview-credentials.js

@@ -0,0 +1,19 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes } from "node:crypto";
+//#region src/build/preview-credentials.ts
+const previewBuildCredentialsStorage = new AsyncLocalStorage();
+function createPreviewBuildCredentials() {
+	return {
+		id: randomBytes(16).toString("hex"),
+		signingKey: randomBytes(32).toString("hex"),
+		encryptionKey: randomBytes(32).toString("hex")
+	};
+}
+function getPreviewBuildCredentials() {
+	return previewBuildCredentialsStorage.getStore();
+}
+function runWithPreviewBuildCredentials(callback) {
+	return previewBuildCredentialsStorage.run(createPreviewBuildCredentials(), callback);
+}
+//#endregion
+export { createPreviewBuildCredentials, getPreviewBuildCredentials, runWithPreviewBuildCredentials };

package/dist/build/report.d.ts

@@ -130,9 +130,6 @@ declare function formatBuildReport(rows: RouteRow[], routerLabel?: string): stri
 /**
  * Scans the project at `root`, classifies all routes, and prints the
  * Next.js-style build report to stdout.
- *
- * `root` must be forward-slash — it is passed to `findDir`. The caller (the
- * `vinext build` entry in cli.ts) normalizes it.
  */
 declare function printBuildReport(options: {
   root: string;

package/dist/build/report.js

@@ -1,3 +1,4 @@
+import { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { findDir } from "../utils/project.js";
 import fs from "node:fs";
 import { parseSync } from "vite";
@@ -415,7 +416,7 @@ function classifyLayoutSegmentConfig(code) {
 * API routes (files under pages/api/) are always `api`.
 */
 function classifyPagesRoute(filePath) {
-	if (filePath.replace(/\\/g, "/").includes("/pages/api/")) return { type: "api" };
+	if (toSlash(filePath).includes("/pages/api/")) return { type: "api" };
 	let code;
 	try {
 		code = fs.readFileSync(filePath, "utf8");
@@ -569,9 +570,6 @@ function formatBuildReport(rows, routerLabel = "app") {
 /**
 * Scans the project at `root`, classifies all routes, and prints the
 * Next.js-style build report to stdout.
-*
-* `root` must be forward-slash — it is passed to `findDir`. The caller (the
-* `vinext build` entry in cli.ts) normalizes it.
 */
 async function printBuildReport(options) {
 	const { root } = options;

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

@@ -3,13 +3,8 @@ import { PrerenderResult, PrerenderRouteResult } from "./prerender.js";
 
 //#region src/build/run-prerender.d.ts
 type RunPrerenderOptions = {
-  /** Project root directory. */root: string;
-  /**
-   * Override next.config values. Merged on top of the config loaded from disk.
-   * Intended for tests that need to exercise a specific config (e.g. output: 'export')
-   * without writing a next.config file.
-   */
-  nextConfigOverride?: Partial<ResolvedNextConfig>;
+  /** Project root directory. */root: string; /** Fully resolved Next.js config. Loaded from disk when omitted. */
+  nextConfig?: ResolvedNextConfig;
   /**
    * Override the path to the Pages Router server bundle.
    * Defaults to `<root>/dist/server/entry.js`.
@@ -58,10 +53,6 @@ type RunPrerenderOptions = {
 declare function assertNoFatalPrerenderRoutes(routes: readonly PrerenderRouteResult[]): void;
 /**
  * Statically generate routes and return the prerender result.
- *
- * `options.root` must be forward-slash — it is passed to `findDir` and flows
- * into the route model. The caller (the `vinext build` entry in cli.ts)
- * normalizes it.
  */
 declare function runPrerender(options: RunPrerenderOptions): Promise<PrerenderResult | null>;
 //#endregion

package/dist/build/run-prerender.js

@@ -1,3 +1,4 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { findDir } from "../utils/project.js";
 import { apiRouter, pagesRouter } from "../routing/pages-router.js";
 import { appRouter } from "../routing/app-router.js";
@@ -8,7 +9,6 @@ import { rememberCurrentServerEntryImportMtime, startProdServer } from "../serve
 import { prerenderApp, prerenderPages, writePrerenderIndex } from "./prerender.js";
 import { injectPregeneratedConcretePaths } from "./inject-pregenerated-paths.js";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/build/run-prerender.ts
 /**
 * Shared prerender runner used by both `vinext build` (cli.ts) and
@@ -98,10 +98,6 @@ function assertNoFatalPrerenderRoutes(routes) {
 }
 /**
 * Statically generate routes and return the prerender result.
-*
-* `options.root` must be forward-slash — it is passed to `findDir` and flows
-* into the route model. The caller (the `vinext build` entry in cli.ts)
-* normalizes it.
 */
 async function runPrerender(options) {
 	const { root } = options;
@@ -113,11 +109,7 @@ async function runPrerender(options) {
 	const manifestDir = path.join(root, "dist", "server");
 	const rscBundlePath = options.rscBundlePath ?? path.join(root, "dist", "server", "index.js");
 	const serverDir = path.dirname(rscBundlePath);
-	const loadedConfig = await resolveNextConfig(await loadNextConfig(root), root);
-	const config = options.nextConfigOverride ? {
-		...loadedConfig,
-		...options.nextConfigOverride
-	} : { ...loadedConfig };
+	const config = options.nextConfig ? { ...options.nextConfig } : { ...await resolveNextConfig(await loadNextConfig(root), root) };
 	const builtBuildId = readBuiltBuildId(serverDir);
 	if (builtBuildId) config.buildId = builtBuildId;
 	const mode = config.output === "export" ? "export" : "default";

package/dist/build/server-manifest.js

@@ -1,5 +1,5 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { readJsonFile } from "../utils/safe-json-file.js";
-import path from "node:path";
 //#region src/build/server-manifest.ts
 /**
 * Shared utilities for reading/writing vinext-server.json.

package/dist/build/ssr-manifest.d.ts

@@ -9,6 +9,10 @@ type BundleBackfillChunk = {
     importedAssets?: Set<string>;
   };
 };
+/**
+ * Realpath with NATIVE separators (backslashes on Windows). Callers apply
+ * `toSlash` where the result becomes a module id / manifest key.
+ */
 declare function tryRealpathSync(candidate: string): string | null;
 declare function relativeWithinRoot(root: string, moduleId: string): string | null;
 declare function augmentSsrManifestFromBundle(ssrManifest: Record<string, string[]>, bundle: Record<string, BundleBackfillChunk | {

package/dist/build/ssr-manifest.js

@@ -1,7 +1,11 @@
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { collapseDuplicateBase, manifestFileWithBase } from "../utils/manifest-paths.js";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/build/ssr-manifest.ts
+/**
+* Realpath with NATIVE separators (backslashes on Windows). Callers apply
+* `toSlash` where the result becomes a module id / manifest key.
+*/
 function tryRealpathSync(candidate) {
 	try {
 		return fs.realpathSync.native(candidate);
@@ -13,26 +17,26 @@ function isWindowsAbsolutePath(candidate) {
 	return /^[a-zA-Z]:[\\/]/.test(candidate) || candidate.startsWith("\\\\");
 }
 function relativeWithinRoot(root, moduleId) {
-	const relativeId = (isWindowsAbsolutePath(root) || isWindowsAbsolutePath(moduleId) ? path.win32.relative(root, moduleId) : path.relative(root, moduleId)).replace(/\\/g, "/");
+	const relativeId = isWindowsAbsolutePath(root) || isWindowsAbsolutePath(moduleId) ? path.win32.relative(root, moduleId) : path.relative(root, moduleId);
 	if (!relativeId || relativeId === ".." || relativeId.startsWith("../")) return null;
 	return relativeId;
 }
 function normalizeManifestModuleId(moduleId, root) {
-	const normalizedId = moduleId.replace(/\\/g, "/");
+	const normalizedId = toSlash(moduleId);
 	if (normalizedId.startsWith("\0")) return normalizedId;
 	if (normalizedId.startsWith("node_modules/") || normalizedId.includes("/node_modules/")) return normalizedId;
 	if (!isWindowsAbsolutePath(moduleId) && !path.isAbsolute(moduleId)) {
 		if (!normalizedId.startsWith(".") && !normalizedId.includes("../")) return normalizedId;
 	}
-	const rootCandidates = new Set([root]);
+	const rootCandidates = /* @__PURE__ */ new Set([root]);
 	const realRoot = tryRealpathSync(root);
-	if (realRoot) rootCandidates.add(realRoot);
+	if (realRoot) rootCandidates.add(toSlash(realRoot));
 	const moduleCandidates = /* @__PURE__ */ new Set();
 	if (isWindowsAbsolutePath(moduleId) || path.isAbsolute(moduleId)) moduleCandidates.add(moduleId);
 	else moduleCandidates.add(path.resolve(root, moduleId));
 	for (const candidate of moduleCandidates) {
 		const realCandidate = tryRealpathSync(candidate);
-		if (realCandidate) moduleCandidates.add(realCandidate);
+		if (realCandidate) moduleCandidates.add(toSlash(realCandidate));
 	}
 	for (const rootCandidate of rootCandidates) for (const moduleCandidate of moduleCandidates) {
 		const relativeId = relativeWithinRoot(rootCandidate, moduleCandidate);