@ai-i18n/eslint-plugin 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/index.js

@@ -1,8 +1,204 @@
 import { createRequire } from "node:module";
+import { AI_I18N_VIRTUAL_MODULE_ID, Analyzer, diagnosticMessage, extractMessages, findInvalidDefineI18nMessagesReferences, findTranslationCalls, findUnboundCalls, validateRecommendedUsage } from "@ai-i18n/analyzer";
 import fs from "node:fs";
 import path from "node:path";
-import { AI_I18N_VIRTUAL_MODULE_ID, Analyzer, extractMessages, findUnboundCalls } from "@ai-i18n/analyzer";
+import { createFilesMatcher, createPathsMatcher, parseTsconfig } from "get-tsconfig";
+import picomatch from "picomatch";
 import { analyzeVueSource } from "@ai-i18n/analyzer/vue";
+import { defaultTreeAdapter, parse, parseFragment } from "parse5";
+//#region src/auto-imports.ts
+const RUNTIME_AUTO_IMPORTS = [
+	"t",
+	"setLang",
+	"getLang",
+	"getLangs",
+	"getLangLoadState",
+	"subscribe"
+];
+const VUE_AUTO_IMPORTS = [
+	"useI18n",
+	...RUNTIME_AUTO_IMPORTS,
+	"tRef",
+	"i18nComputed",
+	"tComputed"
+];
+const REACT_AUTO_IMPORTS = ["useI18n", ...RUNTIME_AUTO_IMPORTS];
+const ALL_AUTO_IMPORT_APIS = [...VUE_AUTO_IMPORTS];
+//#endregion
+//#region src/tsconfig-projects.ts
+const PROJECT_CACHE_TTL_MS = 250;
+const MAX_PROJECT_CACHE_ENTRIES = 1e3;
+const READ_FILE_CACHE_PREFIX = "readFileSync:";
+const READ_FILE_CACHE_SUFFIX = ":utf8";
+const projectGraphCache = /* @__PURE__ */ new Map();
+const discoveryCache = /* @__PURE__ */ new Map();
+function createTsconfigResolver(tsconfigPath) {
+	const explicitRoot = tsconfigPath ? path.normalize(path.resolve(tsconfigPath)) : void 0;
+	return (specifier, importer) => {
+		const rootConfig = explicitRoot ?? findNearestProjectConfig(importer);
+		if (!rootConfig) return [];
+		return selectProject(loadProjectGraph(rootConfig), importer)?.pathsMatcher?.(specifier) ?? [];
+	};
+}
+function findNearestProjectConfig(importer) {
+	let directory = path.dirname(path.resolve(importer));
+	const now = Date.now();
+	const cached = discoveryCache.get(directory);
+	if (cached && cached.expiresAt > now) return cached.configPath;
+	const visited = [];
+	for (;;) {
+		visited.push(directory);
+		for (const filename of ["tsconfig.json", "jsconfig.json"]) {
+			const candidate = path.join(directory, filename);
+			if (isFile$1(candidate)) {
+				cacheDiscovery(visited, candidate, now);
+				return candidate;
+			}
+		}
+		const parent = path.dirname(directory);
+		if (parent === directory) {
+			cacheDiscovery(visited, null, now);
+			return null;
+		}
+		directory = parent;
+	}
+}
+function cacheDiscovery(directories, configPath, now) {
+	if (discoveryCache.size >= MAX_PROJECT_CACHE_ENTRIES) discoveryCache.clear();
+	for (const directory of directories) discoveryCache.set(directory, {
+		expiresAt: now + PROJECT_CACHE_TTL_MS,
+		configPath
+	});
+}
+function loadProjectGraph(rootConfig) {
+	const cached = projectGraphCache.get(rootConfig);
+	if (cached && projectGraphIsFresh(cached)) return cached.projects;
+	const projects = [];
+	const stamps = /* @__PURE__ */ new Map();
+	visitProject(rootConfig, projects, stamps, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+	if (projectGraphCache.size >= MAX_PROJECT_CACHE_ENTRIES) projectGraphCache.clear();
+	projectGraphCache.set(rootConfig, {
+		expiresAt: Date.now() + PROJECT_CACHE_TTL_MS,
+		projects,
+		stamps
+	});
+	return projects;
+}
+function visitProject(filename, projects, stamps, parsingCache, visited) {
+	filename = path.normalize(path.resolve(filename));
+	if (visited.has(filename)) return;
+	visited.add(filename);
+	stamps.set(filename, readFileStamp(filename));
+	let config;
+	try {
+		config = {
+			path: filename,
+			config: parseTsconfig(filename, parsingCache)
+		};
+		captureParsedConfigStamps(parsingCache, stamps);
+	} catch {
+		return;
+	}
+	for (const reference of config.config.references ?? []) {
+		const referenced = resolveReference(filename, reference.path);
+		if (referenced) visitProject(referenced, projects, stamps, parsingCache, visited);
+	}
+	try {
+		projects.push({
+			config,
+			filesMatcher: createProjectFilesMatcher(config),
+			pathsMatcher: createCompatiblePathsMatcher(config)
+		});
+	} catch {}
+}
+function createProjectFilesMatcher(config) {
+	if (path.basename(config.path).toLowerCase() !== "jsconfig.json" || config.config.compilerOptions?.allowJs !== void 0) return createFilesMatcher(config);
+	return createFilesMatcher({
+		...config,
+		config: {
+			...config.config,
+			compilerOptions: {
+				...config.config.compilerOptions,
+				allowJs: true
+			}
+		}
+	});
+}
+function captureParsedConfigStamps(parsingCache, stamps) {
+	for (const key of parsingCache.keys()) {
+		if (!key.startsWith(READ_FILE_CACHE_PREFIX) || !key.endsWith(READ_FILE_CACHE_SUFFIX)) continue;
+		const filename = key.slice(13, -5);
+		stamps.set(filename, readFileStamp(filename));
+	}
+}
+function createCompatiblePathsMatcher(config) {
+	const compilerOptions = config.config.compilerOptions;
+	const paths = compilerOptions?.paths;
+	if (!paths || compilerOptions.baseUrl) return createPathsMatcher(config);
+	const compatiblePaths = Object.fromEntries(Object.entries(paths).map(([pattern, targets]) => [pattern, targets.map((target) => path.isAbsolute(target) || target.startsWith(".") ? target : `./${target}`)]));
+	return createPathsMatcher({
+		path: config.path,
+		config: {
+			...config.config,
+			compilerOptions: {
+				...compilerOptions,
+				paths: compatiblePaths
+			}
+		}
+	});
+}
+function resolveReference(ownerConfig, referencePath) {
+	const candidate = path.resolve(path.dirname(ownerConfig), referencePath);
+	return [
+		candidate,
+		candidate.endsWith(".json") ? candidate : `${candidate}.json`,
+		path.join(candidate, "tsconfig.json")
+	].find(isFile$1) ?? null;
+}
+function selectProject(projects, importer) {
+	const absoluteImporter = path.resolve(importer);
+	return projects.find((project) => projectMatchesImporter(project, absoluteImporter));
+}
+function projectMatchesImporter(project, importer) {
+	if (path.extname(importer) !== ".vue") return Boolean(project.filesMatcher(importer));
+	return matchesExplicitVueInput(project.config, importer);
+}
+function matchesExplicitVueInput({ config, path: configPath }, importer) {
+	const directory = path.dirname(configPath);
+	const relative = normalizePath(path.relative(directory, importer));
+	if (relative.startsWith("../")) return false;
+	if (config.files?.some((file) => path.resolve(directory, file) === path.resolve(importer))) return true;
+	if (config.exclude?.some((pattern) => matchesExclude(relative, pattern))) return false;
+	return Boolean(config.include?.some((pattern) => pattern.includes(".vue") && picomatch.isMatch(relative, normalizePath(pattern), { dot: true })));
+}
+function matchesExclude(relative, pattern) {
+	pattern = normalizePath(pattern).replace(/\/+$/, "");
+	return picomatch.isMatch(relative, pattern, { dot: true }) || picomatch.isMatch(relative, `${pattern}/**`, { dot: true });
+}
+function projectGraphIsFresh(cached) {
+	if (cached.expiresAt <= Date.now()) return false;
+	for (const [filename, stamp] of cached.stamps) if (readFileStamp(filename) !== stamp) return false;
+	return true;
+}
+function readFileStamp(filename) {
+	try {
+		const stat = fs.statSync(filename);
+		return stat.isFile() ? `${stat.mtimeMs}:${stat.ctimeMs}:${stat.size}` : null;
+	} catch {
+		return null;
+	}
+}
+function isFile$1(filename) {
+	try {
+		return fs.statSync(filename).isFile();
+	} catch {
+		return false;
+	}
+}
+function normalizePath(filename) {
+	return filename.replaceAll("\\", "/");
+}
+//#endregion
 //#region src/resolve-import.ts
 const SOURCE_EXTENSIONS = [
 	"",
@@ -11,51 +207,69 @@ const SOURCE_EXTENSIONS = [
 	".js",
 	".jsx",
 	".mts",
-	".cts",
-	".mjs",
-	".cjs"
+	".mjs"
 ];
-function createImportResolver(tsconfigPath) {
-	const aliases = [];
-	let baseUrl = process.cwd();
-	if (tsconfigPath) {
-		const absoluteConfig = path.resolve(tsconfigPath);
-		const config = readTsConfig(absoluteConfig);
-		baseUrl = path.resolve(path.dirname(absoluteConfig), config.compilerOptions?.baseUrl ?? ".");
-		for (const [pattern, targets] of Object.entries(config.compilerOptions?.paths ?? {})) {
-			const star = pattern.indexOf("*");
-			aliases.push({
-				prefix: star < 0 ? pattern : pattern.slice(0, star),
-				suffix: star < 0 ? "" : pattern.slice(star + 1),
-				targets
-			});
-		}
-	}
+const DIRECTORY_STAMP_TTL_MS = 250;
+const MAX_PROBE_CACHE_ENTRIES = 1e4;
+const directoryStampCache = /* @__PURE__ */ new Map();
+const probeCache = /* @__PURE__ */ new Map();
+function createImportResolver(tsconfigPath, alias) {
+	const aliases = normalizeAliases(alias);
+	const resolveTsconfig = createTsconfigResolver(tsconfigPath);
 	return (specifier, importer) => {
 		if (specifier === "virtual:ai-i18n") return specifier;
+		const aliasCandidate = resolveAlias(specifier, aliases);
+		if (aliasCandidate) return probeSource(aliasCandidate);
 		if (specifier.startsWith(".")) return probeSource(path.resolve(path.dirname(importer), specifier));
-		for (const alias of aliases) {
-			if (!specifier.startsWith(alias.prefix) || !specifier.endsWith(alias.suffix)) continue;
-			const value = specifier.slice(alias.prefix.length, specifier.length - alias.suffix.length || void 0);
-			for (const target of alias.targets) {
-				const candidate = target.includes("*") ? target.replace("*", value) : target;
-				const resolved = probeSource(path.resolve(baseUrl, candidate));
-				if (resolved) return resolved;
-			}
+		for (const candidate of resolveTsconfig(specifier, importer)) {
+			const resolved = probeSource(candidate);
+			if (resolved) return resolved;
 		}
 		return null;
 	};
 }
+function normalizeAliases(alias) {
+	return Object.entries(alias ?? {}).map(([find, replacement]) => {
+		if (!find) throw new TypeError(diagnosticMessage("ai-i18n alias 的匹配键不能为空。", "The ai-i18n alias match key must not be empty."));
+		if (typeof replacement !== "string" || !path.isAbsolute(replacement)) throw new TypeError(diagnosticMessage(`ai-i18n alias "${find}" 的 replacement 必须是绝对路径。`, `The replacement for ai-i18n alias "${find}" must be an absolute path.`));
+		return {
+			find,
+			replacement
+		};
+	});
+}
+function resolveAlias(specifier, aliases) {
+	for (const { find, replacement } of aliases) if (specifier === find || specifier.startsWith(`${find}/`)) return path.normalize(`${replacement}${specifier.slice(find.length)}`);
+	return null;
+}
 function probeSource(candidate) {
+	candidate = path.normalize(candidate);
+	if (/\.(?:cjs|cts)$/i.test(candidate)) return null;
+	const cached = probeCache.get(candidate);
+	if (cached && (cached.resolved !== null || cached.expiresAt > Date.now()) && cached.parentDirectory === readDirectoryStamp(path.dirname(candidate)) && cached.candidateDirectory === readDirectoryStamp(candidate)) return cached.resolved;
+	let resolved = null;
 	for (const extension of SOURCE_EXTENSIONS) {
 		const file = `${candidate}${extension}`;
-		if (isFile(file)) return path.normalize(file);
+		if (isFile(file)) {
+			resolved = path.normalize(file);
+			break;
+		}
 	}
-	for (const extension of SOURCE_EXTENSIONS.slice(1)) {
+	if (!resolved) for (const extension of SOURCE_EXTENSIONS.slice(1)) {
 		const file = path.join(candidate, `index${extension}`);
-		if (isFile(file)) return path.normalize(file);
+		if (isFile(file)) {
+			resolved = path.normalize(file);
+			break;
+		}
 	}
-	return null;
+	if (probeCache.size >= MAX_PROBE_CACHE_ENTRIES) probeCache.clear();
+	probeCache.set(candidate, {
+		parentDirectory: readDirectoryStamp(path.dirname(candidate)),
+		candidateDirectory: readDirectoryStamp(candidate),
+		expiresAt: Date.now() + DIRECTORY_STAMP_TTL_MS,
+		resolved
+	});
+	return resolved;
 }
 function isFile(file) {
 	try {
@@ -64,79 +278,103 @@ function isFile(file) {
 		return false;
 	}
 }
-function readTsConfig(filename) {
+function readDirectoryStamp(directory) {
+	const now = Date.now();
+	const cached = directoryStampCache.get(directory);
+	if (cached && cached.expiresAt > now) return cached.value;
+	let value = null;
 	try {
-		return JSON.parse(stripJsonComments(fs.readFileSync(filename, "utf8")));
-	} catch {
-		return {};
-	}
-}
-function stripJsonComments(source) {
-	let result = "";
-	let quote = "";
-	let escaped = false;
-	for (let index = 0; index < source.length; index += 1) {
-		const current = source[index];
-		const next = source[index + 1];
-		if (quote) {
-			result += current;
-			if (escaped) escaped = false;
-			else if (current === "\\") escaped = true;
-			else if (current === quote) quote = "";
-			continue;
-		}
-		if (current === "\"" || current === "'") {
-			quote = current;
-			result += current;
-			continue;
-		}
-		if (current === "/" && next === "/") {
-			while (index < source.length && source[index] !== "\n") index += 1;
-			result += "\n";
-			continue;
-		}
-		if (current === "/" && next === "*") {
-			index += 2;
-			while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) {
-				if (source[index] === "\n") result += "\n";
-				index += 1;
-			}
-			index += 1;
-			continue;
-		}
-		result += current;
-	}
-	return result.replace(/,\s*([}\]])/g, "$1");
+		const stat = fs.statSync(directory);
+		if (stat.isDirectory()) value = `${stat.mtimeMs}:${stat.ctimeMs}:${stat.size}`;
+	} catch {}
+	if (directoryStampCache.size >= MAX_PROBE_CACHE_ENTRIES) directoryStampCache.clear();
+	directoryStampCache.set(directory, {
+		expiresAt: now + DIRECTORY_STAMP_TTL_MS,
+		value
+	});
+	return value;
 }
 //#endregion
 //#region src/analyze.ts
-function analyzeStaticArgs(code, filename, tsconfigPath, lang, autoImport = false) {
-	const resolve = createImportResolver(tsconfigPath);
+const POTENTIAL_TRANSLATION_RE = /virtual:ai-i18n|\b(?:t|tRef|tComputed|useI18n|defineI18nMessages)\b/;
+function analyzeStaticSource(code, filename, tsconfigPath, lang, autoImport = false, maxStaticCandidates = Number.POSITIVE_INFINITY, alias) {
+	if (!hasPotentialTranslationCandidate(code)) return {
+		warnings: [],
+		translationCalls: [],
+		messages: []
+	};
+	const autoImports = normalizeAutoImports$1(autoImport);
+	const translationAutoImports = runtimeAutoImports(autoImports);
+	const resolve = createImportResolver(tsconfigPath, alias);
 	const analyzer = new Analyzer({ resolve });
-	analyzer.addFile(AI_I18N_VIRTUAL_MODULE_ID, "export function t(source) { return source }");
+	analyzer.addFile(AI_I18N_VIRTUAL_MODULE_ID, "export function t(source) { return source } export function tRef(source) { return source } export function tComputed(source) { return source }");
 	const entryPath = normalizeFilename(filename);
 	const entry = analyzer.addFile(entryPath, code, lang ? { lang } : void 0);
-	if (!hasTranslationCandidate(entry, autoImport)) return [];
+	if (!hasTranslationCandidate(entry, autoImports)) return {
+		warnings: [],
+		translationCalls: [],
+		messages: []
+	};
 	loadDependencies(analyzer, entry, resolve);
 	analyzer.link();
-	return extractMessages(entry, AI_I18N_VIRTUAL_MODULE_ID, translationHooks(autoImport), autoImport).warnings.map(({ code: warningCode, line, column, message }) => ({
-		code: warningCode,
-		line,
-		column,
-		message
-	}));
+	const hooks = translationHooks(autoImports);
+	const extraction = extractMessages(entry, AI_I18N_VIRTUAL_MODULE_ID, hooks, translationAutoImports, maxStaticCandidates);
+	const recommended = validateRecommendedUsage(entry, AI_I18N_VIRTUAL_MODULE_ID, hooks, translationAutoImports);
+	return {
+		warnings: (recommended.length ? [
+			...extraction.warnings.filter((warning) => warning.code === "parse-error"),
+			...extraction.warnings.filter((warning) => warning.code === "static-candidate-limit"),
+			...recommended
+		] : extraction.warnings).map(({ code: warningCode, line, column, message }) => ({
+			code: warningCode,
+			line,
+			column,
+			message
+		})),
+		translationCalls: findTranslationCalls(entry, AI_I18N_VIRTUAL_MODULE_ID, hooks, translationAutoImports),
+		messages: extraction.messages
+	};
 }
-function hasTranslationCandidate(module, autoImport) {
-	return module.imports.some((item) => !item.typeOnly && (item.name === "t" || item.name === "useI18n")) || autoImport && findUnboundCalls(module, /* @__PURE__ */ new Set(["t", "useI18n"])).length > 0;
+function hasPotentialTranslationCandidate(code) {
+	return POTENTIAL_TRANSLATION_RE.test(code);
+}
+function normalizeAutoImports$1(autoImport) {
+	if (typeof autoImport === "boolean") return {
+		t: autoImport,
+		tRef: false,
+		tComputed: false,
+		useI18n: autoImport
+	};
+	return {
+		t: autoImport?.includes("t") ?? false,
+		tRef: autoImport?.includes("tRef") ?? false,
+		tComputed: autoImport?.includes("tComputed") ?? false,
+		useI18n: autoImport?.includes("useI18n") ?? false
+	};
 }
-function translationHooks(autoImport) {
+function hasTranslationCandidate(module, autoImports) {
+	const unbound = ["defineI18nMessages"];
+	if (autoImports.t) unbound.push("t");
+	if (autoImports.tRef) unbound.push("tRef");
+	if (autoImports.tComputed) unbound.push("tComputed");
+	if (autoImports.useI18n) unbound.push("useI18n");
+	return module.imports.some((item) => !item.typeOnly && (item.specifier === AI_I18N_VIRTUAL_MODULE_ID || item.name === "t" || item.name === "tRef" || item.name === "tComputed" || item.name === "useI18n")) || findInvalidDefineI18nMessagesReferences(module).length > 0 || findUnboundCalls(module, new Set(unbound)).length > 0;
+}
+function translationHooks(autoImports) {
 	return [{
 		module: AI_I18N_VIRTUAL_MODULE_ID,
 		hook: "useI18n",
 		property: "t",
-		autoImport
+		autoImport: autoImports.useI18n
 	}];
 }
+function runtimeAutoImports(autoImports) {
+	const names = /* @__PURE__ */ new Set();
+	if (autoImports.t) names.add("t");
+	if (autoImports.tRef) names.add("tRef");
+	if (autoImports.tComputed) names.add("tComputed");
+	return names;
+}
 function loadDependencies(analyzer, entry, resolve) {
 	const queue = [entry];
 	const visited = /* @__PURE__ */ new Set();
@@ -162,36 +400,1180 @@ function normalizeFilename(filename) {
 }
 //#endregion
 //#region src/vue-sfc.ts
-const require = createRequire(import.meta.url);
+const packageRequire = createRequire(import.meta.url);
 function createVueAnalysisSource(source, filename, parserServices) {
-	if (!parserServices.getDocumentFragment?.()) throw new Error("检查 .vue 文件需要使用 vue-eslint-parser");
+	if (!parserServices.getDocumentFragment?.()) throw new Error(diagnosticMessage("检查 .vue 文件需要配置 vue-eslint-parser。", "Configure vue-eslint-parser to lint .vue files."));
 	try {
-		return analyzeVueSource(source, filename, require("@vue/compiler-sfc"));
+		return analyzeVueSource(source, filename, loadVueCompiler(filename));
 	} catch (error) {
-		if (isMissingVueCompiler(error)) throw new Error("检查 .vue 文件需要安装 @vue/compiler-sfc");
+		if (isMissingVueCompiler(error)) throw new Error(diagnosticMessage("检查 .vue 文件需要安装 @vue/compiler-sfc。", "Install @vue/compiler-sfc to lint .vue files."));
+		throw error;
+	}
+}
+function loadVueCompiler(filename) {
+	const hostRequire = createRequire(path.resolve(filename));
+	const compiler = tryRequire(hostRequire, "vue/compiler-sfc") ?? tryRequire(packageRequire, "vue/compiler-sfc") ?? tryRequire(hostRequire, "@vue/compiler-sfc") ?? packageRequire("@vue/compiler-sfc");
+	compiler.registerTS?.(() => {
+		const typescript = tryResolve(hostRequire, "typescript") ?? tryResolve(packageRequire, "typescript");
+		return packageRequire(typescript ?? "typescript");
+	});
+	return compiler;
+}
+function tryRequire(require, id) {
+	const resolved = tryResolve(require, id);
+	return resolved ? require(resolved) : null;
+}
+function tryResolve(require, id) {
+	try {
+		return require.resolve(id);
+	} catch (error) {
+		if (isMissingVueCompiler(error)) return null;
 		throw error;
 	}
 }
 function isMissingVueCompiler(error) {
-	return error instanceof Error && "code" in error && error.code === "MODULE_NOT_FOUND";
+	return error instanceof Error && "code" in error && (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED");
+}
+//#endregion
+//#region src/rule-analysis.ts
+const DEFAULT_CANDIDATE_LIMIT = 1e3;
+const cache = /* @__PURE__ */ new WeakMap();
+const reportedAnalysisFailures = /* @__PURE__ */ new WeakSet();
+const EMPTY_ANALYSIS = {
+	warnings: [],
+	translationCalls: [],
+	messages: []
+};
+function analyzeRuleContext(context, options, maxStaticCandidates = Number.POSITIVE_INFINITY) {
+	return analyzeRuleContextResult(context, options, maxStaticCandidates).warnings;
+}
+function analyzeTranslationCalls(context, options) {
+	return analyzeRuleContextResult(context, options, DEFAULT_CANDIDATE_LIMIT).translationCalls;
+}
+function analyzeTranslationMessages(context, options) {
+	return analyzeRuleContextResult(context, options, Number.POSITIVE_INFINITY).messages;
+}
+function reportAnalysisFailureOnce(context, node, error) {
+	if (reportedAnalysisFailures.has(context.sourceCode)) return;
+	reportedAnalysisFailures.add(context.sourceCode);
+	const detail = error instanceof Error ? error.message : String(error);
+	context.report({
+		node,
+		message: diagnosticMessage(`静态分析失败：${detail}`, `Static analysis failed: ${detail}`)
+	});
+}
+function analyzeRuleContextResult(context, options, maxStaticCandidates) {
+	if (!hasPotentialTranslationCandidate(context.sourceCode.text)) return EMPTY_ANALYSIS;
+	const cached = cache.get(context.sourceCode) ?? {
+		source: createAnalysisSource(context),
+		analyses: /* @__PURE__ */ new Map()
+	};
+	cache.set(context.sourceCode, cached);
+	const alias = readImportAlias(context);
+	const analyze = (limit) => {
+		const autoImports = normalizeAutoImports$1(options.autoImport);
+		const key = JSON.stringify([
+			options.tsconfigPath ?? null,
+			autoImports.t,
+			autoImports.tRef,
+			autoImports.tComputed,
+			autoImports.useI18n,
+			Object.entries(alias ?? {}),
+			limit
+		]);
+		const existing = cached.analyses.get(key);
+		if (existing) return existing;
+		const result = analyzeStaticSource(cached.source.code, context.filename, options.tsconfigPath, cached.source.lang, options.autoImport, limit, alias);
+		const analysis = {
+			warnings: result.warnings.map((warning) => ({
+				...warning,
+				...cached.source.mapLocation(warning)
+			})),
+			translationCalls: result.translationCalls.map((call) => ({
+				...call,
+				...cached.source.mapLocation(call)
+			})),
+			messages: result.messages.map((message) => ({
+				...message,
+				locations: message.locations.map((location) => ({
+					...location,
+					...cached.source.mapLocation(location)
+				}))
+			}))
+		};
+		cached.analyses.set(key, analysis);
+		return analysis;
+	};
+	if (Number.isFinite(maxStaticCandidates)) return analyze(maxStaticCandidates);
+	const preflight = analyze(DEFAULT_CANDIDATE_LIMIT);
+	return preflight.warnings.some((warning) => warning.code === "static-candidate-limit") ? analyze(Number.POSITIVE_INFINITY) : preflight;
+}
+function readImportAlias(context) {
+	const settings = context.settings["ai-i18n"];
+	if (!settings || typeof settings !== "object" || Array.isArray(settings)) return;
+	const alias = settings.alias;
+	if (alias === void 0) return void 0;
+	if (!alias || typeof alias !== "object" || Array.isArray(alias)) throw new TypeError(diagnosticMessage("ai-i18n settings.alias 必须是字符串到绝对路径的对象。", "ai-i18n settings.alias must be an object mapping strings to absolute paths."));
+	return alias;
+}
+function createAnalysisSource(context) {
+	return context.filename.endsWith(".vue") ? createVueAnalysisSource(context.sourceCode.text, context.filename, context.sourceCode.parserServices) : {
+		code: context.sourceCode.text,
+		lang: void 0,
+		mapLocation: (location) => location
+	};
+}
+//#endregion
+//#region src/rules/common/translation-call.ts
+function matchTranslationCalls(context, options, candidates) {
+	const calls = new Map(analyzeTranslationCalls(context, options).map((call) => [locationKey(call.line, call.column, call.kind), call]));
+	return candidates.flatMap((candidate) => {
+		const location = candidate.node.loc?.start;
+		if (!location) return [];
+		const call = calls.get(locationKey(location.line, location.column, candidate.kind));
+		return call ? [{
+			...candidate,
+			call
+		}] : [];
+	});
+}
+function locationKey(line, column, kind) {
+	return `${kind}:${line}:${column}`;
+}
+//#endregion
+//#region src/rules/common/ast-context.ts
+const FUNCTION_TYPES = /* @__PURE__ */ new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression"
+]);
+const IMMEDIATE_CONSOLE_METHODS = /* @__PURE__ */ new Set([
+	"debug",
+	"error",
+	"info",
+	"log",
+	"warn"
+]);
+function isFunctionNode(node) {
+	return FUNCTION_TYPES.has(node.type);
+}
+function nearestFunction(node) {
+	let current = node;
+	while (current.parent) {
+		current = current.parent;
+		if (isFunctionNode(current)) return current;
+	}
+	return null;
+}
+function isImmediateConsoleEffect(node) {
+	const call = node.parent;
+	if (call?.type !== "CallExpression" || call.parent?.type !== "ExpressionStatement" || !call.arguments.some((argument) => argument === node) || call.callee.type !== "MemberExpression" || call.callee.object.type !== "Identifier" || call.callee.object.name !== "console") return false;
+	const property = call.callee.property;
+	const method = !call.callee.computed && property.type === "Identifier" ? property.name ?? null : call.callee.computed && property.type === "Literal" && typeof property.value === "string" ? property.value : null;
+	return method !== null && IMMEDIATE_CONSOLE_METHODS.has(method);
+}
+function isVueTemplateEventHandler(node) {
+	let current = node;
+	while (current.parent) {
+		current = current.parent;
+		if (current.type === "VOnExpression") return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/rules/vue/options.ts
+function isOptionsComputedValue(node, context) {
+	let value = node;
+	while (value.parent && isTransparentExpression(value.parent) && expressionChild(value.parent) === value) value = value.parent;
+	const entry = value.parent;
+	if (entry?.type !== "Property" || entry.value !== value) return false;
+	const entries = entry.parent;
+	if (entries?.type !== "ObjectExpression") return false;
+	const computed = entries.parent;
+	return computed?.type === "Property" && computed.value === entries && propertyName(computed.key) === "computed" && computed.parent?.type === "ObjectExpression" && isVueComponentOptionsObject(computed.parent, context);
+}
+function isOptionsComputedSpread(node, context) {
+	const value = unwrapTransparentParent(node);
+	const spread = value.parent;
+	if (spread?.type !== "SpreadElement" || spread.argument !== value) return false;
+	const entries = spread.parent;
+	if (entries?.type !== "ObjectExpression") return false;
+	const computed = entries.parent;
+	return computed?.type === "Property" && computed.value === entries && propertyName(computed.key) === "computed" && computed.parent?.type === "ObjectExpression" && isVueComponentOptionsObject(computed.parent, context);
+}
+function isInsideOptionsComputedGetter(node, context) {
+	const owner = nearestFunction(node);
+	if (!owner) return false;
+	let current = owner;
+	while (current?.parent) {
+		const parent = current.parent;
+		if (current.type === "ObjectExpression" && parent.type === "Property" && parent.value === current && propertyName(parent.key) === "computed" && parent.parent?.type === "ObjectExpression" && isVueComponentOptionsObject(parent.parent, context)) return true;
+		current = current.parent;
+		if (current && current !== owner && isFunctionNode(current)) return false;
+	}
+	return false;
+}
+function vueOptionsSection(node, context) {
+	let current = node;
+	while (current.parent) {
+		const property = current.parent;
+		if (property.type === "Property" && property.value === current && property.parent?.type === "ObjectExpression" && isVueComponentOptionsObject(property.parent, context)) return propertyName(property.key) ?? null;
+		current = current.parent;
+	}
+	return null;
+}
+function isDirectOptionsFunction$1(node, context, name, allowBareExportDefault = true) {
+	const value = unwrapTransparentParent(node);
+	const property = value.parent;
+	if (property?.type !== "Property" || property.value !== value || propertyName(property.key) !== name) return false;
+	const options = property.parent;
+	return options?.type === "ObjectExpression" && isVueComponentOptionsObject(options, context, allowBareExportDefault);
+}
+function isVueComponentSetup(node, context, isVueSfc) {
+	const value = unwrapTransparentParent(node);
+	const directOwner = value.parent;
+	if (directOwner?.type === "CallExpression" && directOwner.arguments?.[0] === value) return isImportedVueDefineComponent(directOwner.callee, context);
+	const property = value.parent;
+	if (property?.type !== "Property" || property.value !== value || property.computed || propertyName(property.key) !== "setup") return false;
+	const options = property.parent;
+	if (options?.type !== "ObjectExpression") return false;
+	const owner = options.parent;
+	if (isVueSfc && owner?.type === "ExportDefaultDeclaration" && owner.declaration === options) return true;
+	return owner?.type === "CallExpression" && owner.arguments?.[0] === options && isImportedVueDefineComponent(owner.callee, context);
+}
+function isVueScriptSetupNode(node, context) {
+	if (!context.filename.toLowerCase().endsWith(".vue") || !node.range) return false;
+	const source = context.sourceCode.text;
+	const before = source.slice(0, node.range[0]);
+	const opening = before.lastIndexOf("<script");
+	if (opening <= before.lastIndexOf("<\/script>")) return false;
+	const closing = source.indexOf(">", opening);
+	if (closing < 0 || closing >= node.range[0]) return false;
+	return /\bsetup(?:\s|=|>)/u.test(source.slice(opening, closing + 1));
+}
+function isImportedVueDefineComponent(node, context) {
+	const callee = node;
+	if (callee?.type === "Identifier") return isVueImport(callee, context, "ImportSpecifier");
+	return callee?.type === "MemberExpression" && !callee.computed && propertyName(callee.property) === "defineComponent" && isVueImport(callee.object, context, "ImportNamespaceSpecifier");
+}
+function propertyName(node) {
+	const key = node;
+	if (key?.type === "Identifier") return key.name;
+	return key?.type === "Literal" && typeof key.value === "string" ? key.value : void 0;
+}
+function isVueComponentOptionsObject(options, context, allowBareExportDefault = true) {
+	const value = unwrapTransparentParent(options);
+	const owner = value.parent;
+	if (allowBareExportDefault && owner?.type === "ExportDefaultDeclaration" && owner.declaration === value) return true;
+	return owner?.type === "CallExpression" && owner.arguments?.[0] === value && isImportedVueDefineComponent(owner.callee, context);
+}
+function isVueImport(node, context, specifierType) {
+	const identifier = node;
+	if (identifier?.type !== "Identifier" || !identifier.name) return false;
+	let scope = context.sourceCode.getScope(identifier);
+	while (true) {
+		const variable = scope.set.get(identifier.name);
+		if (!variable) {
+			if (!scope.upper) return false;
+			scope = scope.upper;
+			continue;
+		}
+		return variable.defs.some((definition) => {
+			if (definition.type !== "ImportBinding" || definition.node.type !== specifierType || definition.parent.source.value !== "vue") return false;
+			return specifierType === "ImportNamespaceSpecifier" || propertyName(definition.node.imported) === "defineComponent";
+		});
+	}
+}
+function unwrapTransparentParent(node) {
+	let value = node;
+	while (value.parent && isTransparentExpression(value.parent) && expressionChild(value.parent) === value) value = value.parent;
+	return value;
+}
+function isTransparentExpression(node) {
+	return node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression" || node.type === "TypeCastExpression";
+}
+function expressionChild(node) {
+	return node.expression;
+}
+//#endregion
+//#region src/rules/common/no-eager-translation.ts
+const noEagerTranslation = {
+	meta: {
+		type: "problem",
+		docs: { description: "警告不会随语言切换更新的提前求值翻译结果" },
+		schema: [{
+			type: "object",
+			properties: {
+				tsconfigPath: { type: "string" },
+				autoImport: { anyOf: [{ type: "boolean" }, {
+					type: "array",
+					items: { enum: [
+						"t",
+						"tRef",
+						"tComputed",
+						"useI18n"
+					] },
+					uniqueItems: true
+				}] },
+				framework: { enum: ["vue"] }
+			},
+			additionalProperties: false
+		}],
+		messages: { eagerTranslation: diagnosticMessage("初始化期间保存的 t() 结果不会随语言切换更新。请改为函数或 Getter，在使用时调用 t()；Vue setup 中使用 tRef()，纯 Options API 的 computed 使用 tComputed()。", "A t() result stored during initialization will not update when the language changes. Evaluate it lazily in a function or getter; use tRef() in Vue setup and tComputed() in pure Options API computed.") }
+	},
+	create(context) {
+		const options = context.options[0] ?? {};
+		const isVueSfc = context.filename.toLowerCase().endsWith(".vue");
+		const candidates = [];
+		return {
+			CallExpression(node) {
+				candidates.push({
+					kind: "call",
+					node
+				});
+			},
+			TaggedTemplateExpression(node) {
+				candidates.push({
+					kind: "tagged-template",
+					node
+				});
+			},
+			"Program:exit"(program) {
+				let matches;
+				try {
+					matches = matchTranslationCalls(context, options, candidates);
+				} catch (error) {
+					reportAnalysisFailureOnce(context, program, error);
+					return;
+				}
+				for (const { call, node } of matches) {
+					if (call.origin === "vue-ref" || call.origin === "vue-computed") continue;
+					if (!storesOutsideFunction(node, context, isVueSfc, options.framework === "vue")) continue;
+					context.report({
+						node,
+						messageId: "eagerTranslation"
+					});
+				}
+			}
+		};
+	}
+};
+function storesOutsideFunction(node, context, isVueSfc, isVueFramework) {
+	let current = node;
+	let storesResult = false;
+	while (current.parent) {
+		const parent = current.parent;
+		if (isFunctionNode(parent)) {
+			const returnsExpression = parent.type === "ArrowFunctionExpression" && parent.body === current;
+			return (isVueComponentSetup(parent, context, isVueSfc) || isDirectOptionsFunction$1(parent, context, "data", isVueSfc || isVueFramework)) && (storesResult || returnsExpression);
+		}
+		if (storesTranslationResult(parent, current)) storesResult = true;
+		if (parent.type === "Program") return storesResult;
+		current = parent;
+	}
+	return storesResult;
+}
+function storesTranslationResult(parent, child) {
+	if (parent.type === "AccessorProperty" && parent.value === child) return true;
+	switch (parent.type) {
+		case "VariableDeclarator": return parent.init === child;
+		case "AssignmentExpression":
+		case "AssignmentPattern": return parent.right === child;
+		case "PropertyDefinition": return parent.value === child;
+		case "ReturnStatement": return parent.argument === child;
+		case "ExportDefaultDeclaration": return parent.declaration === child;
+		default: return false;
+	}
+}
+//#endregion
+//#region src/rules/common/no-embedded-markup.ts
+const noEmbeddedMarkup = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "警告翻译源文中内嵌的静态 HTML 或 SVG 结构" },
+		schema: [{
+			type: "object",
+			properties: {
+				tsconfigPath: { type: "string" },
+				autoImport: { anyOf: [{ type: "boolean" }, {
+					type: "array",
+					items: { enum: [
+						"t",
+						"tRef",
+						"tComputed",
+						"useI18n"
+					] },
+					uniqueItems: true
+				}] }
+			},
+			additionalProperties: false
+		}],
+		messages: { embeddedMarkup: diagnosticMessage("翻译源文包含静态 HTML 或 SVG 结构。请保留完整的自然语言，并将 markup 移出翻译调用或作为占位符传入。", "The translation source contains static HTML or SVG structure. Keep the complete natural-language message, and move markup outside the translation call or pass it as a placeholder.") }
+	},
+	create(context) {
+		const options = context.options[0] ?? {};
+		return { "Program:exit"(program) {
+			let messages;
+			try {
+				messages = analyzeTranslationMessages(context, options);
+			} catch (error) {
+				reportAnalysisFailureOnce(context, program, error);
+				return;
+			}
+			const reported = /* @__PURE__ */ new Set();
+			for (const message of messages) {
+				if (!containsEmbeddedMarkup(message.source)) continue;
+				for (const location of message.locations) {
+					const key = `${location.line}:${location.column}`;
+					if (reported.has(key)) continue;
+					reported.add(key);
+					context.report({
+						node: program,
+						loc: {
+							start: location,
+							end: {
+								line: location.line,
+								column: location.column + 1
+							}
+						},
+						messageId: "embeddedMarkup"
+					});
+				}
+			}
+		} };
+	}
+};
+function containsEmbeddedMarkup(source) {
+	if (!source.includes("<")) return false;
+	const options = { sourceCodeLocationInfo: true };
+	return containsLocatedMarkup(parseFragment(source, options)) || containsLocatedMarkup(parse(source, options));
+}
+function containsLocatedMarkup(parent) {
+	return parent.childNodes.some((node) => {
+		if ((defaultTreeAdapter.isElementNode(node) || defaultTreeAdapter.isCommentNode(node)) && node.sourceCodeLocation) return true;
+		return defaultTreeAdapter.isElementNode(node) && containsLocatedMarkup(node);
+	});
+}
+//#endregion
+//#region src/rules/common/no-redundant-auto-import.ts
+const RUNTIME_MODULE$2 = "virtual:ai-i18n";
+const noRedundantAutoImport = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "禁止显式导入已由 ai-i18n autoImport 注入的 Runtime API" },
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: { autoImport: {
+				type: "array",
+				items: { enum: ALL_AUTO_IMPORT_APIS },
+				minItems: 1,
+				uniqueItems: true
+			} },
+			required: ["autoImport"],
+			additionalProperties: false
+		}],
+		messages: { redundantImport: diagnosticMessage("ai-i18n autoImport 已注入以下 API：{{names}}。请删除来自 virtual:ai-i18n 的冗余导入。", "ai-i18n autoImport injects these APIs: {{names}}. Remove the redundant imports from virtual:ai-i18n.") }
+	},
+	create(context) {
+		const enabled = new Set(context.options[0]?.autoImport ?? []);
+		return { ImportDeclaration(rawNode) {
+			const node = rawNode;
+			if (node.importKind === "type" || node.source.value !== RUNTIME_MODULE$2) return;
+			const named = node.specifiers.filter((specifier) => specifier.type === "ImportSpecifier");
+			const redundant = named.filter((specifier) => {
+				const imported = importedName(specifier);
+				return specifier.importKind !== "type" && imported !== null && imported === specifier.local.name && enabled.has(imported);
+			});
+			if (!redundant.length) return;
+			const names = redundant.map((specifier) => importedName(specifier)).filter((name) => name !== null);
+			const fix = createFix(context, node, named, redundant);
+			context.report({
+				node,
+				messageId: "redundantImport",
+				data: { names: names.join(", ") },
+				fix
+			});
+		} };
+	}
+};
+function importedName(specifier) {
+	if (specifier.imported.type === "Identifier" && "name" in specifier.imported) return specifier.imported.name;
+	return typeof specifier.imported.value === "string" ? specifier.imported.value : null;
+}
+function createFix(context, node, named, redundant) {
+	if (context.sourceCode.getCommentsInside(node).length) return void 0;
+	const redundantSet = new Set(redundant);
+	if (!node.specifiers.filter((specifier) => !redundantSet.has(specifier)).length) return (fixer) => fixer.remove(node);
+	const remainingNamed = named.filter((specifier) => !redundantSet.has(specifier));
+	const firstNamed = named[0];
+	const lastNamed = named.at(-1);
+	if (!firstNamed || !lastNamed) return void 0;
+	const openBrace = context.sourceCode.getTokenBefore(firstNamed);
+	const closeBrace = context.sourceCode.getTokenAfter(lastNamed);
+	if (openBrace?.value !== "{" || closeBrace?.value !== "}") return void 0;
+	if (remainingNamed.length) {
+		const [, openEnd] = context.sourceCode.getRange(openBrace);
+		const [closeStart] = context.sourceCode.getRange(closeBrace);
+		const replacement = remainingNamed.map((specifier) => context.sourceCode.getText(specifier)).join(", ");
+		return (fixer) => fixer.replaceTextRange([openEnd, closeStart], ` ${replacement} `);
+	}
+	const beforeOpen = context.sourceCode.getTokenBefore(openBrace);
+	if (beforeOpen?.value !== ",") return void 0;
+	const [commaStart] = context.sourceCode.getRange(beforeOpen);
+	const [, closeEnd] = context.sourceCode.getRange(closeBrace);
+	return (fixer) => fixer.removeRange([commaStart, closeEnd]);
+}
+//#endregion
+//#region src/rules/vue/runtime-state.ts
+function misplacedI18nComputed(node, context, inTemplate, isVueSfc) {
+	if (inTemplate || isVueScriptSetupNode(node, context)) return true;
+	if (vueOptionsSection(node, context) !== null) return true;
+	const owner = nearestFunction(node);
+	return Boolean(owner && isVueComponentSetup(owner, context, isVueSfc));
+}
+function vueInitializationSnapshotKind(node, owner, context, isVueSfc) {
+	const kind = isVueComponentSetup(owner, context, isVueSfc) ? "setup" : isDirectOptionsFunction$1(owner, context, "data") ? "data" : null;
+	if (!kind || !storesResultBeforeOwner(node, owner)) return null;
+	return kind;
+}
+function reportVueInitializationSnapshot(context, node, api, kind) {
+	context.report({
+		node,
+		messageId: kind === "data" ? "optionsDataSnapshot" : "vueSetupSnapshot",
+		data: {
+			api,
+			replacement: api === "getLang" ? "currentLang" : "langLoadState"
+		}
+	});
+}
+function storesResultBeforeOwner(node, owner) {
+	let current = node;
+	let storesResult = false;
+	while (current.parent && current.parent !== owner) {
+		const parent = current.parent;
+		if (parent.type === "VariableDeclarator" && parent.init === current || (parent.type === "AssignmentExpression" || parent.type === "AssignmentPattern") && parent.right === current || parent.type === "PropertyDefinition" && parent.value === current || parent.type === "ReturnStatement" && parent.argument === current) storesResult = true;
+		current = parent;
+	}
+	return storesResult || owner.type === "ArrowFunctionExpression" && owner.body === current;
 }
 //#endregion
