@nuxt/cli-nightly 3.29.4-20251009-171833-0915ec9 → 3.29.4-20251021-190716-bbf70fc

package/dist/nuxt-Cc9ZTk7m.mjs

@@ -0,0 +1,44 @@
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import { r as rmRecursive } from "./fs-ewAp6tjM.mjs";
+import { promises } from "node:fs";
+import { dirname, resolve } from "pathe";
+import { hash } from "ohash";
+
+//#region ../nuxi/src/utils/nuxt.ts
+async function cleanupNuxtDirs(rootDir, buildDir) {
+	logger.info("Cleaning up generated Nuxt files and caches...");
+	await rmRecursive([
+		buildDir,
+		".output",
+		"dist",
+		"node_modules/.vite",
+		"node_modules/.cache"
+	].map((dir) => resolve(rootDir, dir)));
+}
+function nuxtVersionToGitIdentifier(version) {
+	const id = /\.([0-9a-f]{7,8})$/.exec(version);
+	if (id?.[1]) return id[1];
+	return `v${version}`;
+}
+function resolveNuxtManifest(nuxt) {
+	const manifest = {
+		_hash: null,
+		project: { rootDir: nuxt.options.rootDir },
+		versions: { nuxt: nuxt._version }
+	};
+	manifest._hash = hash(manifest);
+	return manifest;
+}
+async function writeNuxtManifest(nuxt, manifest = resolveNuxtManifest(nuxt)) {
+	const manifestPath = resolve(nuxt.options.buildDir, "nuxt.json");
+	await promises.mkdir(dirname(manifestPath), { recursive: true });
+	await promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+	return manifest;
+}
+async function loadNuxtManifest(buildDir) {
+	const manifestPath = resolve(buildDir, "nuxt.json");
+	return await promises.readFile(manifestPath, "utf-8").then((data) => JSON.parse(data)).catch(() => null);
+}
+
+//#endregion
+export { writeNuxtManifest as a, resolveNuxtManifest as i, loadNuxtManifest as n, nuxtVersionToGitIdentifier as r, cleanupNuxtDirs as t };

package/dist/packageManagers-DbVB5cXf.mjs

@@ -0,0 +1,9 @@
+import { execSync } from "node:child_process";
+
+//#region ../nuxi/src/utils/packageManagers.ts
+function getPackageManagerVersion(name) {
+	return execSync(`${name} --version`).toString("utf8").trim();
+}
+
+//#endregion
+export { getPackageManagerVersion as t };

package/dist/prepare-B0KOhO-L.mjs

@@ -0,0 +1,7 @@
+import "./_shared-C3vB2YLc.mjs";
+import "./logger-Dk0gkCkX.mjs";
+import "./fs-ewAp6tjM.mjs";
+import "./kit-xFxVGu6d.mjs";
+import { t as prepare_default } from "./prepare-xI978yFg.mjs";
+
+export { prepare_default as default };

package/dist/prepare-xI978yFg.mjs

