@geoql/doctor-core 0.1.0-alpha.0 → 0.2.0-alpha.0

package/dist/index.js

@@ -1,13 +1,942 @@
+import { a as listRules, c as InvalidConfigError, i as RULE_REGISTRY, l as BUILT_IN_RECOMMENDED, o as ConfigCycleError, r as validateConfig, s as ConfigFileNotFoundError, t as loadDoctorConfig } from "./load-DiK7Zv0B.js";
 import { dirname, join, relative, resolve } from "node:path";
+import { performance } from "node:perf_hooks";
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { execFile, spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { coerce, gte, major, minor } from "semver";
+import { parseSync } from "oxc-parser";
 import { glob } from "tinyglobby";
-import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { existsSync, readFileSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { spawn } from "node:child_process";
-import { parse } from "@vue/compiler-sfc";
-import { loadConfig } from "c12";
-import * as c from "kolorist";
+import { fileURLToPath } from "node:url";
+import { babelParse, parse } from "@vue/compiler-sfc";
+import { promisify } from "node:util";
+import process$1 from "node:process";
+import pc from "picocolors";
+//#region src/annotations.ts
+function escapeProperty(value) {
+	return value.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C");
+}
+function escapeData(value) {
+	return value.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+}
+function encodeAnnotation(diagnostic) {
+	return `::${diagnostic.severity === "error" ? "error" : "warning"} ${[
+		`file=${escapeProperty(diagnostic.file)}`,
+		`line=${diagnostic.line}`,
+		`col=${diagnostic.column}`,
+		`title=${escapeProperty(diagnostic.ruleId)}`
+	].join(",")}::${escapeData(diagnostic.message)}`;
+}
+function encodeAnnotations(diagnostics) {
+	return diagnostics.map(encodeAnnotation).join("\n");
+}
+//#endregion
+//#region src/project-info/read-package-json.ts
+async function readPackageJson(dir) {
+	try {
+		const source = await readFile(join(dir, "package.json"), "utf8");
+		return JSON.parse(source);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/build-quality/read-deps.ts
+async function readDeps(packageJsonPath) {
+	const pkg = await readPackageJson(dirname(packageJsonPath));
+	if (pkg === null) return null;
+	return {
+		dependencies: pkg.dependencies ?? {},
+		devDependencies: pkg.devDependencies ?? {}
+	};
+}
+//#endregion
+//#region src/build-quality/check-eslint-plugin-vue.ts
+const RULE_ID$6 = "vue-doctor/build-quality/eslint-plugin-vue-installed";
+const DOCS$3 = "https://eslint.vuejs.org/";
+async function checkEslintPluginVue(projectInfo) {
+	if (projectInfo.packageJsonPath === null) return [];
+	if (projectInfo.framework !== "vue" && projectInfo.framework !== "nuxt") return [];
+	const deps = await readDeps(projectInfo.packageJsonPath);
+	if (deps === null) return [];
+	if (deps.devDependencies["eslint-plugin-vue"]) return [];
+	return [{
+		ruleId: RULE_ID$6,
+		file: projectInfo.packageJsonPath,
+		line: 1,
+		column: 1,
+		severity: "info",
+		message: `eslint-plugin-vue is not in devDependencies; it catches many Vue-specific issues. See ${DOCS$3}`,
+		recommendation: "Add eslint-plugin-vue to devDependencies."
+	}];
+}
+//#endregion
+//#region src/build-quality/check-no-vue-cli.ts
+const RULE_ID$5 = "vue-doctor/build-quality/no-vue-cli";
+const DOCS$2 = "https://cli.vuejs.org/migrations/migrate-from-v4.html";
+function isOffendingKey(key) {
+	return key === "@vue/cli-service" || key.startsWith("vue-cli-plugin-");
+}
+async function checkNoVueCli(projectInfo) {
+	if (projectInfo.packageJsonPath === null) return [];
+	const deps = await readDeps(projectInfo.packageJsonPath);
+	if (deps === null) return [];
+	const offenders = [];
+	for (const key of [...Object.keys(deps.dependencies), ...Object.keys(deps.devDependencies)]) if (isOffendingKey(key) && !offenders.includes(key)) offenders.push(key);
+	return offenders.map((key, index) => ({
+		ruleId: RULE_ID$5,
+		file: projectInfo.packageJsonPath,
+		line: index + 1,
+		column: 1,
+		severity: "warn",
+		message: `${key} indicates Vue CLI, which is deprecated; migrate to Vite. See ${DOCS$2}`,
+		recommendation: `Remove ${key} and migrate the build to Vite.`
+	}));
+}
+//#endregion
+//#region src/build-quality/strip-json-comments.ts
+function stripJsonComments(input) {
+	let out = "";
+	let inString = false;
+	let inLineComment = false;
+	let inBlockComment = false;
+	let escaped = false;
+	for (let i = 0; i < input.length; i++) {
+		const char = input[i];
+		const next = input[i + 1];
+		if (inLineComment) {
+			if (char === "\n") {
+				inLineComment = false;
+				out += char;
+			}
+			continue;
+		}
+		if (inBlockComment) {
+			if (char === "*" && next === "/") {
+				inBlockComment = false;
+				i++;
+			}
+			continue;
+		}
+		if (inString) {
+			out += char;
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inString = false;
+			continue;
+		}
+		if (char === "\"") {
+			inString = true;
+			out += char;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			inLineComment = true;
+			i++;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			inBlockComment = true;
+			i++;
+			continue;
+		}
+		out += char;
+	}
+	return out;
+}
+//#endregion
+//#region src/build-quality/check-tsconfig-strict.ts
+const RULE_ID$4 = "vue-doctor/build-quality/tsconfig-strict-required";
+const DOCS$1 = "https://www.typescriptlang.org/tsconfig#strict";
+async function checkTsconfigStrict(projectInfo) {
+	if (projectInfo.packageJsonPath === null) return [];
+	const tsconfigPath = join(dirname(projectInfo.packageJsonPath), "tsconfig.json");
+	let parsed;
+	try {
+		const source = await readFile(tsconfigPath, "utf8");
+		parsed = JSON.parse(stripJsonComments(source));
+	} catch {
+		return [];
+	}
+	if (parsed.compilerOptions?.strict === true) return [];
+	return [{
+		ruleId: RULE_ID$4,
+		file: tsconfigPath,
+		line: 1,
+		column: 1,
+		severity: "warn",
+		message: `tsconfig.json should set compilerOptions.strict to true for full type safety. See ${DOCS$1}`,
+		recommendation: "Set \"strict\": true in tsconfig.json compilerOptions."
+	}];
+}
+//#endregion
+//#region src/build-quality/check-vue-tsc.ts
+const RULE_ID$3 = "vue-doctor/build-quality/vue-tsc-in-devDeps";
+const DOCS = "https://github.com/vuejs/language-tools/tree/master/packages/tsc";
+async function checkVueTsc(projectInfo) {
+	if (projectInfo.packageJsonPath === null) return [];
+	if (projectInfo.framework !== "vue" && projectInfo.framework !== "nuxt") return [];
+	const deps = await readDeps(projectInfo.packageJsonPath);
+	if (deps === null) return [];
+	if (deps.devDependencies["vue-tsc"]) return [];
+	return [{
+		ruleId: RULE_ID$3,
+		file: projectInfo.packageJsonPath,
+		line: 1,
+		column: 1,
+		severity: "warn",
+		message: `Vue projects should type-check with vue-tsc, but it is missing from devDependencies. See ${DOCS}`,
+		recommendation: "Add vue-tsc to devDependencies."
+	}];
+}
+//#endregion
+//#region src/check-build-quality.ts
+async function checkBuildQuality(projectInfo) {
+	if (projectInfo.packageJsonPath === null) return [];
+	return (await Promise.all([
+		checkTsconfigStrict(projectInfo),
+		checkVueTsc(projectInfo),
+		checkNoVueCli(projectInfo),
+		checkEslintPluginVue(projectInfo)
+	])).flat().map((issue) => ({
+		file: issue.file,
+		line: issue.line,
+		column: issue.column,
+		ruleId: issue.ruleId,
+		severity: issue.severity,
+		message: issue.message,
+		source: "project",
+		recommendation: issue.recommendation
+	}));
+}
+//#endregion
+//#region src/dead-code/build-knip-config.ts
+function buildKnipConfig(projectInfo, doctorConfig) {
+	const isNuxt = projectInfo.framework === "nuxt";
+	const entry = isNuxt ? [
+		"app/**/*.vue",
+		"app/**/*.ts",
+		"server/**/*.ts",
+		"nuxt.config.{ts,js,mjs}"
+	] : [
+		"src/main.{ts,js}",
+		"src/App.vue",
+		"index.html",
+		"vite.config.{ts,js}"
+	];
+	const config = {
+		cwd: projectInfo.rootDirectory,
+		entry,
+		project: [
+			"**/*.{ts,vue}",
+			"!**/node_modules/**",
+			"!**/dist/**",
+			"!**/.nuxt/**",
+			"!**/knip.config.mjs"
+		],
+		ignoreFiles: [...doctorConfig.exclude, "knip.config.mjs"],
+		ignoreDependencies: [
+			"vite-plus",
+			"@geoql/vue-doctor",
+			"@geoql/nuxt-doctor"
+		]
+	};
+	if (isNuxt) config.compilers = { nuxt: true };
+	return config;
+}
+//#endregion
+//#region src/dead-code/dedupe.ts
+function dedupeDeadCodeAgainstLint(deadCode, lint) {
+	const lintFiles = new Set(lint.map((d) => d.file));
+	return deadCode.filter((d) => !(d.ruleId === "dead-code/unused-file" && lintFiles.has(d.file)));
+}
+//#endregion
+//#region src/dead-code/errors.ts
+var DeadCodeTimeoutError = class extends Error {
+	name = "DeadCodeTimeoutError";
+	constructor(timeoutMs) {
+		super(`Dead-code analysis timed out after ${timeoutMs}ms`);
+	}
+};
+var DeadCodeImportFailed = class extends Error {
+	name = "DeadCodeImportFailed";
+	constructor(cause) {
+		const message = cause instanceof Error ? `Failed to import knip: ${cause.message}` : "Failed to import knip";
+		super(message, { cause });
+	}
+};
+//#endregion
+//#region src/dead-code/map-knip-diagnostic.ts
+const KIND_MAP = {
+	files: {
+		ruleId: "dead-code/unused-file",
+		severity: "warn",
+		message: "Unused file"
+	},
+	exports: {
+		ruleId: "dead-code/unused-export",
+		severity: "warn",
+		message: "Unused export"
+	},
+	types: {
+		ruleId: "dead-code/unused-type-export",
+		severity: "info",
+		message: "Unused type export"
+	},
+	enumMembers: {
+		ruleId: "dead-code/unused-member",
+		severity: "info",
+		message: "Unused enum member"
+	},
+	namespaceMembers: {
+		ruleId: "dead-code/unused-member",
+		severity: "info",
+		message: "Unused namespace member"
+	},
+	deps: {
+		ruleId: "dead-code/unused-dependency",
+		severity: "warn",
+		message: "Unused dependency"
+	},
+	devDependencies: {
+		ruleId: "dead-code/unused-dependency",
+		severity: "warn",
+		message: "Unused devDependency"
+	},
+	unlisted: {
+		ruleId: "dead-code/unlisted-dependency",
+		severity: "error",
+		message: "Unlisted dependency"
+	},
+	duplicates: {
+		ruleId: "dead-code/duplicate-export",
+		severity: "warn",
+		message: "Duplicate export"
+	},
+	nsExports: null,
+	nsTypes: null,
+	optionalPeerDependencies: null,
+	binaries: null,
+	unresolved: null,
+	catalog: null
+};
+function mapKnipDiagnostic(rootDirectory, issue) {
+	const mapping = KIND_MAP[issue.kind];
+	if (!mapping) return null;
+	return {
+		file: resolve(rootDirectory, issue.file),
+		line: issue.line ?? 1,
+		column: issue.col ?? 1,
+		ruleId: mapping.ruleId,
+		severity: mapping.severity,
+		message: issue.symbol ? `${mapping.message}: ${issue.symbol}` : mapping.message,
+		source: "dead-code"
+	};
+}
+//#endregion
+//#region src/check-dead-code.ts
+const MAPPED_KINDS = [
+	"files",
+	"exports",
+	"types",
+	"deps",
+	"devDependencies",
+	"unlisted",
+	"duplicates",
+	"enumMembers",
+	"namespaceMembers"
+];
+function flattenKnipIssues(issues) {
+	const out = [];
+	for (const kind of MAPPED_KINDS) {
+		const records = issues[kind];
+		if (!records) continue;
+		for (const filePath of Object.keys(records)) {
+			const symbols = records[filePath];
+			for (const symbolName of Object.keys(symbols)) {
+				const entry = symbols[symbolName];
+				out.push({
+					file: entry.filePath,
+					symbol: entry.symbol,
+					line: entry.line,
+					col: entry.col,
+					kind
+				});
+			}
+		}
+	}
+	return out;
+}
+const _knipLoader = { load: async () => {
+	const knipDir = createRequire(import.meta.url).resolve("knip").replace(/\/dist\/index\.js$/, "");
+	const { pathToFileURL } = await import("node:url");
+	const createOptionsUrl = pathToFileURL(join(knipDir, "dist", "util", "create-options.js")).href;
+	const runUrl = pathToFileURL(join(knipDir, "dist", "run.js")).href;
+	const createOptionsModule = await import(createOptionsUrl);
+	const runModule = await import(runUrl);
+	return {
+		createOptions: createOptionsModule.createOptions,
+		run: runModule.run
+	};
+} };
+async function checkDeadCode(options) {
+	if (!options.enabled) return [];
+	const config = buildKnipConfig(options.projectInfo, options.doctorConfig);
+	const timeoutMs = options.timeoutMs ?? 3e4;
+	let createOptions;
+	let run;
+	try {
+		const internals = await _knipLoader.load();
+		createOptions = internals.createOptions;
+		run = internals.run;
+	} catch (err) {
+		throw new DeadCodeImportFailed(err);
+	}
+	const knipOptions = await createOptions({
+		cwd: options.projectInfo.rootDirectory,
+		entry: config.entry,
+		project: config.project,
+		ignoreFiles: config.ignoreFiles,
+		ignoreDependencies: config.ignoreDependencies,
+		...config.compilers ? { compilers: config.compilers } : {}
+	});
+	const diagnostics = flattenKnipIssues((await Promise.race([run(knipOptions), new Promise((_, reject) => setTimeout(() => reject(new DeadCodeTimeoutError(timeoutMs)), timeoutMs))])).results.issues).map((issue) => mapKnipDiagnostic(options.projectInfo.rootDirectory, issue)).filter((d) => d !== null);
+	diagnostics.sort((a, b) => {
+		if (a.file !== b.file) return a.file < b.file ? -1 : 1;
+		if (a.line !== b.line) return a.line - b.line;
+		return a.ruleId.localeCompare(b.ruleId);
+	});
+	return diagnostics;
+}
+//#endregion
+//#region src/deps/exec-list.ts
+function collectVersions(entry, versions) {
+	if (entry.dependencies) {
+		for (const [name, info] of Object.entries(entry.dependencies)) if (name === "vue" && info.version) versions.add(info.version);
+	}
+	if (entry.devDependencies) {
+		for (const [name, info] of Object.entries(entry.devDependencies)) if (name === "vue" && info.version) versions.add(info.version);
+	}
+	if (entry.peers) {
+		for (const peer of entry.peers) if (peer.name === "vue" && peer.version) versions.add(peer.version);
+	}
+}
+async function runPnpmList(rootDir) {
+	return new Promise((resolve) => {
+		const timeout = setTimeout(() => {
+			resolve({
+				versions: [],
+				error: /* @__PURE__ */ new Error("timeout")
+			});
+		}, 1e4);
+		execFile("pnpm", [
+			"list",
+			"vue",
+			"--depth",
+			"Infinity",
+			"--json"
+		], {
+			cwd: rootDir,
+			timeout: 1e4
+		}, (error, stdout, stderr) => {
+			clearTimeout(timeout);
+			if (error || stderr) {
+				resolve({
+					versions: [],
+					error: error ?? new Error(stderr)
+				});
+				return;
+			}
+			try {
+				const parsed = JSON.parse(stdout);
+				const versions = /* @__PURE__ */ new Set();
+				for (const entry of parsed) collectVersions(entry, versions);
+				resolve({
+					versions: [...versions],
+					error: null
+				});
+			} catch {
+				resolve({
+					versions: [],
+					error: /* @__PURE__ */ new Error("parse error")
+				});
+			}
+		});
+	});
+}
+async function runNpmList(rootDir) {
+	return new Promise((resolve) => {
+		const timeout = setTimeout(() => {
+			resolve({
+				versions: [],
+				error: /* @__PURE__ */ new Error("timeout")
+			});
+		}, 1e4);
+		execFile("npm", [
+			"ls",
+			"vue",
+			"--all",
+			"--json"
+		], {
+			cwd: rootDir,
+			timeout: 1e4
+		}, (error, stdout, stderr) => {
+			clearTimeout(timeout);
+			if (error || stderr) {
+				resolve({
+					versions: [],
+					error: error ?? new Error(stderr)
+				});
+				return;
+			}
+			try {
+				const parsed = JSON.parse(stdout);
+				const versions = /* @__PURE__ */ new Set();
+				collectVersions(parsed, versions);
+				resolve({
+					versions: [...versions],
+					error: null
+				});
+			} catch {
+				resolve({
+					versions: [],
+					error: /* @__PURE__ */ new Error("parse error")
+				});
+			}
+		});
+	});
+}
+//#endregion
+//#region src/deps/list-vue-resolutions.ts
+async function listVueResolutions(packageJsonPath) {
+	const rootDir = dirname(packageJsonPath);
+	const pnpmResult = await runPnpmList(rootDir);
+	if (pnpmResult.error === null) return pnpmResult.versions;
+	const npmResult = await runNpmList(rootDir);
+	if (npmResult.error === null) return npmResult.versions;
+	return [];
+}
+//#endregion
+//#region src/deps/check-duplicate-vue.ts
+const RULE_ID$2 = "vue-doctor/deps/duplicate-vue-versions";
+async function checkDuplicateVue(projectInfo) {
+	if (projectInfo.packageJsonPath === null) return [];
+	const versions = await listVueResolutions(projectInfo.packageJsonPath);
+	const uniqueVersions = [...new Set(versions)];
+	if (uniqueVersions.length <= 1) return [];
+	return [{
+		ruleId: RULE_ID$2,
+		file: projectInfo.packageJsonPath,
+		line: 1,
+		column: 1,
+		severity: "error",
+		message: `Multiple versions of vue detected in node_modules: ${uniqueVersions.join(", ")}. Vue's reactivity system requires a single instance.`,
+		recommendation: "Add \"vue\": \"^3.5.0\" to pnpm.overrides (or npm overrides) to deduplicate. Run pnpm dedupe.",
+		versions: uniqueVersions
+	}];
+}
+//#endregion
+//#region src/deps/check-vue-major-current.ts
+const RULE_ID$1 = "vue-doctor/deps/vue-major-current";
+const DOCTOR_BUNDLED_VUE_FLOOR_MAJOR = 3;
+const DOCTOR_BUNDLED_VUE_FLOOR_MINOR = 5;
+function parseMajorMinor(version) {
+	const match = /^v?(\d+)\.(\d+)/.exec(version.trim());
+	if (!match) return null;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2])
+	};
+}
+function checkVueMajorCurrent(projectInfo) {
+	if (projectInfo.packageJsonPath === null) return [];
+	if (projectInfo.vueVersion === null) return [];
+	const parsed = parseMajorMinor(projectInfo.vueVersion);
+	if (parsed === null) return [];
+	if (parsed.major !== DOCTOR_BUNDLED_VUE_FLOOR_MAJOR) return [];
+	if (parsed.minor >= DOCTOR_BUNDLED_VUE_FLOOR_MINOR) return [];
+	return [{
+		ruleId: RULE_ID$1,
+		file: projectInfo.packageJsonPath,
+		line: 1,
+		column: 1,
+		severity: "info",
+		message: `Vue ${projectInfo.vueVersion} is older than the doctor-bundled floor (^${DOCTOR_BUNDLED_VUE_FLOOR_MAJOR}.${DOCTOR_BUNDLED_VUE_FLOOR_MINOR}.0). Newer minors often ship rule-relevant features (e.g. 3.4 reactive props destructure, 3.5 useTemplateRef).`,
+		recommendation: `Bump "vue" to ^${DOCTOR_BUNDLED_VUE_FLOOR_MAJOR}.${DOCTOR_BUNDLED_VUE_FLOOR_MINOR}.0 or later in package.json.`
+	}];
+}
+//#endregion
+//#region src/check-deps.ts
+async function checkDeps(projectInfo) {
+	if (projectInfo.packageJsonPath === null) return [];
+	return (await Promise.all([checkDuplicateVue(projectInfo), Promise.resolve(checkVueMajorCurrent(projectInfo))])).flat().map((issue) => ({
+		file: issue.file,
+		line: issue.line,
+		column: issue.column,
+		ruleId: issue.ruleId,
+		severity: issue.severity,
+		message: issue.message,
+		source: "deps",
+		recommendation: issue.recommendation
+	}));
+}
+//#endregion
+//#region src/disables/parse-directives.ts
+const DIRECTIVE = /doctor-(disable-next-line|disable-line|disable|enable)\b(.*)/;
+function parseRuleList(raw) {
+	return raw.replace(/-->\s*$/, "").split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+}
+function parseDirectives(text) {
+	const blocks = [];
+	const nextLine = [];
+	const sameLine = [];
+	const lines = text.split("\n");
+	let open = null;
+	for (let index = 0; index < lines.length; index += 1) {
+		const match = DIRECTIVE.exec(lines[index]);
+		if (!match) continue;
+		const keyword = match[1];
+		const rules = parseRuleList(match[2]);
+		const lineNumber = index + 1;
+		if (keyword === "disable-next-line") nextLine.push({
+			line: lineNumber + 1,
+			rules
+		});
+		else if (keyword === "disable-line") sameLine.push({
+			line: lineNumber,
+			rules
+		});
+		else if (keyword === "disable") {
+			if (!open) open = {
+				start: lineNumber,
+				rules
+			};
+		} else if (open) {
+			blocks.push({
+				start: open.start,
+				end: lineNumber,
+				rules: open.rules
+			});
+			open = null;
+		}
+	}
+	if (open) blocks.push({
+		start: open.start,
+		end: lines.length,
+		rules: open.rules
+	});
+	return {
+		blocks,
+		nextLine,
+		sameLine
+	};
+}
+//#endregion
+//#region src/disables/apply.ts
+function ruleMatches(ruleId, rules) {
+	if (rules.length === 0) return true;
+	return rules.some((token) => ruleId === token || ruleId.endsWith(`/${token}`));
+}
+function isSuppressed(set, diagnostic) {
+	const { line, ruleId } = diagnostic;
+	for (const block of set.blocks) if (line >= block.start && line <= block.end && ruleMatches(ruleId, block.rules)) return true;
+	for (const target of set.nextLine) if (target.line === line && ruleMatches(ruleId, target.rules)) return true;
+	for (const target of set.sameLine) if (target.line === line && ruleMatches(ruleId, target.rules)) return true;
+	return false;
+}
+function loadDirectives(file, cache) {
+	const cached = cache.get(file);
+	if (cached !== void 0) return cached;
+	let set;
+	try {
+		set = parseDirectives(readFileSync(file, "utf-8"));
+	} catch {
+		set = null;
+	}
+	cache.set(file, set);
+	return set;
+}
+function applyInlineDisables(diags, opts) {
+	if (!opts.respect) return diags;
+	const cache = /* @__PURE__ */ new Map();
+	return diags.filter((diagnostic) => {
+		const set = loadDirectives(diagnostic.file, cache);
+		return set === null || !isSuppressed(set, diagnostic);
+	});
+}
+//#endregion
+//#region src/code-snippet.ts
+async function readLines(file) {
+	try {
+		return (await readFile(file, "utf-8")).split("\n");
+	} catch {
+		return [];
+	}
+}
+async function attachCodeSnippets(diagnostics) {
+	const cache = /* @__PURE__ */ new Map();
+	const out = [];
+	for (const d of diagnostics) {
+		let lines = cache.get(d.file);
+		if (lines === void 0) {
+			lines = await readLines(d.file);
+			cache.set(d.file, lines);
+		}
+		const raw = lines[d.line - 1];
+		if (raw === void 0) out.push(d);
+		else out.push({
+			...d,
+			codeSnippet: raw.trim()
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/project-info/path-exists.ts
+async function pathExists(target) {
+	try {
+		await access(target);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/project-info/find-monorepo-root.ts
+async function detectKind(dir) {
+	if (await pathExists(join(dir, "pnpm-workspace.yaml"))) return "pnpm";
+	if ((await readPackageJson(dir))?.workspaces) {
+		if (await pathExists(join(dir, "yarn.lock"))) return "yarn";
+		if (await pathExists(join(dir, "package-lock.json"))) return "npm";
+	}
+	if (await pathExists(join(dir, "turbo.json"))) return "turbo";
+	return null;
+}
+async function findMonorepoRoot(rootDirectory) {
+	let current = rootDirectory;
+	for (;;) {
+		const kind = await detectKind(current);
+		if (kind) return {
+			root: current,
+			kind
+		};
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return {
+		root: rootDirectory,
+		kind: null
+	};
+}
+//#endregion
+//#region src/project-info/parse-nuxt-config.ts
+const CONFIG_FILES = [
+	"nuxt.config.ts",
+	"nuxt.config.js",
+	"nuxt.config.mjs"
+];
+async function readConfigSource(dir) {
+	for (const name of CONFIG_FILES) try {
+		return await readFile(join(dir, name), "utf8");
+	} catch {
+		continue;
+	}
+	return null;
+}
+function* objectEntries(obj) {
+	for (const prop of obj.properties) {
+		if (prop.type !== "Property") continue;
+		const key = prop.key;
+		if (key.type !== "Identifier") continue;
+		yield [key.name, prop.value];
+	}
+}
+function findEntry(obj, name) {
+	for (const [key, value] of objectEntries(obj)) if (key === name) return value;
+}
+function stringLiteral(node) {
+	return node.type === "Literal" && typeof node.value === "string" ? node.value : void 0;
+}
+function unwrapDefault(decl) {
+	if (decl.type !== "CallExpression") return decl;
+	const callee = decl.callee;
+	if (callee.type !== "Identifier") return null;
+	if (callee.name !== "defineNuxtConfig") return null;
+	return decl.arguments[0] ?? null;
+}
+function extractConfigObject(source) {
+	const exported = parseSync("nuxt.config.ts", source, {
+		sourceType: "module",
+		lang: "ts"
+	}).program.body.find((n) => n.type === "ExportDefaultDeclaration");
+	if (!exported) return null;
+	const node = unwrapDefault(exported.declaration);
+	if (!node) return null;
+	return node.type === "ObjectExpression" ? node : null;
+}
+function readNitroPreset(value) {
+	if (value.type !== "ObjectExpression") return void 0;
+	const preset = findEntry(value, "preset");
+	return preset ? stringLiteral(preset) : void 0;
+}
+function readImportsAutoImport(value) {
+	if (value.type !== "ObjectExpression") return void 0;
+	const node = findEntry(value, "autoImport");
+	if (node?.type === "Literal" && typeof node.value === "boolean") return node.value;
+}
+function readModules(value) {
+	if (value.type !== "ArrayExpression") return void 0;
+	const out = [];
+	for (const element of value.elements) {
+		if (!element) continue;
+		const str = stringLiteral(element);
+		if (str !== void 0) out.push(str);
+	}
+	return out;
+}
+function readCompatibility(value) {
+	return value.type === "Literal" && typeof value.value === "number" ? value.value : void 0;
+}
+async function parseNuxtConfig(dir) {
+	const source = await readConfigSource(dir);
+	if (source === null) return null;
+	const info = {};
+	const config = extractConfigObject(source);
+	if (!config) return info;
+	for (const [key, value] of objectEntries(config)) if (key === "compatibilityVersion") {
+		const compat = readCompatibility(value);
+		if (compat !== void 0) info.compatibilityVersion = compat;
+	} else if (key === "nitro") {
+		const preset = readNitroPreset(value);
+		if (preset !== void 0) info.nitroPreset = preset;
+	} else if (key === "modules") {
+		const modules = readModules(value);
+		if (modules !== void 0) info.modules = modules;
+	} else if (key === "imports") {
+		const autoImport = readImportsAutoImport(value);
+		if (autoImport !== void 0) info.importsAutoImport = autoImport;
+	}
+	return info;
+}
+//#endregion
+//#region src/project-info/resolve-dep-version.ts
+async function readInstalledVersion(base, dep) {
+	try {
+		const source = await readFile(join(base, "node_modules", dep, "package.json"), "utf8");
+		return JSON.parse(source).version ?? null;
+	} catch {
+		return null;
+	}
+}
+function declaredRange(dep, pkg) {
+	return pkg?.dependencies?.[dep] ?? pkg?.devDependencies?.[dep] ?? null;
+}
+async function resolveDepVersion(dep, rootDirectory, monorepoRoot, pkg) {
+	const installed = await readInstalledVersion(rootDirectory, dep) ?? await readInstalledVersion(monorepoRoot, dep);
+	if (installed) return installed;
+	const range = declaredRange(dep, pkg);
+	if (!range) return null;
+	return coerce(range)?.version ?? null;
+}
+//#endregion
+//#region src/project-info/parse-nuxt-version.ts
+function parseNuxtVersion(rootDirectory, monorepoRoot, pkg) {
+	return resolveDepVersion("nuxt", rootDirectory, monorepoRoot, pkg);
+}
+//#endregion
+//#region src/project-info/parse-vue-version.ts
+function parseVueVersion(rootDirectory, monorepoRoot, pkg) {
+	return resolveDepVersion("vue", rootDirectory, monorepoRoot, pkg);
+}
+//#endregion
+//#region src/detect-project.ts
+function hasDependency(pkg, name) {
+	return Boolean(pkg?.dependencies?.[name] ?? pkg?.devDependencies?.[name]);
+}
+function resolveFramework(pkg) {
+	if (hasDependency(pkg, "nuxt")) return "nuxt";
+	if (hasDependency(pkg, "vue")) return "vue";
+	return "unknown";
+}
+function resolveCompatibility(nuxtVersion, compatibilityVersion) {
+	const nuxtMajor = nuxtVersion ? major(nuxtVersion) : 0;
+	if (compatibilityVersion === 4 || nuxtMajor >= 4) return 4;
+	if (compatibilityVersion === 3) return 3;
+	return null;
+}
+function buildCapabilities(input) {
+	const caps = /* @__PURE__ */ new Set();
+	if (input.framework === "unknown") return caps;
+	if (input.vueVersion && major(input.vueVersion) === 3) {
+		caps.add("vue:3");
+		if (minor(input.vueVersion) >= 4) caps.add("vue:3.4");
+		if (minor(input.vueVersion) >= 5) caps.add("vue:3.5");
+	}
+	if (input.nuxtCompatibilityVersion === 4) caps.add("nuxt:4");
+	if (input.nuxtVersion && gte(input.nuxtVersion, "4.4.0")) caps.add("nuxt:4.4");
+	if (input.hasAutoImports) caps.add("auto-imports:vue");
+	if (input.hasComponentsAutoImport) caps.add("components:auto");
+	if (input.hasPinia) caps.add("pinia");
+	if (input.hasVueRouter) caps.add("vue-router");
+	if (input.hasTypescript) caps.add("typescript");
+	if (input.typescriptVersion && major(input.typescriptVersion) >= 6) caps.add("typescript:6");
+	if (input.monorepoKind === "pnpm" || input.monorepoKind === "yarn" || input.monorepoKind === "npm") caps.add(`monorepo:${input.monorepoKind}`);
+	if (input.hasWrangler || input.nitroPreset === "cloudflare-pages") caps.add("cf-pages:enabled");
+	if (input.nitroPreset === "node-server") caps.add("nitro:node-server");
+	return caps;
+}
+async function detectProject(rootDirectory) {
+	const pkg = await readPackageJson(rootDirectory);
+	const packageJsonPath = pkg ? join(rootDirectory, "package.json") : null;
+	const { root: monorepoRoot, kind: monorepoKind } = await findMonorepoRoot(rootDirectory);
+	const framework = resolveFramework(pkg);
+	const vueVersion = await parseVueVersion(rootDirectory, monorepoRoot, pkg);
+	const nuxtVersion = await parseNuxtVersion(rootDirectory, monorepoRoot, pkg);
+	const typescriptVersion = await resolveDepVersion("typescript", rootDirectory, monorepoRoot, pkg);
+	const nuxtConfig = framework === "nuxt" ? await parseNuxtConfig(rootDirectory) : null;
+	const nitroPreset = nuxtConfig?.nitroPreset ?? null;
+	const nuxtCompatibilityVersion = resolveCompatibility(nuxtVersion, nuxtConfig?.compatibilityVersion);
+	const isNuxt = framework === "nuxt";
+	const hasAutoImports = isNuxt ? nuxtConfig?.importsAutoImport !== false : hasDependency(pkg, "unplugin-auto-import");
+	const hasComponentsAutoImport = isNuxt || hasDependency(pkg, "unplugin-vue-components");
+	const hasPinia = hasDependency(pkg, "pinia");
+	const hasVueRouter = hasDependency(pkg, "vue-router") && !isNuxt;
+	const tsconfigExists = await pathExists(join(rootDirectory, "tsconfig.json"));
+	return {
+		framework,
+		rootDirectory,
+		packageJsonPath,
+		vueVersion,
+		nuxtVersion,
+		typescriptVersion,
+		hasAutoImports,
+		hasComponentsAutoImport,
+		hasPinia,
+		hasVueRouter,
+		nitroPreset,
+		nuxtCompatibilityVersion,
+		monorepoKind,
+		capabilities: buildCapabilities({
+			framework,
+			vueVersion,
+			nuxtVersion,
+			typescriptVersion,
+			hasTypescript: hasDependency(pkg, "typescript") || tsconfigExists,
+			hasAutoImports,
+			hasComponentsAutoImport,
+			hasPinia,
+			hasVueRouter,
+			nitroPreset,
+			nuxtCompatibilityVersion,
+			monorepoKind,
+			hasWrangler: await pathExists(join(rootDirectory, "wrangler.toml")) || await pathExists(join(rootDirectory, "wrangler.jsonc"))
+		})
+	};
+}
+//#endregion
 //#region src/file-scan.ts
 async function listSourceFiles(opts) {
 	return (await glob(opts.include, {
@@ -39,7 +968,7 @@ function mergeDiagnostics(...batches) {
 }
 //#endregion
 //#region src/oxlint/diagnostic.ts
-const OXLINT_CODE_PATTERN = /^([a-z0-9_-]+)\(([a-z0-9_-]+)\)$/i;
+const OXLINT_CODE_PATTERN = /^([a-z0-9_-]+)\(([a-z0-9/_-]+)\)$/i;
 function normalizeOxlintRuleId(raw) {
 	if (raw.code) {
 		const match = OXLINT_CODE_PATTERN.exec(raw.code);
@@ -51,7 +980,7 @@ function normalizeOxlintRuleId(raw) {
 }
 function toCanonicalDiagnostic(raw, rootDir) {
 	const ruleId = normalizeOxlintRuleId(raw);
-	const severity = raw.severity === "warning" ? "warning" : "error";
+	const severity = raw.severity === "warning" ? "warn" : "error";
 	const primary = raw.labels?.[0]?.span;
 	const line = primary?.line ?? raw.start_line ?? 1;
 	const column = primary?.column ?? raw.start_column ?? 1;
@@ -74,29 +1003,68 @@ function toCanonicalDiagnostics(raws, rootDir) {
 //#region src/oxlint/generate-config.ts
 const DEFAULT_RULES = {
 	"vue/no-export-in-script-setup": "error",
-	"vue/require-typed-ref": "warning",
-	"vue-doctor/no-em-dash-in-string": "warning"
+	"vue/require-typed-ref": "warn",
+	"vue-doctor/no-em-dash-in-string": "warn",
+	"vue-doctor/no-destructure-props-without-to-refs": "error",
+	"vue-doctor/no-destructure-reactive-without-to-refs": "error",
+	"vue-doctor/no-non-null-assertion-on-ref-value": "warn",
+	"vue-doctor/no-imports-from-vue-when-auto-imported": "warn",
+	"vue-doctor/reactivity/watch-without-cleanup": "warn",
+	"vue-doctor/composition/prefer-script-setup-for-new-files": "warn",
+	"vue-doctor/composition/defineProps-typed": "warn"
 };
 function toOxlintSeverity(s) {
-	if (s === "warning") return "warn";
-	return s;
+	if (s === "error") return "error";
+	return "warn";
+}
+async function resolveCacheDir(rootDir) {
+	if (rootDir && existsSync(join(rootDir, "node_modules"))) {
+		const dir = join(rootDir, "node_modules", ".cache", "doctor");
+		await mkdir(dir, { recursive: true });
+		return {
+			dir,
+			removeDir: false
+		};
+	}
+	return {
+		dir: await mkdtemp(join(tmpdir(), "geoql-doctor-")),
+		removeDir: true
+	};
+}
+function resolveUserConfig(rootDir) {
+	if (!rootDir) return void 0;
+	for (const name of [".oxlintrc.json", ".oxlintrc"]) {
+		const candidate = join(rootDir, name);
+		if (existsSync(candidate)) return candidate;
+	}
 }
 async function generateOxlintConfig(input) {
-	const dir = await mkdtemp(join(tmpdir(), "geoql-doctor-"));
+	const { dir, removeDir } = await resolveCacheDir(input.rootDir);
 	const merged = { ...DEFAULT_RULES };
 	if (input.ruleOverrides) for (const [id, sev] of Object.entries(input.ruleOverrides)) if (sev === "off") delete merged[id];
 	else merged[id] = sev;
 	const rules = {};
 	for (const [id, sev] of Object.entries(merged)) rules[id] = toOxlintSeverity(sev);
+	const userConfig = resolveUserConfig(input.rootDir);
 	const config = {
 		$schema: "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json",
+		...userConfig ? { extends: [userConfig] } : {},
 		plugins: ["vue"],
 		jsPlugins: [input.pluginPath],
 		rules
 	};
 	const configPath = join(dir, ".oxlintrc.json");
 	await writeFile(configPath, JSON.stringify(config, null, 2));
-	return configPath;
+	const cleanup = async () => {
+		await rm(removeDir ? dir : configPath, {
+			recursive: true,
+			force: true
+		});
+	};
+	return {
+		configPath,
+		cleanup
+	};
 }
 //#endregion
 //#region src/oxlint/resolve-plugin.ts
@@ -124,18 +1092,21 @@ function lookUpwards(fromDir, relPath) {
 		current = parent;
 	}
 }
+function resolveFromSelf(specifier) {
+	try {
+		return fileURLToPath(import.meta.resolve(specifier));
+	} catch {
+		return;
+	}
+}
 function resolveVueDoctorPluginPath(fromDir) {
 	const pkgJson = lookUpwards(fromDir, "node_modules/@geoql/oxlint-plugin-vue-doctor/package.json");
 	if (pkgJson) {
 		const main = readPkgMain(pkgJson) ?? "./dist/index.js";
 		return resolve(dirname(pkgJson), main);
 	}
-	if (typeof import.meta.resolve === "function") try {
-		const baseUrl = pathToFileURL(resolve(fromDir, "package.json")).href;
-		return fileURLToPath(import.meta.resolve("@geoql/oxlint-plugin-vue-doctor", baseUrl));
-	} catch {
-		return throwResolveError(fromDir);
-	}
+	const selfMain = resolveFromSelf("@geoql/oxlint-plugin-vue-doctor");
+	if (selfMain) return selfMain;
 	return throwResolveError(fromDir);
 }
 function throwResolveError(fromDir) {
@@ -144,11 +1115,32 @@ function throwResolveError(fromDir) {
 function resolveOxlintBin(fromDir) {
 	const pkgJson = lookUpwards(fromDir, "node_modules/oxlint/package.json");
 	if (pkgJson) return resolve(dirname(pkgJson), "bin/oxlint");
+	const selfPkgJson = resolveFromSelf("oxlint/package.json");
+	if (selfPkgJson) return resolve(dirname(selfPkgJson), "bin/oxlint");
 	throw new Error(`Failed to resolve oxlint from ${fromDir}. Install oxlint as a dependency of your project.`);
 }
 //#endregion
-//#region src/oxlint/spawn.ts
-const DEFAULT_TIMEOUT_MS = 6e4;
+//#region src/oxlint/errors.ts
+const STDERR_TAIL_LIMIT = 2e3;
+var OxlintSpawnFailed = class extends Error {
+	name = "OxlintSpawnFailed";
+	constructor(exitCode, stderr) {
+		const tail = stderr.slice(-STDERR_TAIL_LIMIT);
+		super(`oxlint subprocess exited with code ${exitCode}: ${tail}`);
+	}
+};
+var OxlintOutputTooLarge = class extends Error {
+	name = "OxlintOutputTooLarge";
+	constructor(maxBytes) {
+		super(`oxlint subprocess output exceeded ${maxBytes} bytes`);
+	}
+};
+function sanitizedEnv() {
+	const env = { ...process.env };
+	delete env.NODE_OPTIONS;
+	for (const key of Object.keys(env)) if (key.startsWith("npm_config_")) delete env[key];
+	return env;
+}
 async function runOxlint(opts) {
 	return new Promise((resolve, reject) => {
 		const args = [
@@ -164,30 +1156,53 @@ async function runOxlint(opts) {
 				"ignore",
 				"pipe",
 				"pipe"
-			]
+			],
+			env: sanitizedEnv()
 		});
 		const stdoutChunks = [];
 		const stderrChunks = [];
+		let stdoutBytes = 0;
+		let settled = false;
 		let timer;
-		const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+		const timeoutMs = opts.timeoutMs ?? 6e4;
+		const maxOutputBytes = opts.maxOutputBytes ?? 33554432;
+		const finish = (fn) => {
+			if (settled) return;
+			settled = true;
+			if (timer) clearTimeout(timer);
+			fn();
+		};
 		if (timeoutMs > 0) timer = setTimeout(() => {
 			child.kill("SIGKILL");
-			reject(/* @__PURE__ */ new Error(`oxlint subprocess timed out after ${timeoutMs}ms`));
+			finish(() => reject(/* @__PURE__ */ new Error(`oxlint subprocess timed out after ${timeoutMs}ms`)));
 		}, timeoutMs);
-		child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+		child.stdout.on("data", (chunk) => {
+			stdoutBytes += chunk.length;
+			if (stdoutBytes > maxOutputBytes) {
+				child.kill("SIGKILL");
+				finish(() => reject(new OxlintOutputTooLarge(maxOutputBytes)));
+				return;
+			}
+			stdoutChunks.push(chunk);
+		});
 		child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
 		child.on("error", (err) => {
-			if (timer) clearTimeout(timer);
-			reject(err);
+			finish(() => reject(err));
 		});
 		child.on("close", (exitCode) => {
-			if (timer) clearTimeout(timer);
-			const stdout = Buffer.concat(stdoutChunks).toString("utf8");
-			const stderr = Buffer.concat(stderrChunks).toString("utf8");
-			resolve({
-				diagnostics: parseOxlintJsonStream(stdout),
-				stderr,
-				exitCode
+			finish(() => {
+				const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+				const stderr = Buffer.concat(stderrChunks).toString("utf8");
+				const diagnostics = parseOxlintJsonStream(stdout);
+				if (exitCode !== 0 && exitCode !== null && diagnostics.length === 0) {
+					reject(new OxlintSpawnFailed(exitCode, stderr));
+					return;
+				}
+				resolve({
+					diagnostics,
+					stderr,
+					exitCode
+				});
 			});
 		});
 	});
@@ -221,40 +1236,228 @@ function parseNdjson(text) {
 async function runScriptPass(opts) {
 	const pluginPath = resolveVueDoctorPluginPath(opts.rootDir);
 	const oxlintBin = resolveOxlintBin(opts.rootDir);
-	const configPath = await generateOxlintConfig({
+	const { configPath, cleanup } = await generateOxlintConfig({
 		pluginPath,
-		ruleOverrides: opts.ruleOverrides
+		ruleOverrides: opts.ruleOverrides,
+		rootDir: opts.rootDir
 	});
-	const raw = await runOxlint({
-		rootDir: opts.rootDir,
-		targetPath: opts.targetPath,
-		configPath,
-		oxlintBin,
-		timeoutMs: opts.timeoutMs
-	});
-	return {
-		diagnostics: toCanonicalDiagnostics(raw.diagnostics, opts.rootDir),
-		stderr: raw.stderr,
-		exitCode: raw.exitCode
-	};
+	try {
+		const raw = await runOxlint({
+			rootDir: opts.rootDir,
+			targetPath: opts.targetPath,
+			configPath,
+			oxlintBin,
+			timeoutMs: opts.timeoutMs
+		});
+		return {
+			diagnostics: toCanonicalDiagnostics(raw.diagnostics, opts.rootDir),
+			stderr: raw.stderr,
+			exitCode: raw.exitCode
+		};
+	} finally {
+		await cleanup();
+	}
 }
 //#endregion
 //#region src/score.ts
-const ERROR_PENALTY = 10;
-const WARNING_PENALTY = 2;
-function scoreDiagnostics(diagnostics) {
+const SEVERITY_WEIGHTS = {
+	error: 5,
+	warn: 2,
+	info: .5
+};
+function scoreDiagnostics(diagnostics, config) {
+	const threshold = config?.threshold ?? 0;
 	let errorCount = 0;
-	let warningCount = 0;
-	for (const d of diagnostics) if (d.severity === "error") errorCount += 1;
-	else warningCount += 1;
-	const penalty = errorCount * ERROR_PENALTY + warningCount * WARNING_PENALTY;
+	let warnCount = 0;
+	let infoCount = 0;
+	const byRule = /* @__PURE__ */ new Map();
+	for (const d of diagnostics) {
+		if (d.severity === "error") errorCount += 1;
+		else if (d.severity === "warn") warnCount += 1;
+		else infoCount += 1;
+		const list = byRule.get(d.ruleId);
+		if (list) list.push(d);
+		else byRule.set(d.ruleId, [d]);
+	}
+	const sortedRuleIds = [...byRule.keys()].sort();
+	const breakdown = [];
+	let penalty = 0;
+	for (const ruleId of sortedRuleIds) {
+		const list = byRule.get(ruleId);
+		const weight = config?.rules?.[ruleId]?.weight ?? SEVERITY_WEIGHTS[list[0].severity];
+		let rulePenalty = 0;
+		for (let i = 0; i < list.length; i++) rulePenalty += weight * (i === 0 ? 1 : 1 / Math.sqrt(i + 1));
+		penalty += rulePenalty;
+		breakdown.push({
+			ruleId,
+			occurrences: list.length,
+			weightPerOccurrence: weight,
+			penalty: rulePenalty
+		});
+	}
+	breakdown.sort((a, b) => b.penalty - a.penalty);
+	const score = Math.max(0, Math.round(100 - penalty));
 	return {
-		score: Math.max(0, 100 - penalty),
+		score,
+		passed: score >= threshold,
+		threshold,
+		totalFindings: diagnostics.length,
 		errorCount,
-		warningCount
+		warnCount,
+		infoCount,
+		breakdown
 	};
 }
 //#endregion
+//#region src/sfc/parse-sfc-descriptor.ts
+const cache$1 = /* @__PURE__ */ new Map();
+async function parseSfcDescriptor(absPath) {
+	if (cache$1.has(absPath)) return cache$1.get(absPath) ?? null;
+	let source;
+	try {
+		source = await readFile(absPath, "utf8");
+	} catch {
+		cache$1.set(absPath, null);
+		return null;
+	}
+	const { descriptor, errors } = parse(source, { filename: absPath });
+	if (errors.length > 0) {
+		cache$1.set(absPath, null);
+		return null;
+	}
+	cache$1.set(absPath, descriptor);
+	return descriptor;
+}
+//#endregion
+//#region src/sfc/rules/no-mixed-options-and-composition-api.ts
+const RULE_ID = "vue-doctor/sfc/no-mixed-options-and-composition-api";
+const MESSAGE = "Mixed Options API in a <script setup> SFC. Move data/methods/computed/watch/lifecycle into <script setup> Composition API; keep <script> only for options like name/inheritAttrs. See https://vuejs.org/api/sfc-script-setup.html#usage-alongside-normal-script";
+const RECOMMENDATION = "Move this option into the <script setup> block using the Composition API, or keep <script> only for options-only config such as name or inheritAttrs.";
+const DISALLOWED = new Set([
+	"data",
+	"methods",
+	"computed",
+	"watch",
+	"props",
+	"emits",
+	"provide",
+	"inject",
+	"beforeCreate",
+	"created",
+	"beforeMount",
+	"mounted",
+	"beforeUpdate",
+	"updated",
+	"beforeUnmount",
+	"unmounted",
+	"activated",
+	"deactivated",
+	"errorCaptured",
+	"serverPrefetch"
+]);
+function resolveDefineComponentCall(call) {
+	if (call.callee.type !== "Identifier") return null;
+	if (call.callee.name !== "defineComponent") return null;
+	const first = call.arguments[0];
+	if (!first || first.type !== "ObjectExpression") return null;
+	return first;
+}
+function findBindingInit(body, name) {
+	for (const stmt of body) {
+		if (stmt.type !== "VariableDeclaration") continue;
+		for (const declarator of stmt.declarations) {
+			if (declarator.id.type !== "Identifier") continue;
+			if (declarator.id.name !== name) continue;
+			return declarator.init;
+		}
+	}
+	return null;
+}
+function resolveOptionsObject(program) {
+	const exported = program.body.find((node) => node.type === "ExportDefaultDeclaration");
+	if (!exported) return null;
+	const declaration = exported.declaration;
+	if (declaration.type === "ObjectExpression") return declaration;
+	if (declaration.type === "CallExpression") return resolveDefineComponentCall(declaration);
+	if (declaration.type === "Identifier") {
+		const init = findBindingInit(program.body, declaration.name);
+		if (init && init.type === "CallExpression") return resolveDefineComponentCall(init);
+		return null;
+	}
+	return null;
+}
+function locate(content, offset, startLine, startColumn) {
+	let line = startLine;
+	let lastNewline = -1;
+	for (let i = 0; i < offset; i += 1) if (content.charCodeAt(i) === 10) {
+		line += 1;
+		lastNewline = i;
+	}
+	const column = lastNewline === -1 ? startColumn + offset : offset - lastNewline;
+	return {
+		line,
+		column
+	};
+}
+function check$6(ctx) {
+	const { script, scriptSetup } = ctx.descriptor;
+	if (!script || !scriptSetup) return { diagnostics: [] };
+	const lang = script.lang === "ts" ? "ts" : "js";
+	const { program } = parseSync(`script.${lang}`, script.content, {
+		sourceType: "module",
+		lang
+	});
+	const options = resolveOptionsObject(program);
+	if (!options) return { diagnostics: [] };
+	const diagnostics = [];
+	for (const property of options.properties) {
+		if (property.type !== "Property") continue;
+		if (property.key.type !== "Identifier") continue;
+		if (!DISALLOWED.has(property.key.name)) continue;
+		const { line, column } = locate(script.content, property.start, script.loc.start.line, script.loc.start.column);
+		diagnostics.push({
+			file: ctx.file,
+			line,
+			column,
+			ruleId: RULE_ID,
+			severity: "error",
+			message: MESSAGE,
+			source: "sfc",
+			recommendation: RECOMMENDATION
+		});
+	}
+	return { diagnostics };
+}
+//#endregion
+//#region src/sfc/rules/index.ts
+const SFC_RULES = [{
+	id: "vue-doctor/sfc/no-mixed-options-and-composition-api",
+	check: check$6
+}];
+//#endregion
+//#region src/sfc/run.ts
+async function runSfcPass(opts) {
+	const all = [];
+	for (const file of opts.files) {
+		if (!file.endsWith(".vue")) continue;
+		const descriptor = await parseSfcDescriptor(file);
+		if (!descriptor) continue;
+		for (const rule of SFC_RULES) {
+			const override = opts.ruleOverrides?.[rule.id];
+			if (override === "off") continue;
+			const { diagnostics } = rule.check({
+				file,
+				descriptor
+			});
+			for (const d of diagnostics) all.push(override ? {
+				...d,
+				severity: override
+			} : d);
+		}
+	}
+	return all;
+}
+//#endregion
 //#region src/template/parse-sfc.ts
 const cache = /* @__PURE__ */ new Map();
 async function parseSfc(absPath) {
@@ -276,13 +1479,13 @@ async function parseSfc(absPath) {
 }
 //#endregion
 //#region src/template/directive-helpers.ts
-const NODE_DIRECTIVE = 7;
+const NODE_DIRECTIVE$3 = 7;
 function findDirective(el, name) {
-	for (const prop of el.props) if (prop.type === NODE_DIRECTIVE && prop.name === name) return prop;
+	for (const prop of el.props) if (prop.type === NODE_DIRECTIVE$3 && prop.name === name) return prop;
 }
 function findBindAttr(el, attrName) {
 	for (const prop of el.props) {
-		if (prop.type !== NODE_DIRECTIVE) continue;
+		if (prop.type !== NODE_DIRECTIVE$3) continue;
 		const dir = prop;
 		if (dir.name !== "bind") continue;
 		if (dir.arg?.content === attrName) return dir;
@@ -293,9 +1496,9 @@ function findStaticAttr(el, attrName) {
 }
 //#endregion
 //#region src/template/walk.ts
-const NODE_ELEMENT = 1;
+const NODE_ELEMENT$2 = 1;
 function isElementNode(node) {
-	return node !== null && node !== void 0 && node.type === NODE_ELEMENT;
+	return node !== null && node !== void 0 && node.type === NODE_ELEMENT$2;
 }
 function walkElements(root, visit) {
 	const stack = [...root.children];
@@ -310,7 +1513,7 @@ function walkElements(root, visit) {
 }
 //#endregion
 //#region src/template/rules/v-for-has-key.ts
-function check$1(ctx) {
+function check$5(ctx) {
 	const diagnostics = [];
 	walkElements(ctx.template, (el) => {
 		if (!findDirective(el, "for")) return;
@@ -332,7 +1535,7 @@ function check$1(ctx) {
 }
 //#endregion
 //#region src/template/rules/v-if-v-for-precedence.ts
-function check(ctx) {
+function check$4(ctx) {
 	const diagnostics = [];
 	walkElements(ctx.template, (el) => {
 		const vIf = findDirective(el, "if");
@@ -354,14 +1557,221 @@ function check(ctx) {
 	return { diagnostics };
 }
 //#endregion
+//#region src/template/rules/v-memo-on-large-list.ts
+const ARRAY_LITERAL_THRESHOLD = 100;
+function findLargeArrayBindings(script) {
+	const bindings = /* @__PURE__ */ new Map();
+	try {
+		const ast = babelParse(script, { sourceType: "module" });
+		for (const node of ast.program.body) {
+			if (node.type !== "VariableDeclaration") continue;
+			if (node.kind !== "const" && node.kind !== "let") continue;
+			for (const decl of node.declarations) {
+				if (decl.id.type !== "Identifier") continue;
+				const init = decl.init;
+				if (!init || init.type !== "ArrayExpression") continue;
+				if (!init.elements || init.elements.length <= ARRAY_LITERAL_THRESHOLD) continue;
+				bindings.set(decl.id.name, init.elements.length);
+			}
+		}
+	} catch {}
+	return bindings;
+}
+function check$3(ctx) {
+	const diagnostics = [];
+	const largeArrays = ctx.script && ctx.script.length > 0 ? findLargeArrayBindings(ctx.script) : /* @__PURE__ */ new Map();
+	walkElements(ctx.template, (el) => {
+		const vFor = findDirective(el, "for");
+		if (!vFor) return;
+		if (findDirective(el, "memo")) return;
+		const source = vFor.forParseResult?.source;
+		if (!source) return;
+		const sourceName = source.content;
+		const largeArraySize = largeArrays.get(sourceName);
+		if (largeArraySize !== void 0 && largeArraySize > ARRAY_LITERAL_THRESHOLD) diagnostics.push({
+			file: ctx.file,
+			line: el.loc.start.line,
+			column: el.loc.start.column,
+			endLine: el.loc.end.line,
+			endColumn: el.loc.end.column,
+			ruleId: "vue-doctor/template/v-memo-on-large-list",
+			severity: "warn",
+			message: `<${el.tag}> uses v-for over a large dataset (array literal with ${largeArraySize} items) without v-memo. Vue cannot skip diffing this list on every render.`,
+			source: "template",
+			recommendation: "Add v-memo with a meaningful memoization key so Vue can skip re-rendering unchanged items."
+		});
+	});
+	return { diagnostics };
+}
+//#endregion
+//#region src/template/rules/no-inline-object-prop-in-list.ts
+const NODE_DIRECTIVE$2 = 7;
+function checkElement$2(el, inVForSubtree, ctx, diagnostics) {
+	const isVFor = el.props.some((p) => p.type === NODE_DIRECTIVE$2 && p.name === "for");
+	const effectiveInVFor = inVForSubtree || isVFor;
+	if (effectiveInVFor) for (const prop of el.props) {
+		if (prop.type !== NODE_DIRECTIVE$2) continue;
+		const dir = prop;
+		if (dir.name !== "bind") continue;
+		const attrName = dir.arg?.content;
+		if (!attrName || attrName === "key") continue;
+		const astType = dir.exp?.ast?.type;
+		if (astType !== "ObjectExpression" && astType !== "ArrayExpression") continue;
+		diagnostics.push({
+			file: ctx.file,
+			line: dir.loc.start.line,
+			column: dir.loc.start.column,
+			endLine: dir.loc.end.line,
+			endColumn: dir.loc.end.column,
+			ruleId: "vue-doctor/template/no-inline-object-prop-in-list",
+			severity: "warn",
+			message: `<${el.tag}> has an inline ${attrName} prop with an object or array literal inside a v-for subtree. Inline objects and arrays create new references on every render, defeating v-for's ability to reuse DOM nodes.`,
+			source: "template",
+			recommendation: "Move the object or array to a computed property or a module-level constant so the reference remains stable across renders."
+		});
+	}
+	for (const child of el.children) if (child.type === 1) checkElement$2(child, effectiveInVFor, ctx, diagnostics);
+}
+function check$2(ctx) {
+	const diagnostics = [];
+	function walk(node, inVForSubtree) {
+		if (node.type === 1) checkElement$2(node, inVForSubtree, ctx, diagnostics);
+		else if (node.type === 0) {
+			const root = node;
+			for (const child of root.children) walk(child, inVForSubtree);
+		}
+	}
+	walk(ctx.template, false);
+	return { diagnostics };
+}
+//#endregion
+//#region src/template/rules/no-computed-getter-in-template-loop.ts
+const NODE_ELEMENT$1 = 1;
+const NODE_INTERPOLATION = 5;
+const NODE_DIRECTIVE$1 = 7;
+function isValueDeref(node) {
+	if (node.type !== "MemberExpression" || node.computed === true) return false;
+	const { object, property } = node;
+	return object.type === "Identifier" && property.name === "value";
+}
+function containsValueDeref(value) {
+	if (value === null || typeof value !== "object") return false;
+	if (Array.isArray(value)) return value.some((item) => containsValueDeref(item));
+	const node = value;
+	return isValueDeref(node) || Object.values(node).some((child) => containsValueDeref(child));
+}
+function pushDiagnostic(el, loc, ctx, diagnostics) {
+	diagnostics.push({
+		file: ctx.file,
+		line: loc.start.line,
+		column: loc.start.column,
+		endLine: loc.end.line,
+		endColumn: loc.end.column,
+		ruleId: "vue-doctor/template/no-computed-getter-in-template-loop",
+		severity: "warn",
+		message: `<${el.tag}> reads a ref or computed via .value inside a v-for subtree. The getter re-runs on every item and every render, which is easy to hoist out of the loop.`,
+		source: "template",
+		recommendation: "Read .value once into a computed property or a local binding outside the loop so the getter runs a single time per render."
+	});
+}
+function checkElement$1(el, inVForSubtree, ctx, diagnostics) {
+	const isVFor = el.props.some((p) => p.type === NODE_DIRECTIVE$1 && p.name === "for");
+	const effectiveInVFor = inVForSubtree || isVFor;
+	if (effectiveInVFor) {
+		for (const prop of el.props) {
+			if (prop.type !== NODE_DIRECTIVE$1) continue;
+			const dir = prop;
+			if (dir.name !== "bind") continue;
+			if (containsValueDeref(dir.exp?.ast)) pushDiagnostic(el, dir.loc, ctx, diagnostics);
+		}
+		for (const child of el.children) if (child.type === NODE_INTERPOLATION) {
+			const interp = child;
+			if (containsValueDeref(interp.content.ast)) pushDiagnostic(el, interp.loc, ctx, diagnostics);
+		}
+	}
+	for (const child of el.children) if (child.type === NODE_ELEMENT$1) checkElement$1(child, effectiveInVFor, ctx, diagnostics);
+}
+function check$1(ctx) {
+	const diagnostics = [];
+	function walk(node, inVForSubtree) {
+		if (node.type === NODE_ELEMENT$1) checkElement$1(node, inVForSubtree, ctx, diagnostics);
+		else if (node.type === 0) {
+			const root = node;
+			for (const child of root.children) walk(child, inVForSubtree);
+		}
+	}
+	walk(ctx.template, false);
+	return { diagnostics };
+}
+//#endregion
+//#region src/template/rules/avoid-deep-v-bind-spread-in-list.ts
+const NODE_ELEMENT = 1;
+const NODE_DIRECTIVE = 7;
+function isIdentifierSpread(dir) {
+	return dir.name === "bind" && dir.arg === void 0 && dir.exp?.ast === null;
+}
+function checkElement(el, inVForSubtree, ctx, diagnostics) {
+	const isVFor = el.props.some((p) => p.type === NODE_DIRECTIVE && p.name === "for");
+	const effectiveInVFor = inVForSubtree || isVFor;
+	if (effectiveInVFor) for (const prop of el.props) {
+		if (prop.type !== NODE_DIRECTIVE) continue;
+		const dir = prop;
+		if (!isIdentifierSpread(dir)) continue;
+		diagnostics.push({
+			file: ctx.file,
+			line: dir.loc.start.line,
+			column: dir.loc.start.column,
+			endLine: dir.loc.end.line,
+			endColumn: dir.loc.end.column,
+			ruleId: "vue-doctor/template/avoid-deep-v-bind-spread-in-list",
+			severity: "info",
+			message: `<${el.tag}> spreads a whole object via v-bind inside a v-for subtree. Spreading a reactive object binds every property per item, which can churn props and defeat patching on large lists.`,
+			source: "template",
+			recommendation: "Bind only the props each item needs explicitly, or hoist a stable per-item object so Vue can patch instead of re-binding the full spread."
+		});
+	}
+	for (const child of el.children) if (child.type === NODE_ELEMENT) checkElement(child, effectiveInVFor, ctx, diagnostics);
+}
+function check(ctx) {
+	const diagnostics = [];
+	function walk(node, inVForSubtree) {
+		if (node.type === NODE_ELEMENT) checkElement(node, inVForSubtree, ctx, diagnostics);
+		else if (node.type === 0) {
+			const root = node;
+			for (const child of root.children) walk(child, inVForSubtree);
+		}
+	}
+	walk(ctx.template, false);
+	return { diagnostics };
+}
+//#endregion
 //#region src/template/rules/index.ts
-const TEMPLATE_RULES = [{
-	id: "vue-doctor/template/v-for-has-key",
-	check: check$1
-}, {
-	id: "vue-doctor/template/v-if-v-for-precedence",
-	check
-}];
+const TEMPLATE_RULES = [
+	{
+		id: "vue-doctor/template/v-for-has-key",
+		check: check$5
+	},
+	{
+		id: "vue-doctor/template/v-if-v-for-precedence",
+		check: check$4
+	},
+	{
+		id: "vue-doctor/template/v-memo-on-large-list",
+		check: check$3
+	},
+	{
+		id: "vue-doctor/template/no-inline-object-prop-in-list",
+		check: check$2
+	},
+	{
+		id: "vue-doctor/template/no-computed-getter-in-template-loop",
+		check: check$1
+	},
+	{
+		id: "vue-doctor/template/avoid-deep-v-bind-spread-in-list",
+		check
+	}
+];
 //#endregion
 //#region src/template/run.ts
 async function runTemplatePass(opts) {
@@ -375,7 +1785,8 @@ async function runTemplatePass(opts) {
 			if (override === "off") continue;
 			const { diagnostics } = rule.check({
 				file,
-				template: descriptor.template.ast
+				template: descriptor.template.ast,
+				script: descriptor.scriptSetup?.content ?? descriptor.script?.content
 			});
 			for (const d of diagnostics) all.push(override ? {
 				...d,
@@ -401,23 +1812,40 @@ const DEFAULT_EXCLUDE = [
 	".output",
 	"coverage"
 ];
+function countRuleCounts(diagnostics) {
+	const counts = {};
+	for (const d of diagnostics) counts[d.ruleId] = (counts[d.ruleId] ?? 0) + 1;
+	return counts;
+}
 async function audit(config = {}) {
 	const rootDir = resolve(config.rootDir ?? process.cwd());
 	const include = config.include ?? DEFAULT_INCLUDE;
 	const exclude = config.exclude ?? DEFAULT_EXCLUDE;
 	const failOn = config.failOn ?? "error";
+	const threshold = config.threshold ?? 0;
+	const lintEnabled = config.lint !== false;
 	const files = await listSourceFiles({
 		rootDir,
 		include,
 		exclude
 	});
-	const templateDiagnostics = await runTemplatePass({
+	const overallStart = performance.now();
+	const templateStart = performance.now();
+	const templateDiagnostics = lintEnabled ? await runTemplatePass({
 		files,
 		ruleOverrides: config.rules
-	});
+	}) : [];
+	const templateElapsed = performance.now() - templateStart;
+	const sfcStart = performance.now();
+	const sfcDiagnostics = lintEnabled ? await runSfcPass({
+		files,
+		ruleOverrides: config.rules
+	}) : [];
+	const sfcElapsed = performance.now() - sfcStart;
 	let scriptDiagnostics = [];
 	let oxlintStderr = "";
-	try {
+	const scriptStart = performance.now();
+	if (lintEnabled) try {
 		const result = await runScriptPass({
 			rootDir,
 			targetPath: rootDir,
@@ -429,95 +1857,573 @@ async function audit(config = {}) {
 		oxlintStderr = err instanceof Error ? err.message : String(err);
 		if (process.env.DOCTOR_DEBUG) process.stderr.write(`[doctor-core] script pass failed: ${oxlintStderr}\n`);
 	}
-	const merged = mergeDiagnostics(templateDiagnostics, scriptDiagnostics);
-	const { score, errorCount, warningCount } = scoreDiagnostics(merged);
+	const scriptElapsed = performance.now() - scriptStart;
+	const project = await detectProject(rootDir);
+	let deadCodeDiagnostics = [];
+	let deadCodeElapsed = 0;
+	if (config.deadCode !== false) {
+		const deadCodeStart = performance.now();
+		try {
+			const { loadDoctorConfig } = await import("./load-DiK7Zv0B.js").then((n) => n.n);
+			deadCodeDiagnostics = dedupeDeadCodeAgainstLint(await checkDeadCode({
+				projectInfo: project,
+				doctorConfig: await loadDoctorConfig(rootDir),
+				enabled: true
+			}), [
+				...templateDiagnostics,
+				...sfcDiagnostics,
+				...scriptDiagnostics
+			]).filter((d) => config.rules?.[d.ruleId] !== "off");
+		} catch {}
+		deadCodeElapsed = performance.now() - deadCodeStart;
+	}
+	let buildQualityDiagnostics = [];
+	try {
+		buildQualityDiagnostics = (await checkBuildQuality(project)).filter((d) => config.rules?.[d.ruleId] !== "off").map((d) => {
+			const override = config.rules?.[d.ruleId];
+			return override ? {
+				...d,
+				severity: override
+			} : d;
+		});
+	} catch {}
+	let depsDiagnostics = [];
+	try {
+		depsDiagnostics = (await checkDeps(project)).filter((d) => config.rules?.[d.ruleId] !== "off").map((d) => {
+			const override = config.rules?.[d.ruleId];
+			return override ? {
+				...d,
+				severity: override
+			} : d;
+		});
+	} catch {}
+	const elapsedMs = performance.now() - overallStart;
+	const timings = {
+		template: templateElapsed,
+		sfc: sfcElapsed,
+		script: scriptElapsed,
+		deadCode: deadCodeElapsed,
+		total: elapsedMs
+	};
+	let afterDisables = applyInlineDisables(mergeDiagnostics(templateDiagnostics, sfcDiagnostics, scriptDiagnostics, deadCodeDiagnostics, buildQualityDiagnostics, depsDiagnostics), { respect: config.respectInlineDisables !== false });
+	if (config.scopeFiles) {
+		const scope = new Set(config.scopeFiles.map((f) => resolve(rootDir, f)));
+		afterDisables = afterDisables.filter((d) => scope.has(resolve(rootDir, d.file)));
+	}
+	const diagnostics = await attachCodeSnippets(afterDisables);
+	const scored = scoreDiagnostics(diagnostics, { threshold });
+	const ruleCounts = countRuleCounts(diagnostics);
+	const projectInfo = {
+		framework: project.framework,
+		vueVersion: project.vueVersion,
+		nuxtVersion: project.nuxtVersion,
+		capabilities: [...project.capabilities].sort(),
+		rootDirectory: project.rootDirectory
+	};
 	let exitCode = 0;
 	if (oxlintStderr && scriptDiagnostics.length === 0 && oxlintStderr.includes("Failed")) exitCode = 2;
-	else if ((failOn === "warning" ? errorCount + warningCount : errorCount) > 0) exitCode = 1;
+	else if (failOn !== "none") {
+		if ((failOn === "warn" ? scored.errorCount + scored.warnCount : scored.errorCount) > 0) exitCode = 1;
+	}
 	return {
 		rootDir,
 		filesScanned: files.length,
-		diagnostics: merged,
-		score,
-		errorCount,
-		warningCount,
-		exitCode
+		diagnostics,
+		score: scored.score,
+		errorCount: scored.errorCount,
+		warnCount: scored.warnCount,
+		infoCount: scored.infoCount,
+		exitCode,
+		scoreResult: scored,
+		projectInfo,
+		elapsedMs,
+		timings,
+		ruleCounts
 	};
 }
 //#endregion
-//#region src/config.ts
-const DEFAULTS = {
-	include: [
-		"**/*.vue",
-		"**/*.ts",
-		"**/*.tsx",
-		"**/*.js",
-		"**/*.jsx"
-	],
-	exclude: [
-		"node_modules",
-		"dist",
-		".nuxt",
-		".output",
-		"coverage"
-	],
-	failOn: "error"
-};
-async function loadAuditConfig(rootDir, explicitPath) {
-	const { config, configFile } = await loadConfig({
-		cwd: rootDir,
-		name: "doctor",
-		configFile: explicitPath,
-		defaults: DEFAULTS
+//#region src/config/define-config.ts
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+//#region src/config/merge-cli-overrides.ts
+function mergeCliOverrides(resolved, cli) {
+	const rules = { ...resolved.rules };
+	if (cli.rules) for (const [key, value] of Object.entries(cli.rules)) if (value === "off") delete rules[key];
+	else rules[key] = value;
+	return {
+		rootDir: resolved.rootDir,
+		include: cli.include ?? resolved.include,
+		exclude: cli.exclude ?? resolved.exclude,
+		failOn: cli.failOn ?? resolved.failOn,
+		threshold: cli.threshold ?? resolved.threshold,
+		rules,
+		source: resolved.source,
+		configFile: resolved.configFile
+	};
+}
+//#endregion
+//#region src/git-scope.ts
+const execFileAsync = promisify(execFile);
+const SOURCE_EXTENSIONS = [
+	".vue",
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+];
+function isSourceFile(path) {
+	return SOURCE_EXTENSIONS.some((ext) => path.endsWith(ext));
+}
+async function gitLines(rootDir, args) {
+	const { stdout } = await execFileAsync("git", args, { cwd: rootDir });
+	return stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+async function listChangedFiles(options) {
+	const { rootDir, mode } = options;
+	let relPaths;
+	if (mode === "staged") relPaths = await gitLines(rootDir, [
+		"diff",
+		"--name-only",
+		"--cached",
+		"--diff-filter=ACMR"
+	]);
+	else {
+		const tracked = await gitLines(rootDir, [
+			"diff",
+			"--name-only",
+			"HEAD",
+			"--diff-filter=ACMR"
+		]);
+		const untracked = await gitLines(rootDir, [
+			"ls-files",
+			"--others",
+			"--exclude-standard"
+		]);
+		relPaths = [...tracked, ...untracked];
+	}
+	const absolute = relPaths.filter(isSourceFile).map((rel) => resolve(rootDir, rel));
+	return [...new Set(absolute)].sort();
+}
+//#endregion
+//#region src/reporters/docs-url.ts
+function docsUrl(ruleId) {
+	return `https://docs.doctor.geoql.in/rules/${ruleId}`;
+}
+//#endregion
+//#region src/reporters/render.ts
+const CODE_WIDTH = 80;
+const WHY_WIDTH = 70;
+const SEVERITY_WIDTH = 6;
+const CONTINUATION_INDENT = " ".repeat(10);
+function relativize$1(file, rootDirectory) {
+	return relative(rootDirectory, file).replaceAll("\\", "/");
+}
+function compareStrings(a, b) {
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+}
+function truncateCode(code) {
+	if (code.length <= CODE_WIDTH) return code;
+	return `${code.slice(0, CODE_WIDTH - 1)}…`;
+}
+function wrapText(text, width) {
+	const words = text.trim().split(/\s+/);
+	const lines = [];
+	let current = "";
+	for (const word of words) if (current === "") current = word;
+	else if (`${current} ${word}`.length <= width) current = `${current} ${word}`;
+	else {
+		lines.push(current);
+		current = word;
+	}
+	if (current !== "") lines.push(current);
+	return lines;
+}
+function formatWhy(message) {
+	return wrapText(message, WHY_WIDTH).join(`\n${CONTINUATION_INDENT}`);
+}
+function severityTag(severity, theme) {
+	const padding = " ".repeat(SEVERITY_WIDTH - severity.length);
+	return `${theme.severity(severity)}${padding}`;
+}
+function sortDiagnostics(diagnostics, rootDirectory) {
+	return [...diagnostics].sort((a, b) => {
+		const byFile = compareStrings(relativize$1(a.file, rootDirectory), relativize$1(b.file, rootDirectory));
+		if (byFile !== 0) return byFile;
+		if (a.line !== b.line) return a.line - b.line;
+		if (a.column !== b.column) return a.column - b.column;
+		return compareStrings(a.ruleId, b.ruleId);
+	});
+}
+function diagnosticBlock(index, diagnostic, rootDirectory, theme) {
+	const tag = severityTag(diagnostic.severity, theme);
+	const location = `${relativize$1(diagnostic.file, rootDirectory)}:${diagnostic.line}:${diagnostic.column}`;
+	const code = truncateCode(diagnostic.codeSnippet ?? "");
+	const fix = diagnostic.recommendation ?? "(no automated fix)";
+	const why = formatWhy(diagnostic.message);
+	return [
+		`[${index}] ${tag} ${diagnostic.ruleId}`,
+		`    file: ${location}`,
+		`    code: ${code}`,
+		`    fix:  ${fix}`,
+		`    why:  ${why}`,
+		`    docs: ${docsUrl(diagnostic.ruleId)}`
+	].join("\n");
+}
+function findingsLine(score) {
+	if (score.totalFindings === 0) return "FINDINGS: 0 (clean)";
+	return `FINDINGS: ${score.totalFindings} (${score.errorCount} error, ${score.warnCount} warn, ${score.infoCount} info)`;
+}
+function nextSteps(breakdown) {
+	const lines = breakdown.slice(0, 3).map((entry) => `  −${Math.round(entry.penalty)} pts  ${entry.occurrences}× ${entry.ruleId}`);
+	lines.push(`  Run \`vue-doctor explain ${breakdown[0].ruleId}\` for full context.`);
+	return ["NEXT STEPS:", ...lines].join("\n");
+}
+function render(input, options, theme) {
+	if (options?.quiet) return `SCORE: ${theme.scoreValue(input.score.score)}/100 (threshold: ${input.score.threshold})\n`;
+	const seconds = (input.elapsedMs / 1e3).toFixed(1);
+	const segments = [
+		`${input.toolName} v${input.toolVersion}`,
+		`analyzed ${input.analyzedFileCount} files in ${seconds}s`,
+		"",
+		`SCORE: ${theme.scoreValue(input.score.score)}/100 (threshold: ${input.score.threshold})`,
+		"",
+		findingsLine(input.score)
+	];
+	sortDiagnostics(input.diagnostics, input.rootDirectory).forEach((diagnostic, i) => {
+		segments.push("");
+		segments.push(diagnosticBlock(i + 1, diagnostic, input.rootDirectory, theme));
 	});
+	if (input.score.breakdown.length > 0) {
+		segments.push("");
+		segments.push(nextSteps(input.score.breakdown));
+	}
+	return `${segments.join("\n")}\n`;
+}
+//#endregion
+//#region src/reporters/agent.ts
+const plainTheme = {
+	severity: (severity) => severity,
+	scoreValue: (score) => String(score)
+};
+function agentReport(input, options) {
+	return render(input, options, plainTheme);
+}
+//#endregion
+//#region src/rule-docs.ts
+function autoDescription(rule) {
+	const presetNote = rule.recommended ? "Active in the `recommended` preset." : "Off by default in `recommended`; enable via `--rule <id>:warn` or in `doctor.config.ts`.";
+	return `\`${rule.id}\` is a ${rule.severity}-severity ${rule.category} rule from ${rule.source}. ${presetNote}\n\nSee ${docsUrl(rule.id)} for details when the docs site lands.`;
+}
+function resolveDocsRoot() {
+	return resolve(dirname(fileURLToPath(import.meta.url)), "..", "docs", "rules");
+}
+function safeReadOverride(ruleId, docsRoot) {
+	const candidate = join(docsRoot, `${ruleId.replace(/\//g, "__")}.md`);
+	if (!existsSync(candidate)) return null;
+	return readFileSync(candidate, "utf-8");
+}
+function loadRuleDoc(ruleId, options = {}) {
+	const rule = RULE_REGISTRY.find((r) => r.id === ruleId);
+	if (!rule) return null;
+	const override = safeReadOverride(ruleId, options.docsRoot ?? resolveDocsRoot());
+	const description = override ?? autoDescription(rule);
 	return {
-		config: {
-			rootDir,
-			...config
-		},
-		configFile
+		id: rule.id,
+		title: rule.id,
+		severity: rule.severity,
+		category: rule.category,
+		recommended: rule.recommended,
+		source: rule.source,
+		helpUri: docsUrl(rule.id),
+		description,
+		hasOverride: override !== null
+	};
+}
+function loadAllRuleDocs(options = {}) {
+	return RULE_REGISTRY.map((rule) => loadRuleDoc(rule.id, options));
+}
+//#endregion
+//#region src/reporters/sarif.ts
+const SARIF_SCHEMA = "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/main/sarif-2.1/schema/sarif-schema-2.1.0.json";
+const INFORMATION_URI = "https://github.com/geoql/doctor";
+function toSarifLevel(severity) {
+	if (severity === "error") return "error";
+	if (severity === "warn") return "warning";
+	return "note";
+}
+function toRelativeUri(filePath, rootDirectory) {
+	const normalizedRoot = rootDirectory.endsWith("/") ? rootDirectory : `${rootDirectory}/`;
+	if (filePath.startsWith(normalizedRoot)) return filePath.slice(normalizedRoot.length);
+	return filePath;
+}
+function toSarifResult(diag, rootDirectory) {
+	const region = {
+		startLine: diag.line,
+		startColumn: diag.column
+	};
+	if (diag.endLine !== void 0) region.endLine = diag.endLine;
+	if (diag.endColumn !== void 0) region.endColumn = diag.endColumn;
+	const uri = toRelativeUri(diag.file, rootDirectory);
+	return {
+		ruleId: diag.ruleId,
+		level: toSarifLevel(diag.severity),
+		message: { text: diag.message },
+		locations: [{ physicalLocation: {
+			artifactLocation: {
+				uri,
+				uriBaseId: "%SRCROOT%"
+			},
+			region
+		} }],
+		partialFingerprints: { primaryLocationLineHash: `${uri}:${diag.line}:${diag.ruleId}` }
 	};
 }
+function collectRuleIds(diagnostics) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const d of diagnostics) ids.add(d.ruleId);
+	return ids;
+}
+function toRuleDescriptor(ruleId) {
+	const registered = RULE_REGISTRY.find((r) => r.id === ruleId);
+	const severity = registered?.severity ?? "warn";
+	const category = registered?.category ?? "doctor-owned";
+	const name = ruleId.includes("/") ? ruleId.split("/").slice(1).join("/") : ruleId;
+	const fullDescription = loadRuleDoc(ruleId)?.description ?? ruleId;
+	return {
+		id: ruleId,
+		name,
+		shortDescription: { text: ruleId },
+		fullDescription: { text: fullDescription },
+		helpUri: docsUrl(ruleId),
+		defaultConfiguration: { level: toSarifLevel(severity) },
+		properties: { category }
+	};
+}
+function sarifReport(input) {
+	const rules = [...collectRuleIds(input.diagnostics)].sort().map(toRuleDescriptor);
+	const results = input.diagnostics.map((d) => toSarifResult(d, input.rootDirectory));
+	const log = {
+		$schema: SARIF_SCHEMA,
+		version: "2.1.0",
+		runs: [{
+			tool: { driver: {
+				name: input.toolName,
+				version: input.toolVersion,
+				informationUri: INFORMATION_URI,
+				rules
+			} },
+			results
+		}]
+	};
+	return `${JSON.stringify(log, null, 2)}\n`;
+}
+//#endregion
+//#region src/reporters/html.ts
+const SEVERITY_LABEL = {
+	error: "Error",
+	warn: "Warn",
+	info: "Info"
+};
+function escapeHtml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function relativize(file, rootDir) {
+	return file.startsWith(`${rootDir}/`) ? file.slice(rootDir.length + 1) : file;
+}
+function renderDiagnosticRow(d, rootDir) {
+	const loc = `${escapeHtml(relativize(d.file, rootDir))}:${d.line}:${d.column}`;
+	const recommendation = d.recommendation ? `<div class="rec"><strong>Fix:</strong> ${escapeHtml(d.recommendation)}</div>` : "";
+	return [
+		`<details class="finding sev-${d.severity}">`,
+		`  <summary>`,
+		`    <span class="sev">${SEVERITY_LABEL[d.severity]}</span>`,
+		`    <code class="rule">${escapeHtml(d.ruleId)}</code>`,
+		`    <span class="loc">${loc}</span>`,
+		`    <span class="msg">${escapeHtml(d.message)}</span>`,
+		`  </summary>`,
+		`  <div class="body">`,
+		recommendation,
+		`    <div class="docs"><a href="${escapeHtml(docsUrl(d.ruleId))}" target="_blank" rel="noopener">Rule docs</a></div>`,
+		`  </div>`,
+		`</details>`
+	].join("\n");
+}
+const STYLES = `
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body { font: 14px/1.5 system-ui, -apple-system, sans-serif; background: #0f0f0f; color: #e5e5e5; padding: 2rem; }
+header { border-bottom: 1px solid #2a2a2a; padding-bottom: 1.5rem; margin-bottom: 1.5rem; }
+h1 { font-size: 1.25rem; font-weight: 500; color: #fafafa; }
+.meta { color: #888; margin-top: 0.5rem; font-size: 0.85rem; }
+.score-row { display: flex; gap: 2rem; margin-top: 1rem; align-items: baseline; }
+.score-row .score { font-size: 3rem; font-weight: 200; color: #fafafa; }
+.score-row .score.pass { color: #4ade80; }
+.score-row .score.fail { color: #f87171; }
+.score-row .breakdown { color: #aaa; font-size: 0.9rem; }
+.finding { border: 1px solid #2a2a2a; border-radius: 6px; margin-bottom: 0.5rem; background: #1a1a1a; overflow: hidden; }
+.finding summary { padding: 0.75rem 1rem; cursor: pointer; display: grid; grid-template-columns: 4rem 14rem 14rem 1fr; gap: 0.75rem; align-items: baseline; font-size: 0.85rem; list-style: none; }
+.finding summary::-webkit-details-marker { display: none; }
+.sev { font-size: 0.7rem; text-transform: uppercase; font-weight: 600; letter-spacing: 0.05em; }
+.sev-error .sev { color: #f87171; }
+.sev-warn .sev { color: #fbbf24; }
+.sev-info .sev { color: #60a5fa; }
+.rule { color: #aaa; font-family: ui-monospace, monospace; font-size: 0.8rem; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.loc { color: #888; font-family: ui-monospace, monospace; font-size: 0.8rem; }
+.msg { color: #d4d4d4; }
+.body { padding: 0 1rem 1rem; border-top: 1px solid #2a2a2a; color: #ccc; font-size: 0.85rem; }
+.rec { margin-top: 0.75rem; }
+.docs { margin-top: 0.5rem; }
+.docs a { color: #60a5fa; text-decoration: none; }
+.docs a:hover { text-decoration: underline; }
+.empty { color: #888; padding: 2rem 0; text-align: center; }
+`;
+function htmlReport(input) {
+	const score = input.score.score;
+	const pass = input.score.passed;
+	const rows = input.diagnostics.map((d) => renderDiagnosticRow(d, input.rootDirectory)).join("\n");
+	const body = input.diagnostics.length === 0 ? `<p class="empty">No findings. Clean run.</p>` : rows;
+	const findingsLabel = `${input.diagnostics.length} finding${input.diagnostics.length === 1 ? "" : "s"}`;
+	const meta = `${input.toolName} v${input.toolVersion} · ${input.analyzedFileCount} file${input.analyzedFileCount === 1 ? "" : "s"} · ${input.elapsedMs.toFixed(0)}ms`;
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${escapeHtml(input.toolName)} — Report</title>
+<style>${STYLES}</style>
+</head>
+<body>
+<header>
+  <h1>${escapeHtml(input.toolName)} report</h1>
+  <div class="meta">${escapeHtml(meta)} · ${escapeHtml(input.rootDirectory)}</div>
+  <div class="score-row">
+    <div class="score ${pass ? "pass" : "fail"}">${score}<span style="font-size:1.5rem;color:#888">/100</span></div>
+    <div class="breakdown">${findingsLabel} · ${input.score.errorCount} error · ${input.score.warnCount} warn · ${input.score.infoCount} info</div>
+  </div>
+</header>
+<main>
+${body}
+</main>
+</body>
+</html>
+`;
+}
 //#endregion
 //#region src/reporters/json.ts
-function formatJson(report) {
-	return JSON.stringify(report, null, 2);
+const DOCTOR_REPORT_SCHEMA_VERSION = "1";
+function buildDoctorReport(input) {
+	return {
+		schemaVersion: "1",
+		tool: {
+			name: input.toolName,
+			version: input.toolVersion
+		},
+		projectInfo: {
+			framework: input.projectInfo.framework,
+			vueVersion: input.projectInfo.vueVersion,
+			nuxtVersion: input.projectInfo.nuxtVersion,
+			capabilities: [...input.projectInfo.capabilities].sort(),
+			rootDirectory: input.projectInfo.rootDirectory
+		},
+		score: {
+			value: input.score.score,
+			threshold: input.score.threshold,
+			passed: input.score.passed,
+			bySeverity: {
+				error: input.score.errorCount,
+				warn: input.score.warnCount,
+				info: input.score.infoCount
+			},
+			breakdown: input.score.breakdown.map((entry) => ({
+				ruleId: entry.ruleId,
+				occurrences: entry.occurrences,
+				weightPerOccurrence: entry.weightPerOccurrence,
+				penalty: entry.penalty
+			}))
+		},
+		diagnostics: input.diagnostics.map((d) => ({
+			file: relative(input.rootDirectory, d.file).replaceAll("\\", "/"),
+			line: d.line,
+			column: d.column,
+			endLine: d.endLine,
+			endColumn: d.endColumn,
+			ruleId: d.ruleId,
+			severity: d.severity,
+			message: d.message,
+			source: d.source,
+			recommendation: d.recommendation
+		})),
+		timing: {
+			elapsedMs: input.elapsedMs,
+			analyzedFileCount: input.analyzedFileCount
+		}
+	};
+}
+function jsonReport(input) {
+	return JSON.stringify(buildDoctorReport(input), null, 2);
+}
+//#endregion
+//#region src/reporters/json-compact.ts
+function jsonCompactReport(input) {
+	return `${JSON.stringify(buildDoctorReport(input))}\n`;
 }
 //#endregion
-//#region src/reporters/text.ts
-function formatText(report) {
+//#region src/reporters/pretty.ts
+const colors = pc.createColors(true);
+const colorTheme = {
+	severity: (severity) => {
+		if (severity === "error") return colors.red(severity);
+		if (severity === "warn") return colors.yellow(severity);
+		return colors.cyan(severity);
+	},
+	scoreValue: (score) => {
+		if (score <= 50) return colors.red(String(score));
+		if (score <= 79) return colors.yellow(String(score));
+		return colors.green(String(score));
+	}
+};
+function prettyReport(input, options) {
+	if (options?.color === false || Boolean(process$1.env.NO_COLOR)) return agentReport(input, options);
+	return render(input, options, colorTheme);
+}
+//#endregion
+//#region src/reporters/verbose.ts
+function formatMs(ms) {
+	return `${ms.toFixed(1)}ms`;
+}
+function renderVerboseTrace(report, options) {
 	const lines = [];
-	const groups = /* @__PURE__ */ new Map();
-	for (const d of report.diagnostics) {
-		const arr = groups.get(d.file) ?? [];
-		arr.push(d);
-		groups.set(d.file, arr);
-	}
-	for (const [file, diags] of groups) {
-		const rel = relative(report.rootDir, file) || file;
-		lines.push(c.underline(c.bold(rel)));
-		for (const d of diags) {
-			const sev = d.severity === "error" ? c.red("error") : c.yellow("warning");
-			const loc = c.dim(`${d.line}:${d.column}`);
-			const rule = c.dim(`(${d.ruleId})`);
-			lines.push(`  ${loc}  ${sev}  ${d.message} ${rule}`);
-			if (d.recommendation) lines.push(`        ${c.dim("hint:")} ${d.recommendation}`);
-		}
-		lines.push("");
+	lines.push("TIMINGS");
+	lines.push(`  template: ${formatMs(report.timings.template)}`);
+	lines.push(`  sfc:      ${formatMs(report.timings.sfc)}`);
+	lines.push(`  script:   ${formatMs(report.timings.script)}`);
+	lines.push(`  deadCode: ${formatMs(report.timings.deadCode)}`);
+	lines.push(`  total:   ${formatMs(report.timings.total)}`);
+	const ruleKeys = Object.keys(report.ruleCounts);
+	if (ruleKeys.length > 0) {
+		lines.push("RULE COUNTS");
+		for (const ruleId of ruleKeys.sort()) lines.push(`  ${ruleId}: ${report.ruleCounts[ruleId]}`);
+	}
+	if (options.configSource) {
+		lines.push("CONFIG");
+		lines.push(`  source: ${options.configSource}`);
 	}
-	const summary = `${report.errorCount} error${report.errorCount === 1 ? "" : "s"}, ${report.warningCount} warning${report.warningCount === 1 ? "" : "s"} in ${report.filesScanned} file${report.filesScanned === 1 ? "" : "s"}`;
-	const scoreLine = `Score: ${c.bold(String(report.score))}/100`;
-	lines.push(summary);
-	lines.push(scoreLine);
 	return lines.join("\n");
 }
 //#endregion
 //#region src/reporters/index.ts
-function format(report, kind) {
-	if (kind === "json") return formatJson(report);
-	return formatText(report);
+function format(input, kind = "agent", options) {
+	if (kind === "pretty") return prettyReport(input, options);
+	if (kind === "json") return jsonReport(input);
+	if (kind === "json-compact") return jsonCompactReport(input);
+	if (kind === "sarif") return sarifReport(input);
+	if (kind === "html") return htmlReport(input);
+	return agentReport(input, options);
 }
 //#endregion
-export { audit, format, loadAuditConfig };
+export { BUILT_IN_RECOMMENDED, ConfigCycleError, ConfigFileNotFoundError, DOCTOR_REPORT_SCHEMA_VERSION, DeadCodeImportFailed, DeadCodeTimeoutError, InvalidConfigError, OxlintOutputTooLarge, OxlintSpawnFailed, RULE_REGISTRY, agentReport, applyInlineDisables, audit, buildDoctorReport, checkBuildQuality, checkDeadCode, checkDeps, dedupeDeadCodeAgainstLint, defineConfig, detectProject, docsUrl, encodeAnnotation, encodeAnnotations, format, jsonCompactReport, jsonReport, listChangedFiles, listRules, loadAllRuleDocs, loadDoctorConfig, loadRuleDoc, mergeCliOverrides, parseDirectives, prettyReport, renderVerboseTrace, sarifReport, scoreDiagnostics, validateConfig };
 
 //# sourceMappingURL=index.js.map