-//#region src/rules/t-static-args.ts
+//#region src/rules/common/no-unsubscribed-runtime-state.ts
+const RUNTIME_MODULE$1 = "virtual:ai-i18n";
+const STATE_APIS = ["getLang", "getLangLoadState"];
+const VUE_COMPUTED_API = "i18nComputed";
+const TRACKED_APIS = [...STATE_APIS, VUE_COMPUTED_API];
+const noUnsubscribedRuntimeState = {
+	meta: {
+		type: "problem",
+		docs: { description: "检查初始化、模块和组件渲染路径中的 Runtime 状态快照" },
+		schema: [{
+			type: "object",
+			properties: {
+				autoImport: { anyOf: [{ type: "boolean" }, {
+					type: "array",
+					items: { enum: TRACKED_APIS },
+					uniqueItems: true
+				}] },
+				framework: { enum: ["react", "vue"] }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			moduleSnapshot: diagnosticMessage("模块顶层调用 {{api}}() 只会保存初始化时的状态快照，后续语言状态变化不会更新该值。请在需要时调用，或通过 subscribe() / useI18n() 建立订阅。", "Calling {{api}}() at module scope stores only the initialization snapshot, which will not update after language state changes. Read it when needed, or subscribe through subscribe() / useI18n()."),
+			renderSnapshot: diagnosticMessage("组件渲染期间调用 {{api}}() 不会订阅语言状态。请使用 useI18n() 返回的 {{replacement}}。", "Calling {{api}}() while rendering a component does not subscribe to language state. Use {{replacement}} from useI18n()."),
+			vueRenderSnapshot: diagnosticMessage("Vue 渲染期间调用 {{api}}() 不会订阅语言状态。Composition API 请使用 useI18n() 返回的 {{replacement}}；纯 Options API 请在 computed 中展开 ...i18nComputed() 后使用 {{replacement}}。", "Calling {{api}}() while rendering Vue does not subscribe to language state. With the Composition API, use {{replacement}} from useI18n(); with the pure Options API, spread ...i18nComputed() into computed and use {{replacement}}."),
+			optionsComputedSnapshot: diagnosticMessage("纯 Options API 的 computed 中调用 {{api}}() 仍然只会读取快照。请改为在 computed 中展开 ...i18nComputed()，并直接使用响应式的 {{replacement}}。", "Calling {{api}}() inside a pure Options API computed getter still reads only a snapshot. Spread ...i18nComputed() into computed and use the reactive {{replacement}} instead."),
+			vueSetupSnapshot: diagnosticMessage("Vue setup 中保存 {{api}}() 只会保留初始化快照。请使用 useI18n() 返回的响应式 {{replacement}}。", "Storing {{api}}() in Vue setup keeps only the initialization snapshot. Use the reactive {{replacement}} returned by useI18n()."),
+			optionsDataSnapshot: diagnosticMessage("纯 Options API 的 data 中保存 {{api}}() 只会保留初始化快照。请在 computed 中展开 ...i18nComputed()，并使用响应式的 {{replacement}}。", "Storing {{api}}() in pure Options API data keeps only the initialization snapshot. Spread ...i18nComputed() into computed and use the reactive {{replacement}}."),
+			misplacedI18nComputed: diagnosticMessage("i18nComputed() 只应直接展开到纯 Options API 的 computed，例如 computed: { ...i18nComputed() }。", "Spread i18nComputed() directly into pure Options API computed, for example computed: { ...i18nComputed() }.")
+		}
+	},
+	create(context) {
+		const options = context.options[0] ?? {};
+		const autoImports = normalizeAutoImports(options.autoImport);
+		const importedBindings = /* @__PURE__ */ new Map();
+		const jsxOwners = /* @__PURE__ */ new Set();
+		const templateCalls = /* @__PURE__ */ new Set();
+		const candidates = [];
+		const isVueSfc = context.filename.toLowerCase().endsWith(".vue");
+		const collectJsxOwner = (node) => {
+			const owner = nearestFunction(node);
+			if (owner) jsxOwners.add(owner);
+		};
+		const collectCall = (node) => {
+			candidates.push(node);
+		};
+		const scriptVisitor = {
+			CallExpression: collectCall,
+			ImportDeclaration(node) {
+				if (node.source.value !== RUNTIME_MODULE$1) return;
+				for (const specifier of node.specifiers) {
+					if (specifier.type !== "ImportSpecifier") continue;
+					const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : typeof specifier.imported.value === "string" ? specifier.imported.value : null;
+					if (TRACKED_APIS.includes(imported)) importedBindings.set(specifier.local.name, imported);
+				}
+			},
+			JSXElement: collectJsxOwner,
+			JSXFragment: collectJsxOwner,
+			"Program:exit"() {
+				for (const node of candidates) {
+					const api = runtimeStateApi(context, node, autoImports, importedBindings, templateCalls.has(node));
+					if (!api) continue;
+					if (api === VUE_COMPUTED_API) {
+						if (options.framework === "vue" && !isOptionsComputedSpread(node, context) && misplacedI18nComputed(node, context, templateCalls.has(node), isVueSfc)) context.report({
+							node,
+							messageId: "misplacedI18nComputed"
+						});
+						continue;
+					}
+					if (templateCalls.has(node)) {
+						if (!isVueTemplateEventHandler(node)) reportRenderSnapshot(context, node, api, true);
+						continue;
+					}
+					const owner = nearestFunction(node);
+					if (!owner) {
+						context.report({
+							node,
+							messageId: "moduleSnapshot",
+							data: { api }
+						});
+						continue;
+					}
+					if (options.framework === "vue" && isInsideOptionsComputedGetter(node, context)) {
+						reportOptionsComputedSnapshot(context, node, api);
+						continue;
+					}
+					const initializationKind = options.framework === "vue" ? vueInitializationSnapshotKind(node, owner, context, isVueSfc) : null;
+					if (initializationKind) {
+						reportVueInitializationSnapshot(context, node, api, initializationKind);
+						continue;
+					}
+					if (jsxOwners.has(owner) && !isImmediateConsoleEffect(node)) reportRenderSnapshot(context, node, api, options.framework === "vue");
+				}
+			}
+		};
+		const parserServices = context.sourceCode.parserServices;
+		if (!parserServices.defineTemplateBodyVisitor) return scriptVisitor;
+		return parserServices.defineTemplateBodyVisitor({ CallExpression(node) {
+			candidates.push(node);
+			templateCalls.add(node);
+		} }, scriptVisitor, { templateBodyTriggerSelector: "Program" });
+	}
+};
+function normalizeAutoImports(option) {
+	if (option === true) return new Set(TRACKED_APIS);
+	if (!option) return /* @__PURE__ */ new Set();
+	return new Set(option);
+}
+function runtimeStateApi(context, rawNode, autoImports, importedBindings, inTemplate) {
+	if (rawNode.type !== "CallExpression") return null;
+	const callee = rawNode.callee;
+	if (callee.type !== "Identifier") return null;
+	if (inTemplate) {
+		if (isTemplateLocalIdentifier(callee)) return null;
+		const imported = importedBindings.get(callee.name);
+		if (imported) return imported;
+		if (hasTopLevelScriptBinding(context, callee.name)) return null;
+		return autoImports.has(callee.name) ? callee.name : null;
+	}
+	const variable = findVariable$1(context.sourceCode.getScope(callee), callee.name);
+	if (variable?.defs.length) return importedRuntimeStateApi(variable);
+	return autoImports.has(callee.name) ? callee.name : null;
+}
+function importedRuntimeStateApi(variable) {
+	for (const definition of variable.defs) {
+		if (definition.type !== "ImportBinding") continue;
+		const specifier = definition.node;
+		const declaration = specifier.parent;
+		if (specifier.type !== "ImportSpecifier" || declaration?.type !== "ImportDeclaration" || declaration.source.value !== RUNTIME_MODULE$1) continue;
+		const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : typeof specifier.imported.value === "string" ? specifier.imported.value : null;
+		return TRACKED_APIS.includes(imported) ? imported : null;
+	}
+	return null;
+}
+function hasTopLevelScriptBinding(context, name) {
+	return context.sourceCode.scopeManager.scopes.some((scope) => (scope.type === "global" || scope.type === "module") && scope.variables.some((variable) => variable.name === name && variable.defs.length > 0));
+}
+function isTemplateLocalIdentifier(identifier) {
+	let current = identifier;
+	while (current) {
+		if (current.type === "VExpressionContainer") return current.references.some((reference) => reference.id === identifier && reference.variable !== null);
+		current = current.parent;
+	}
+	return false;
+}
+function findVariable$1(scope, name) {
+	let current = scope;
+	while (current) {
+		const variable = current.variables.find((item) => item.name === name);
+		if (variable) return variable;
+		current = current.upper;
+	}
+	return null;
+}
+function reportRenderSnapshot(context, node, api, isVue) {
+	context.report({
+		node,
+		messageId: isVue ? "vueRenderSnapshot" : "renderSnapshot",
+		data: {
+			api,
+			replacement: api === "getLang" ? "currentLang" : "langLoadState"
+		}
+	});
+}
+function reportOptionsComputedSnapshot(context, node, api) {
+	context.report({
+		node,
+		messageId: "optionsComputedSnapshot",
+		data: {
+			api,
+			replacement: api === "getLang" ? "currentLang" : "langLoadState"
+		}
+	});
+}
+//#endregion
+//#region src/rules/react/no-unsubscribed-t.ts
+function reportReactUnsubscribedT(context, call, node, jsxOwners) {
+	if (call.origin !== "runtime") return;
+	const owner = nearestFunction(node);
+	if (!owner || !jsxOwners.has(owner) || isImmediateConsoleEffect(node)) return;
+	context.report({
+		node,
+		messageId: "unsubscribedT"
+	});
+}
+//#endregion
+//#region src/rules/vue/instance-member.ts
+const RUNTIME_MODULE = "virtual:ai-i18n";
+const TRANSPARENT_EXPRESSIONS = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"TypeCastExpression"
+]);
+const STATIC_INSTANCE_SOURCES = /* @__PURE__ */ new Set([
+	"computed",
+	"inject",
+	"props"
+]);
+const RETURNED_INSTANCE_SOURCES = /* @__PURE__ */ new Set(["data", "setup"]);
+const UNCERTAIN_INSTANCE_SOURCES = /* @__PURE__ */ new Set(["extends", "mixins"]);
+function resolveVueInstanceMemberOrigin(context, node, name, inTemplate) {
+	const options = inTemplate ? defaultComponentOptions(context) : enclosingComponentOptions(node, context);
+	if (options === "unknown") return "unknown";
+	if (!options) return inTemplate ? "missing" : "not-component";
+	if (!inTemplate && !usesComponentThis(node, options)) return "not-component";
+	return resolveOptionsMember(options, name, context);
+}
+function resolveOptionsMember(options, name, context) {
+	let methods = null;
+	let localSource = false;
+	let uncertainSource = false;
+	for (const entry of options.properties ?? []) {
+		if (entry.type === "SpreadElement") {
+			methods = "unknown";
+			uncertainSource = true;
+			continue;
+		}
+		if (entry.type !== "Property") continue;
+		const key = staticPropertyName(entry);
+		if (key === null) {
+			methods = "unknown";
+			uncertainSource = true;
+			continue;
+		}
+		if (key === "methods") {
+			const value = unwrapExpression(entry.value);
+			methods = value?.type === "ObjectExpression" ? value : "unknown";
+			continue;
+		}
+		if (STATIC_INSTANCE_SOURCES.has(key)) {
+			const origin = resolveStaticSourceMember(entry.value, name, context);
+			if (origin === "local") localSource = true;
+			if (origin === "unknown") uncertainSource = true;
+			continue;
+		}
+		if (RETURNED_INSTANCE_SOURCES.has(key)) {
+			const origin = resolveReturnedSourceMember(entry.value, name, context);
+			if (origin === "local") localSource = true;
+			if (origin === "unknown") uncertainSource = true;
+			continue;
+		}
+		if (UNCERTAIN_INSTANCE_SOURCES.has(key)) uncertainSource = true;
+	}
+	if (methods === "unknown") return "unknown";
+	const methodOrigin = methods ? resolveObjectMember(methods, name, context) : "missing";
+	if (methodOrigin === "local" || localSource) return "local";
+	if (methodOrigin === "unknown" || uncertainSource) return "unknown";
+	return methodOrigin;
+}
+function resolveStaticSourceMember(rawValue, name, context) {
+	const value = unwrapExpression(rawValue);
+	if (!value) return "unknown";
+	if (value.type === "ObjectExpression") {
+		const origin = resolveObjectMember(value, name, context);
+		return origin === "missing" ? "missing" : origin === "unknown" ? "unknown" : "local";
+	}
+	if (value.type !== "ArrayExpression") return "unknown";
+	for (const element of value.elements ?? []) {
+		if (propertyName(element) === name) return "local";
+		if (element.type !== "Literal") return "unknown";
+	}
+	return "missing";
+}
+function resolveReturnedSourceMember(rawValue, name, context) {
+	const fn = unwrapExpression(rawValue);
+	if (!fn || fn.type !== "FunctionExpression" && fn.type !== "ArrowFunctionExpression") return "unknown";
+	const rawBody = fn.body;
+	if (!rawBody) return "unknown";
+	if (rawBody.type === "ObjectExpression") return localObjectMemberOrigin(rawBody, name, context);
+	if (rawBody.type !== "BlockStatement") return "unknown";
+	const statements = rawBody.body ?? [];
+	const returned = statements.at(-1);
+	if (returned?.type !== "ReturnStatement" || statements.slice(0, -1).some((statement) => !isStraightLineStatement(statement))) return "unknown";
+	const value = unwrapExpression(returned.argument);
+	return value?.type === "ObjectExpression" ? localObjectMemberOrigin(value, name, context) : "unknown";
+}
+function localObjectMemberOrigin(object, name, context) {
+	const origin = resolveObjectMember(object, name, context);
+	return origin === "missing" ? "missing" : origin === "unknown" ? "unknown" : "local";
+}
+function isStraightLineStatement(node) {
+	return node.type === "ExpressionStatement" || node.type === "FunctionDeclaration" || node.type === "VariableDeclaration";
+}
+function resolveObjectMember(object, name, context) {
+	let origin = "missing";
+	for (const entry of object.properties ?? []) {
+		if (entry.type === "SpreadElement") {
+			origin = "unknown";
+			continue;
+		}
+		if (entry.type !== "Property") continue;
+		const key = staticPropertyName(entry);
+		if (key === null) {
+			origin = "unknown";
+			continue;
+		}
+		if (key !== name) continue;
+		origin = methodValueOrigin(entry.value, context);
+	}
+	return origin;
+}
+function methodValueOrigin(rawValue, context) {
+	const value = unwrapExpression(rawValue);
+	if (!value) return "unknown";
+	if (value.type !== "Identifier" || !value.name) return "local";
+	const variable = findVariable(context, value);
+	if (!variable) return "unknown";
+	return variable.defs.some(isRuntimeTImport) ? "ai-i18n" : "local";
+}
+function findVariable(context, identifier) {
+	let scope = context.sourceCode.getScope(identifier);
+	while (scope) {
+		const variable = scope.set.get(identifier.name);
+		if (variable) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+function isRuntimeTImport(definition) {
+	if (definition.type !== "ImportBinding") return false;
+	const specifier = definition.node;
+	const declaration = specifier.parent;
+	return specifier.type === "ImportSpecifier" && declaration?.type === "ImportDeclaration" && declaration.source?.value === RUNTIME_MODULE && propertyName(specifier.imported) === "t";
+}
+function enclosingComponentOptions(node, context) {
+	let current = node;
+	while (current.parent) {
+		current = current.parent;
+		if (current.type === "ObjectExpression" && isComponentOptions(current, context)) return current;
+	}
+	return null;
+}
+function defaultComponentOptions(context) {
+	const owner = context.sourceCode.ast.body?.find((entry) => entry.type === "ExportDefaultDeclaration");
+	if (!owner) return null;
+	const declaration = unwrapExpression(owner.declaration);
+	if (!declaration) return "unknown";
+	if (declaration.type === "ObjectExpression") return declaration;
+	if (declaration.type !== "CallExpression" || !isImportedVueDefineComponent(declaration.callee, context)) return "unknown";
+	const options = unwrapExpression(declaration.arguments?.[0]);
+	return options?.type === "ObjectExpression" ? options : "unknown";
+}
+function isComponentOptions(options, context) {
+	const value = unwrapParent(options);
+	const owner = value.parent;
+	if (owner?.type === "ExportDefaultDeclaration" && owner.declaration === value) return true;
+	return owner?.type === "CallExpression" && owner.arguments?.[0] === value && isImportedVueDefineComponent(owner.callee, context);
+}
+function usesComponentThis(node, options) {
+	let current = node;
+	while (current.parent && current.parent !== options) {
+		current = current.parent;
+		if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression") return isDirectOptionsFunction(current, options);
+	}
+	return false;
+}
+function isDirectOptionsFunction(fn, options) {
+	const property = fn.parent;
+	if (property?.type !== "Property" || unwrapExpression(property.value) !== fn) return false;
+	if (property.parent === options) return true;
+	const section = property.parent;
+	const sectionProperty = section?.parent;
+	return section?.type === "ObjectExpression" && sectionProperty?.type === "Property" && unwrapExpression(sectionProperty.value) === section && sectionProperty.parent === options;
+}
+function staticPropertyName(property) {
+	return propertyName(property.key) ?? null;
+}
+function unwrapExpression(node) {
+	let value = node;
+	while (value && TRANSPARENT_EXPRESSIONS.has(value.type)) value = value.expression;
+	return value;
+}
+function unwrapParent(node) {
+	let value = node;
+	while (value.parent && TRANSPARENT_EXPRESSIONS.has(value.parent.type) && value.parent.expression === value) value = value.parent;
+	return value;
+}
+//#endregion
+//#region src/rules/vue/no-unsubscribed-t.ts
+function reportVueTranslationLifecycle(context, call, node, templateNodes, jsxOwners) {
+	if (call.origin === "vue-computed") {
+		if (!isOptionsComputedValue(node, context)) context.report({
+			node,
+			messageId: "misplacedTComputed"
+		});
+		return true;
+	}
+	if (call.origin !== "vue-ref") return false;
+	if (templateNodes.has(node)) {
+		if (!isVueTemplateEventHandler(node)) context.report({
+			node,
+			messageId: "renderTRef"
+		});
+		return true;
+	}
+	const section = vueOptionsSection(node, context);
+	if (section === "computed" || section === "data" || section === "methods") {
+		context.report({
+			node,
+			messageId: "optionsTRef"
+		});
+		return true;
+	}
+	if (section === "render") {
+		context.report({
+			node,
+			messageId: "renderTRef"
+		});
+		return true;
+	}
+	const owner = nearestFunction(node);
+	if (owner && jsxOwners.has(owner)) context.report({
+		node,
+		messageId: "renderTRef"
+	});
+	return true;
+}
+function reportUnsupportedVueInstanceTranslation(context, node, isVueFramework, inTemplate) {
+	if (!isVueFramework) return;
+	const name = vueInstanceTranslationMemberName(node);
+	if (!name) return;
+	const origin = resolveVueInstanceMemberOrigin(context, node, name, inTemplate);
+	if (origin === "local" || origin === "unknown" || origin === "not-component") return;
+	context.report({
+		node,
+		messageId: "unsupportedInstanceTranslation"
+	});
+}
+function vueInstanceTranslationMemberName(node) {
+	if (node.type !== "MemberExpression" || node.object.type !== "ThisExpression") return null;
+	const name = !node.computed && node.property.type === "Identifier" ? node.property.name : node.computed && node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : null;
+	return name === "t" || name === "$t" ? name : null;
+}
+//#endregion
+//#region src/rules/common/no-unsubscribed-t.ts
+const noUnsubscribedT = {
+	meta: {
+		type: "problem",
+		docs: { description: "检查组件渲染路径中的翻译 API 生命周期" },
+		schema: [{
+			type: "object",
+			properties: {
+				tsconfigPath: { type: "string" },
+				autoImport: { anyOf: [{ type: "boolean" }, {
+					type: "array",
+					items: { enum: [
+						"t",
+						"tRef",
+						"tComputed",
+						"useI18n"
+					] },
+					uniqueItems: true
+				}] },
+				framework: { enum: ["react", "vue"] }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			unsubscribedT: diagnosticMessage("组件渲染期间使用顶层 t 不会订阅语言状态，语言切换不会主动刷新，缓存的渲染结果也可能继续使用旧译文。请使用 useI18n() 返回的 t。", "Top-level t does not subscribe the component to language updates, so language changes do not trigger a render and cached render results may remain stale. Use the t returned by useI18n()."),
+			renderTRef: diagnosticMessage("不要在组件渲染或 template 中调用 tRef()，否则每次渲染都会创建新的 computed。请在 setup 中创建一次并使用返回的 Ref；Vue 渲染函数中请直接调用 t。", "Do not call tRef() during component rendering or in a template because each render creates a new computed. Create it once in setup and use the returned Ref; call t directly in Vue render functions."),
+			misplacedTComputed: diagnosticMessage("tComputed() 只应直接作为纯 Options API 的 computed 属性值使用，例如 computed: { label: tComputed(\"保存\") }。setup 中请使用 tRef()，template 或 render 中请直接使用 t()。", "Use tComputed() only as the direct value of a pure Options API computed property, for example computed: { label: tComputed(\"Save\") }. Use tRef() in setup, and call t() directly in templates or render functions."),
+			optionsTRef: diagnosticMessage("不要在纯 Options API 的 computed、data 或 methods 中调用 tRef()。computed 请直接使用 tComputed()，methods 请在执行时调用 t()；tRef() 仅用于 setup 或 composable。", "Do not call tRef() in pure Options API computed, data, or methods. Use tComputed() directly in computed properties, call t() when a method runs, and reserve tRef() for setup or composables."),
+			unsupportedInstanceTranslation: diagnosticMessage("ai-i18n 不支持把 Vue 组件实例成员 this.t / this.$t 当作翻译 API。请直接调用词法作用域中的 t()；开启自动导入时无需 import，关闭时请从 virtual:ai-i18n 显式导入。", "ai-i18n does not support Vue instance members this.t or this.$t as translation APIs. Call lexical t() directly; no import is needed with auto import enabled, otherwise import it from virtual:ai-i18n.")
+		}
+	},
+	create(context) {
+		const options = context.options[0] ?? {};
+		const candidates = [];
+		const jsxOwners = /* @__PURE__ */ new Set();
+		const templateNodes = /* @__PURE__ */ new Set();
+		const collectJsxOwner = (node) => {
+			const owner = nearestFunction(node);
+			if (owner) jsxOwners.add(owner);
+		};
+		const scriptVisitor = {
+			CallExpression(node) {
+				candidates.push({
+					kind: "call",
+					node
+				});
+			},
+			TaggedTemplateExpression(node) {
+				candidates.push({
+					kind: "tagged-template",
+					node
+				});
+			},
+			MemberExpression(node) {
+				reportUnsupportedVueInstanceTranslation(context, node, options.framework === "vue", false);
+			},
+			JSXElement: collectJsxOwner,
+			JSXFragment: collectJsxOwner,
+			"Program:exit"(program) {
+				let matches;
+				try {
+					matches = matchTranslationCalls(context, options, candidates);
+				} catch (error) {
+					reportAnalysisFailureOnce(context, program, error);
+					return;
+				}
+				for (const { call, node } of matches) {
+					if (reportVueTranslationLifecycle(context, call, node, templateNodes, jsxOwners)) continue;
+					if (call.origin !== "runtime") continue;
+					if (options.framework === "vue") continue;
+					if (templateNodes.has(node)) continue;
+					reportReactUnsubscribedT(context, call, node, jsxOwners);
+				}
+			}
+		};
+		const parserServices = context.sourceCode.parserServices;
+		if (!parserServices.defineTemplateBodyVisitor) return scriptVisitor;
+		return parserServices.defineTemplateBodyVisitor({
+			CallExpression(node) {
+				candidates.push({
+					kind: "call",
+					node
+				});
+				templateNodes.add(node);
+			},
+			TaggedTemplateExpression(node) {
+				candidates.push({
+					kind: "tagged-template",
+					node
+				});
+				templateNodes.add(node);
+			},
+			MemberExpression(node) {
+				reportUnsupportedVueInstanceTranslation(context, node, options.framework === "vue", true);
+			}
+		}, scriptVisitor, { templateBodyTriggerSelector: "Program" });
+	}
+};
+//#endregion
+//#region src/rules/common/static-candidate-limit.ts
+const staticCandidateLimit = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "警告单个翻译调用展开的静态候选数量过多" },
+		schema: [{
+			type: "object",
+			properties: {
+				tsconfigPath: { type: "string" },
+				autoImport: { anyOf: [{ type: "boolean" }, {
+					type: "array",
+					items: { enum: [
+						"t",
+						"tRef",
+						"tComputed",
+						"useI18n"
+					] },
+					uniqueItems: true
+				}] },
+				maxStaticCandidates: {
+					type: "integer",
+					minimum: 1,
+					maximum: Number.MAX_SAFE_INTEGER
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: { candidateLimit: "{{reason}}" }
+	},
+	create(context) {
+		const options = context.options[0] ?? {};
+		return { "Program:exit"(node) {
+			try {
+				const warnings = analyzeRuleContext(context, options, options.maxStaticCandidates ?? 1e3);
+				for (const warning of warnings) {
+					if (warning.code !== "static-candidate-limit") continue;
+					context.report({
+						node,
+						loc: {
+							start: warning,
+							end: {
+								line: warning.line,
+								column: warning.column + 1
+							}
+						},
+						messageId: "candidateLimit",
+						data: { reason: warning.message }
+					});
+				}
+			} catch (error) {
+				reportAnalysisFailureOnce(context, node, error);
+			}
+		} };
+	}
+};
+//#endregion
+//#region src/rules/common/t-static-args.ts
 const tStaticArgs = {
 	meta: {
 		type: "problem",
-		docs: { description: "要求 virtual:ai-i18n 的 t() 参数可被静态提取" },
+		docs: { description: "要求 virtual:ai-i18n 的翻译 API 参数可被静态提取" },
 		schema: [{
 			type: "object",
 			properties: {
 				tsconfigPath: { type: "string" },
-				autoImport: { type: "boolean" }
+				autoImport: { anyOf: [{ type: "boolean" }, {
+					type: "array",
+					items: { enum: [
+						"t",
+						"tRef",
+						"tComputed",
+						"useI18n"
+					] },
+					uniqueItems: true
+				}] }
 			},
 			additionalProperties: false
 		}],
 		messages: {
-			analysisFailed: "ai-i18n 静态分析失败：{{reason}}",
-			dynamicArg: "t() 参数无法静态提取，请使用字符串字面量、静态模板、条件表达式或可解析的 const 字符串。"
+			analysisFailed: "{{reason}}",
+			dynamicArg: "{{reason}}",
+			invalidUsage: "{{reason}}"
 		}
 	},
 	create(context) {
@@ -199,26 +1581,14 @@ const tStaticArgs = {
 		return { "Program:exit"(node) {
 			let warnings;
 			try {
-				const source = context.filename.endsWith(".vue") ? createVueAnalysisSource(context.sourceCode.text, context.filename, context.sourceCode.parserServices) : {
-					code: context.sourceCode.text,
-					lang: void 0,
-					mapLocation: (location) => location
-				};
-				warnings = analyzeStaticArgs(source.code, context.filename, options.tsconfigPath, source.lang, options.autoImport);
-				warnings = warnings.map((warning) => ({
-					...warning,
-					...source.mapLocation(warning)
-				}));
+				warnings = analyzeRuleContext(context, options);
 			} catch (error) {
-				context.report({
-					node,
-					messageId: "analysisFailed",
-					data: { reason: error instanceof Error ? error.message : String(error) }
-				});
+				reportAnalysisFailureOnce(context, node, error);
 				return;
 			}
 			for (const warning of warnings) {
 				const analysisFailed = warning.code === "parse-error";
+				const invalidUsage = warning.code !== "dynamic-argument" && warning.code !== "unresolved-argument" && !analysisFailed;
 				context.report({
 					node,
 					loc: {
@@ -228,8 +1598,8 @@ const tStaticArgs = {
 							column: warning.column + 1
 						}
 					},
-					messageId: analysisFailed ? "analysisFailed" : "dynamicArg",
-					...analysisFailed ? { data: { reason: warning.message } } : {}
+					messageId: analysisFailed ? "analysisFailed" : invalidUsage ? "invalidUsage" : "dynamicArg",
+					data: { reason: analysisFailed ? diagnosticMessage(`静态分析失败：${warning.message}`, `Static analysis failed: ${warning.message}`) : invalidUsage ? warning.message : diagnosticMessage("翻译调用的参数无法静态提取。source 请使用静态字符串，options 请使用只包含 comment 的静态对象。", "The translation-call arguments cannot be statically extracted. Use a static string for source and a static object containing only comment for options.") }
 				});
 			}
 		} };
@@ -244,39 +1614,129 @@ const plugin = {
 		version,
 		namespace: "ai-i18n"
 	},
-	rules: { "t-static-args": tStaticArgs },
+	rules: {
+		"no-embedded-markup": noEmbeddedMarkup,
+		"no-eager-translation": noEagerTranslation,
+		"no-redundant-auto-import": noRedundantAutoImport,
+		"no-unsubscribed-runtime-state": noUnsubscribedRuntimeState,
+		"no-unsubscribed-t": noUnsubscribedT,
+		"static-candidate-limit": staticCandidateLimit,
+		"t-static-args": tStaticArgs
+	},
 	configs: {}
 };
 plugin.configs.recommended = [{
-	ignores: ["**/*.vue"],
+	ignores: ["**/*.{vue,cjs,cts}"],
 	plugins: { "ai-i18n": plugin },
-	rules: { "ai-i18n/t-static-args": "error" }
+	languageOptions: { globals: { defineI18nMessages: "readonly" } },
+	rules: {
+		"ai-i18n/t-static-args": "error",
+		"ai-i18n/no-embedded-markup": "warn",
+		"ai-i18n/no-eager-translation": "warn",
+		"ai-i18n/no-unsubscribed-runtime-state": "warn",
+		"ai-i18n/no-unsubscribed-t": "warn",
+		"ai-i18n/static-candidate-limit": "warn"
+	}
 }];
 plugin.configs.vue = [{
-	files: ["**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx,vue}"],
+	files: ["**/*.{js,mjs,ts,mts,jsx,tsx,vue}"],
 	plugins: { "ai-i18n": plugin },
-	languageOptions: { globals: { useI18n: "readonly" } },
-	rules: { "ai-i18n/t-static-args": ["error", { autoImport: true }] }
+	languageOptions: { globals: { defineI18nMessages: "readonly" } },
+	rules: {
+		"ai-i18n/t-static-args": "error",
+		"ai-i18n/no-embedded-markup": "warn",
+		"ai-i18n/no-eager-translation": ["warn", { framework: "vue" }],
+		"ai-i18n/no-unsubscribed-runtime-state": ["warn", { framework: "vue" }],
+		"ai-i18n/no-unsubscribed-t": ["warn", { framework: "vue" }],
+		"ai-i18n/static-candidate-limit": "warn"
+	}
 }];
-plugin.configs.react = [{
-	files: ["**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+plugin.configs["vanilla-auto-import"] = [{
+	files: ["**/*.{js,mjs,ts,mts}"],
 	plugins: { "ai-i18n": plugin },
-	languageOptions: { globals: { useI18n: "readonly" } },
-	rules: { "ai-i18n/t-static-args": ["error", { autoImport: true }] }
+	languageOptions: { globals: {
+		...Object.fromEntries(RUNTIME_AUTO_IMPORTS.map((name) => [name, "readonly"])),
+		defineI18nMessages: "readonly"
+	} },
+	rules: {
+		"ai-i18n/t-static-args": ["error", { autoImport: ["t"] }],
+		"ai-i18n/no-embedded-markup": ["warn", { autoImport: ["t"] }],
+		"ai-i18n/no-eager-translation": ["warn", { autoImport: ["t"] }],
+		"ai-i18n/no-unsubscribed-runtime-state": ["warn", { autoImport: ["getLang", "getLangLoadState"] }],
+		"ai-i18n/static-candidate-limit": ["warn", { autoImport: ["t"] }]
+	}
+}];
+plugin.configs["vue-auto-import"] = [{
+	files: ["**/*.{js,mjs,ts,mts,jsx,tsx,vue}"],
+	plugins: { "ai-i18n": plugin },
+	languageOptions: { globals: {
+		...Object.fromEntries(VUE_AUTO_IMPORTS.map((name) => [name, "readonly"])),
+		defineI18nMessages: "readonly"
+	} },
+	rules: {
+		"ai-i18n/t-static-args": ["error", { autoImport: [
+			"t",
+			"tRef",
+			"tComputed",
+			"useI18n"
+		] }],
+		"ai-i18n/no-embedded-markup": ["warn", { autoImport: [
+			"t",
+			"tRef",
+			"tComputed",
+			"useI18n"
+		] }],
+		"ai-i18n/no-eager-translation": ["warn", {
+			autoImport: [
+				"t",
+				"tRef",
+				"tComputed",
+				"useI18n"
+			],
+			framework: "vue"
+		}],
+		"ai-i18n/no-unsubscribed-runtime-state": ["warn", {
+			autoImport: [
+				"getLang",
+				"getLangLoadState",
+				"i18nComputed"
+			],
+			framework: "vue"
+		}],
+		"ai-i18n/no-unsubscribed-t": ["warn", {
+			autoImport: [
+				"t",
+				"tRef",
+				"tComputed",
+				"useI18n"
+			],
+			framework: "vue"
+		}],
+		"ai-i18n/static-candidate-limit": ["warn", { autoImport: [
+			"t",
+			"tRef",
+			"tComputed",
+			"useI18n"
+		] }]
+	}
 }];
-plugin.configs.vanilla = [{
-	files: ["**/*.{js,mjs,cjs,ts,mts,cts}"],
+plugin.configs["react-auto-import"] = [{
+	files: ["**/*.{js,mjs,ts,mts,jsx,tsx}"],
 	plugins: { "ai-i18n": plugin },
 	languageOptions: { globals: {
-		t: "readonly",
-		setLang: "readonly",
-		getLang: "readonly",
-		getLangs: "readonly",
-		subscribe: "readonly"
+		...Object.fromEntries(REACT_AUTO_IMPORTS.map((name) => [name, "readonly"])),
+		defineI18nMessages: "readonly"
 	} },
-	rules: { "ai-i18n/t-static-args": ["error", { autoImport: true }] }
+	rules: {
+		"ai-i18n/t-static-args": ["error", { autoImport: ["t", "useI18n"] }],
+		"ai-i18n/no-embedded-markup": ["warn", { autoImport: ["t", "useI18n"] }],
+		"ai-i18n/no-eager-translation": ["warn", { autoImport: ["t", "useI18n"] }],
+		"ai-i18n/no-unsubscribed-runtime-state": ["warn", { autoImport: ["getLang", "getLangLoadState"] }],
+		"ai-i18n/no-unsubscribed-t": ["warn", { autoImport: ["t", "useI18n"] }],
+		"ai-i18n/static-candidate-limit": ["warn", { autoImport: ["t", "useI18n"] }]
+	}
 }];
 //#endregion
-export { plugin as default, tStaticArgs };
+export { plugin as default, noEagerTranslation, noEmbeddedMarkup, noRedundantAutoImport, noUnsubscribedRuntimeState, noUnsubscribedT, staticCandidateLimit, tStaticArgs };
 
 //# sourceMappingURL=index.js.map