@@ -0,0 +1,49 @@
+import { a as legacyRootDirArgs, i as extendsArgs, n as dotEnvArgs, o as logLevelArgs, r as envNameArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import { t as clearBuildDir } from "./fs-ewAp6tjM.mjs";
+import { t as loadKit } from "./kit-xFxVGu6d.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { relative, resolve } from "pathe";
+
+//#region ../nuxi/src/commands/prepare.ts
+var prepare_default = defineCommand({
+	meta: {
+		name: "prepare",
+		description: "Prepare Nuxt for development/build"
+	},
+	args: {
+		...dotEnvArgs,
+		...cwdArgs,
+		...logLevelArgs,
+		...envNameArgs,
+		...extendsArgs,
+		...legacyRootDirArgs
+	},
+	async run(ctx) {
+		process.env.NODE_ENV = process.env.NODE_ENV || "production";
+		const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+		const { loadNuxt, buildNuxt, writeTypes } = await loadKit(cwd);
+		const nuxt = await loadNuxt({
+			cwd,
+			dotenv: {
+				cwd,
+				fileName: ctx.args.dotenv
+			},
+			envName: ctx.args.envName,
+			overrides: {
+				_prepare: true,
+				logLevel: ctx.args.logLevel,
+				...ctx.args.extends && { extends: ctx.args.extends },
+				...ctx.data?.overrides
+			}
+		});
+		await clearBuildDir(nuxt.options.buildDir);
+		await buildNuxt(nuxt);
+		await writeTypes(nuxt);
+		logger.success("Types generated in", relative(process.cwd(), nuxt.options.buildDir));
+	}
+});
+
+//#endregion
+export { prepare_default as t };

package/dist/preview-C5fNqrC6.mjs

@@ -0,0 +1,109 @@
+import { a as legacyRootDirArgs, i as extendsArgs, n as dotEnvArgs, o as logLevelArgs, r as envNameArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import { t as loadKit } from "./kit-xFxVGu6d.mjs";
+import { dirname, relative } from "node:path";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { existsSync, promises } from "node:fs";
+import { resolve as resolve$1 } from "pathe";
+import { box, colors } from "consola/utils";
+import { getArgs } from "listhen/cli";
+import { x } from "tinyexec";
+import { setupDotenv } from "c12";
+
+//#region ../nuxi/src/commands/preview.ts
+const command = defineCommand({
+	meta: {
+		name: "preview",
+		description: "Launches Nitro server for local testing after `nuxi build`."
+	},
+	args: {
+		...cwdArgs,
+		...logLevelArgs,
+		...envNameArgs,
+		...extendsArgs,
+		...legacyRootDirArgs,
+		port: {
+			...getArgs().port,
+			alias: ["p"]
+		},
+		...dotEnvArgs
+	},
+	async run(ctx) {
+		process.env.NODE_ENV = process.env.NODE_ENV || "production";
+		const cwd = resolve$1(ctx.args.cwd || ctx.args.rootDir);
+		const { loadNuxt } = await loadKit(cwd);
+		const nitroJSONPaths = [await new Promise((res) => {
+			loadNuxt({
+				cwd,
+				envName: ctx.args.envName,
+				ready: true,
+				overrides: {
+					...ctx.args.extends && { extends: ctx.args.extends },
+					modules: [function(_, nuxt) {
+						nuxt.hook("nitro:init", (nitro) => {
+							res(resolve$1(nuxt.options.srcDir || cwd, nitro.options.output.dir || ".output", "nitro.json"));
+						});
+					}]
+				}
+			}).then((nuxt) => nuxt.close()).catch(() => "");
+		}), resolve$1(cwd, ".output", "nitro.json")].filter(Boolean);
+		const nitroJSONPath = nitroJSONPaths.find((p) => existsSync(p));
+		if (!nitroJSONPath) {
+			logger.error("Cannot find `nitro.json`. Did you run `nuxi build` first? Search path:\n", nitroJSONPaths);
+			process.exit(1);
+		}
+		const outputPath = dirname(nitroJSONPath);
+		const nitroJSON = JSON.parse(await promises.readFile(nitroJSONPath, "utf-8"));
+		if (!nitroJSON.commands.preview) {
+			logger.error("Preview is not supported for this build.");
+			process.exit(1);
+		}
+		const info = [
+			["Node.js:", `v${process.versions.node}`],
+			["Nitro Preset:", nitroJSON.preset],
+			["Working directory:", relative(process.cwd(), outputPath)]
+		];
+		const _infoKeyLen = Math.max(...info.map(([label]) => label.length));
+		logger.log(box([
+			"You are running Nuxt production build in preview mode.",
+			`For production deployments, please directly use ${colors.cyan(nitroJSON.commands.preview)} command.`,
+			"",
+			...info.map(([label, value]) => `${label.padEnd(_infoKeyLen, " ")} ${colors.cyan(value)}`)
+		].join("\n"), {
+			title: colors.yellow("Preview Mode"),
+			style: { borderColor: "yellow" }
+		}));
+		const envFileName = ctx.args.dotenv || ".env";
+		if (existsSync(resolve$1(cwd, envFileName))) {
+			logger.info(`Loading \`${envFileName}\`. This will not be loaded when running the server in production.`);
+			await setupDotenv({
+				cwd,
+				fileName: envFileName
+			});
+		} else if (ctx.args.dotenv) logger.error(`Cannot find \`${envFileName}\`.`);
+		const { port } = _resolveListenOptions(ctx.args);
+		logger.info(`Starting preview command: \`${nitroJSON.commands.preview}\``);
+		const [command$1, ...commandArgs] = nitroJSON.commands.preview.split(" ");
+		logger.log("");
+		await x(command$1, commandArgs, {
+			throwOnError: true,
+			nodeOptions: {
+				stdio: "inherit",
+				cwd: outputPath,
+				env: {
+					...process.env,
+					NUXT_PORT: port,
+					NITRO_PORT: port
+				}
+			}
+		});
+	}
+});
+var preview_default = command;
+function _resolveListenOptions(args) {
+	return { port: args.port ?? process.env.NUXT_PORT ?? process.env.NITRO_PORT ?? process.env.PORT };
+}
+
+//#endregion
+export { preview_default as default };

package/dist/search-DCyXfxzn.mjs

@@ -0,0 +1,113 @@
+import { t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import { t as getNuxtVersion } from "./versions-CSy_3o_-.mjs";
+import { n as fetchModules, t as checkNuxtCompatibility } from "./_utils-DTrPahho.mjs";
+import { defineCommand } from "citty";
+import { kebabCase, upperFirst } from "scule";
+import { colors } from "consola/utils";
+import Fuse from "fuse.js";
+
+//#region ../nuxi/src/commands/module/search.ts
+const { format: formatNumber } = Intl.NumberFormat("en-GB", {
+	notation: "compact",
+	maximumFractionDigits: 1
+});
+var search_default = defineCommand({
+	meta: {
+		name: "search",
+		description: "Search in Nuxt modules"
+	},
+	args: {
+		...cwdArgs,
+		query: {
+			type: "positional",
+			description: "keywords to search for",
+			required: true
+		},
+		nuxtVersion: {
+			type: "string",
+			description: "Filter by Nuxt version and list compatible modules only (auto detected by default)",
+			required: false,
+			valueHint: "2|3"
+		}
+	},
+	async setup(ctx) {
+		const nuxtVersion = await getNuxtVersion(ctx.args.cwd);
+		return findModuleByKeywords(ctx.args._.join(" "), nuxtVersion);
+	}
+});
+async function findModuleByKeywords(query, nuxtVersion) {
+	const fuse = new Fuse((await fetchModules()).filter((m) => checkNuxtCompatibility(m, nuxtVersion)), {
+		threshold: .1,
+		keys: [
+			{
+				name: "name",
+				weight: 1
+			},
+			{
+				name: "npm",
+				weight: 1
+			},
+			{
+				name: "repo",
+				weight: 1
+			},
+			{
+				name: "tags",
+				weight: 1
+			},
+			{
+				name: "category",
+				weight: 1
+			},
+			{
+				name: "description",
+				weight: .5
+			},
+			{
+				name: "maintainers.name",
+				weight: .5
+			},
+			{
+				name: "maintainers.github",
+				weight: .5
+			}
+		]
+	});
+	const { bold, green, magenta, cyan, gray, yellow } = colors;
+	const results = fuse.search(query).map((result) => {
+		const res = {
+			name: bold(result.item.name),
+			homepage: cyan(result.item.website),
+			compatibility: `nuxt: ${result.item.compatibility?.nuxt || "*"}`,
+			repository: gray(result.item.github),
+			description: gray(result.item.description),
+			package: gray(result.item.npm),
+			install: cyan(`npx nuxi module add ${result.item.name}`),
+			stars: yellow(formatNumber(result.item.stats.stars)),
+			monthlyDownloads: yellow(formatNumber(result.item.stats.downloads))
+		};
+		if (result.item.github === result.item.website) delete res.homepage;
+		if (result.item.name === result.item.npm) delete res.packageName;
+		return res;
+	});
+	if (!results.length) {
+		logger.info(`No Nuxt modules found matching query ${magenta(query)} for Nuxt ${cyan(nuxtVersion)}`);
+		return;
+	}
+	logger.success(`Found ${results.length} Nuxt ${results.length > 1 ? "modules" : "module"} matching ${cyan(query)} ${nuxtVersion ? `for Nuxt ${cyan(nuxtVersion)}` : ""}:\n`);
+	for (const foundModule of results) {
+		let maxLength = 0;
+		const entries = Object.entries(foundModule).map(([key, val]) => {
+			const label = upperFirst(kebabCase(key)).replace(/-/g, " ");
+			if (label.length > maxLength) maxLength = label.length;
+			return [label, val || "-"];
+		});
+		let infoStr = "";
+		for (const [label, value] of entries) infoStr += `${bold(label === "Install" ? "→ " : "- ") + green(label.padEnd(maxLength + 2)) + value}\n`;
+		logger.log(infoStr);
+	}
+}
+
+//#endregion
+export { search_default as default };

package/dist/test-CBt1emEB.mjs

@@ -0,0 +1,55 @@
+import { a as legacyRootDirArgs, o as logLevelArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { resolve } from "pathe";
+
+//#region ../nuxi/src/commands/test.ts
+var test_default = defineCommand({
+	meta: {
+		name: "test",
+		description: "Run tests"
+	},
+	args: {
+		...cwdArgs,
+		...logLevelArgs,
+		...legacyRootDirArgs,
+		dev: {
+			type: "boolean",
+			description: "Run in dev mode"
+		},
+		watch: {
+			type: "boolean",
+			description: "Watch mode"
+		}
+	},
+	async run(ctx) {
+		process.env.NODE_ENV = process.env.NODE_ENV || "test";
+		const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+		const { runTests } = await importTestUtils();
+		await runTests({
+			rootDir: cwd,
+			dev: ctx.args.dev,
+			watch: ctx.args.watch
+		});
+	}
+});
+async function importTestUtils() {
+	let err;
+	for (const pkg of [
+		"@nuxt/test-utils-nightly",
+		"@nuxt/test-utils-edge",
+		"@nuxt/test-utils"
+	]) try {
+		const exports = await import(pkg);
+		if (!exports.runTests) throw new Error("Invalid version of `@nuxt/test-utils` is installed!");
+		return exports;
+	} catch (_err) {
+		err = _err;
+	}
+	logger.error(err);
+	throw new Error("`@nuxt/test-utils` seems missing. Run `npm i -D @nuxt/test-utils` or `yarn add -D @nuxt/test-utils` to install.");
+}
+
+//#endregion
+export { test_default as default };

package/dist/typecheck-DCWe7Iej.mjs

@@ -0,0 +1,102 @@
+import { a as legacyRootDirArgs, i as extendsArgs, n as dotEnvArgs, o as logLevelArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as loadKit } from "./kit-xFxVGu6d.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { isBun } from "std-env";
+import { resolveModulePath } from "exsolve";
+import { resolve } from "pathe";
+import { x } from "tinyexec";
+import { readTSConfig } from "pkg-types";
+
+//#region ../nuxi/src/commands/typecheck.ts
+var typecheck_default = defineCommand({
+	meta: {
+		name: "typecheck",
+		description: "Runs `vue-tsc` to check types throughout your app."
+	},
+	args: {
+		...cwdArgs,
+		...logLevelArgs,
+		...dotEnvArgs,
+		...extendsArgs,
+		...legacyRootDirArgs
+	},
+	async run(ctx) {
+		process.env.NODE_ENV = process.env.NODE_ENV || "production";
+		const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+		const [supportsProjects, resolvedTypeScript, resolvedVueTsc] = await Promise.all([
+			readTSConfig(cwd).then((r) => !!r.references?.length),
+			resolveModulePath("typescript", { try: true }),
+			resolveModulePath("vue-tsc/bin/vue-tsc.js", { try: true }),
+			writeTypes(cwd, ctx.args.dotenv, ctx.args.logLevel, {
+				...ctx.data?.overrides,
+				...ctx.args.extends && { extends: ctx.args.extends }
+			})
+		]);
+		const typeCheckArgs = supportsProjects ? ["-b", "--noEmit"] : ["--noEmit"];
+		if (resolvedTypeScript && resolvedVueTsc) return await x(resolvedVueTsc, typeCheckArgs, {
+			throwOnError: true,
+			nodeOptions: {
+				stdio: "inherit",
+				cwd
+			}
+		});
+		if (isBun) {
+			await x("bun", [
+				"install",
+				"typescript",
+				"vue-tsc",
+				"--global",
+				"--silent"
+			], {
+				throwOnError: true,
+				nodeOptions: {
+					stdio: "inherit",
+					cwd
+				}
+			});
+			return await x("bunx", ["vue-tsc", ...typeCheckArgs], {
+				throwOnError: true,
+				nodeOptions: {
+					stdio: "inherit",
+					cwd
+				}
+			});
+		}
+		await x("npx", [
+			"-p",
+			"vue-tsc",
+			"-p",
+			"typescript",
+			"vue-tsc",
+			...typeCheckArgs
+		], {
+			throwOnError: true,
+			nodeOptions: {
+				stdio: "inherit",
+				cwd
+			}
+		});
+	}
+});
+async function writeTypes(cwd, dotenv, logLevel, overrides) {
+	const { loadNuxt, buildNuxt, writeTypes: writeTypes$1 } = await loadKit(cwd);
+	const nuxt = await loadNuxt({
+		cwd,
+		dotenv: {
+			cwd,
+			fileName: dotenv
+		},
+		overrides: {
+			_prepare: true,
+			logLevel,
+			...overrides
+		}
+	});
+	await writeTypes$1(nuxt);
+	await buildNuxt(nuxt);
+	await nuxt.close();
+}
+
+//#endregion
+export { typecheck_default as default };

package/dist/upgrade-BMSFcUWJ.mjs

@@ -0,0 +1,184 @@
+import { a as legacyRootDirArgs, o as logLevelArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import "./fs-ewAp6tjM.mjs";
+import { t as loadKit } from "./kit-xFxVGu6d.mjs";
+import { r as nuxtVersionToGitIdentifier, t as cleanupNuxtDirs } from "./nuxt-Cc9ZTk7m.mjs";
+import { t as getPackageManagerVersion } from "./packageManagers-DbVB5cXf.mjs";
+import { t as getNuxtVersion } from "./versions-CSy_3o_-.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { existsSync } from "node:fs";
+import { resolve } from "pathe";
+import { colors } from "consola/utils";
+import { addDependency, dedupeDependencies, detectPackageManager } from "nypm";
+import { readPackageJSON } from "pkg-types";
+
+//#region ../nuxi/src/commands/upgrade.ts
+function checkNuxtDependencyType(pkg) {
+	if (pkg.dependencies?.nuxt) return "dependencies";
+	if (pkg.devDependencies?.nuxt) return "devDependencies";
+	return "dependencies";
+}
+const nuxtVersionTags = {
+	"3.x": "3x",
+	"4.x": "latest"
+};
+function getNightlyDependency(dep, nuxtVersion) {
+	return `${dep}@npm:${dep}-nightly@${nuxtVersionTags[nuxtVersion]}`;
+}
+async function getNightlyVersion(packageNames) {
+	const nuxtVersion = await logger.prompt("Which nightly Nuxt release channel do you want to install? (3.x or 4.x)", {
+		type: "select",
+		options: ["3.x", "4.x"],
+		default: "4.x",
+		cancel: "reject"
+	}).catch(() => process.exit(1));
+	return {
+		npmPackages: packageNames.map((p) => getNightlyDependency(p, nuxtVersion)),
+		nuxtVersion
+	};
+}
+async function getRequiredNewVersion(packageNames, channel) {
+	switch (channel) {
+		case "nightly": return getNightlyVersion(packageNames);
+		case "v3": return {
+			npmPackages: packageNames.map((p) => `${p}@3`),
+			nuxtVersion: "3.x"
+		};
+		case "v3-nightly": return {
+			npmPackages: packageNames.map((p) => getNightlyDependency(p, "3.x")),
+			nuxtVersion: "3.x"
+		};
+		case "v4": return {
+			npmPackages: packageNames.map((p) => `${p}@4`),
+			nuxtVersion: "4.x"
+		};
+		case "v4-nightly": return {
+			npmPackages: packageNames.map((p) => getNightlyDependency(p, "4.x")),
+			nuxtVersion: "4.x"
+		};
+		case "stable":
+		default: return {
+			npmPackages: packageNames.map((p) => `${p}@latest`),
+			nuxtVersion: "4.x"
+		};
+	}
+}
+var upgrade_default = defineCommand({
+	meta: {
+		name: "upgrade",
+		description: "Upgrade Nuxt"
+	},
+	args: {
+		...cwdArgs,
+		...logLevelArgs,
+		...legacyRootDirArgs,
+		dedupe: {
+			type: "boolean",
+			description: "Dedupe dependencies after upgrading"
+		},
+		force: {
+			type: "boolean",
+			alias: "f",
+			description: "Force upgrade to recreate lockfile and node_modules"
+		},
+		channel: {
+			type: "string",
+			alias: "ch",
+			default: "stable",
+			description: "Specify a channel to install from (default: stable)",
+			valueHint: "stable|nightly|v3|v4|v4-nightly|v3-nightly"
+		}
+	},
+	async run(ctx) {
+		const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+		const packageManager = await detectPackageManager(cwd);
+		if (!packageManager) {
+			logger.error(`Unable to determine the package manager used by this project.\n\nNo lock files found in \`${cwd}\`, and no \`packageManager\` field specified in \`package.json\`.\n\nPlease either add the \`packageManager\` field to \`package.json\` or execute the installation command for your package manager. For example, you can use \`pnpm i\`, \`npm i\`, \`bun i\`, or \`yarn i\`, and then try again.`);
+			process.exit(1);
+		}
+		const { name: packageManagerName, lockFile: lockFileCandidates } = packageManager;
+		const packageManagerVersion = getPackageManagerVersion(packageManagerName);
+		logger.info("Package manager:", packageManagerName, packageManagerVersion);
+		const currentVersion = await getNuxtVersion(cwd, false) || "[unknown]";
+		logger.info("Current Nuxt version:", currentVersion);
+		const pkg = await readPackageJSON(cwd).catch(() => null);
+		const nuxtDependencyType = pkg ? checkNuxtDependencyType(pkg) : "dependencies";
+		const { npmPackages, nuxtVersion } = await getRequiredNewVersion(["nuxt", ...pkg ? [
+			"@nuxt/kit",
+			"@nuxt/schema",
+			"@nuxt/vite-builder",
+			"@nuxt/webpack-builder",
+			"@nuxt/rspack-builder"
+		].filter((p) => pkg.dependencies?.[p] || pkg.devDependencies?.[p]) : []], ctx.args.channel);
+		const toRemove = ["node_modules"];
+		const lockFile = normaliseLockFile(cwd, lockFileCandidates);
+		if (lockFile) toRemove.push(lockFile);
+		const forceRemovals = toRemove.map((p) => colors.cyan(p)).join(" and ");
+		let method = ctx.args.force ? "force" : ctx.args.dedupe ? "dedupe" : void 0;
+		method ||= await logger.prompt(`Would you like to dedupe your lockfile (recommended) or recreate ${forceRemovals}? This can fix problems with hoisted dependency versions and ensure you have the most up-to-date dependencies.`, {
+			type: "select",
+			initial: "dedupe",
+			cancel: "reject",
+			options: [
+				{
+					label: "dedupe lockfile",
+					value: "dedupe",
+					hint: "recommended"
+				},
+				{
+					label: `recreate ${forceRemovals}`,
+					value: "force"
+				},
+				{
+					label: "skip",
+					value: "skip"
+				}
+			]
+		}).catch(() => process.exit(1));
+		const versionType = ctx.args.channel === "nightly" ? "nightly" : `latest ${ctx.args.channel}`;
+		logger.info(`Installing ${versionType} Nuxt ${nuxtVersion} release...`);
+		await addDependency(npmPackages, {
+			cwd,
+			packageManager,
+			dev: nuxtDependencyType === "devDependencies"
+		});
+		if (method === "force") {
+			logger.info(`Recreating ${forceRemovals}. If you encounter any issues, revert the changes and try with \`--no-force\``);
+			await dedupeDependencies({ recreateLockfile: true });
+		}
+		if (method === "dedupe") {
+			logger.info("Try deduping dependencies...");
+			await dedupeDependencies();
+		}
+		let buildDir = ".nuxt";
+		try {
+			const { loadNuxtConfig } = await loadKit(cwd);
+			buildDir = (await loadNuxtConfig({ cwd })).buildDir;
+		} catch {}
+		await cleanupNuxtDirs(cwd, buildDir);
+		const upgradedVersion = await getNuxtVersion(cwd, false) || "[unknown]";
+		logger.info("Upgraded Nuxt version:", upgradedVersion);
+		if (upgradedVersion === "[unknown]") return;
+		if (upgradedVersion === currentVersion) logger.success("You're using the latest version of Nuxt.");
+		else {
+			logger.success("Successfully upgraded Nuxt from", currentVersion, "to", upgradedVersion);
+			if (currentVersion === "[unknown]") return;
+			const commitA = nuxtVersionToGitIdentifier(currentVersion);
+			const commitB = nuxtVersionToGitIdentifier(upgradedVersion);
+			if (commitA && commitB) logger.info("Changelog:", `https://github.com/nuxt/nuxt/compare/${commitA}...${commitB}`);
+		}
+	}
+});
+function normaliseLockFile(cwd, lockFiles) {
+	if (typeof lockFiles === "string") lockFiles = [lockFiles];
+	const lockFile = lockFiles?.find((file) => existsSync(resolve(cwd, file)));
+	if (lockFile === void 0) {
+		logger.error(`Unable to find any lock files in ${cwd}`);
+		return;
+	}
+	return lockFile;
+}
+
+//#endregion
+export { upgrade_default as default };

package/dist/versions-CSy_3o_-.mjs

@@ -0,0 +1,18 @@
+import { coerce } from "semver";
+import { readPackageJSON } from "pkg-types";
+
+//#region ../nuxi/src/utils/versions.ts
+async function getNuxtVersion(cwd, cache = true) {
+	const nuxtPkg = await readPackageJSON("nuxt", {
+		url: cwd,
+		try: true,
+		cache
+	});
+	if (nuxtPkg) return nuxtPkg.version;
+	const pkg = await readPackageJSON(cwd);
+	const pkgDep = pkg?.dependencies?.nuxt || pkg?.devDependencies?.nuxt;
+	return pkgDep && coerce(pkgDep)?.version || "3.0.0";
+}
+
+//#endregion
+export { getNuxtVersion as t };