vize 0.64.0 → 0.66.0

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 import { loadConfig } from "./config.mjs";
 import { createRequire } from "node:module";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import { spawnSync } from "node:child_process";
 import { pathToFileURL } from "node:url";
@@ -37,12 +37,19 @@ function getBindingPackageName() {
 		default: throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
 	}
 }
-function loadNative() {
+const REQUIRED_BINDINGS = {
+	build: "compileSfcBatchWithResults",
+	check: "typeCheck",
+	fmt: "formatSfc",
+	lint: "lint"
+};
+function loadNative(command) {
 	const attemptedPackages = getAttemptedPackages();
 	let lastError = null;
+	const requiredBinding = REQUIRED_BINDINGS[command];
 	for (const packageName of attemptedPackages) try {
 		const binding = require(packageName);
-		if (typeof binding.lint !== "function") throw new Error(`${packageName} does not expose the lint binding.`);
+		if (typeof binding[requiredBinding] !== "function") throw new Error(`${packageName} does not expose the ${command} binding.`);
 		return binding;
 	} catch (error) {
 		lastError = error;
@@ -71,7 +78,55 @@ function shouldPreferWorkspaceBinding(resolvedPath) {
 }
 function printUsage() {
 	console.error("Usage: vize <command> [options]");
-	console.error("Commands: lint, musea");
+	console.error("Commands: build, fmt, check, lint, upgrade, ready, musea");
+}
+function printBuildUsage() {
+	console.error("Usage: vize build [options] [files-or-directories]");
+	console.error("Options:");
+	console.error("  -o, --output <dir>             Output directory");
+	console.error("  -f, --format <js|json|stats>   Output format");
+	console.error("      --ssr                      Enable SSR compilation");
+	console.error("      --script-ext <mode>        preserve or downcompile");
+	console.error("  -j, --threads <number>         Worker thread count");
+}
+function printFmtUsage() {
+	console.error("Usage: vize fmt [options] [files-or-directories]");
+	console.error("Options:");
+	console.error("      --check                    Exit with an error if files need formatting");
+	console.error("  -w, --write                    Write formatted output");
+	console.error("      --single-quote             Use single quotes");
+	console.error("      --print-width <number>     Maximum line width");
+	console.error("      --tab-width <number>       Indentation width");
+	console.error("      --use-tabs                 Indent with tabs");
+	console.error("      --no-semi                  Omit semicolons");
+}
+function printCheckUsage() {
+	console.error("Usage: vize check [options] [files-or-directories]");
+	console.error("Options:");
+	console.error("  -f, --format <text|json>       Output format");
+	console.error("  -q, --quiet                    Show summary only");
+	console.error("      --strict                   Enable strict checks");
+	console.error("      --show-virtual-ts          Print generated Virtual TS");
+	console.error("      --max-warnings <number>    Fail when warnings exceed the limit");
+	console.error("  -c, --config <path>            Use a specific vize config file");
+	console.error("      --no-config                Disable config discovery");
+	console.error("");
+	console.error("Note: npm `vize check` uses the packaged NAPI checker. Install the Rust CLI for project-backed Corsa diagnostics.");
+}
+function printUpgradeUsage() {
+	console.error("Usage: vize upgrade [options]");
+	console.error("Options:");
+	console.error("      --package-manager <name>   npm, pnpm, yarn, bun, or vp");
+	console.error("  -g, --global                   Upgrade the global installation");
+	console.error("      --dry-run                  Print the command without running it");
+}
+function printReadyUsage() {
+	console.error("Usage: vize ready [options] [files-or-directories]");
+	console.error("Runs: fmt --write -> lint -> check -> build");
+	console.error("Options:");
+	console.error("  -o, --output <dir>             Output directory for build");
+	console.error("      --ssr                      Enable SSR compilation for build");
+	console.error("      --script-ext <mode>        preserve or downcompile");
 }
 function resolvePackageBinaryFromCwd(packageName, binName = packageName) {
 	const packageJsonPath = createRequire(pathToFileURL(path.join(process.cwd(), "package.json")).href).resolve(`${packageName}/package.json`);
@@ -127,6 +182,459 @@ function parseLintCommand(args) {
 		sharedConfig
 	};
 }
+function parseBuildCommand(args) {
+	const patterns = [];
+	const options = {
+		output: "./dist",
+		format: "js",
+		scriptExt: "downcompile"
+	};
+	const sharedConfig = { configMode: "root" };
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--output" || arg === "-o") options.output = args[++i] ?? options.output;
+		else if (arg === "--format" || arg === "-f") {
+			const format = args[++i];
+			if (format === "js" || format === "json" || format === "stats") options.format = format;
+		} else if (arg === "--ssr") options.ssr = true;
+		else if (arg === "--vapor") options.vapor = true;
+		else if (arg === "--custom-renderer") options.customRenderer = true;
+		else if (arg === "--script-ext") {
+			const scriptExt = args[++i];
+			if (scriptExt === "preserve" || scriptExt === "downcompile") options.scriptExt = scriptExt;
+		} else if (arg === "--threads" || arg === "-j") options.threads = Number.parseInt(args[++i], 10);
+		else if (arg === "--config" || arg === "-c") {
+			const configFile = args[++i];
+			if (!configFile) throw new Error("Missing path after --config");
+			sharedConfig.configFile = configFile;
+		} else if (arg === "--no-config") sharedConfig.configMode = "none";
+		else if (arg === "--profile" || arg === "--continue-on-error") {} else if (arg === "--help" || arg === "-h") options.help = true;
+		else if (!arg.startsWith("-")) patterns.push(arg);
+	}
+	return {
+		patterns,
+		options,
+		sharedConfig
+	};
+}
+function getScriptLang(source) {
+	return source.match(/<script\b[^>]*\blang=["']([^"']+)["']/i)?.[1] ?? "js";
+}
+function getOutputExtension(source, scriptExt) {
+	if (scriptExt === "downcompile") return "js";
+	const lang = getScriptLang(source);
+	return lang === "ts" || lang === "tsx" || lang === "jsx" ? lang : "js";
+}
+function outputFileName(file, extension) {
+	return path.basename(file).replace(/\.vue$/i, `.${extension}`);
+}
+function toNativeBuildOptions(options) {
+	const isTs = options.scriptExt === "preserve";
+	return {
+		ssr: options.ssr,
+		vapor: options.vapor,
+		customRenderer: options.customRenderer,
+		custom_renderer: options.customRenderer,
+		isTs,
+		is_ts: isTs,
+		threads: options.threads
+	};
+}
+async function runBuild(args) {
+	const { patterns, options, sharedConfig } = parseBuildCommand(args);
+	if (options.help) {
+		printBuildUsage();
+		return;
+	}
+	const config = await loadConfig(process.cwd(), {
+		mode: sharedConfig.configMode,
+		configFile: sharedConfig.configFile,
+		env: {
+			mode: process.env.NODE_ENV ?? "development",
+			command: "build"
+		}
+	});
+	if (sharedConfig.configFile && !config) throw new Error(`Could not find config file: ${sharedConfig.configFile}`);
+	options.ssr ??= config?.compiler?.ssr;
+	options.vapor ??= config?.compiler?.vapor;
+	options.customRenderer ??= config?.compiler?.customRenderer;
+	if (config?.compiler?.scriptExt === "ts") options.scriptExt = "preserve";
+	else if (config?.compiler?.scriptExt === "js") options.scriptExt = "downcompile";
+	const files = collectVueFiles(patterns);
+	if (files.length === 0) {
+		process.stderr.write(`No Vue files found matching inputs: ${JSON.stringify(patterns)}\n`);
+		process.exit(1);
+	}
+	const inputs = files.map((file) => ({
+		path: file,
+		source: readFileSync(file, "utf8")
+	}));
+	const native = loadNative("build");
+	const startedAt = performance.now();
+	const result = native.compileSfcBatchWithResults(inputs, toNativeBuildOptions(options));
+	const timeMs = result.timeMs ?? result.time_ms ?? performance.now() - startedAt;
+	const results = [...result.results].sort((left, right) => left.path.localeCompare(right.path));
+	if (options.format !== "stats") mkdirSync(options.output, { recursive: true });
+	for (const fileResult of results) {
+		const source = inputs.find((input) => input.path === fileResult.path)?.source ?? "";
+		for (const warning of fileResult.warnings) process.stderr.write(`warning: ${displayPath(fileResult.path)} ${warning}\n`);
+		for (const error of fileResult.errors) process.stderr.write(`error: ${displayPath(fileResult.path)} ${error}\n`);
+		if (fileResult.errors.length > 0 || options.format === "stats") continue;
+		const extension = options.format === "json" ? "json" : getOutputExtension(source, options.scriptExt);
+		writeFileSync(path.join(options.output, outputFileName(fileResult.path, extension)), options.format === "json" ? JSON.stringify(fileResult, null, 2) : fileResult.code);
+	}
+	const failed = result.failedCount ?? result.failed_count ?? results.filter((r) => r.errors.length).length;
+	const success = result.successCount ?? result.success_count ?? results.length - failed;
+	process.stderr.write(`\x1b[32mOK\x1b[0m Built ${success} Vue file(s) in ${timeMs.toFixed(2)}ms\n`);
+	if (failed > 0) {
+		process.stderr.write(`\x1b[31mERR\x1b[0m ${failed} file(s) failed\n`);
+		process.exit(1);
+	}
+}
+function parseFmtCommand(args) {
+	const patterns = [];
+	const options = {};
+	const sharedConfig = { configMode: "root" };
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--check") options.check = true;
+		else if (arg === "--write" || arg === "-w") options.write = true;
+		else if (arg === "--single-quote") options.singleQuote = true;
+		else if (arg === "--print-width") options.printWidth = Number.parseInt(args[++i], 10);
+		else if (arg === "--tab-width") options.tabWidth = Number.parseInt(args[++i], 10);
+		else if (arg === "--use-tabs") options.useTabs = true;
+		else if (arg === "--no-semi") options.semi = false;
+		else if (arg === "--sort-attributes") options.sortAttributes = true;
+		else if (arg === "--single-attribute-per-line") options.singleAttributePerLine = true;
+		else if (arg === "--max-attributes-per-line") options.maxAttributesPerLine = Number.parseInt(args[++i], 10);
+		else if (arg === "--normalize-directive-shorthands") options.normalizeDirectiveShorthands = true;
+		else if (arg === "--config" || arg === "-c") {
+			const configFile = args[++i];
+			if (!configFile) throw new Error("Missing path after --config");
+			sharedConfig.configFile = configFile;
+		} else if (arg === "--no-config") sharedConfig.configMode = "none";
+		else if (arg === "--profile") {} else if (arg === "--help" || arg === "-h") options.help = true;
+		else if (!arg.startsWith("-")) patterns.push(arg);
+	}
+	return {
+		patterns,
+		options,
+		sharedConfig
+	};
+}
+function toNativeFormatOptions(options) {
+	return {
+		printWidth: options.printWidth,
+		print_width: options.printWidth,
+		tabWidth: options.tabWidth,
+		tab_width: options.tabWidth,
+		useTabs: options.useTabs,
+		use_tabs: options.useTabs,
+		semi: options.semi,
+		singleQuote: options.singleQuote,
+		single_quote: options.singleQuote,
+		sortAttributes: options.sortAttributes,
+		sort_attributes: options.sortAttributes,
+		singleAttributePerLine: options.singleAttributePerLine,
+		single_attribute_per_line: options.singleAttributePerLine,
+		maxAttributesPerLine: options.maxAttributesPerLine,
+		max_attributes_per_line: options.maxAttributesPerLine,
+		normalizeDirectiveShorthands: options.normalizeDirectiveShorthands,
+		normalize_directive_shorthands: options.normalizeDirectiveShorthands
+	};
+}
+async function runFmt(args) {
+	const { patterns, options, sharedConfig } = parseFmtCommand(args);
+	if (options.help) {
+		printFmtUsage();
+		return;
+	}
+	const config = await loadConfig(process.cwd(), {
+		mode: sharedConfig.configMode,
+		configFile: sharedConfig.configFile,
+		env: {
+			mode: process.env.NODE_ENV ?? "development",
+			command: "fmt"
+		}
+	});
+	if (sharedConfig.configFile && !config) throw new Error(`Could not find config file: ${sharedConfig.configFile}`);
+	options.printWidth ??= config?.formatter?.printWidth;
+	options.tabWidth ??= config?.formatter?.tabWidth;
+	options.useTabs ??= config?.formatter?.useTabs;
+	options.semi ??= config?.formatter?.semi;
+	options.singleQuote ??= config?.formatter?.singleQuote;
+	const files = collectVueFiles(patterns);
+	if (files.length === 0) {
+		process.stderr.write(`No Vue files found matching inputs: ${JSON.stringify(patterns)}\n`);
+		return;
+	}
+	const native = loadNative("fmt");
+	let changed = 0;
+	let errored = 0;
+	for (const file of files) {
+		const source = readFileSync(file, "utf8");
+		try {
+			const result = native.formatSfc(source, toNativeFormatOptions(options));
+			if (!result.changed) continue;
+			changed++;
+			if (options.check) process.stderr.write(`Would reformat: ${displayPath(file)}\n`);
+			else if (options.write) {
+				writeFileSync(file, result.code);
+				process.stderr.write(`Reformatted: ${displayPath(file)}\n`);
+			} else process.stderr.write(`Would reformat: ${displayPath(file)}\n`);
+		} catch (error) {
+			errored++;
+			process.stderr.write(`Error formatting ${displayPath(file)}: ${error instanceof Error ? error.message : String(error)}\n`);
+		}
+	}
+	process.stderr.write(`\x1b[32mOK\x1b[0m Formatted ${files.length} Vue file(s), ${changed} changed\n`);
+	if (errored > 0 || options.check && changed > 0) process.exit(1);
+}
+function parseCheckCommand(args) {
+	const patterns = [];
+	const options = {};
+	const sharedConfig = { configMode: "root" };
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--format" || arg === "-f") options.format = args[++i];
+		else if (arg === "--quiet" || arg === "-q") options.quiet = true;
+		else if (arg === "--strict") options.strict = true;
+		else if (arg === "--no-strict") options.strict = false;
+		else if (arg === "--show-virtual-ts" || arg === "--include-virtual-ts") options.includeVirtualTs = true;
+		else if (arg === "--max-warnings") options.maxWarnings = Number.parseInt(args[++i], 10);
+		else if (arg === "--no-check-props") options.checkProps = false;
+		else if (arg === "--no-check-emits") options.checkEmits = false;
+		else if (arg === "--no-check-template-bindings") options.checkTemplateBindings = false;
+		else if (arg === "--no-check-reactivity") options.checkReactivity = false;
+		else if (arg === "--no-check-setup-context") options.checkSetupContext = false;
+		else if (arg === "--no-check-invalid-exports") options.checkInvalidExports = false;
+		else if (arg === "--no-check-fallthrough-attrs") options.checkFallthroughAttrs = false;
+		else if (arg === "--config" || arg === "-c") {
+			const configFile = args[++i];
+			if (!configFile) throw new Error("Missing path after --config");
+			sharedConfig.configFile = configFile;
+		} else if (arg === "--no-config") sharedConfig.configMode = "none";
+		else if (arg === "--help" || arg === "-h") options.help = true;
+		else if (arg === "--tsconfig" || arg === "--corsa-path" || arg === "--servers") i++;
+		else if (arg === "--socket" || arg === "-s" || arg === "--declaration-dir") i++;
+		else if (arg === "--profile" || arg === "--declaration") {} else if (!arg.startsWith("-")) patterns.push(arg);
+	}
+	return {
+		patterns,
+		options,
+		sharedConfig
+	};
+}
+function hasGlobSyntax(pattern) {
+	return pattern.includes("*") || pattern.includes("?") || pattern.includes("[");
+}
+function normalizePath(filePath) {
+	return filePath.split(path.sep).join("/");
+}
+function displayPath(filePath) {
+	const relative = path.relative(process.cwd(), filePath);
+	if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) return normalizePath(relative);
+	return normalizePath(filePath);
+}
+function isVueFile(filePath) {
+	return path.extname(filePath) === ".vue";
+}
+function collectVueFilesFromDirectory(directory, recursive) {
+	const files = [];
+	const entries = readdirSync(directory, { withFileTypes: true });
+	for (const entry of entries) {
+		const entryPath = path.join(directory, entry.name);
+		if (entry.isDirectory()) {
+			if (entry.name === "node_modules" || entry.name === ".git") continue;
+			if (recursive) files.push(...collectVueFilesFromDirectory(entryPath, true));
+		} else if (entry.isFile() && isVueFile(entryPath)) files.push(entryPath);
+	}
+	return files;
+}
+function globBase(pattern) {
+	const normalized = normalizePath(pattern);
+	const globIndex = normalized.search(/[*?[]/);
+	if (globIndex === -1) return normalized;
+	const beforeGlob = normalized.slice(0, globIndex);
+	const slashIndex = beforeGlob.lastIndexOf("/");
+	if (slashIndex === -1) return ".";
+	return beforeGlob.slice(0, slashIndex) || "/";
+}
+function globToRegExp(pattern) {
+	const normalized = normalizePath(pattern);
+	let source = "";
+	for (let i = 0; i < normalized.length; i++) {
+		const char = normalized[i];
+		const next = normalized[i + 1];
+		const afterNext = normalized[i + 2];
+		if (char === "*" && next === "*" && afterNext === "/") {
+			source += "(?:.*/)?";
+			i += 2;
+		} else if (char === "*" && next === "*") {
+			source += ".*";
+			i++;
+		} else if (char === "*") source += "[^/]*";
+		else if (char === "?") source += "[^/]";
+		else if ("\\^$+?.()|{}[]".includes(char)) source += `\\${char}`;
+		else source += char;
+	}
+	return new RegExp(`^${source}$`);
+}
+function shouldRecurseGlob(pattern, base) {
+	const normalizedPattern = normalizePath(pattern);
+	const normalizedBase = normalizePath(base);
+	return (normalizedBase === "." ? normalizedPattern : normalizedPattern.slice(normalizedBase.length).replace(/^\/+/, "")).includes("/");
+}
+function collectVueFilesFromGlob(pattern) {
+	const basePattern = globBase(pattern);
+	const base = path.resolve(process.cwd(), basePattern);
+	if (!existsSync(base)) return [];
+	const isAbsolutePattern = path.isAbsolute(pattern);
+	const regex = globToRegExp(normalizePath(isAbsolutePattern ? path.resolve(pattern) : pattern));
+	return collectVueFilesFromDirectory(base, shouldRecurseGlob(pattern, basePattern)).filter((file) => {
+		const comparable = isAbsolutePattern ? normalizePath(file) : normalizePath(path.relative(process.cwd(), file));
+		return regex.test(comparable);
+	});
+}
+function collectVueFiles(patterns) {
+	const files = /* @__PURE__ */ new Set();
+	const inputs = patterns.length === 0 ? ["."] : patterns;
+	for (const input of inputs) {
+		if (hasGlobSyntax(input)) {
+			for (const file of collectVueFilesFromGlob(input)) files.add(path.resolve(file));
+			continue;
+		}
+		const resolved = path.resolve(process.cwd(), input);
+		if (!existsSync(resolved)) continue;
+		const stats = statSync(resolved);
+		if (stats.isDirectory()) for (const file of collectVueFilesFromDirectory(resolved, true)) files.add(path.resolve(file));
+		else if (stats.isFile() && isVueFile(resolved)) files.add(resolved);
+	}
+	return Array.from(files).sort();
+}
+function lineStarts(source) {
+	const starts = [0];
+	for (let i = 0; i < source.length; i++) if (source.charCodeAt(i) === 10) starts.push(i + 1);
+	return starts;
+}
+function offsetToLineColumn(starts, offset) {
+	let low = 0;
+	let high = starts.length - 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		if (starts[mid] <= offset) low = mid + 1;
+		else high = mid - 1;
+	}
+	const lineIndex = Math.max(0, high);
+	return {
+		line: lineIndex + 1,
+		column: offset - starts[lineIndex] + 1
+	};
+}
+function toNativeTypeCheckOptions(file, options) {
+	return {
+		filename: file,
+		strict: options.strict,
+		includeVirtualTs: options.includeVirtualTs,
+		include_virtual_ts: options.includeVirtualTs,
+		checkProps: options.checkProps,
+		check_props: options.checkProps,
+		checkEmits: options.checkEmits,
+		check_emits: options.checkEmits,
+		checkTemplateBindings: options.checkTemplateBindings,
+		check_template_bindings: options.checkTemplateBindings,
+		checkReactivity: options.checkReactivity,
+		check_reactivity: options.checkReactivity,
+		checkSetupContext: options.checkSetupContext,
+		check_setup_context: options.checkSetupContext,
+		checkInvalidExports: options.checkInvalidExports,
+		check_invalid_exports: options.checkInvalidExports,
+		checkFallthroughAttrs: options.checkFallthroughAttrs,
+		check_fallthrough_attrs: options.checkFallthroughAttrs
+	};
+}
+function renderCheckText(results, options, timeMs) {
+	let totalErrors = 0;
+	let totalWarnings = 0;
+	for (const { file, source, result } of results) {
+		totalErrors += result.errorCount;
+		totalWarnings += result.warningCount;
+		if (options.includeVirtualTs && result.virtualTs) process.stderr.write(`\n=== ${displayPath(file)} ===\n${result.virtualTs}\n`);
+		if (options.quiet || result.diagnostics.length === 0) continue;
+		const starts = lineStarts(source);
+		process.stdout.write(`\n\x1b[4m${displayPath(file)}\x1b[0m\n`);
+		for (const diagnostic of result.diagnostics) {
+			const color = diagnostic.severity === "error" ? "\x1B[31m" : "\x1B[33m";
+			const location = offsetToLineColumn(starts, diagnostic.start);
+			const code = diagnostic.code ? ` [${diagnostic.code}]` : "";
+			process.stdout.write(`  ${color}${diagnostic.severity}:${location.line}:${location.column}\x1b[0m${code} ${diagnostic.message}\n`);
+			if (diagnostic.help) process.stdout.write(`    help: ${diagnostic.help}\n`);
+		}
+	}
+	const status = totalErrors > 0 ? "\x1B[31mERR\x1B[0m" : "\x1B[32mOK\x1B[0m";
+	process.stdout.write(`\n${status} Type checked ${results.length} Vue files in ${timeMs.toFixed(2)}ms\n`);
+	if (totalErrors > 0) process.stdout.write(`  \x1b[31m${totalErrors} error(s)\x1b[0m\n`);
+	else process.stdout.write("  \x1B[32mNo type errors found!\x1B[0m\n");
+	if (totalWarnings > 0) process.stdout.write(`  \x1b[33m${totalWarnings} warning(s)\x1b[0m\n`);
+}
+async function runCheck(args) {
+	const { patterns, options, sharedConfig } = parseCheckCommand(args);
+	if (options.help) {
+		printCheckUsage();
+		return;
+	}
+	const config = await loadConfig(process.cwd(), {
+		mode: sharedConfig.configMode,
+		configFile: sharedConfig.configFile,
+		env: {
+			mode: process.env.NODE_ENV ?? "development",
+			command: "check"
+		}
+	});
+	if (sharedConfig.configFile && !config) throw new Error(`Could not find config file: ${sharedConfig.configFile}`);
+	if (config?.typeChecker?.enabled === false) {
+		process.stderr.write("[vize] Skipping check because typeChecker.enabled is false in vize.config.\n");
+		return;
+	}
+	options.strict ??= config?.typeChecker?.strict;
+	options.checkProps ??= config?.typeChecker?.checkProps;
+	options.checkEmits ??= config?.typeChecker?.checkEmits;
+	options.checkTemplateBindings ??= config?.typeChecker?.checkTemplateBindings;
+	const files = collectVueFiles(patterns);
+	if (files.length === 0) {
+		process.stderr.write(`No Vue files found matching inputs: ${JSON.stringify(patterns)}\n`);
+		return;
+	}
+	const native = loadNative("check");
+	const start = performance.now();
+	const results = files.map((file) => {
+		const source = readFileSync(file, "utf8");
+		return {
+			file,
+			source,
+			result: native.typeCheck(source, toNativeTypeCheckOptions(file, options))
+		};
+	});
+	const timeMs = performance.now() - start;
+	const totalErrors = results.reduce((sum, { result }) => sum + result.errorCount, 0);
+	const totalWarnings = results.reduce((sum, { result }) => sum + result.warningCount, 0);
+	if (options.format === "json") process.stdout.write(`${JSON.stringify({
+		files: results.map(({ file, result }) => ({
+			file: displayPath(file),
+			diagnostics: result.diagnostics,
+			virtualTs: result.virtualTs
+		})),
+		errorCount: totalErrors,
+		warningCount: totalWarnings,
+		fileCount: results.length
+	}, null, 2)}\n`);
+	else renderCheckText(results, options, timeMs);
+	if (totalErrors > 0) process.exit(1);
+	if (options.maxWarnings !== void 0 && totalWarnings > options.maxWarnings) {
+		process.stderr.write(`\nToo many warnings (${totalWarnings} > max ${options.maxWarnings})\n`);
+		process.exit(1);
+	}
+}
 async function runLint(args) {
 	const { patterns, options, sharedConfig } = parseLintCommand(args);
 	const config = await loadConfig(process.cwd(), {
@@ -144,7 +652,7 @@ async function runLint(args) {
 	}
 	options.preset ??= config?.linter?.preset;
 	if (patterns.length === 0) patterns.push(".");
-	const result = loadNative().lint(patterns, {
+	const result = loadNative("lint").lint(patterns, {
 		format: options.format,
 		max_warnings: options.maxWarnings,
 		quiet: options.quiet,
@@ -163,8 +671,158 @@ async function runLint(args) {
 		process.exit(1);
 	}
 }
-const NAPI_COMMANDS = new Set(["lint"]);
-const JS_COMMANDS = new Set(["musea"]);
+function parseUpgradeCommand(args) {
+	const options = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--package-manager") {
+			const packageManager = args[++i];
+			if (packageManager === "bun" || packageManager === "npm" || packageManager === "pnpm" || packageManager === "vp" || packageManager === "yarn") options.packageManager = packageManager;
+		} else if (arg === "--global" || arg === "-g") options.global = true;
+		else if (arg === "--dry-run") options.dryRun = true;
+		else if (arg === "--help" || arg === "-h") options.help = true;
+	}
+	return options;
+}
+function readCwdPackageJson() {
+	const packageJsonPath = path.join(process.cwd(), "package.json");
+	if (!existsSync(packageJsonPath)) return null;
+	return JSON.parse(readFileSync(packageJsonPath, "utf8"));
+}
+function detectPackageManager(explicit) {
+	if (explicit) return explicit;
+	const userAgent = process.env.npm_config_user_agent ?? "";
+	if (userAgent.startsWith("pnpm")) return "pnpm";
+	if (userAgent.startsWith("yarn")) return "yarn";
+	if (userAgent.startsWith("bun")) return "bun";
+	if (userAgent.startsWith("npm")) return "npm";
+	const packageManager = readCwdPackageJson()?.packageManager;
+	if (packageManager?.startsWith("pnpm")) return "pnpm";
+	if (packageManager?.startsWith("yarn")) return "yarn";
+	if (packageManager?.startsWith("bun")) return "bun";
+	return "npm";
+}
+function buildUpgradeCommand(packageManager, options) {
+	const saveDev = !readCwdPackageJson()?.dependencies?.vize;
+	const packageSpec = "vize@latest";
+	if (packageManager === "vp") return {
+		command: "vp",
+		args: [
+			"install",
+			...options.global ? ["-g"] : saveDev ? ["-D"] : [],
+			packageSpec
+		]
+	};
+	if (packageManager === "pnpm") return {
+		command: "pnpm",
+		args: [
+			"add",
+			...options.global ? ["-g"] : saveDev ? ["-D"] : [],
+			packageSpec
+		]
+	};
+	if (packageManager === "yarn") return {
+		command: "yarn",
+		args: options.global ? [
+			"global",
+			"add",
+			packageSpec
+		] : [
+			"add",
+			...saveDev ? ["-D"] : [],
+			packageSpec
+		]
+	};
+	if (packageManager === "bun") return {
+		command: "bun",
+		args: [
+			"add",
+			...options.global ? ["-g"] : saveDev ? ["-d"] : [],
+			packageSpec
+		]
+	};
+	return {
+		command: "npm",
+		args: [
+			"install",
+			...options.global ? ["-g"] : saveDev ? ["-D"] : [],
+			packageSpec
+		]
+	};
+}
+function runUpgrade(args) {
+	const options = parseUpgradeCommand(args);
+	if (options.help) {
+		printUpgradeUsage();
+		return;
+	}
+	const command = buildUpgradeCommand(detectPackageManager(options.packageManager), options);
+	if (options.dryRun) {
+		process.stdout.write(`${command.command} ${command.args.join(" ")}\n`);
+		return;
+	}
+	const result = spawnSync(command.command, command.args, {
+		stdio: "inherit",
+		cwd: process.cwd(),
+		env: process.env
+	});
+	if (result.error) throw result.error;
+	process.exit(result.status ?? 1);
+}
+function parseReadyCommand(args) {
+	const patterns = [];
+	const options = {
+		output: "./dist",
+		scriptExt: "downcompile"
+	};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--output" || arg === "-o") options.output = args[++i] ?? options.output;
+		else if (arg === "--ssr") options.ssr = true;
+		else if (arg === "--script-ext") {
+			const scriptExt = args[++i];
+			if (scriptExt === "preserve" || scriptExt === "downcompile") options.scriptExt = scriptExt;
+		} else if (arg === "--help" || arg === "-h") options.help = true;
+		else if (!arg.startsWith("-")) patterns.push(arg);
+	}
+	return {
+		patterns,
+		options
+	};
+}
+async function runReady(args) {
+	const { patterns, options } = parseReadyCommand(args);
+	if (options.help) {
+		printReadyUsage();
+		return;
+	}
+	process.stderr.write("vize ready: fmt\n");
+	await runFmt(["--write", ...patterns]);
+	process.stderr.write("vize ready: lint\n");
+	await runLint(patterns);
+	process.stderr.write("vize ready: check\n");
+	await runCheck(patterns);
+	process.stderr.write("vize ready: build\n");
+	await runBuild([
+		"--output",
+		options.output,
+		"--script-ext",
+		options.scriptExt,
+		...options.ssr ? ["--ssr"] : [],
+		...patterns
+	]);
+}
+const NAPI_COMMANDS = new Set([
+	"build",
+	"check",
+	"fmt",
+	"lint"
+]);
+const JS_COMMANDS = new Set([
+	"musea",
+	"ready",
+	"upgrade"
+]);
 async function main() {
 	const args = process.argv.slice(2);
 	const command = args[0];
@@ -175,6 +833,15 @@ async function main() {
 	if (NAPI_COMMANDS.has(command)) {
 		const commandArgs = args.slice(1);
 		switch (command) {
+			case "build":
+				await runBuild(commandArgs);
+				break;
+			case "check":
+				await runCheck(commandArgs);
+				break;
+			case "fmt":
+				await runFmt(commandArgs);
+				break;
 			case "lint":
 				await runLint(commandArgs);
 				break;
@@ -185,6 +852,12 @@ async function main() {
 			case "musea":
 				runMusea(commandArgs);
 				break;
+			case "ready":
+				await runReady(commandArgs);
+				break;
+			case "upgrade":
+				runUpgrade(commandArgs);
+				break;
 		}
 	} else {
 		printUsage();