vinext 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/build/standalone.js

@@ -2,7 +2,7 @@ import { readJsonFile } from "../utils/safe-json-file.js";
 import { resolveVinextPackageRoot } from "../utils/vinext-root.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
-import path from "node:path";
+import nodePath from "node:path";
 //#region src/build/standalone.ts
 function readPackageJson(packageJsonPath) {
 	return JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
@@ -29,7 +29,7 @@ function runtimeDeps(pkg) {
 * running against a build that predates this feature).
 */
 function readServerExternalsManifest(serverDir) {
-	const manifestPath = path.join(serverDir, "vinext-externals.json");
+	const manifestPath = nodePath.join(serverDir, "vinext-externals.json");
 	if (!fs.existsSync(manifestPath)) return [];
 	return readJsonFile(manifestPath, { onError: (err) => {
 		console.warn(`[vinext] Warning: failed to parse ${manifestPath}, proceeding without externals manifest: ${String(err)}`);
@@ -41,28 +41,28 @@ function resolvePackageJsonPath(packageName, resolver) {
 	} catch {
 		const lookupPaths = resolver.resolve.paths(packageName) ?? [];
 		for (const lookupPath of lookupPaths) {
-			const candidate = path.join(lookupPath, packageName, "package.json");
+			const candidate = nodePath.join(lookupPath, packageName, "package.json");
 			if (fs.existsSync(candidate)) {
 				if (readPackageJson(candidate).name === packageName) return candidate;
 			}
 		}
 		try {
 			const entryPath = resolver.resolve(packageName);
-			let dir = path.dirname(entryPath);
-			while (dir !== path.dirname(dir)) {
-				const candidate = path.join(dir, "package.json");
+			let dir = nodePath.dirname(entryPath);
+			while (dir !== nodePath.dirname(dir)) {
+				const candidate = nodePath.join(dir, "package.json");
 				if (fs.existsSync(candidate)) {
 					if (readPackageJson(candidate).name === packageName) return candidate;
 				}
-				dir = path.dirname(dir);
+				dir = nodePath.dirname(dir);
 			}
 		} catch {}
 		return null;
 	}
 }
 function copyPackageAndRuntimeDeps(root, targetNodeModulesDir, initialPackages, alreadyCopied) {
-	const rootResolver = createRequire(path.join(root, "package.json"));
-	const rootPkg = readPackageJson(path.join(root, "package.json"));
+	const rootResolver = createRequire(nodePath.join(root, "package.json"));
+	const rootPkg = readPackageJson(nodePath.join(root, "package.json"));
 	const rootOptional = new Set(Object.keys(rootPkg.optionalDependencies ?? {}));
 	const copied = alreadyCopied ?? /* @__PURE__ */ new Set();
 	const queue = initialPackages.map((packageName) => ({
@@ -80,14 +80,14 @@ function copyPackageAndRuntimeDeps(root, targetNodeModulesDir, initialPackages,
 			throw new Error(`Failed to resolve required runtime dependency "${entry.packageName}" for standalone output`);
 		}
 		const realPackageJsonPath = fs.realpathSync(packageJsonPath);
-		const packageRoot = path.dirname(realPackageJsonPath);
-		const packageTarget = path.join(targetNodeModulesDir, entry.packageName);
-		fs.mkdirSync(path.dirname(packageTarget), { recursive: true });
+		const packageRoot = nodePath.dirname(realPackageJsonPath);
+		const packageTarget = nodePath.join(targetNodeModulesDir, entry.packageName);
+		fs.mkdirSync(nodePath.dirname(packageTarget), { recursive: true });
 		fs.cpSync(packageRoot, packageTarget, {
 			recursive: true,
 			dereference: true,
 			filter: (src) => {
-				return !path.relative(packageRoot, src).split(path.sep).includes("node_modules");
+				return !nodePath.relative(packageRoot, src).split(nodePath.sep).includes("node_modules");
 			}
 		});
 		copied.add(entry.packageName);
@@ -144,58 +144,58 @@ function writeStandalonePackageJson(filePath) {
 * included.
 */
 function emitStandaloneOutput(options) {
-	const root = path.resolve(options.root);
-	const outDir = path.resolve(options.outDir);
-	const clientDir = path.join(outDir, "client");
-	const serverDir = path.join(outDir, "server");
+	const root = nodePath.resolve(options.root);
+	const outDir = nodePath.resolve(options.outDir);
+	const clientDir = nodePath.join(outDir, "client");
+	const serverDir = nodePath.join(outDir, "server");
 	if (!fs.existsSync(clientDir) || !fs.existsSync(serverDir)) throw new Error(`No build output found in ${outDir}. Run vinext build first.`);
-	const standaloneDir = path.join(outDir, "standalone");
-	const standaloneDistDir = path.join(standaloneDir, "dist");
-	const standaloneNodeModulesDir = path.join(standaloneDir, "node_modules");
+	const standaloneDir = nodePath.join(outDir, "standalone");
+	const standaloneDistDir = nodePath.join(standaloneDir, "dist");
+	const standaloneNodeModulesDir = nodePath.join(standaloneDir, "node_modules");
 	fs.rmSync(standaloneDir, {
 		recursive: true,
 		force: true
 	});
 	fs.mkdirSync(standaloneDistDir, { recursive: true });
-	fs.cpSync(clientDir, path.join(standaloneDistDir, "client"), {
+	fs.cpSync(clientDir, nodePath.join(standaloneDistDir, "client"), {
 		recursive: true,
 		dereference: true,
-		filter: (src) => !path.relative(clientDir, src).split(path.sep).includes("node_modules")
+		filter: (src) => !nodePath.relative(clientDir, src).split(nodePath.sep).includes("node_modules")
 	});
-	fs.cpSync(serverDir, path.join(standaloneDistDir, "server"), {
+	fs.cpSync(serverDir, nodePath.join(standaloneDistDir, "server"), {
 		recursive: true,
 		dereference: true,
-		filter: (src) => !path.relative(serverDir, src).split(path.sep).includes("node_modules")
+		filter: (src) => !nodePath.relative(serverDir, src).split(nodePath.sep).includes("node_modules")
 	});
-	const clientAssetsSidecar = path.join(outDir, "vinext-client-assets.js");
-	if (fs.existsSync(clientAssetsSidecar)) fs.copyFileSync(clientAssetsSidecar, path.join(standaloneDistDir, "vinext-client-assets.js"));
-	const publicDir = path.join(root, "public");
-	if (fs.existsSync(publicDir)) fs.cpSync(publicDir, path.join(standaloneDir, "public"), {
+	const clientAssetsSidecar = nodePath.join(outDir, "vinext-client-assets.js");
+	if (fs.existsSync(clientAssetsSidecar)) fs.copyFileSync(clientAssetsSidecar, nodePath.join(standaloneDistDir, "vinext-client-assets.js"));
+	const publicDir = nodePath.join(root, "public");
+	if (fs.existsSync(publicDir)) fs.cpSync(publicDir, nodePath.join(standaloneDir, "public"), {
 		recursive: true,
 		dereference: true,
-		filter: (src) => !path.relative(publicDir, src).split(path.sep).includes("node_modules")
+		filter: (src) => !nodePath.relative(publicDir, src).split(nodePath.sep).includes("node_modules")
 	});
 	fs.mkdirSync(standaloneNodeModulesDir, { recursive: true });
 	const initialPackages = readServerExternalsManifest(serverDir).filter((name) => name !== "vinext");
 	const copiedSet = /* @__PURE__ */ new Set();
 	copyPackageAndRuntimeDeps(root, standaloneNodeModulesDir, initialPackages, copiedSet);
 	const vinextPackageRoot = resolveVinextPackageRoot(options.vinextPackageRoot);
-	const vinextDistDir = path.join(vinextPackageRoot, "dist");
+	const vinextDistDir = nodePath.join(vinextPackageRoot, "dist");
 	if (!fs.existsSync(vinextDistDir)) throw new Error(`vinext runtime dist/ not found at ${vinextPackageRoot}`);
-	const vinextTargetDir = path.join(standaloneNodeModulesDir, "vinext");
+	const vinextTargetDir = nodePath.join(standaloneNodeModulesDir, "vinext");
 	fs.mkdirSync(vinextTargetDir, { recursive: true });
-	fs.copyFileSync(path.join(vinextPackageRoot, "package.json"), path.join(vinextTargetDir, "package.json"));
-	fs.cpSync(vinextDistDir, path.join(vinextTargetDir, "dist"), {
+	fs.copyFileSync(nodePath.join(vinextPackageRoot, "package.json"), nodePath.join(vinextTargetDir, "package.json"));
+	fs.cpSync(vinextDistDir, nodePath.join(vinextTargetDir, "dist"), {
 		recursive: true,
 		dereference: true,
 		filter: (src) => {
-			return !path.relative(vinextDistDir, src).split(path.sep).includes("node_modules");
+			return !nodePath.relative(vinextDistDir, src).split(nodePath.sep).includes("node_modules");
 		}
 	});
 	copiedSet.add("vinext");
-	copyPackageAndRuntimeDeps(vinextPackageRoot, standaloneNodeModulesDir, runtimeDeps(readPackageJson(path.join(vinextPackageRoot, "package.json"))).filter((name) => !copiedSet.has(name)), copiedSet);
-	writeStandaloneServerEntry(path.join(standaloneDir, "server.js"));
-	writeStandalonePackageJson(path.join(standaloneDir, "package.json"));
+	copyPackageAndRuntimeDeps(vinextPackageRoot, standaloneNodeModulesDir, runtimeDeps(readPackageJson(nodePath.join(vinextPackageRoot, "package.json"))).filter((name) => !copiedSet.has(name)), copiedSet);
+	writeStandaloneServerEntry(nodePath.join(standaloneDir, "server.js"));
+	writeStandalonePackageJson(nodePath.join(standaloneDir, "package.json"));
 	return {
 		standaloneDir,
 		copiedPackages: [...copiedSet]

package/dist/cache/cache-adapters-virtual.d.ts

@@ -1,20 +1,4 @@
 //#region src/cache/cache-adapters-virtual.d.ts
-/**
- * Code generation for the `virtual:vinext-cache-adapters` module, resolved by
- * the vinext vite plugin from the user's `cache` config ({@link VinextCacheConfig}).
- *
- * The generated module exports `registerConfiguredCacheAdapters(env)`, which the
- * server entries call on each request. It self-guards (adapters instantiate once
- * per isolate) and is a no-op when nothing is configured. Registration is
- * resilient: a factory that throws (e.g. a KV adapter on the Node.js server,
- * where the binding can't exist) is logged and skipped rather than failing every
- * request, so the same config can be registered from every runtime/router entry.
- *
- * Descriptor `options` are inlined into the generated module and forwarded to the
- * factory at runtime, so a config-time builder like `kvDataAdapter({ binding })`
- * never touches the Workers runtime — instantiation is deferred to the first
- * request.
- */
 /**
  * A serializable pointer to a cache adapter module — the shape of each `cache`
  * slot in the vinext() plugin config. Produced by an adapter builder (e.g.
@@ -45,7 +29,7 @@ declare const VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY = "__vinextCacheConfig";
 type ViteConfigLoader = {
   loadConfigFromFile: typeof import("vite").loadConfigFromFile;
 };
-declare function findVinextCacheConfigInPlugins(plugins: import("vite").PluginOption[] | undefined): VinextCacheConfig | null;
+declare function findVinextCacheConfigInPlugins(plugins: import("vite").PluginOption[] | undefined): Promise<VinextCacheConfig | null>;
 declare function loadVinextCacheConfigFromViteConfig(vite: ViteConfigLoader, root: string): Promise<VinextCacheConfig | null>;
 /**
  * Generate the source of the `virtual:vinext-cache-adapters` module for the

package/dist/cache/cache-adapters-virtual.js

@@ -1,17 +1,26 @@
+import { flattenPluginOptions } from "../utils/plugin-options.js";
 //#region src/cache/cache-adapters-virtual.ts
+/**
+* Code generation for the `virtual:vinext-cache-adapters` module, resolved by
+* the vinext vite plugin from the user's `cache` config ({@link VinextCacheConfig}).
+*
+* The generated module exports `registerConfiguredCacheAdapters(env)`, which the
+* server entries call on each request. It self-guards (adapters instantiate once
+* per isolate) and is a no-op when nothing is configured. Registration is
+* resilient: a factory that throws (e.g. a KV adapter on the Node.js server,
+* where the binding can't exist) is logged and skipped rather than failing every
+* request, so the same config can be registered from every runtime/router entry.
+*
+* Descriptor `options` are inlined into the generated module and forwarded to the
+* factory at runtime, so a config-time builder like `kvDataAdapter({ binding })`
+* never touches the Workers runtime — instantiation is deferred to the first
+* request.
+*/
 /** Public virtual module id imported by the server entries. */
 const VIRTUAL_CACHE_ADAPTERS = "virtual:vinext-cache-adapters";
 const VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY = "__vinextCacheConfig";
-function flattenPluginOptions(value, target) {
-	if (Array.isArray(value)) {
-		for (const item of value) flattenPluginOptions(item, target);
-		return;
-	}
-	if (value) target.push(value);
-}
-function findVinextCacheConfigInPlugins(plugins) {
-	const flattened = [];
-	flattenPluginOptions(plugins, flattened);
+async function findVinextCacheConfigInPlugins(plugins) {
+	const flattened = await flattenPluginOptions(plugins);
 	for (const plugin of flattened) {
 		if (!plugin || typeof plugin !== "object") continue;
 		const cacheConfig = plugin[VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY];
@@ -20,7 +29,7 @@ function findVinextCacheConfigInPlugins(plugins) {
 	return null;
 }
 async function loadVinextCacheConfigFromViteConfig(vite, root) {
-	return findVinextCacheConfigInPlugins((await vite.loadConfigFromFile({
+	return await findVinextCacheConfigInPlugins((await vite.loadConfigFromFile({
 		command: "build",
 		mode: "production"
 	}, void 0, root))?.config.plugins);

package/dist/check.d.ts

@@ -59,38 +59,22 @@ type CheckResult = {
 declare function hasFreeCjsGlobal(content: string): boolean;
 /**
  * Scan source files for `import ... from 'next/...'` statements.
- *
- * `root` must be forward-slash: it is passed to `findSourceFiles`, which
- * requires it.
  */
 declare function scanImports(root: string): CheckItem[];
 /**
  * Analyze next.config.js/mjs/ts for supported and unsupported options.
- *
- * `root` must be forward-slash — joined with `path.posix.join`. Only called
- * from `runCheck`, which normalizes it.
  */
 declare function analyzeConfig(root: string): CheckItem[];
 /**
  * Check package.json dependencies for known libraries.
- *
- * `root` must be forward-slash — joined with `path.posix.join`. Only called
- * from `runCheck`, which normalizes it.
  */
 declare function checkLibraries(root: string): CheckItem[];
 /**
  * Check file conventions (pages, app directory, middleware, etc.)
- *
- * `root` must be forward-slash — joined with `path.posix.join` and passed to
- * `findDir`. Only called from `runCheck`, which normalizes it.
  */
 declare function checkConventions(root: string): CheckItem[];
 /**
  * Run the full compatibility check.
- *
- * `root` must be forward-slash — callers normalize it at the CLI entry, and it
- * is forwarded to `scanImports` / `checkConventions` / `findDir`, which build
- * paths with `path.posix.*`.
  */
 declare function runCheck(root: string): CheckResult;
 /**

package/dist/check.js

@@ -1,7 +1,6 @@
+import path from "./deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { detectPackageManager, findDir } from "./utils/project.js";
-import { normalizePathSeparators } from "./utils/path.js";
 import fs from "node:fs";
-import path from "node:path";
 import { parseAst } from "vite";
 //#region src/check.ts
 /**
@@ -371,11 +370,6 @@ const LIBRARY_SUPPORT = {
 };
 /**
 * Recursively find all source files in a directory.
-*
-* `dir` must be forward-slash, and the returned paths are forward-slash too:
-* each entry is joined with `path.posix.join`, which only stays canonical when
-* the base already is. This keeps downstream substring checks (e.g.
-* `f.includes("/api/")`) and reported paths consistent across platforms.
 */
 function findSourceFiles(dir, extensions = [
 	".ts",
@@ -388,7 +382,7 @@ function findSourceFiles(dir, extensions = [
 	if (!fs.existsSync(dir)) return results;
 	const entries = fs.readdirSync(dir, { withFileTypes: true });
 	for (const entry of entries) {
-		const fullPath = path.posix.join(dir, entry.name);
+		const fullPath = path.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist" || entry.name === ".git") continue;
 			results.push(...findSourceFiles(fullPath, extensions));
@@ -396,14 +390,27 @@ function findSourceFiles(dir, extensions = [
 	}
 	return results;
 }
+/**
+* Find files that can contribute to the application compatibility surface.
+* Test modules and test-runner configuration are executed by their own runners
+* rather than bundled into the vinext application, so reporting their imports
+* or CJS globals as migration blockers produces false positives.
+*/
+function findRuntimeSourceFiles(root) {
+	return findSourceFiles(root).filter((file) => {
+		const basename = path.basename(file);
+		const isTestRunnerConfig = /^(?:jest|playwright|vitest)\.config\.[cm]?[jt]sx?$/.test(basename);
+		return !/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(basename) && !isTestRunnerConfig;
+	});
+}
 function isIdentStart(c) {
 	return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_" || c === "$";
 }
 function isIdentChar(c) {
 	return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "_" || c === "$";
 }
-const CJS_GLOBALS = new Set(["__dirname", "__filename"]);
-const REGEX_PRECEDING_KEYWORDS = new Set([
+const CJS_GLOBALS = /* @__PURE__ */ new Set(["__dirname", "__filename"]);
+const REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
 	"return",
 	"typeof",
 	"instanceof",
@@ -592,12 +599,9 @@ function hasFreeCjsGlobal(content) {
 }
 /**
 * Scan source files for `import ... from 'next/...'` statements.
-*
-* `root` must be forward-slash: it is passed to `findSourceFiles`, which
-* requires it.
 */
 function scanImports(root) {
-	const files = findSourceFiles(root);
+	const files = findRuntimeSourceFiles(root);
 	const importUsage = /* @__PURE__ */ new Map();
 	const importRegex = /(?:import\s+(?:[\w{},\s*]+\s+from\s+)?|require\s*\()['"]([^'"]+)['"]\)?/g;
 	const typeOnlyImportRegex = /import\s+type\s+/;
@@ -612,7 +616,7 @@ function scanImports(root) {
 			if (mod.startsWith("next/") || mod === "next" || mod === "server-only" || mod === "client-only") {
 				const normalized = mod === "next" ? "next" : mod;
 				if (!importUsage.has(normalized)) importUsage.set(normalized, []);
-				const relFile = normalizePathSeparators(path.relative(root, file));
+				const relFile = path.relative(root, file);
 				const usedInFiles = importUsage.get(normalized) ?? [];
 				if (!usedInFiles.includes(relFile)) usedInFiles.push(relFile);
 			}
@@ -739,9 +743,6 @@ function collectConfigKeys(source) {
 }
 /**
 * Analyze next.config.js/mjs/ts for supported and unsupported options.
-*
-* `root` must be forward-slash — joined with `path.posix.join`. Only called
-* from `runCheck`, which normalizes it.
 */
 function analyzeConfig(root) {
 	const configFiles = [
@@ -753,7 +754,7 @@ function analyzeConfig(root) {
 	];
 	let configPath = null;
 	for (const f of configFiles) {
-		const p = path.posix.join(root, f);
+		const p = path.join(root, f);
 		if (fs.existsSync(p)) {
 			configPath = p;
 			break;
@@ -811,12 +812,9 @@ function analyzeConfig(root) {
 }
 /**
 * Check package.json dependencies for known libraries.
-*
-* `root` must be forward-slash — joined with `path.posix.join`. Only called
-* from `runCheck`, which normalizes it.
 */
 function checkLibraries(root) {
-	const pkgPath = path.posix.join(root, "package.json");
+	const pkgPath = path.join(root, "package.json");
 	if (!fs.existsSync(pkgPath)) return [];
 	const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
 	const allDeps = {
@@ -834,16 +832,13 @@ function checkLibraries(root) {
 }
 /**
 * Check file conventions (pages, app directory, middleware, etc.)
-*
-* `root` must be forward-slash — joined with `path.posix.join` and passed to
-* `findDir`. Only called from `runCheck`, which normalizes it.
 */
 function checkConventions(root) {
 	const items = [];
 	const pagesDir = findDir(root, "pages", "src/pages");
 	const appDirPath = findDir(root, "app", "src/app");
-	const hasProxy = fs.existsSync(path.posix.join(root, "proxy.ts")) || fs.existsSync(path.posix.join(root, "proxy.js"));
-	const hasMiddleware = fs.existsSync(path.posix.join(root, "middleware.ts")) || fs.existsSync(path.posix.join(root, "middleware.js"));
+	const hasProxy = fs.existsSync(path.join(root, "proxy.ts")) || fs.existsSync(path.join(root, "proxy.js"));
+	const hasMiddleware = fs.existsSync(path.join(root, "middleware.ts")) || fs.existsSync(path.join(root, "middleware.js"));
 	if (pagesDir !== null) {
 		const isSrc = pagesDir.includes("src/pages");
 		items.push({
@@ -921,7 +916,7 @@ function checkConventions(root) {
 		status: "unsupported",
 		detail: "vinext requires a pages/ or app/ directory"
 	});
-	const pkgPath = path.posix.join(root, "package.json");
+	const pkgPath = path.join(root, "package.json");
 	if (fs.existsSync(pkgPath)) {
 		if (JSON.parse(fs.readFileSync(pkgPath, "utf-8")).type !== "module") items.push({
 			name: "Missing \"type\": \"module\" in package.json",
@@ -929,13 +924,13 @@ function checkConventions(root) {
 			detail: "required for Vite — vinext init will add it automatically"
 		});
 	}
-	const allSourceFiles = findSourceFiles(root);
+	const allSourceFiles = findRuntimeSourceFiles(root);
 	const viewTransitionRegex = /import\s+\{[^}]*\bViewTransition\b[^}]*\}\s+from\s+['"]react['"]/;
 	const viewTransitionFiles = [];
 	const cjsGlobalFiles = [];
 	for (const file of allSourceFiles) {
 		const content = fs.readFileSync(file, "utf-8");
-		const rel = normalizePathSeparators(path.relative(root, file));
+		const rel = path.relative(root, file);
 		if (viewTransitionRegex.test(content)) viewTransitionFiles.push(rel);
 		if (hasFreeCjsGlobal(content)) cjsGlobalFiles.push(rel);
 	}
@@ -950,7 +945,7 @@ function checkConventions(root) {
 		"postcss.config.js",
 		"postcss.config.cjs"
 	]) {
-		const configPath = path.posix.join(root, configFile);
+		const configPath = path.join(root, configFile);
 		if (fs.existsSync(configPath)) {
 			const content = fs.readFileSync(configPath, "utf-8");
 			if (/plugins\s*:\s*\[\s*['"]/.test(content)) items.push({
@@ -971,10 +966,6 @@ function checkConventions(root) {
 }
 /**
 * Run the full compatibility check.
-*
-* `root` must be forward-slash — callers normalize it at the CLI entry, and it
-* is forwarded to `scanImports` / `checkConventions` / `findDir`, which build
-* paths with `path.posix.*`.
 */
 function runCheck(root) {
 	const imports = scanImports(root);

package/dist/cli.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
+import path, { toSlash } from "./deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { detectPackageManager, ensureViteConfigCompatibility, hasAppDir, hasViteConfig } from "./utils/project.js";
-import { normalizePathSeparators } from "./utils/path.js";
 import { formatReport, runCheck } from "./check.js";
 import { parseArgs } from "./cli-args.js";
 import { createDevServerConfigPlugin, normalizeDevServerHostname } from "./cli-dev-config.js";
 import { PHASE_PRODUCTION_BUILD } from "./shims/constants.js";
-import { createRscCompatibilityId, loadNextConfig, resolveNextConfig } from "./config/next-config.js";
+import { createRscCompatibilityId, findVinextNextConfigInPlugins, loadNextConfig, resolveNextConfig, resolveNextConfigInput } from "./config/next-config.js";
 import { generateRouteTypes } from "./typegen.js";
 import { clearPagesClientAssetsBuildMetadata } from "./build/pages-client-assets-module.js";
+import { runWithPreviewBuildCredentials } from "./build/preview-credentials.js";
 import { findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, resolveVinextPrerenderDecision } from "./config/prerender.js";
 import vinext from "./index.js";
 import { runPrerender } from "./build/run-prerender.js";
@@ -22,7 +23,6 @@ import { cleanBuildOutput } from "./build/clean-output.js";
 import { formatAlreadyRunningError, tryAcquireLockfile } from "./server/dev-lockfile.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
-import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { randomBytes } from "node:crypto";
 import { execFileSync } from "node:child_process";
@@ -127,6 +127,7 @@ function hasPagesDir() {
 }
 async function loadBuildViteConfigMetadata(vite, root) {
 	if (!hasViteConfig(root)) return {
+		nextConfig: null,
 		prerenderConfig: null,
 		routeRootConfig: null
 	};
@@ -137,8 +138,9 @@ async function loadBuildViteConfigMetadata(vite, root) {
 	const emptyOutDir = loaded?.config.build?.emptyOutDir;
 	return {
 		emptyOutDir: typeof emptyOutDir === "boolean" ? emptyOutDir : void 0,
-		prerenderConfig: findVinextPrerenderConfigInPlugins(loaded?.config.plugins),
-		routeRootConfig: findVinextRouteRootConfigInPlugins(loaded?.config.plugins)
+		nextConfig: await findVinextNextConfigInPlugins(loaded?.config.plugins),
+		prerenderConfig: await findVinextPrerenderConfigInPlugins(loaded?.config.plugins),
+		routeRootConfig: await findVinextRouteRootConfigInPlugins(loaded?.config.plugins)
 	};
 }
 /**
@@ -281,9 +283,10 @@ async function buildApp() {
 	const vite = await loadVite();
 	const withBuildBundlerOptions = (bundlerOptions) => ({ rolldownOptions: bundlerOptions });
 	console.log(`\n  vinext build  (Vite ${getViteVersion()})\n`);
-	const root = process.cwd();
-	const isApp = hasAppDir(normalizePathSeparators(root));
-	const resolvedNextConfig = await resolveNextConfig(await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root);
+	const root = toSlash(process.cwd());
+	const isApp = hasAppDir(root);
+	const buildConfigMetadata = await loadBuildViteConfigMetadata(vite, root);
+	const resolvedNextConfig = await resolveNextConfig(buildConfigMetadata.nextConfig ? await resolveNextConfigInput(buildConfigMetadata.nextConfig, PHASE_PRODUCTION_BUILD) : await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root);
 	process.env.__VINEXT_SHARED_BUILD_ID = resolvedNextConfig.buildId;
 	process.env.__VINEXT_SHARED_RSC_COMPATIBILITY_ID = createRscCompatibilityId(resolvedNextConfig);
 	if (!process.env.__VINEXT_SHARED_REVALIDATE_SECRET) process.env.__VINEXT_SHARED_REVALIDATE_SECRET = randomBytes(32).toString("hex");
@@ -309,7 +312,6 @@ async function buildApp() {
 			});
 		}
 	}
-	const buildConfigMetadata = await loadBuildViteConfigMetadata(vite, root);
 	cleanBuildOutput({
 		root,
 		outDir: distDir,
@@ -318,46 +320,48 @@ async function buildApp() {
 	const isHybrid = isApp && hasPagesDir();
 	const pagesClientAssetsBuildSession = isHybrid ? randomBytes(16).toString("hex") : null;
 	if (pagesClientAssetsBuildSession) process.env.__VINEXT_PAGES_CLIENT_ASSETS_BUILD_SESSION = pagesClientAssetsBuildSession;
-	try {
-		const config = buildViteConfig({}, logger);
-		await (await vite.createBuilder(config)).buildApp();
-		if (isHybrid) {
-			console.log("  Building Pages Router server (hybrid)...");
-			const root = process.cwd();
-			let userTransformPlugins = [];
-			if (hasViteConfig(process.cwd())) {
-				const loaded = await vite.loadConfigFromFile({
-					command: "build",
-					mode: "production",
-					isSsrBuild: true
-				}, void 0, root);
-				if (loaded?.config.plugins) userTransformPlugins = loaded.config.plugins.flat(Infinity).filter((p) => !!p && typeof p.name === "string" && !p.name.startsWith("vinext:") && !p.name.startsWith("vite:react") && !p.name.startsWith("rsc:") && p.name !== "vite-rsc-load-module-dev-proxy" && !p.name.startsWith("vite-plugin-cloudflare"));
-			}
-			await vite.build({
-				root,
-				configFile: false,
-				plugins: [...userTransformPlugins, vinext({ disableAppRouter: true })],
-				resolve: { dedupe: [
-					"react",
-					"react-dom",
-					"react/jsx-runtime",
-					"react/jsx-dev-runtime"
-				] },
-				...logger ? { customLogger: logger } : {},
-				build: {
-					outDir: "dist/server",
-					emptyOutDir: false,
-					ssr: "virtual:vinext-server-entry",
-					...withBuildBundlerOptions({ output: { entryFileNames: "entry.js" } })
+	await runWithPreviewBuildCredentials(async () => {
+		try {
+			const config = buildViteConfig({}, logger);
+			await (await vite.createBuilder(config)).buildApp();
+			if (isHybrid) {
+				console.log("  Building Pages Router server (hybrid)...");
+				const root = process.cwd();
+				let userTransformPlugins = [];
+				if (hasViteConfig(process.cwd())) {
+					const loaded = await vite.loadConfigFromFile({
+						command: "build",
+						mode: "production",
+						isSsrBuild: true
+					}, void 0, root);
+					if (loaded?.config.plugins) userTransformPlugins = loaded.config.plugins.flat(Infinity).filter((p) => !!p && typeof p.name === "string" && !p.name.startsWith("vinext:") && !p.name.startsWith("vite:react") && !p.name.startsWith("rsc:") && p.name !== "vite-rsc-load-module-dev-proxy" && !p.name.startsWith("vite-plugin-cloudflare"));
 				}
-			});
-		}
-	} finally {
-		if (pagesClientAssetsBuildSession) {
-			clearPagesClientAssetsBuildMetadata(pagesClientAssetsBuildSession);
-			if (process.env.__VINEXT_PAGES_CLIENT_ASSETS_BUILD_SESSION === pagesClientAssetsBuildSession) delete process.env.__VINEXT_PAGES_CLIENT_ASSETS_BUILD_SESSION;
+				await vite.build({
+					root,
+					configFile: false,
+					plugins: [...userTransformPlugins, vinext({ disableAppRouter: true })],
+					resolve: { dedupe: [
+						"react",
+						"react-dom",
+						"react/jsx-runtime",
+						"react/jsx-dev-runtime"
+					] },
+					...logger ? { customLogger: logger } : {},
+					build: {
+						outDir: "dist/server",
+						emptyOutDir: false,
+						ssr: "virtual:vinext-server-entry",
+						...withBuildBundlerOptions({ output: { entryFileNames: "entry.js" } })
+					}
+				});
+			}
+		} finally {
+			if (pagesClientAssetsBuildSession) {
+				clearPagesClientAssetsBuildMetadata(pagesClientAssetsBuildSession);
+				if (process.env.__VINEXT_PAGES_CLIENT_ASSETS_BUILD_SESSION === pagesClientAssetsBuildSession) delete process.env.__VINEXT_PAGES_CLIENT_ASSETS_BUILD_SESSION;
+			}
 		}
-	}
+	});
 	if (outputMode === "standalone") {
 		const standalone = emitStandaloneOutput({
 			root: process.cwd(),
@@ -381,19 +385,20 @@ async function buildApp() {
 		process.stdout.write("\x1B[0m");
 		console.log(`  ${formatVinextPrerenderLabel(prerenderDecision)}`);
 		prerenderResult = await runPrerender({
-			root: normalizePathSeparators(process.cwd()),
-			concurrency: parsed.prerenderConcurrency
+			root,
+			concurrency: parsed.prerenderConcurrency,
+			nextConfig: resolvedNextConfig
 		});
 		await emitPrerenderPathManifest({
-			root: normalizePathSeparators(process.cwd()),
-			nextConfigOverride: resolvedNextConfig,
+			root,
+			nextConfig: resolvedNextConfig,
 			routeRootConfig: buildConfigMetadata.routeRootConfig
 		});
 	}
 	process.stdout.write("\x1B[0m");
 	const { printBuildReport } = await import("./build/report.js");
 	await printBuildReport({
-		root: normalizePathSeparators(process.cwd()),
+		root,
 		pageExtensions: resolvedNextConfig.pageExtensions,
 		prerenderResult: prerenderResult ?? void 0
 	});
@@ -466,7 +471,7 @@ async function check() {
 	if (parseArgs(rawArgs).help) return printHelp("check");
 	console.log(`\n  vinext check\n`);
 	console.log("  Scanning project...\n");
-	const result = runCheck(normalizePathSeparators(process.cwd()));
+	const result = runCheck(toSlash(process.cwd()));
 	console.log(formatReport(result));
 }
 async function typegen() {
@@ -477,11 +482,12 @@ async function typegen() {
 		root,
 		mode: "production"
 	});
-	const outputPath = await generateRouteTypes({
+	const result = await generateRouteTypes({
 		root,
 		pageExtensions: (await resolveNextConfig(await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root)).pageExtensions
 	});
-	console.log(`\n  Generated route types at ${path.relative(root, outputPath)}\n`);
+	const nextEnvMessage = result.nextEnvStatus === "unchanged" ? `${path.relative(root, result.nextEnvPath)} is up to date` : `${result.nextEnvStatus === "created" ? "Created" : "Updated"} ${path.relative(root, result.nextEnvPath)}`;
+	console.log(`\n  Generated route types at ${path.relative(root, result.routeTypesPath)}\n  ${nextEnvMessage}\n`);
 }
 async function initCommand() {
 	const parsed = parseArgs(rawArgs);

package/dist/client/instrumentation-client-inject.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/client/instrumentation-client-inject.ts
 /** Resolve empty-module next to this file (.js in dist, .ts in source). */
 function resolveInstrumentationClientEmptyModule(dir) {