@ripast/vue 0.2.2 → 0.4.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
-import { extractTemplateExpressions, hyphenateVueName, isInsideAutoImportScope, posToLineCol, rewriteTemplateReferences, rgFiles, scan } from "@ripast/core/adapter";
+import { extractTemplateExpressions, hyphenateVueName, isInsideAutoImportScope, parseSourceFile, parseVueTemplateAst, posToLineCol, rewriteTemplateReferences, rgFiles, rgFilesMany, scan } from "@ripast/core/adapter";
 import { URI } from "vscode-uri";
 import process from "node:process";
 import { FileType, createLanguage, createLanguageService, createUriMap } from "@volar/language-service";
@@ -11,7 +11,67 @@ import ts from "typescript";
 import { create } from "volar-service-typescript";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import { spawnSync } from "node:child_process";
+function stringifyArg(arg) {
+	if (arg instanceof Error) return arg.message;
+	if (typeof arg === "string") return arg;
+	return String(arg);
+}
+function isNoisyDiagnostic(text) {
+	return text.includes("languageId not found") || text.includes(".d.ts.map") || text.includes(".d.mts.map") || text.includes(".d.cts.map");
+}
+function withFilteredConsoleWarn(fn) {
+	const original = console.warn;
+	console.warn = (...args) => {
+		const first = typeof args[0] === "string" ? args[0] : "";
+		if (first.startsWith("[Vue] Resolve plugin path failed") || first.startsWith("[Vue] Load plugin failed")) return;
+		if (first.startsWith("languageId not found")) return;
+		original.apply(console, args);
+	};
+	const restore = () => {
+		console.warn = original;
+	};
+	try {
+		const result = fn();
+		if (result && typeof result.then === "function") return result.then((v) => {
+			restore();
+			return v;
+		}, (e) => {
+			restore();
+			throw e;
+		});
+		restore();
+		return result;
+	} catch (err) {
+		restore();
+		throw err;
+	}
+}
 function createVueService(tsconfigPath, cwd) {
+	const restore = installFilteredConsoleWarn();
+	const service = createVueServiceInternal(tsconfigPath, cwd);
+	const origDispose = service.dispose;
+	service.dispose = () => {
+		try {
+			origDispose();
+		} finally {
+			restore();
+		}
+	};
+	return service;
+}
+function installFilteredConsoleWarn() {
+	const original = console.warn;
+	console.warn = (...args) => {
+		const first = typeof args[0] === "string" ? args[0] : "";
+		if (first.startsWith("[Vue] Resolve plugin path failed") || first.startsWith("[Vue] Load plugin failed")) return;
+		if (first.startsWith("languageId not found")) return;
+		original.apply(console, args);
+	};
+	return () => {
+		console.warn = original;
+	};
+}
+function createVueServiceInternal(tsconfigPath, cwd) {
 	const commandLine = createParsedCommandLine(ts, ts.sys, tsconfigPath);
 	const vueExts = getAllExtensions(commandLine.vueOptions).map((ext) => {
 		return {
@@ -72,8 +132,12 @@ function createVueService(tsconfigPath, cwd) {
 		console: {
 			log() {},
 			warn() {},
-			error: process.stderr.write.bind(process.stderr),
-			info() {}
+			info() {},
+			error(...args) {
+				const text = args.map(stringifyArg).join(" ");
+				if (isNoisyDiagnostic(text)) return;
+				process.stderr.write(`${text}\n`);
+			}
 		}
 	};
 	const project = { typescript: {
@@ -133,7 +197,7 @@ function workspaceEditToChanges(edit, vue, cwd, filter) {
 function workspaceRelativePath(fileName, cwd) {
 	return fileName.startsWith(cwd) ? fileName.slice(cwd.length).replace(/^[/\\]/, "") : fileName;
 }
-function hasVueFilesContaining$1(cwd, pattern) {
+function hasVueFilesContaining(cwd, pattern) {
 	return listVueFilesContaining(cwd, pattern).length > 0;
 }
 function listVueFiles(cwd) {
@@ -159,9 +223,6 @@ function rgVueFiles(cwd, args) {
 		encoding: "utf8"
 	}).stdout.split("\n").filter(Boolean).map((path) => resolve(cwd, path));
 }
-function hasVueFilesContaining(cwd, pattern) {
-	return hasVueFilesContaining$1(cwd, pattern);
-}
 async function applyVueRename(tsconfigPath, cwd, from, to, sites) {
 	const vue = createVueService(tsconfigPath, cwd);
 	try {
@@ -236,11 +297,11 @@ async function vueRegressions(tsconfigPath, cwd, pendingChanges) {
 	if (!vueFiles.length) return [];
 	const vue = createVueService(tsconfigPath, cwd);
 	try {
-		const baselinePairs = await Promise.all(vueFiles.map(async (file) => [file, await collectDiagKeys(vue, file)]));
+		const baselinePairs = await withFilteredConsoleWarn(() => Promise.all(vueFiles.map(async (file) => [file, await collectDiagKeys(vue, file)])));
 		const baseline = new Map(baselinePairs);
 		for (const c of pendingChanges) vue.setSnapshot(c.path, c.after);
 		const checkSet = [...new Set([...vueFiles, ...pendingChanges.filter((c) => c.path.endsWith(".vue")).map((c) => c.path)])];
-		const postPairs = await Promise.all(checkSet.map(async (file) => [file, await getDiags(vue, file)]));
+		const postPairs = await withFilteredConsoleWarn(() => Promise.all(checkSet.map(async (file) => [file, await getDiags(vue, file)])));
 		const out = [];
 		for (const [file, post] of postPairs) {
 			const before = baseline.get(file) ?? /* @__PURE__ */ new Set();
@@ -273,7 +334,531 @@ async function getDiags(vue, fileName) {
 function diagKey(d) {
 	return `${d.range.start.line}:${d.range.start.character}:${d.code ?? ""}:${d.message}`;
 }
-const MODULE_EXT_RE = /\.(?:tsx?|jsx?|mts|cts|mjs|cjs|vue)$/;
+function parseComponent(absPath) {
+	return parseComponentSource(absPath, readFileSync(absPath, "utf8"));
+}
+function parseComponentSource(absPath, source) {
+	const empty = {
+		props: [],
+		emits: [],
+		slots: [],
+		exposes: [],
+		scriptLang: null,
+		setup: false,
+		propsResolution: "literal"
+	};
+	if (!absPath.endsWith(".vue")) {
+		const program = safeParse(absPath, source);
+		if (!program) return empty;
+		return walkProgram(program, {
+			...empty,
+			scriptLang: absPath.endsWith(".ts") || absPath.endsWith(".tsx") ? "ts" : "js"
+		});
+	}
+	const block = extractScriptBlock(source);
+	if (!block) return empty;
+	const program = safeParse(`${absPath}.ts`, block.code);
+	if (!program) return {
+		...empty,
+		scriptLang: block.lang,
+		setup: block.setup
+	};
+	return walkProgram(program, {
+		...empty,
+		scriptLang: block.lang,
+		setup: block.setup
+	});
+}
+const SCRIPT_TAG_RE$1 = /<script(\s[^>]*)?>([\s\S]*?)<\/script>/gi;
+function extractScriptBlock(source) {
+	const blocks = [];
+	for (const m of source.matchAll(SCRIPT_TAG_RE$1)) {
+		const attrs = m[1] ?? "";
+		const code = m[2] ?? "";
+		if (/\bsrc\s*=/.test(attrs)) continue;
+		const lang = /\blang\s*=\s*["']ts["']/.test(attrs) ? "ts" : "js";
+		const setup = /\bsetup\b/.test(attrs);
+		blocks.push({
+			code,
+			lang,
+			setup
+		});
+	}
+	if (!blocks.length) return null;
+	return blocks.find((b) => b.setup) ?? blocks.reduce((a, b) => b.code.length > a.code.length ? b : a);
+}
+function safeParse(path, code) {
+	try {
+		return parseSourceFile(path, code).program;
+	} catch {
+		return null;
+	}
+}
+function walkProgram(program, base) {
+	let propsResolution = "literal";
+	const props = [];
+	const emits = [];
+	const slots = [];
+	const exposes = [];
+	const withDefaultsKeys = /* @__PURE__ */ new Set();
+	walkAst(program, (node) => {
+		if (node.type === "CallExpression") switch (calleeName(node)) {
+			case "defineProps": {
+				const result = extractProps(node);
+				if (result.unresolved) propsResolution = "unresolved";
+				for (const p of result.props) props.push(p);
+				break;
+			}
+			case "defineEmits": {
+				const result = extractEmits(node);
+				if (result.unresolved) propsResolution = "unresolved";
+				for (const e of result.emits) emits.push(e);
+				break;
+			}
+			case "defineSlots": {
+				const result = extractStringKeyedTypeLiteral(node);
+				if (result.unresolved) propsResolution = "unresolved";
+				for (const s of result.keys) slots.push(s);
+				break;
+			}
+			case "defineExpose": {
+				const result = extractExpose(node);
+				if (result.unresolved) propsResolution = "unresolved";
+				for (const e of result.keys) exposes.push(e);
+				break;
+			}
+			case "withDefaults": {
+				const second = node.arguments?.[1];
+				if (second?.type === "ObjectExpression") for (const prop of second.properties ?? []) {
+					const key = propKey(prop);
+					if (key) withDefaultsKeys.add(key);
+				}
+				break;
+			}
+			case "defineComponent": {
+				const arg = node.arguments?.[0];
+				if (arg?.type === "ObjectExpression") for (const prop of arg.properties ?? []) {
+					const key = propKey(prop);
+					if (key === "props") {
+						const r = extractPropsFromOptionsValue(prop.value);
+						if (r.unresolved) propsResolution = "unresolved";
+						for (const p of r.props) props.push(p);
+					} else if (key === "emits") {
+						const r = extractEmitsFromValue(prop.value);
+						if (r.unresolved) propsResolution = "unresolved";
+						for (const e of r.emits) emits.push(e);
+					}
+				}
+				break;
+			}
+		}
+	});
+	for (const p of props) if (withDefaultsKeys.has(p.name)) p.hasDefault = true;
+	return {
+		...base,
+		props: dedupePropsByName(props),
+		emits: [...new Set(emits)].sort(),
+		slots: [...new Set(slots)].sort(),
+		exposes: [...new Set(exposes)].sort(),
+		propsResolution
+	};
+}
+function calleeName(node) {
+	const callee = node.callee;
+	if (callee?.type === "Identifier") return callee.name;
+	if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier" && !callee.computed) return callee.property.name;
+	return null;
+}
+function propKey(prop) {
+	if (prop?.type !== "Property" && prop?.type !== "ObjectProperty") return null;
+	if (!prop.key) return null;
+	if (prop.computed) return null;
+	if (prop.key.type === "Identifier") return prop.key.name;
+	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
+	return null;
+}
+function extractProps(callNode) {
+	const typeArg = callNode.typeArguments?.params?.[0] ?? callNode.typeParameters?.params?.[0];
+	if (typeArg) return propsFromTypeLiteral(typeArg);
+	const arg = callNode.arguments?.[0];
+	if (!arg) return {
+		props: [],
+		unresolved: false
+	};
+	return extractPropsFromOptionsValue(arg);
+}
+function extractPropsFromOptionsValue(arg) {
+	if (!arg) return {
+		props: [],
+		unresolved: false
+	};
+	if (arg.type === "ArrayExpression") {
+		const out = [];
+		for (const el of arg.elements ?? []) if (el?.type === "Literal" && typeof el.value === "string") out.push({ name: el.value });
+		return {
+			props: out,
+			unresolved: false
+		};
+	}
+	if (arg.type === "ObjectExpression") {
+		const out = [];
+		for (const prop of arg.properties ?? []) {
+			const key = propKey(prop);
+			if (!key) continue;
+			const sig = { name: key };
+			const value = prop.value;
+			if (value?.type === "ObjectExpression") for (const inner of value.properties ?? []) {
+				const innerKey = propKey(inner);
+				if (innerKey === "required" && inner.value?.type === "Literal") sig.required = !!inner.value.value;
+				if (innerKey === "default") sig.hasDefault = true;
+				if (innerKey === "type") sig.type = stringifyTypeNode(inner.value);
+			}
+			else if (value) sig.type = stringifyTypeNode(value);
+			out.push(sig);
+		}
+		return {
+			props: out,
+			unresolved: false
+		};
+	}
+	return {
+		props: [],
+		unresolved: true
+	};
+}
+function propsFromTypeLiteral(typeNode) {
+	if (typeNode?.type !== "TSTypeLiteral") return {
+		props: [],
+		unresolved: true
+	};
+	const out = [];
+	for (const member of typeNode.members ?? []) {
+		if (member.type !== "TSPropertySignature") continue;
+		const name = member.key?.type === "Identifier" ? member.key.name : member.key?.type === "Literal" && typeof member.key.value === "string" ? member.key.value : null;
+		if (!name) continue;
+		out.push({
+			name,
+			required: !member.optional,
+			type: member.typeAnnotation?.typeAnnotation ? stringifyTypeNode(member.typeAnnotation.typeAnnotation) : void 0
+		});
+	}
+	return {
+		props: out,
+		unresolved: false
+	};
+}
+function extractEmits(callNode) {
+	const typeArg = callNode.typeArguments?.params?.[0] ?? callNode.typeParameters?.params?.[0];
+	if (typeArg) {
+		if (typeArg.type === "TSTypeLiteral") {
+			const out = [];
+			for (const member of typeArg.members ?? []) if (member.type === "TSCallSignatureDeclaration") {
+				const literal = (member.params?.[0])?.typeAnnotation?.typeAnnotation;
+				if (literal?.type === "TSLiteralType" && literal.literal?.type === "Literal" && typeof literal.literal.value === "string") out.push(literal.literal.value);
+			} else if (member.type === "TSPropertySignature" && member.key?.type === "Identifier") out.push(member.key.name);
+			return {
+				emits: out,
+				unresolved: false
+			};
+		}
+		return {
+			emits: [],
+			unresolved: true
+		};
+	}
+	const arg = callNode.arguments?.[0];
+	return extractEmitsFromValue(arg);
+}
+function extractEmitsFromValue(arg) {
+	if (!arg) return {
+		emits: [],
+		unresolved: false
+	};
+	if (arg.type === "ArrayExpression") {
+		const out = [];
+		for (const el of arg.elements ?? []) if (el?.type === "Literal" && typeof el.value === "string") out.push(el.value);
+		return {
+			emits: out,
+			unresolved: false
+		};
+	}
+	if (arg.type === "ObjectExpression") {
+		const out = [];
+		for (const prop of arg.properties ?? []) {
+			const key = propKey(prop);
+			if (key) out.push(key);
+		}
+		return {
+			emits: out,
+			unresolved: false
+		};
+	}
+	return {
+		emits: [],
+		unresolved: true
+	};
+}
+function extractStringKeyedTypeLiteral(callNode) {
+	const typeArg = callNode.typeArguments?.params?.[0] ?? callNode.typeParameters?.params?.[0];
+	if (typeArg?.type === "TSTypeLiteral") {
+		const out = [];
+		for (const member of typeArg.members ?? []) {
+			if (member.type !== "TSPropertySignature" && member.type !== "TSMethodSignature") continue;
+			if (member.key?.type === "Identifier") out.push(member.key.name);
+			else if (member.key?.type === "Literal" && typeof member.key.value === "string") out.push(member.key.value);
+		}
+		return {
+			keys: out,
+			unresolved: false
+		};
+	}
+	return {
+		keys: [],
+		unresolved: !!typeArg
+	};
+}
+function extractExpose(callNode) {
+	const arg = callNode.arguments?.[0];
+	if (arg?.type === "ObjectExpression") {
+		const out = [];
+		for (const prop of arg.properties ?? []) {
+			const key = propKey(prop);
+			if (key) out.push(key);
+		}
+		return {
+			keys: out,
+			unresolved: false
+		};
+	}
+	return {
+		keys: [],
+		unresolved: !!arg
+	};
+}
+function stringifyTypeNode(node) {
+	if (!node) return void 0;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "TSTypeReference" && node.typeName?.type === "Identifier") return node.typeName.name;
+	if (node.type === "TSStringKeyword") return "String";
+	if (node.type === "TSNumberKeyword") return "Number";
+	if (node.type === "TSBooleanKeyword") return "Boolean";
+	if (node.type === "TSArrayType") return `${stringifyTypeNode(node.elementType) ?? "?"}[]`;
+}
+function walkAst(node, visit) {
+	if (!node || typeof node !== "object") return;
+	if (typeof node.type === "string") visit(node);
+	for (const key in node) {
+		if (key === "parent" || key === "loc" || key === "range") continue;
+		const value = node[key];
+		if (Array.isArray(value)) for (const child of value) walkAst(child, visit);
+		else if (value && typeof value === "object" && typeof value.type === "string") walkAst(value, visit);
+	}
+}
+function dedupePropsByName(props) {
+	const out = /* @__PURE__ */ new Map();
+	for (const p of props) {
+		const existing = out.get(p.name);
+		if (!existing) {
+			out.set(p.name, p);
+			continue;
+		}
+		out.set(p.name, {
+			name: p.name,
+			type: existing.type ?? p.type,
+			required: existing.required ?? p.required,
+			hasDefault: existing.hasDefault || p.hasDefault
+		});
+	}
+	return [...out.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+const NODE_ELEMENT$1 = 1;
+const NODE_DIRECTIVE = 7;
+const ATTRIBUTE = 6;
+const DEFAULT_GLOB = [
+	"*.vue",
+	"*.ts",
+	"*.tsx",
+	"*.js",
+	"*.jsx",
+	"*.mjs"
+];
+function findComponentUsages(names, opts = {}) {
+	const cwd = opts.cwd ?? process.cwd();
+	const aliasIndex = buildAliasIndex(names);
+	const candidates = candidateFiles(cwd, aliasIndex, opts.glob);
+	const out = [];
+	for (const abs of candidates) {
+		const source = readOrEmpty(abs);
+		if (!source) continue;
+		if (abs.endsWith(".vue")) collectFromSfc(abs, source, cwd, aliasIndex, out);
+		collectFromScript(abs, source, cwd, aliasIndex, out);
+	}
+	return out.sort(sortUsages);
+}
+function buildAliasIndex(names) {
+	const byTag = /* @__PURE__ */ new Map();
+	const byString = /* @__PURE__ */ new Set();
+	const search = /* @__PURE__ */ new Set();
+	for (const name of names) {
+		byTag.set(name, name);
+		const kebab = hyphenateVueName(name);
+		if (kebab !== name) byTag.set(kebab, name);
+		byString.add(name);
+		search.add(name);
+		if (kebab !== name) search.add(kebab);
+	}
+	return {
+		byTag,
+		byString,
+		search: [...search]
+	};
+}
+function candidateFiles(cwd, alias, glob) {
+	const globs = glob ? Array.isArray(glob) ? glob : [glob] : DEFAULT_GLOB;
+	return rgFilesMany(alias.search, {
+		cwd,
+		glob: globs
+	});
+}
+function readOrEmpty(abs) {
+	try {
+		return readFileSync(abs, "utf8");
+	} catch {
+		return "";
+	}
+}
+function collectFromSfc(abs, source, cwd, alias, out) {
+	const ast = parseVueTemplateAst(source);
+	if (!ast) return;
+	walkTemplate(ast, (node) => {
+		if (node.type !== NODE_ELEMENT$1) return;
+		const canonical = alias.byTag.get(node.tag);
+		if (canonical) {
+			const { line, col } = posToLineCol(source, node.loc.start.offset + 1);
+			out.push({
+				name: canonical,
+				file: abs,
+				rel: relative(cwd, abs),
+				line,
+				col,
+				form: /^[a-z]/.test(node.tag) ? "tag-kebab" : "tag-pascal"
+			});
+		}
+		if (node.tag === "component") {
+			const isProp = (node.props ?? []).find((p) => isIsDirective(p));
+			if (isProp) collectDynamicIs(abs, source, cwd, isProp, alias, out);
+		}
+	});
+}
+function isIsDirective(prop) {
+	if (!prop) return false;
+	if (prop.type === ATTRIBUTE && prop.name === "is") return true;
+	if (prop.type === NODE_DIRECTIVE && prop.name === "bind" && prop.arg?.content === "is") return true;
+	return false;
+}
+function collectDynamicIs(abs, source, cwd, prop, alias, out) {
+	if (prop.type === ATTRIBUTE) {
+		const value = prop.value?.content;
+		if (typeof value === "string" && alias.byString.has(value)) {
+			const offset = prop.value.loc.start.offset;
+			const { line, col } = posToLineCol(source, offset);
+			out.push({
+				name: value,
+				file: abs,
+				rel: relative(cwd, abs),
+				line,
+				col,
+				form: "dynamic-is-literal"
+			});
+		}
+		return;
+	}
+	const exp = prop.exp;
+	if (!exp?.content) return;
+	const trimmed = exp.content.trim();
+	const literal = trimmed.match(/^['"]([^'"]+)['"]$/);
+	if (literal) {
+		const name = literal[1];
+		if (alias.byString.has(name)) {
+			const offset = exp.loc.start.offset;
+			const { line, col } = posToLineCol(source, offset);
+			out.push({
+				name,
+				file: abs,
+				rel: relative(cwd, abs),
+				line,
+				col,
+				form: "dynamic-is-literal"
+			});
+		}
+		return;
+	}
+	const offset = exp.loc.start.offset;
+	const { line, col } = posToLineCol(source, offset);
+	out.push({
+		name: "*",
+		file: abs,
+		rel: relative(cwd, abs),
+		line,
+		col,
+		form: "dynamic-is-binding",
+		binding: trimmed
+	});
+}
+function walkTemplate(node, visit) {
+	if (!node || typeof node !== "object") return;
+	if (typeof node.type === "number") visit(node);
+	for (const child of node.children ?? []) walkTemplate(child, visit);
+}
+function collectFromScript(abs, source, cwd, alias, out) {
+	const program = parseSourceFile(abs.endsWith(".vue") ? `${abs}.ts` : abs, abs.endsWith(".vue") ? extractScriptOnly(source) ?? "" : source).program;
+	if (!program) return;
+	const scriptOffset = abs.endsWith(".vue") ? scriptOffsetIn(source) : 0;
+	walkScript(program, (node) => {
+		if (node.type !== "CallExpression") return;
+		const callee = node.callee;
+		if (!(callee?.type === "Identifier" && callee.name === "resolveComponent")) return;
+		const arg = node.arguments?.[0];
+		if (arg?.type !== "Literal" || typeof arg.value !== "string") return;
+		if (!alias.byString.has(arg.value)) return;
+		const { line, col } = posToLineCol(source, (arg.start ?? 0) + scriptOffset);
+		out.push({
+			name: arg.value,
+			file: abs,
+			rel: relative(cwd, abs),
+			line,
+			col,
+			form: "resolveComponent"
+		});
+	});
+}
+function walkScript(node, visit) {
+	if (!node || typeof node !== "object") return;
+	if (typeof node.type === "string") visit(node);
+	for (const key in node) {
+		if (key === "parent" || key === "loc" || key === "range") continue;
+		const value = node[key];
+		if (Array.isArray(value)) for (const child of value) walkScript(child, visit);
+		else if (value && typeof value === "object" && typeof value.type === "string") walkScript(value, visit);
+	}
+}
+const SCRIPT_TAG_RE = /<script(\s[^>]*)?>([\s\S]*?)<\/script>/i;
+function extractScriptOnly(source) {
+	const m = source.match(SCRIPT_TAG_RE);
+	return m ? m[2] ?? null : null;
+}
+function scriptOffsetIn(source) {
+	const m = source.match(/<script(\s[^>]*)?>/i);
+	if (!m || m.index == null) return 0;
+	return m.index + m[0].length;
+}
+function sortUsages(a, b) {
+	return a.rel.localeCompare(b.rel) || a.line - b.line || a.col - b.col;
+}
+function findComponentUsage(name, opts = {}) {
+	return findComponentUsages([name], opts);
+}
+const MODULE_EXT_RE$1 = /\.(?:tsx?|jsx?|mts|cts|mjs|cjs|vue)$/;
 const WIN_SEP_RE = /\\/g;
 function isGeneratedNuxtPath(cwd, filePath) {
 	const rel = relative(cwd, filePath).replace(/\\/g, "/");
@@ -341,6 +926,40 @@ function readTsconfigPaths(tsconfigPath) {
 function stripJsonComments(source) {
 	return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
 }
+function loadConsumerLocalAliases(consumerFile, workspaceCwd) {
+	const workspaceNorm = workspaceCwd.replace(WIN_SEP_RE, "/");
+	let dir = dirname(consumerFile);
+	while (true) {
+		const tsconfig = join(dir, ".nuxt/tsconfig.json");
+		const dirNorm = dir.replace(WIN_SEP_RE, "/");
+		if (dirNorm !== workspaceNorm && existsSync(tsconfig)) return readTsconfigPaths(tsconfig);
+		if (dirNorm === workspaceNorm || dirNorm === "/" || dirNorm === "") return [];
+		const parent = dirname(dir);
+		if (parent === dir) return [];
+		dir = parent;
+	}
+}
+function aliasResolvesToTarget(consumerAliases, specifier, targetFile) {
+	const targetNorm = targetFile.replace(WIN_SEP_RE, "/");
+	for (const alias of consumerAliases) {
+		const base = alias.wildcard ? alias.pattern.replace(/\/\*$/, "") : alias.pattern;
+		if (!alias.wildcard) {
+			if (specifier !== alias.pattern) continue;
+			if (alias.targets.some((t) => t.replace(WIN_SEP_RE, "/") === targetNorm)) return true;
+			continue;
+		}
+		if (specifier !== base && !specifier.startsWith(`${base}/`)) continue;
+		const remainder = specifier === base ? "" : specifier.slice(base.length + 1);
+		for (const target of alias.targets) {
+			const normTarget = target.replace(WIN_SEP_RE, "/");
+			const candidate = remainder ? `${normTarget}/${remainder}` : normTarget;
+			if (targetNorm === candidate) return true;
+			if (stripModuleExt(targetNorm) === candidate) return true;
+			if (targetNorm === `${candidate}/index.ts` || targetNorm === `${candidate}/index.js` || targetNorm === `${candidate}/index.vue`) return true;
+		}
+	}
+	return false;
+}
 function resolveBestImportSpecifier(fromFile, toFile, aliases, oldSpec) {
 	const targetAlias = pickAliasFor(toFile, aliases);
 	const sourceAlias = pickAliasFor(fromFile, aliases);
@@ -376,18 +995,704 @@ function pickAliasFor(file, aliases) {
 function formatAliasSpecifier(match, oldSpec) {
 	if (!match.wildcard) return match.pattern;
 	const base = match.pattern.replace(/\/\*$/, "");
-	const tail = oldSpec !== void 0 && MODULE_EXT_RE.test(oldSpec) ? match.remainder : match.remainder.replace(MODULE_EXT_RE, "");
+	const tail = oldSpec !== void 0 && MODULE_EXT_RE$1.test(oldSpec) ? match.remainder : match.remainder.replace(MODULE_EXT_RE$1, "");
 	return tail ? `${base}/${tail}` : base;
 }
 function formatRelativeSpecifier(fromFile, toFile, oldSpec) {
-	const hasExt = oldSpec !== void 0 && MODULE_EXT_RE.test(oldSpec);
+	const hasExt = oldSpec !== void 0 && MODULE_EXT_RE$1.test(oldSpec);
 	let rel = relative(dirname(fromFile), toFile).replace(WIN_SEP_RE, "/");
-	if (!hasExt) rel = rel.replace(MODULE_EXT_RE, "");
+	if (!hasExt) rel = rel.replace(MODULE_EXT_RE$1, "");
 	if (!rel.startsWith(".")) rel = `./${rel}`;
 	return rel;
 }
 function stripModuleExt(path) {
-	return path.replace(MODULE_EXT_RE, "");
+	return path.replace(MODULE_EXT_RE$1, "");
+}
+const MANIFEST_PATH = ".nuxt/components.d.ts";
+const MANIFEST_ENTRY_RE = /^\s*(?:export\s+const\s+)?([A-Z]\w*)\s*:\s*(?:LazyComponent<\s*)?typeof\s+import\(\s*["']([^"']+)["']\s*\)\s*\[\s*["']default["']\s*\]/gm;
+const COMPONENT_DIR_NAMES = new Set(["components"]);
+const DEFAULT_VUE_GLOB = ["*.vue"];
+function listComponents(cwd, opts = {}) {
+	const source = opts.source ?? "auto";
+	const warn = opts.warn ?? ((msg) => process.stderr.write(`${msg}\n`));
+	const manifestPath = join(cwd, MANIFEST_PATH);
+	const manifestPresent = existsSync(manifestPath);
+	if (source === "manifest" || source === "auto" && manifestPresent) {
+		if (!manifestPresent) {
+			warn(`ripast components: ${MANIFEST_PATH} not found at ${cwd}; cannot use manifest source.`);
+			return [];
+		}
+		const fromManifest = readManifest(cwd, manifestPath);
+		const overlay = filesystemOverlay(cwd, opts.glob ?? DEFAULT_VUE_GLOB, fromManifest);
+		return [...fromManifest, ...overlay].sort(sortComponents);
+	}
+	if (source === "auto") warn(`ripast components: ${MANIFEST_PATH} not found; falling back to filesystem glob. Run \`nuxi prepare\` for accurate resolution.`);
+	return filesystemOnly(cwd, opts.glob ?? DEFAULT_VUE_GLOB).sort(sortComponents);
+}
+function readManifest(cwd, manifestPath) {
+	const entries = parseManifest(readFileSync(manifestPath, "utf8"), cwd, manifestPath);
+	const byImportPath = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const list = byImportPath.get(entry.importPath) ?? [];
+		list.push(entry);
+		byImportPath.set(entry.importPath, list);
+	}
+	const out = [];
+	for (const [importPath, group] of byImportPath) {
+		const file = resolveImportPath(cwd, manifestPath, importPath);
+		if (!file) continue;
+		const primary = group.find((g) => !g.lazy) ?? group[0];
+		const aliases = /* @__PURE__ */ new Set();
+		aliases.add(hyphenateVueName(primary.name));
+		for (const g of group) aliases.add(g.name);
+		aliases.delete(primary.name);
+		out.push({
+			id: file,
+			name: primary.name,
+			registeredName: primary.name,
+			aliases: [...aliases].sort(),
+			file,
+			rel: relative(cwd, file),
+			kind: file.endsWith(".vue") ? "sfc" : "define-component",
+			scope: "auto-import",
+			shadowed: false,
+			source: "manifest"
+		});
+	}
+	return out;
+}
+function parseManifest(source, _cwd, _manifestPath) {
+	const out = [];
+	for (const match of source.matchAll(MANIFEST_ENTRY_RE)) {
+		const fullName = match[1];
+		const importPath = match[2];
+		const lazy = fullName.startsWith("Lazy") && /^Lazy[A-Z]/.test(fullName);
+		out.push({
+			name: fullName,
+			importPath,
+			lazy
+		});
+	}
+	return out;
+}
+function resolveImportPath(cwd, manifestPath, importPath) {
+	const bases = candidateBases(cwd, resolve(manifestPath, ".."), importPath);
+	for (const base of bases) {
+		if (existsSync(base) && statSync(base).isFile()) return base;
+		for (const ext of [
+			".vue",
+			".ts",
+			".tsx",
+			".js",
+			".jsx",
+			".mjs"
+		]) {
+			const candidate = `${base}${ext}`;
+			if (existsSync(candidate)) return candidate;
+		}
+	}
+	return null;
+}
+function candidateBases(cwd, manifestDir, importPath) {
+	if (importPath.startsWith(".")) return [resolve(manifestDir, importPath)];
+	const aliases = loadNuxtPathAliases(cwd);
+	const out = [];
+	for (const alias of aliases) {
+		if (!alias.wildcard) {
+			if (importPath === alias.pattern) for (const target of alias.targets) out.push(resolve(cwd, target));
+			continue;
+		}
+		const prefix = alias.pattern.replace(/\*$/, "");
+		if (!importPath.startsWith(prefix)) continue;
+		const tail = importPath.slice(prefix.length);
+		for (const target of alias.targets) {
+			const targetPrefix = target.replace(/\*$/, "");
+			out.push(resolve(cwd, targetPrefix + tail));
+		}
+	}
+	out.push(resolve(cwd, importPath));
+	return out;
+}
+function filesystemOverlay(cwd, glob, manifestComponents) {
+	const manifestByRealPath = /* @__PURE__ */ new Set();
+	for (const c of manifestComponents) manifestByRealPath.add(realOrSelf(c.id));
+	const manifestByName = new Map(manifestComponents.map((c) => [c.name, c]));
+	const candidates = discoverVueFiles(cwd, glob);
+	const out = [];
+	for (const file of candidates) {
+		if (manifestByRealPath.has(realOrSelf(file))) continue;
+		if (!isUnderComponentsDir(cwd, file)) continue;
+		const name = filenameToComponentName(file);
+		const shadowedBy = manifestByName.get(name);
+		out.push({
+			id: file,
+			name,
+			registeredName: null,
+			aliases: [hyphenateVueName(name)],
+			file,
+			rel: relative(cwd, file),
+			kind: "sfc",
+			scope: "auto-import",
+			shadowed: !!shadowedBy,
+			shadowedBy: shadowedBy?.id,
+			source: "filesystem"
+		});
+	}
+	return out;
+}
+function realOrSelf(file) {
+	try {
+		return realpathSync(file);
+	} catch {
+		return file;
+	}
+}
+function filesystemOnly(cwd, glob) {
+	const files = discoverVueFiles(cwd, glob).filter((file) => isUnderComponentsDir(cwd, file));
+	const byName = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const name = filenameToComponentName(file);
+		const list = byName.get(name) ?? [];
+		list.push(file);
+		byName.set(name, list);
+	}
+	const out = [];
+	for (const file of files) {
+		const name = filenameToComponentName(file);
+		const sameName = byName.get(name) ?? [];
+		const isFirst = sameName[0] === file;
+		out.push({
+			id: file,
+			name,
+			registeredName: null,
+			aliases: [hyphenateVueName(name)],
+			file,
+			rel: relative(cwd, file),
+			kind: "sfc",
+			scope: "auto-import",
+			shadowed: !isFirst,
+			shadowedBy: isFirst ? void 0 : sameName[0],
+			source: "filesystem"
+		});
+	}
+	return out;
+}
+function discoverVueFiles(cwd, glob) {
+	return rgFiles("", {
+		cwd,
+		glob,
+		listAll: true
+	}).filter((f) => f.endsWith(".vue"));
+}
+function isUnderComponentsDir(cwd, file) {
+	const rel = relative(cwd, file).replace(/\\/g, "/");
+	if (!rel || rel.startsWith("..")) return false;
+	return rel.split("/").some((seg) => COMPONENT_DIR_NAMES.has(seg));
+}
+function filenameToComponentName(file) {
+	return basename(file).replace(/\.vue$/, "").split(/[-_.]/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+}
+function sortComponents(a, b) {
+	return a.name.localeCompare(b.name) || a.rel.localeCompare(b.rel);
+}
+const NUXT_ENTRY_PATTERNS = [
+	"nuxt.config.ts",
+	"nuxt.config.js",
+	"nuxt.config.mjs",
+	"nuxt.config.mts",
+	"app.vue",
+	"error.vue",
+	"app.config.ts",
+	"vitest.config.ts",
+	"vitest.config.mts"
+];
+const NUXT_ENTRY_DIRS = [
+	"pages",
+	"layouts",
+	"middleware",
+	"plugins",
+	"server",
+	"modules",
+	"app/middleware",
+	"app/plugins",
+	"app/pages",
+	"app/layouts"
+];
+const NUXT_AUTOIMPORT_DIRS = [
+	"components",
+	"composables",
+	"utils",
+	"shared",
+	"server/utils",
+	"server/middleware",
+	"server/api",
+	"server/routes",
+	"server/plugins",
+	"app/components",
+	"app/composables",
+	"app/utils"
+];
+const ENTRY_EXTS = [
+	".ts",
+	".tsx",
+	".js",
+	".mjs",
+	".cjs",
+	".vue"
+];
+function isNuxtProject$1(cwd) {
+	for (const p of NUXT_ENTRY_PATTERNS) if (p.startsWith("nuxt.config") && existsSync(join(cwd, p))) return true;
+	if (existsSync(join(cwd, ".nuxt"))) return true;
+	const pkgPath = join(cwd, "package.json");
+	if (!existsSync(pkgPath)) return false;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+		const deps = {
+			...pkg.dependencies,
+			...pkg.devDependencies,
+			...pkg.peerDependencies
+		};
+		return Boolean(deps.nuxt || deps["@nuxt/kit"]);
+	} catch {
+		return false;
+	}
+}
+function listLayerRoots(cwd) {
+	const roots = [cwd];
+	for (const parent of [
+		"layers",
+		"apps",
+		"packages"
+	]) {
+		const dir = join(cwd, parent);
+		if (!existsSync(dir)) continue;
+		for (const name of readdirSync(dir)) {
+			const abs = join(dir, name);
+			try {
+				if (statSync(abs).isDirectory()) roots.push(abs);
+			} catch {}
+		}
+	}
+	return roots;
+}
+const ROOT_CONFIG_FILES = [
+	"eslint.config.js",
+	"eslint.config.ts",
+	"eslint.config.mjs",
+	"drizzle.config.ts",
+	"tailwind.config.ts",
+	"tailwind.config.js",
+	"content.config.ts",
+	"mdc.config.ts",
+	"router.options.ts",
+	"vitest.config.e2e.ts",
+	"vitest.config.ts",
+	"app.config.ts"
+];
+const CONFIG_FILE_RE = /(?:^|\/)(?:eslint\.config\.[mc]?[jt]s|drizzle\.config\.[mc]?[jt]s|tailwind\.config\.[mc]?[jt]s|content\.config\.[mc]?[jt]s|mdc\.config\.[mc]?[jt]s|router\.options\.[mc]?[jt]s|vitest\.config(?:\.\w+)?\.[mc]?[jt]s|app\.config\.[mc]?[jt]s|.*\.d\.ts)$/;
+function walkDir(dir, out) {
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return;
+	}
+	for (const name of entries) {
+		const abs = join(dir, name);
+		let s;
+		try {
+			s = statSync(abs);
+		} catch {
+			continue;
+		}
+		if (s.isDirectory()) {
+			walkDir(abs, out);
+			continue;
+		}
+		if (ENTRY_EXTS.some((ext) => name.endsWith(ext))) out.push(abs);
+	}
+}
+function isNuxtModulePackage(root) {
+	const moduleTs = join(root, "src", "module.ts");
+	if (!existsSync(moduleTs)) return false;
+	try {
+		return readFileSync(moduleTs, "utf8").includes("defineNuxtModule");
+	} catch {
+		return false;
+	}
+}
+function collectEntries(cwd) {
+	const abs = [];
+	for (const root of listLayerRoots(cwd)) {
+		for (const p of [...NUXT_ENTRY_PATTERNS, ...ROOT_CONFIG_FILES]) {
+			const f = join(root, p);
+			if (existsSync(f)) abs.push(f);
+		}
+		for (const d of [...NUXT_ENTRY_DIRS, ...NUXT_AUTOIMPORT_DIRS]) {
+			const dir = join(root, d);
+			if (existsSync(dir)) walkDir(dir, abs);
+		}
+		if (isNuxtModulePackage(root)) {
+			const runtime = join(root, "src", "runtime");
+			if (existsSync(runtime)) walkDir(runtime, abs);
+		}
+	}
+	return [...new Set(abs.map((p) => relative(cwd, p)))];
+}
+function isAutoImportRel(rel) {
+	return NUXT_AUTOIMPORT_DIRS.some((d) => rel.includes(`/${d}/`) || rel.startsWith(`${d}/`)) || rel.includes("/server/api/") || rel.includes("/server/routes/") || rel.includes("/server/middleware/") || rel.includes("/server/plugins/") || rel.includes("/pages/") || rel.includes("/layouts/") || rel.includes("/middleware/") || rel.includes("/plugins/") || rel.endsWith("nuxt.config.ts") || rel.endsWith("app.vue") || rel.endsWith("error.vue");
+}
+const doctor = {
+	entryFiles(cwd) {
+		if (!isNuxtProject$1(cwd)) return [];
+		return collectEntries(cwd);
+	},
+	filterFinding(_cwd, finding) {
+		if (finding.check === "orphan-file" && (isAutoImportRel(finding.file) || CONFIG_FILE_RE.test(finding.file))) return false;
+		return true;
+	},
+	extraFindings(cwd, ctx) {
+		if (!isNuxtProject$1(cwd)) return [];
+		const out = [];
+		try {
+			const components = listComponents(cwd, { source: "auto" });
+			const byName = /* @__PURE__ */ new Map();
+			for (const c of components) {
+				const arr = byName.get(c.name) ?? [];
+				arr.push(c);
+				byName.set(c.name, arr);
+			}
+			for (const [name, group] of byName) {
+				if (group.length < 2) continue;
+				const winner = group.find((c) => !c.shadowed) ?? group[0];
+				for (const c of group) {
+					if (!c.shadowed) continue;
+					out.push({
+						check: "shadowed-component",
+						file: c.rel,
+						message: `component "${name}" is shadowed by ${winner.rel}`,
+						detail: {
+							name,
+							winner: winner.rel,
+							shadowed: c.rel
+						}
+					});
+				}
+			}
+		} catch {}
+		try {
+			out.push(...findPhantomComponents(cwd));
+		} catch {}
+		if (ctx) try {
+			out.push(...findCrossRealmImports(cwd, ctx));
+		} catch {}
+		try {
+			out.push(...findStaleNuxtConfigRefs(cwd));
+		} catch {}
+		return out;
+	}
+};
+const VUE_BUILTINS = new Set([
+	"Transition",
+	"TransitionGroup",
+	"KeepAlive",
+	"Teleport",
+	"Suspense",
+	"Component",
+	"Slot",
+	"Template",
+	"ClientOnly"
+]);
+const NUXT_BUILTINS = new Set([
+	"NuxtPage",
+	"NuxtLink",
+	"NuxtLayout",
+	"NuxtLoadingIndicator",
+	"NuxtErrorBoundary",
+	"NuxtWelcome",
+	"NuxtIsland",
+	"NuxtClientFallback",
+	"NuxtImg",
+	"NuxtPicture",
+	"NuxtRouteAnnouncer",
+	"DevOnly",
+	"ServerOnly",
+	"RouterView",
+	"RouterLink",
+	"Icon",
+	"Html",
+	"Head",
+	"Body",
+	"Title",
+	"Meta",
+	"Link",
+	"Style",
+	"NoScript",
+	"Base"
+]);
+const PASCAL = /^[A-Z][A-Z0-9a-z]*$/;
+const NODE_ELEMENT = 1;
+function listAppRoots(cwd) {
+	const roots = [];
+	const parent = join(cwd, "apps");
+	if (!existsSync(parent)) return roots;
+	for (const name of readdirSync(parent)) {
+		const abs = join(parent, name);
+		try {
+			if (statSync(abs).isDirectory() && existsSync(join(abs, ".nuxt", "components.d.ts"))) roots.push(abs);
+		} catch {}
+	}
+	return roots;
+}
+function scopeForFile(abs, roots, cwd) {
+	let best = cwd;
+	let bestLen = -1;
+	for (const root of roots) if ((abs === root || abs.startsWith(`${root}/`)) && root.length > bestLen) {
+		best = root;
+		bestLen = root.length;
+	}
+	return best;
+}
+function buildKnownSet(root) {
+	const known = new Set([...VUE_BUILTINS, ...NUXT_BUILTINS]);
+	for (const c of listComponents(root, {
+		source: "auto",
+		warn: () => {}
+	})) {
+		known.add(c.name);
+		for (const alias of c.aliases ?? []) known.add(alias);
+	}
+	return known;
+}
+function buildUnionKnownSet(roots, cwd) {
+	const known = new Set([...VUE_BUILTINS, ...NUXT_BUILTINS]);
+	const sources = roots.length ? roots : [cwd];
+	for (const root of sources) for (const c of listComponents(root, {
+		source: "auto",
+		warn: () => {}
+	})) {
+		known.add(c.name);
+		for (const alias of c.aliases ?? []) known.add(alias);
+	}
+	return known;
+}
+function findPhantomComponents(cwd) {
+	const files = rgFiles("", {
+		cwd,
+		glob: ["*.vue"],
+		listAll: true
+	});
+	const appRoots = listAppRoots(cwd);
+	const knownByRoot = /* @__PURE__ */ new Map();
+	if (appRoots.length) knownByRoot.set(cwd, buildUnionKnownSet(appRoots, cwd));
+	const out = [];
+	for (const abs of files) {
+		let source;
+		try {
+			source = readFileSync(abs, "utf8");
+		} catch {
+			continue;
+		}
+		const ast = parseVueTemplateAst(source);
+		if (!ast) continue;
+		const root = scopeForFile(abs, appRoots, cwd);
+		let known = knownByRoot.get(root);
+		if (!known) {
+			known = buildKnownSet(root);
+			knownByRoot.set(root, known);
+		}
+		const localImports = collectLocalImports(source);
+		const seen = /* @__PURE__ */ new Set();
+		walkTpl(ast, (node) => {
+			if (node?.type !== NODE_ELEMENT) return;
+			const tag = node.tag;
+			if (typeof tag !== "string") return;
+			if (!PASCAL.test(tag)) return;
+			if (known.has(tag) || known.has(hyphenateVueName(tag))) return;
+			if (localImports.has(tag)) return;
+			const key = `${abs}::${tag}::${node.loc?.start?.offset ?? 0}`;
+			if (seen.has(key)) return;
+			seen.add(key);
+			const offset = node.loc?.start?.offset ?? 0;
+			const { line, col } = posToLineCol(source, offset);
+			out.push({
+				check: "phantom-component",
+				file: relative(cwd, abs),
+				line,
+				message: `<${tag}> is not a known component (auto-import scope, local import, or built-in)`,
+				detail: {
+					name: tag,
+					col,
+					scope: relative(cwd, root) || "."
+				}
+			});
+		});
+	}
+	return out;
+}
+function walkTpl(node, visit) {
+	if (!node || typeof node !== "object") return;
+	if (typeof node.type === "number") visit(node);
+	for (const child of node.children ?? []) walkTpl(child, visit);
+}
+function collectLocalImports(source) {
+	const out = /* @__PURE__ */ new Set();
+	const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/g);
+	if (!scriptMatch) return out;
+	for (const block of scriptMatch) for (const m of block.matchAll(/import\s+(?:\{([^}]+)\}|(\w+)|\*\s+as\s+(\w+))\s+from/g)) if (m[1]) for (const part of m[1].split(",")) {
+		const name = part.trim().replace(/^type\s+/, "").split(/\s+as\s+/).pop().trim();
+		if (name) out.add(name);
+	}
+	else if (m[2]) out.add(m[2]);
+	else if (m[3]) out.add(m[3]);
+	return out;
+}
+const APP_DIR_RE = /(?:^|\/)(?:app|pages|layouts|components|composables|middleware|plugins)(?:\/|$)/;
+const SERVER_DIR_RE = /(?:^|\/)server(?:\/|$)/;
+const SERVER_SUFFIX_RE = /\.server\.(?:[mc]?[jt]sx?|vue)$/;
+const CLIENT_SUFFIX_RE = /\.client\.(?:[mc]?[jt]sx?|vue)$/;
+function fileRealm(rel) {
+	if (SERVER_SUFFIX_RE.test(rel)) return "server";
+	if (CLIENT_SUFFIX_RE.test(rel)) return "app";
+	if (SERVER_DIR_RE.test(rel) && !APP_DIR_RE.test(rel)) return "server";
+	if (APP_DIR_RE.test(rel) && !SERVER_DIR_RE.test(rel)) return "app";
+	return null;
+}
+function findCrossRealmImports(cwd, ctx) {
+	const out = [];
+	for (const file of ctx.index.files) {
+		const fromRealm = fileRealm(file.file);
+		if (!fromRealm) continue;
+		for (const imp of file.imports) {
+			if (imp.typeOnly) continue;
+			if (!imp.source.startsWith(".")) continue;
+			const resolved = resolveRelativeFs(file.file, imp.source, cwd);
+			if (!resolved) continue;
+			const toRealm = fileRealm(relative(cwd, resolved));
+			if (!toRealm || toRealm === fromRealm) continue;
+			out.push({
+				check: "cross-realm-import",
+				file: file.file,
+				line: imp.line,
+				message: `${fromRealm}-realm file imports runtime value "${imp.imported || "*"}" from ${toRealm}-realm "${imp.source}"`,
+				detail: {
+					fromRealm,
+					toRealm,
+					source: imp.source,
+					imported: imp.imported
+				}
+			});
+		}
+	}
+	return out;
+}
+const RESOLVE_EXTS = [
+	"",
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".vue",
+	"/index.ts",
+	"/index.tsx",
+	"/index.js"
+];
+function resolveRelativeFs(fromRel, specifier, cwd) {
+	if (!specifier.startsWith(".")) return null;
+	const base = resolve(cwd, fromRel, "..", specifier);
+	for (const ext of RESOLVE_EXTS) {
+		const candidate = base + ext;
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+const CONFIG_NAMES = [
+	"nuxt.config.ts",
+	"nuxt.config.js",
+	"nuxt.config.mjs",
+	"nuxt.config.mts"
+];
+const STRING_FIELDS = [
+	"extends",
+	"modules",
+	"css"
+];
+const COMPONENT_PATH_RE = /\{\s*path\s*:\s*['"]([^'"]+)['"]/g;
+const ARRAY_FIELD_RE = (field) => new RegExp(`\\b${field}\\s*:\\s*\\[([\\s\\S]*?)\\]`);
+const IMPORT_DIRS_RE = /\bimports\s*:\s*\{[\s\S]*?\bdirs\s*:\s*\[([\s\S]*?)\]/;
+function findStaleNuxtConfigRefs(cwd) {
+	const out = [];
+	for (const root of listLayerRoots(cwd)) for (const name of CONFIG_NAMES) {
+		const abs = join(root, name);
+		if (!existsSync(abs)) continue;
+		let source;
+		try {
+			source = readFileSync(abs, "utf8");
+		} catch {
+			continue;
+		}
+		const rel = relative(cwd, abs);
+		for (const field of STRING_FIELDS) {
+			const match = ARRAY_FIELD_RE(field).exec(source);
+			if (!match) continue;
+			for (const lit of match[1].matchAll(/['"`]([^'"`]+)['"`]/g)) {
+				const value = lit[1];
+				if (!value.startsWith(".") && !value.startsWith("/")) continue;
+				const targetPath = resolve(root, value);
+				if (existsSync(targetPath)) continue;
+				let exists = false;
+				for (const ext of RESOLVE_EXTS) if (existsSync(targetPath + ext)) {
+					exists = true;
+					break;
+				}
+				if (exists) continue;
+				out.push({
+					check: "stale-nuxt-config-ref",
+					file: rel,
+					message: `${field}: "${value}" does not resolve from ${rel}`,
+					detail: {
+						field,
+						value,
+						root: relative(cwd, root)
+					}
+				});
+			}
+		}
+		const importsMatch = IMPORT_DIRS_RE.exec(source);
+		if (importsMatch) for (const lit of importsMatch[1].matchAll(/['"`]([^'"`]+)['"`]/g)) {
+			const value = lit[1];
+			if (!value.startsWith(".") && !value.startsWith("/")) continue;
+			if (existsSync(resolve(root, value.replace(/\/\*\*.*$/, "").replace(/\/\*.*$/, "")))) continue;
+			out.push({
+				check: "stale-nuxt-config-ref",
+				file: rel,
+				message: `imports.dirs: "${value}" does not resolve from ${rel}`,
+				detail: {
+					field: "imports.dirs",
+					value,
+					root: relative(cwd, root)
+				}
+			});
+		}
+		for (const m of source.matchAll(COMPONENT_PATH_RE)) {
+			const value = m[1];
+			if (!value.startsWith(".") && !value.startsWith("/")) continue;
+			if (existsSync(resolve(root, value.replace(/\/\*\*.*$/, "").replace(/\/\*.*$/, "")))) continue;
+			out.push({
+				check: "stale-nuxt-config-ref",
+				file: rel,
+				message: `components: path "${value}" does not resolve from ${rel}`,
+				detail: {
+					field: "components.path",
+					value,
+					root: relative(cwd, root)
+				}
+			});
+		}
+	}
+	return out;
 }
 function addNuxtExplicitImports(ctx) {
 	const { cwd, symbols, toAbs, fromAbs, existingChanges, noScriptError, scan } = ctx;
@@ -490,6 +1795,7 @@ async function finalizeVueFileRename(cwd, oldAbs, newAbs, existingChanges, autoI
 		const oldName = basename(oldAbs, ".vue");
 		const newName = basename(newAbs, ".vue");
 		mergeIntoChanges(changes, rewriteResolveComponentSites(cwd, oldName, newName, existingChanges, oldAbs, newAbs, warnings));
+		if (oldName !== newName) mergeIntoChanges(changes, rewriteIsAttributeSites(cwd, oldName, newName, mergeView(existingChanges, changes), oldAbs, newAbs, warnings));
 		if (autoImportScopes.size && isInsideAutoImportScope(oldAbs, autoImportScopes) && !isInsideAutoImportScope(newAbs, autoImportScopes)) mergeIntoChanges(changes, addExplicitComponentImports(cwd, oldName, newName, newAbs, mergeView(existingChanges, changes), oldAbs));
 		return {
 			changes,
@@ -602,6 +1908,48 @@ function addExplicitComponentImports(cwd, oldName, newName, newAbs, changes, old
 function escapeRe(s) {
 	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function rewriteIsAttributeSites(cwd, oldName, newName, changes, oldAbs, newAbs, warnings) {
+	const oldKebab = hyphenateVueName(oldName);
+	const newKebab = hyphenateVueName(newName);
+	const candidates = new Set([...rgFiles(oldName, {
+		cwd,
+		glob: "*.vue"
+	}), ...rgFiles(oldKebab, {
+		cwd,
+		glob: "*.vue"
+	})]);
+	if (!candidates.size) return [];
+	const byPath = new Map(changes.map((change) => [change.path, change]));
+	const oldRe = `${escapeRe(oldName)}|${escapeRe(oldKebab)}`;
+	const isStringLiteralRe = new RegExp(`(:is\\s*=\\s*)(?:"\\s*'(${oldRe})'\\s*"|'\\s*"(${oldRe})"\\s*')`, "g");
+	const isStaticRe = new RegExp(`(\\bis\\s*=\\s*)(['"])(${oldRe})\\2`, "g");
+	const dynamicBindingRe = /:is\s*=\s*"\s*([A-Za-z_$][\w$]*)\s*"/g;
+	const out = [];
+	const dynamicBindingWarn = [];
+	const mapToken = (token) => token === oldName ? newName : newKebab;
+	for (const path of candidates) {
+		if (path === oldAbs || path === newAbs || isGeneratedNuxtPath(cwd, path)) continue;
+		const before = byPath.get(path)?.before ?? readFileSync(path, "utf8");
+		let current = byPath.get(path)?.after ?? before;
+		current = current.replace(isStringLiteralRe, (_m, prefix, p1, p2) => {
+			return `${prefix}"'${mapToken(p1 ?? p2)}'"`;
+		});
+		current = current.replace(isStaticRe, (_m, prefix, quote, name) => `${prefix}${quote}${mapToken(name)}${quote}`);
+		for (const m of current.matchAll(dynamicBindingRe)) if (m[1] === oldName) {
+			dynamicBindingWarn.push(relative(cwd, path));
+			break;
+		}
+		if (current === before) continue;
+		out.push({
+			path,
+			rel: relative(cwd, path),
+			before,
+			after: current
+		});
+	}
+	if (dynamicBindingWarn.length) warnings.push(`rename-file: "${oldName}" may be referenced via dynamic <component :is="ref"> in ${dynamicBindingWarn.length} file(s) [${dynamicBindingWarn.join(", ")}]. These cannot be auto-rewritten; inspect and update manually.`);
+	return out;
+}
 function hasDefaultImportFromVue(source, name) {
 	return new RegExp(`\\bimport\\s+${escapeRe(name)}\\s+from\\s+['"\`][^'"\`]+\\.vue['"\`]`).test(source);
 }
@@ -624,7 +1972,7 @@ const adapter = {
 		const vue = createVueService(tsconfigPath, cwd);
 		try {
 			const edits = await vue.service.getFileRenameEdits(URI.file(oldAbs), URI.file(newAbs));
-			return edits ? workspaceEditToChanges(edits, vue, cwd) : [];
+			return rewriteUnportableAliasSpecifiers(cwd, edits ? workspaceEditToChanges(edits, vue, cwd) : [], newAbs);
 		} finally {
 			vue.dispose();
 		}
@@ -641,7 +1989,10 @@ const adapter = {
 	}),
 	async finalizeFileRename(cwd, oldAbs, newAbs, existingChanges) {
 		return finalizeVueFileRename(cwd, oldAbs, newAbs, existingChanges, isNuxtProject(cwd) ? nuxtAutoImportScopes(cwd) : /* @__PURE__ */ new Set());
-	}
+	},
+	listComponents,
+	findComponentUsages,
+	doctor
 };
 const DEFAULT_NUXT_AUTO_IMPORT_DIRS = [
 	"composables",
@@ -688,4 +2039,48 @@ function extractConfiguredDirs(source) {
 function stripGlob(dir) {
 	return dir.replace(/\/\*\*.*$/, "").replace(/\/\*.*$/, "");
 }
-export { adapter as default };
+const MODULE_EXT_RE = /\.(?:tsx?|jsx?|mts|cts|mjs|cjs|vue)$/;
+const ALIAS_PREFIX_RE = /^[~@#]/;
+const IMPORT_FROM_RE = /\b(?:import|export)\b[^;\n]+from\s*(['"`])([^'"`]+)\1/g;
+const DYNAMIC_IMPORT_RE = /\bimport\s*\(\s*(['"`])([^'"`]+)\1\s*\)/g;
+function rewriteUnportableAliasSpecifiers(cwd, changes, newAbs) {
+	for (const change of changes) {
+		if (change.path === newAbs) continue;
+		const localAliases = loadConsumerLocalAliases(change.path, cwd);
+		if (!localAliases.length) continue;
+		const before = change.before;
+		const after = change.after;
+		const beforeSpecs = collectSpecifiers(before);
+		const afterSpecs = collectSpecifiers(after);
+		const changedNew = /* @__PURE__ */ new Set();
+		for (const spec of afterSpecs) if (!beforeSpecs.has(spec) && ALIAS_PREFIX_RE.test(spec)) changedNew.add(spec);
+		if (!changedNew.size) continue;
+		let rewritten = after;
+		for (const spec of changedNew) {
+			if (aliasResolvesToTarget(localAliases, spec, newAbs)) continue;
+			const replacement = toRelativeSpecifier(change.path, newAbs, spec);
+			rewritten = replaceSpecifier(rewritten, spec, replacement);
+		}
+		change.after = rewritten;
+	}
+	return changes;
+}
+function collectSpecifiers(source) {
+	const out = /* @__PURE__ */ new Set();
+	IMPORT_FROM_RE.lastIndex = 0;
+	for (const m of source.matchAll(IMPORT_FROM_RE)) out.add(m[2]);
+	for (const m of source.matchAll(DYNAMIC_IMPORT_RE)) out.add(m[2]);
+	return out;
+}
+function replaceSpecifier(source, oldSpec, newSpec) {
+	const escaped = oldSpec.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return source.replace(new RegExp(`(['"\`])${escaped}\\1`, "g"), `$1${newSpec}$1`);
+}
+function toRelativeSpecifier(consumerFile, targetFile, oldSpec) {
+	const hasExt = MODULE_EXT_RE.test(oldSpec);
+	let rel = relative(dirname(consumerFile), targetFile).replace(/\\/g, "/");
+	if (!hasExt) rel = rel.replace(MODULE_EXT_RE, "");
+	if (!rel.startsWith(".")) rel = `./${rel}`;
+	return rel;
+}
+export { adapter as default, findComponentUsage, findComponentUsages, listComponents, parseComponent, parseComponentSource };