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

package/dist/index.mjs

@@ -1,8 +1,129 @@
-export { m as main, r as runCommand, f as runMain } from './shared/cli-nightly.BRlCc6aT.mjs';
-import 'node:path';
-import 'node:process';
-import 'citty';
-import 'std-env';
-import 'consola';
-import './shared/cli-nightly.B9AmABr3.mjs';
-import 'node:url';
+import { t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import { resolve } from "node:path";
+import process from "node:process";
+import { defineCommand, runCommand as runCommand$1, runMain as runMain$1 } from "citty";
+import { provider } from "std-env";
+import { consola } from "consola";
+import { fileURLToPath } from "node:url";
+
+//#region ../nuxi/src/commands/index.ts
+const _rDefault = (r) => r.default || r;
+const commands = {
+	add: () => import("./add-BGMHIn5L.mjs").then(_rDefault),
+	analyze: () => import("./analyze-CUKAi_IN.mjs").then(_rDefault),
+	build: () => import("./build-KNIBU0AI.mjs").then(_rDefault),
+	cleanup: () => import("./cleanup-8GRakeLu.mjs").then(_rDefault),
+	_dev: () => import("./dev-child-CSiX6Uyv.mjs").then(_rDefault),
+	dev: () => import("./dev-Bs_0dzlh.mjs").then(_rDefault),
+	devtools: () => import("./devtools-BLGzUSNU.mjs").then(_rDefault),
+	generate: () => import("./generate-CGy3-x2K.mjs").then(_rDefault),
+	info: () => import("./info-BDdsghj1.mjs").then(_rDefault),
+	init: () => import("./init-_n9DXzzY.mjs").then(_rDefault),
+	module: () => import("./module-CqBrGD-s.mjs").then(_rDefault),
+	prepare: () => import("./prepare-B0KOhO-L.mjs").then(_rDefault),
+	preview: () => import("./preview-C5fNqrC6.mjs").then(_rDefault),
+	start: () => import("./preview-C5fNqrC6.mjs").then(_rDefault),
+	test: () => import("./test-CBt1emEB.mjs").then(_rDefault),
+	typecheck: () => import("./typecheck-DCWe7Iej.mjs").then(_rDefault),
+	upgrade: () => import("./upgrade-BMSFcUWJ.mjs").then(_rDefault)
+};
+
+//#endregion
+//#region ../nuxi/src/utils/console.ts
+function wrapReporter(reporter) {
+	return { log(logObj, ctx) {
+		if (!logObj.args || !logObj.args.length) return;
+		const msg = logObj.args[0];
+		if (typeof msg === "string" && !process.env.DEBUG) {
+			if (msg.startsWith("[Vue Router warn]: No match found for location with path")) return;
+			if (msg.includes("ExperimentalWarning: The Fetch API is an experimental feature")) return;
+			if (msg.startsWith("Sourcemap") && msg.includes("node_modules")) return;
+		}
+		return reporter.log(logObj, ctx);
+	} };
+}
+function setupGlobalConsole(opts = {}) {
+	consola.options.reporters = consola.options.reporters.map(wrapReporter);
+	if (opts.dev) consola.wrapAll();
+	else consola.wrapConsole();
+	process.on("unhandledRejection", (err) => consola.error("[unhandledRejection]", err));
+	process.on("uncaughtException", (err) => consola.error("[uncaughtException]", err));
+}
+
+//#endregion
+//#region ../nuxi/src/utils/engines.ts
+async function checkEngines() {
+	const satisfies = await import("semver/functions/satisfies.js").then((r) => r.default || r);
+	const currentNode = process.versions.node;
+	const nodeRange = ">= 18.0.0";
+	if (!satisfies(currentNode, nodeRange)) logger.warn(`Current version of Node.js (\`${currentNode}\`) is unsupported and might cause issues.\n       Please upgrade to a compatible version \`${nodeRange}\`.`);
+}
+
+//#endregion
+//#region package.json
+var name = "@nuxt/cli-nightly";
+var version = "3.29.4-20251021-190716-bbf70fc";
+var description = "Nuxt CLI";
+
+//#endregion
+//#region src/main.ts
+const _main = defineCommand({
+	meta: {
+		name: name.endsWith("nightly") ? name : "nuxi",
+		version,
+		description
+	},
+	args: {
+		...cwdArgs,
+		command: {
+			type: "positional",
+			required: false
+		}
+	},
+	subCommands: commands,
+	async setup(ctx) {
+		const command = ctx.args._[0];
+		setupGlobalConsole({ dev: command === "dev" });
+		let backgroundTasks;
+		if (command !== "_dev" && provider !== "stackblitz") backgroundTasks = Promise.all([checkEngines()]).catch((err) => logger.error(err));
+		if (command === "init") await backgroundTasks;
+		if (ctx.args.command && !(ctx.args.command in commands)) {
+			const cwd = resolve(ctx.args.cwd);
+			try {
+				const { x } = await import("tinyexec");
+				await x(`nuxt-${ctx.args.command}`, ctx.rawArgs.slice(1), {
+					nodeOptions: {
+						stdio: "inherit",
+						cwd
+					},
+					throwOnError: true
+				});
+			} catch (err) {
+				if (err instanceof Error && "code" in err && err.code === "ENOENT") return;
+			}
+			process.exit();
+		}
+	}
+});
+const main = _main;
+
+//#endregion
+//#region src/run.ts
+globalThis.__nuxt_cli__ = globalThis.__nuxt_cli__ || {
+	startTime: Date.now(),
+	entry: fileURLToPath(new URL("../../bin/nuxi.mjs", import.meta.url)),
+	devEntry: fileURLToPath(new URL("../dev/index.mjs", import.meta.url))
+};
+const runMain = () => runMain$1(main);
+async function runCommand(name$1, argv = process.argv.slice(2), data = {}) {
+	argv.push("--no-clear");
+	if (!(name$1 in commands)) throw new Error(`Invalid command ${name$1}`);
+	return await runCommand$1(await commands[name$1](), {
+		rawArgs: argv,
+		data: { overrides: data.overrides || {} }
+	});
+}
+
+//#endregion
+export { main, runCommand, runMain };

package/dist/info-BDdsghj1.mjs

@@ -0,0 +1,120 @@
+import { a as legacyRootDirArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import { n as tryResolveNuxt } from "./kit-xFxVGu6d.mjs";
+import { t as getPackageManagerVersion } from "./packageManagers-DbVB5cXf.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { isMinimal } from "std-env";
+import { resolve } from "pathe";
+import { splitByCase } from "scule";
+import os from "node:os";
+import { copy } from "copy-paste";
+import { detectPackageManager } from "nypm";
+import { readPackageJSON } from "pkg-types";
+
+//#region ../nuxi/package.json
+var version = "3.29.4-20251021-190708-bbf70fc";
+
+//#endregion
+//#region ../nuxi/src/commands/info.ts
+var info_default = defineCommand({
+	meta: {
+		name: "info",
+		description: "Get information about Nuxt project"
+	},
+	args: {
+		...cwdArgs,
+		...legacyRootDirArgs
+	},
+	async run(ctx) {
+		const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+		const nuxtConfig = await getNuxtConfig(cwd);
+		const { dependencies = {}, devDependencies = {} } = await readPackageJSON(cwd).catch(() => ({}));
+		const nuxtPath = tryResolveNuxt(cwd);
+		async function getDepVersion(name) {
+			for (const url of [cwd, nuxtPath]) {
+				if (!url) continue;
+				const pkg = await readPackageJSON(name, { url }).catch(() => null);
+				if (pkg) return pkg.version;
+			}
+			return dependencies[name] || devDependencies[name];
+		}
+		async function listModules(arr = []) {
+			const info = [];
+			for (let m of arr) {
+				if (Array.isArray(m)) m = m[0];
+				const name = normalizeConfigModule(m, cwd);
+				if (name) {
+					const v = await getDepVersion(name.split("/").splice(0, 2).join("/"));
+					info.push(`\`${v ? `${name}@${v}` : name}\``);
+				}
+			}
+			return info.join(", ");
+		}
+		const nuxtVersion = await getDepVersion("nuxt") || await getDepVersion("nuxt-nightly") || await getDepVersion("nuxt-edge") || await getDepVersion("nuxt3") || "-";
+		const isLegacy = nuxtVersion.startsWith("2");
+		const builder = !isLegacy ? nuxtConfig.builder || "-" : nuxtConfig.bridge?.vite ? "vite" : nuxtConfig.buildModules?.includes("nuxt-vite") ? "vite" : "webpack";
+		let packageManager = (await detectPackageManager(cwd))?.name;
+		if (packageManager) packageManager += `@${getPackageManagerVersion(packageManager)}`;
+		const infoObj = {
+			OperatingSystem: os.type(),
+			NodeVersion: process.version,
+			NuxtVersion: nuxtVersion,
+			CLIVersion: version,
+			NitroVersion: await getDepVersion("nitropack"),
+			PackageManager: packageManager ?? "unknown",
+			Builder: typeof builder === "string" ? builder : "custom",
+			UserConfig: Object.keys(nuxtConfig).map((key) => `\`${key}\``).join(", "),
+			RuntimeModules: await listModules(nuxtConfig.modules),
+			BuildModules: await listModules(nuxtConfig.buildModules || [])
+		};
+		logger.log("Working directory:", cwd);
+		let maxLength = 0;
+		const entries = Object.entries(infoObj).map(([key, val]) => {
+			const label = splitByCase(key).join(" ");
+			if (label.length > maxLength) maxLength = label.length;
+			return [label, val || "-"];
+		});
+		let infoStr = "";
+		for (const [label, value] of entries) infoStr += `- ${`${label}: `.padEnd(maxLength + 2)}${value.includes("`") ? value : `\`${value}\``}\n`;
+		const copied = !isMinimal && await new Promise((resolve$1) => copy(infoStr, (err) => resolve$1(!err)));
+		const isNuxt3 = !isLegacy;
+		const isBridge = !isNuxt3 && infoObj.BuildModules.includes("bridge");
+		const repo = isBridge ? "nuxt/bridge" : "nuxt/nuxt";
+		const log = [
+			(isNuxt3 || isBridge) && `👉 Report an issue: https://github.com/${repo}/issues/new?template=bug-report.yml`,
+			(isNuxt3 || isBridge) && `👉 Suggest an improvement: https://github.com/${repo}/discussions/new`,
+			`👉 Read documentation: ${isNuxt3 || isBridge ? "https://nuxt.com" : "https://v2.nuxt.com"}`
+		].filter(Boolean).join("\n");
+		const splitter = "------------------------------";
+		logger.log(`Nuxt project info: ${copied ? "(copied to clipboard)" : ""}\n\n${splitter}\n${infoStr}${splitter}\n\n${log}\n`);
+	}
+});
+function normalizeConfigModule(module, rootDir) {
+	if (!module) return null;
+	if (typeof module === "string") return module.split(rootDir).pop().split("node_modules").pop().replace(/^\//, "");
+	if (typeof module === "function") return `${module.name}()`;
+	if (Array.isArray(module)) return normalizeConfigModule(module[0], rootDir);
+	return null;
+}
+async function getNuxtConfig(rootDir) {
+	try {
+		const { createJiti } = await import("jiti");
+		const jiti = createJiti(rootDir, {
+			interopDefault: true,
+			alias: {
+				"~": rootDir,
+				"@": rootDir
+			}
+		});
+		globalThis.defineNuxtConfig = (c) => c;
+		const result = await jiti.import("./nuxt.config", { default: true });
+		delete globalThis.defineNuxtConfig;
+		return result;
+	} catch {
+		return {};
+	}
+}
+
+//#endregion
+export { info_default as default };

package/dist/init-_n9DXzzY.mjs

@@ -0,0 +1,336 @@
+import { o as logLevelArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import "./fs-ewAp6tjM.mjs";
+import "./kit-xFxVGu6d.mjs";
+import { n as runCommand$1, t as add_default } from "./add-CRBwIlDF.mjs";
+import "./versions-CSy_3o_-.mjs";
+import "./prepare-xI978yFg.mjs";
+import "./_utils-DTrPahho.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { hasTTY } from "std-env";
+import { existsSync } from "node:fs";
+import { basename, join, relative, resolve } from "pathe";
+import { colors } from "consola/utils";
+import { x } from "tinyexec";
+import { installDependencies } from "nypm";
+import { findFile, readPackageJSON, writePackageJSON } from "pkg-types";
+import { downloadTemplate, startShell } from "giget";
+import { $fetch } from "ofetch";
+
+//#region ../nuxi/src/utils/ascii.ts
+/**
+* Thank you to IndyJoenz for this ASCII art
+* https://bsky.app/profile/durdraw.org/post/3liadod3gv22a
+*/
+const themeColor = "\x1B[38;2;0;220;130m";
+const icon = [
+	`        .d$b.`,
+	`       i$$A$$L  .d$b`,
+	`     .$$F\` \`$$L.$$A$$.`,
+	`    j$$'    \`4$$:\` \`$$.`,
+	`   j$$'     .4$:    \`$$.`,
+	`  j$$\`     .$$:      \`4$L`,
+	` :$$:____.d$$:  _____.:$$:`,
+	` \`4$$$$$$$$P\` .i$$$$$$$$P\``
+];
+const nuxtIcon = icon.map((line) => line.split("").join(themeColor)).join("\n");
+
+//#endregion
+//#region ../nuxi/src/commands/init.ts
+const DEFAULT_REGISTRY = "https://raw.githubusercontent.com/nuxt/starter/templates/templates";
+const DEFAULT_TEMPLATE_NAME = "v4";
+const packageManagerOptions = Object.keys({
+	npm: void 0,
+	pnpm: void 0,
+	yarn: void 0,
+	bun: void 0,
+	deno: void 0
+});
+async function getModuleDependencies(moduleName) {
+	try {
+		const dependencies = (await $fetch(`https://registry.npmjs.org/${moduleName}/latest`)).dependencies || {};
+		return Object.keys(dependencies);
+	} catch (err) {
+		logger.warn(`Could not get dependencies for ${moduleName}: ${err}`);
+		return [];
+	}
+}
+function filterModules(modules, allDependencies) {
+	const result = {
+		toInstall: [],
+		skipped: []
+	};
+	for (const module of modules) if (modules.some((otherModule) => {
+		if (otherModule === module) return false;
+		return (allDependencies[otherModule] || []).includes(module);
+	})) result.skipped.push(module);
+	else result.toInstall.push(module);
+	return result;
+}
+async function getTemplateDependencies(templateDir) {
+	try {
+		const packageJsonPath = join(templateDir, "package.json");
+		if (!existsSync(packageJsonPath)) return [];
+		const packageJson = await readPackageJSON(packageJsonPath);
+		const directDeps = {
+			...packageJson.dependencies,
+			...packageJson.devDependencies
+		};
+		const directDepNames = Object.keys(directDeps);
+		const allDeps = new Set(directDepNames);
+		(await Promise.all(directDepNames.map((dep) => getModuleDependencies(dep)))).forEach((deps) => {
+			deps.forEach((dep) => allDeps.add(dep));
+		});
+		return Array.from(allDeps);
+	} catch (err) {
+		logger.warn(`Could not read template dependencies: ${err}`);
+		return [];
+	}
+}
+var init_default = defineCommand({
+	meta: {
+		name: "init",
+		description: "Initialize a fresh project"
+	},
+	args: {
+		...cwdArgs,
+		...logLevelArgs,
+		dir: {
+			type: "positional",
+			description: "Project directory",
+			default: ""
+		},
+		template: {
+			type: "string",
+			alias: "t",
+			description: "Template name"
+		},
+		force: {
+			type: "boolean",
+			alias: "f",
+			description: "Override existing directory"
+		},
+		offline: {
+			type: "boolean",
+			description: "Force offline mode"
+		},
+		preferOffline: {
+			type: "boolean",
+			description: "Prefer offline mode"
+		},
+		install: {
+			type: "boolean",
+			default: true,
+			description: "Skip installing dependencies"
+		},
+		gitInit: {
+			type: "boolean",
+			description: "Initialize git repository"
+		},
+		shell: {
+			type: "boolean",
+			description: "Start shell after installation in project directory"
+		},
+		packageManager: {
+			type: "string",
+			description: "Package manager choice (npm, pnpm, yarn, bun)"
+		},
+		modules: {
+			type: "string",
+			required: false,
+			description: "Nuxt modules to install (comma separated without spaces)",
+			negativeDescription: "Skip module installation prompt",
+			alias: "M"
+		},
+		nightly: {
+			type: "string",
+			description: "Use Nuxt nightly release channel (3x or latest)"
+		}
+	},
+	async run(ctx) {
+		if (hasTTY) process.stdout.write(`\n${nuxtIcon}\n\n`);
+		logger.info(colors.bold(`Welcome to Nuxt!`.split("").map((m) => `${themeColor}${m}`).join("")));
+		if (ctx.args.dir === "") ctx.args.dir = await logger.prompt("Where would you like to create your project?", {
+			placeholder: "./nuxt-app",
+			type: "text",
+			default: "nuxt-app",
+			cancel: "reject"
+		}).catch(() => process.exit(1));
+		const cwd = resolve(ctx.args.cwd);
+		let templateDownloadPath = resolve(cwd, ctx.args.dir);
+		logger.info(`Creating a new project in ${colors.cyan(relative(cwd, templateDownloadPath) || templateDownloadPath)}.`);
+		const templateName = ctx.args.template || DEFAULT_TEMPLATE_NAME;
+		if (typeof templateName !== "string") {
+			logger.error("Please specify a template!");
+			process.exit(1);
+		}
+		let shouldForce = Boolean(ctx.args.force);
+		if (!shouldForce && existsSync(templateDownloadPath)) switch (await logger.prompt(`The directory ${colors.cyan(templateDownloadPath)} already exists. What would you like to do?`, {
+			type: "select",
+			options: [
+				"Override its contents",
+				"Select different directory",
+				"Abort"
+			]
+		})) {
+			case "Override its contents":
+				shouldForce = true;
+				break;
+			case "Select different directory":
+				templateDownloadPath = resolve(cwd, await logger.prompt("Please specify a different directory:", {
+					type: "text",
+					cancel: "reject"
+				}).catch(() => process.exit(1)));
+				break;
+			default: process.exit(1);
+		}
+		let template;
+		try {
+			template = await downloadTemplate(templateName, {
+				dir: templateDownloadPath,
+				force: shouldForce,
+				offline: Boolean(ctx.args.offline),
+				preferOffline: Boolean(ctx.args.preferOffline),
+				registry: process.env.NUXI_INIT_REGISTRY || DEFAULT_REGISTRY
+			});
+			if (ctx.args.dir.length > 0) {
+				const path = await findFile("package.json", {
+					startingFrom: join(templateDownloadPath, "package.json"),
+					reverse: true
+				});
+				if (path) {
+					const pkg = await readPackageJSON(path, { try: true });
+					if (pkg && pkg.name) {
+						const slug = basename(templateDownloadPath).replace(/[^\w-]/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+						if (slug) {
+							pkg.name = slug;
+							await writePackageJSON(path, pkg);
+						}
+					}
+				}
+			}
+		} catch (err) {
+			if (process.env.DEBUG) throw err;
+			logger.error(err.toString());
+			process.exit(1);
+		}
+		if (ctx.args.nightly !== void 0 && !ctx.args.offline && !ctx.args.preferOffline) {
+			const response = await $fetch("https://registry.npmjs.org/nuxt-nightly");
+			const nightlyChannelTag = ctx.args.nightly || "latest";
+			if (!nightlyChannelTag) {
+				logger.error(`Error getting nightly channel tag.`);
+				process.exit(1);
+			}
+			const nightlyChannelVersion = response["dist-tags"][nightlyChannelTag];
+			if (!nightlyChannelVersion) {
+				logger.error(`Nightly channel version for tag '${nightlyChannelTag}' not found.`);
+				process.exit(1);
+			}
+			const nightlyNuxtPackageJsonVersion = `npm:nuxt-nightly@${nightlyChannelVersion}`;
+			const packageJsonPath = resolve(cwd, ctx.args.dir);
+			const packageJson = await readPackageJSON(packageJsonPath);
+			if (packageJson.dependencies && "nuxt" in packageJson.dependencies) packageJson.dependencies.nuxt = nightlyNuxtPackageJsonVersion;
+			else if (packageJson.devDependencies && "nuxt" in packageJson.devDependencies) packageJson.devDependencies.nuxt = nightlyNuxtPackageJsonVersion;
+			await writePackageJSON(join(packageJsonPath, "package.json"), packageJson);
+		}
+		function detectCurrentPackageManager() {
+			const userAgent = process.env.npm_config_user_agent;
+			if (!userAgent) return;
+			const [name] = userAgent.split("/");
+			if (packageManagerOptions.includes(name)) return name;
+		}
+		const currentPackageManager = detectCurrentPackageManager();
+		const packageManagerArg = ctx.args.packageManager;
+		const packageManagerSelectOptions = packageManagerOptions.map((pm) => ({
+			label: pm,
+			value: pm,
+			hint: currentPackageManager === pm ? "current" : void 0
+		}));
+		const selectedPackageManager = packageManagerOptions.includes(packageManagerArg) ? packageManagerArg : await logger.prompt("Which package manager would you like to use?", {
+			type: "select",
+			options: packageManagerSelectOptions,
+			initial: currentPackageManager,
+			cancel: "reject"
+		}).catch(() => process.exit(1));
+		if (ctx.args.install === false) logger.info("Skipping install dependencies step.");
+		else {
+			logger.start("Installing dependencies...");
+			try {
+				await installDependencies({
+					cwd: template.dir,
+					packageManager: {
+						name: selectedPackageManager,
+						command: selectedPackageManager
+					}
+				});
+			} catch (err) {
+				if (process.env.DEBUG) throw err;
+				logger.error(err.toString());
+				process.exit(1);
+			}
+			logger.success("Installation completed.");
+		}
+		if (ctx.args.gitInit === void 0) ctx.args.gitInit = await logger.prompt("Initialize git repository?", {
+			type: "confirm",
+			cancel: "reject"
+		}).catch(() => process.exit(1));
+		if (ctx.args.gitInit) {
+			logger.info("Initializing git repository...\n");
+			try {
+				await x("git", ["init", template.dir], {
+					throwOnError: true,
+					nodeOptions: { stdio: "inherit" }
+				});
+			} catch (err) {
+				logger.warn(`Failed to initialize git repository: ${err}`);
+			}
+		}
+		const modulesToAdd = [];
+		if (ctx.args.modules !== void 0) modulesToAdd.push(...(ctx.args.modules || "").split(",").map((module) => module.trim()).filter(Boolean));
+		else if (!ctx.args.offline && !ctx.args.preferOffline) {
+			const modulesPromise = $fetch("https://api.nuxt.com/modules");
+			if (await logger.prompt(`Would you like to install any of the official modules?`, {
+				initial: false,
+				type: "confirm",
+				cancel: "reject"
+			}).catch(() => process.exit(1))) {
+				const [response, templateDeps] = await Promise.all([modulesPromise, getTemplateDependencies(template.dir)]);
+				const officialModules = response.modules.filter((module) => module.type === "official" && module.npm !== "@nuxt/devtools").filter((module) => !templateDeps.includes(module.npm));
+				if (officialModules.length === 0) logger.info("All official modules are already included in this template.");
+				else {
+					const selectedOfficialModules = await logger.prompt("Pick the modules to install:", {
+						type: "multiselect",
+						options: officialModules.map((module) => ({
+							label: `${colors.bold(colors.greenBright(module.npm))} – ${module.description.replace(/\.$/, "")}`,
+							value: module.npm
+						})),
+						required: false
+					});
+					if (selectedOfficialModules === void 0) process.exit(1);
+					if (selectedOfficialModules.length > 0) {
+						const modules = selectedOfficialModules;
+						const { toInstall, skipped } = filterModules(modules, Object.fromEntries(await Promise.all(modules.map(async (module) => [module, await getModuleDependencies(module)]))));
+						if (skipped.length) logger.info(`The following modules are already included as dependencies of another module and will not be installed: ${skipped.map((m) => colors.cyan(m)).join(", ")}`);
+						modulesToAdd.push(...toInstall);
+					}
+				}
+			}
+		}
+		if (modulesToAdd.length > 0) await runCommand$1(add_default, [
+			...modulesToAdd,
+			`--cwd=${templateDownloadPath}`,
+			ctx.args.install ? "" : "--skipInstall",
+			ctx.args.logLevel ? `--logLevel=${ctx.args.logLevel}` : ""
+		].filter(Boolean));
+		logger.log(`\n✨ Nuxt project has been created with the \`${template.name}\` template. Next steps:`);
+		const relativeTemplateDir = relative(process.cwd(), template.dir) || ".";
+		const runCmd = selectedPackageManager === "deno" ? "task" : "run";
+		const nextSteps = [!ctx.args.shell && relativeTemplateDir.length > 1 && `\`cd ${relativeTemplateDir}\``, `Start development server with \`${selectedPackageManager} ${runCmd} dev\``].filter(Boolean);
+		for (const step of nextSteps) logger.log(` › ${step}`);
+		if (ctx.args.shell) startShell(template.dir);
+	}
+});
+
+//#endregion
+export { init_default as default };

package/dist/kit-xFxVGu6d.mjs

@@ -0,0 +1,37 @@
+import { pathToFileURL } from "node:url";
+import { resolveModulePath } from "exsolve";
+
+//#region ../nuxi/src/utils/kit.ts
+async function loadKit(rootDir) {
+	try {
+		let kit = await import(pathToFileURL(resolveModulePath("@nuxt/kit", { from: tryResolveNuxt(rootDir) || rootDir })).href);
+		if (!kit.writeTypes) kit = {
+			...kit,
+			writeTypes: () => {
+				throw new Error("`writeTypes` is not available in this version of `@nuxt/kit`. Please upgrade to v3.7 or newer.");
+			}
+		};
+		return kit;
+	} catch (e) {
+		if (e.toString().includes("Cannot find module '@nuxt/kit'")) throw new Error("nuxi requires `@nuxt/kit` to be installed in your project. Try installing `nuxt` v3+ or `@nuxt/bridge` first.");
+		throw e;
+	}
+}
+function tryResolveNuxt(rootDir) {
+	for (const pkg of [
+		"nuxt-nightly",
+		"nuxt",
+		"nuxt3",
+		"nuxt-edge"
+	]) {
+		const path = resolveModulePath(pkg, {
+			from: rootDir,
+			try: true
+		});
+		if (path) return path;
+	}
+	return null;
+}
+
+//#endregion
+export { tryResolveNuxt as n, loadKit as t };

package/dist/logger-Dk0gkCkX.mjs

@@ -0,0 +1,7 @@
+import { consola } from "consola";
+
+//#region ../nuxi/src/utils/logger.ts
+const logger = consola.withTag("nuxi");
+
+//#endregion
+export { logger as t };

package/dist/module-CqBrGD-s.mjs

@@ -0,0 +1,17 @@
+import { defineCommand } from "citty";
+
+//#region ../nuxi/src/commands/module/index.ts
+var module_default = defineCommand({
+	meta: {
+		name: "module",
+		description: "Manage Nuxt modules"
+	},
+	args: {},
+	subCommands: {
+		add: () => import("./add-hFFIzkcy.mjs").then((r) => r.default || r),
+		search: () => import("./search-DCyXfxzn.mjs").then((r) => r.default || r)
+	}
+});
+
+//#endregion
+export { module_default as default };