From 9c908781ea305a3d2f9e817a591846b2859bf43d Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Mon, 29 Dec 2025 13:39:10 +0300
Subject: [PATCH 01/11] wip

---
 packages/astro-language/package.json          |  37 ++
 packages/astro-language/src/index.ts          | 428 +++++++++++++++
 .../src/rules/anyReturns.test.ts              |  40 ++
 .../astro-language/src/rules/ruleTester.ts    |  14 +
 packages/astro-language/tsconfig.json         |  13 +
 packages/core/src/index.ts                    |   1 +
 .../core/src/ts-patch/install-patch-hooks.ts  |   4 +-
 packages/ts/src/index.ts                      |   1 +
 packages/vue-language/package.json            |  38 ++
 packages/vue-language/src/index.ts            |   2 +
 packages/vue-language/src/language.ts         | 492 ++++++++++++++++++
 packages/vue-language/src/plugin.ts           |  13 +
 .../vue-language/src/rules/MyComponent.vue    |   5 +
 .../vue-language/src/rules/anyReturns.test.ts |  98 ++++
 .../src/rules/asyncComputed.test.ts           | 414 +++++++++++++++
 .../vue-language/src/rules/asyncComputed.ts   |  93 ++++
 .../src/rules/debuggerStatements.test.ts      |  78 +++
 packages/vue-language/src/rules/fixture.ts    |   1 +
 packages/vue-language/src/rules/ruleTester.ts |  14 +
 .../src/rules/scriptSetupExports.test.ts      | 285 ++++++++++
 .../src/rules/scriptSetupExports.ts           |  79 +++
 .../vue-language/src/rules/vForKey.test.ts    | 464 +++++++++++++++++
 packages/vue-language/src/rules/vForKey.ts    | 261 ++++++++++
 packages/vue-language/tsconfig.json           |  13 +
 pnpm-lock.yaml                                | 422 ++++++++++++++-
 tsconfig.json                                 |   2 +
 26 files changed, 3309 insertions(+), 3 deletions(-)
 create mode 100644 packages/astro-language/package.json
 create mode 100644 packages/astro-language/src/index.ts
 create mode 100644 packages/astro-language/src/rules/anyReturns.test.ts
 create mode 100644 packages/astro-language/src/rules/ruleTester.ts
 create mode 100644 packages/astro-language/tsconfig.json
 create mode 100644 packages/vue-language/package.json
 create mode 100644 packages/vue-language/src/index.ts
 create mode 100644 packages/vue-language/src/language.ts
 create mode 100644 packages/vue-language/src/plugin.ts
 create mode 100644 packages/vue-language/src/rules/MyComponent.vue
 create mode 100644 packages/vue-language/src/rules/anyReturns.test.ts
 create mode 100644 packages/vue-language/src/rules/asyncComputed.test.ts
 create mode 100644 packages/vue-language/src/rules/asyncComputed.ts
 create mode 100644 packages/vue-language/src/rules/debuggerStatements.test.ts
 create mode 100644 packages/vue-language/src/rules/fixture.ts
 create mode 100644 packages/vue-language/src/rules/ruleTester.ts
 create mode 100644 packages/vue-language/src/rules/scriptSetupExports.test.ts
 create mode 100644 packages/vue-language/src/rules/scriptSetupExports.ts
 create mode 100644 packages/vue-language/src/rules/vForKey.test.ts
 create mode 100644 packages/vue-language/src/rules/vForKey.ts
 create mode 100644 packages/vue-language/tsconfig.json

diff --git a/packages/astro-language/package.json b/packages/astro-language/package.json
new file mode 100644
index 000000000..f782d025f
--- /dev/null
+++ b/packages/astro-language/package.json
@@ -0,0 +1,37 @@
+{
+	"name": "@flint.fyi/astro-language",
+	"version": "0.0.1",
+	"description": "[Experimental] TypeScript language plugin for Flint.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/JoshuaKGoldberg/flint",
+		"directory": "packages/ts"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "JoshuaKGoldberg",
+		"email": "npm@joshuakgoldberg.com"
+	},
+	"type": "module",
+	"main": "./lib/index.js",
+	"dependencies": {
+		"@astrojs/language-server": "^2.16.2",
+		"@flint.fyi/core": "workspace:",
+		"@flint.fyi/ts": "workspace:",
+		"@volar/language-core": "2.4.27",
+		"@volar/typescript": "2.4.27",
+		"ts-api-utils": "^2.1.0",
+		"typescript": ">=5.9.3",
+		"vscode-uri": "^3.1.0"
+	},
+	"devDependencies": {
+		"@flint.fyi/rule-tester": "workspace:"
+	},
+	"engines": {
+		"node": ">=24.0.0"
+	},
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	}
+}
diff --git a/packages/astro-language/src/index.ts b/packages/astro-language/src/index.ts
new file mode 100644
index 000000000..355f67c42
--- /dev/null
+++ b/packages/astro-language/src/index.ts
@@ -0,0 +1,428 @@
+import {
+	LanguagePlugin as VolarLanguagePlugin,
+	Language as VolarLanguage,
+	Mapper as VolarMapper,
+	CodegenContext as VolarCodegenContext,
+} from "@volar/language-core";
+import {
+	AstroVirtualCode,
+	getAstroLanguagePlugin,
+} from "@astrojs/language-server/dist/core/index.js";
+import {
+	convertTypeScriptDiagnosticToLanguageFileDiagnostic,
+	extractDirectivesFromTypeScriptFile,
+	NodeSyntaxKinds,
+	prepareTypeScriptBasedLanguage,
+	prepareTypeScriptFile,
+	TSNodesByName,
+	TypeScriptBasedLanguageFile,
+	TypeScriptFileServices,
+} from "@flint.fyi/ts";
+// for LanguagePlugin interface augmentation
+import "@volar/typescript";
+import { URI } from "vscode-uri";
+
+import {
+	CharacterReportRange,
+	createLanguage,
+	DirectivesCollector,
+	getColumnAndLineOfPosition,
+	isSuggestionForFiles,
+	LanguagePreparedDefinition,
+	NormalizedReport,
+	NormalizedReportRangeObject,
+	RuleContext,
+	setTSExtraSupportedExtensions,
+	setTSProgramCreationProxy,
+	SourceFileWithLineMap,
+} from "@flint.fyi/core";
+import { proxyCreateProgram } from "@volar/typescript/lib/node/proxyCreateProgram.js";
+import ts from "typescript";
+
+type ProxiedTSProgram = ts.Program & {
+	__flintVolarLanguage?: undefined | VolarLanguage<string>;
+};
+
+setTSExtraSupportedExtensions([".astro"]);
+setTSProgramCreationProxy(
+	(ts, createProgram) =>
+		new Proxy(function () {} as unknown as typeof createProgram, {
+			apply(target, thisArg, args) {
+				let volarLanguage = null as null | VolarLanguage<string>;
+				const proxied = proxyCreateProgram(ts, createProgram, (ts, options) => {
+					const {
+						getLanguageId,
+						createVirtualCode,
+						updateVirtualCode,
+						disposeVirtualCode,
+						isAssociatedFileOnly,
+						typescript,
+					} = getAstroLanguagePlugin();
+					const languagePlugin: VolarLanguagePlugin<string, AstroVirtualCode> =
+						{
+							getLanguageId(scriptId) {
+								return getLanguageId(URI.file(scriptId));
+							},
+							createVirtualCode(scriptId, languageId, snapshot) {
+								// astro never touches ctx
+								const ctx = {} as VolarCodegenContext<URI>;
+								return createVirtualCode?.(
+									URI.file(scriptId),
+									languageId,
+									snapshot,
+									ctx,
+								);
+							},
+							updateVirtualCode(scriptId, virtualCode, newSnapshot) {
+								// astro never touches ctx
+								const ctx = {} as VolarCodegenContext<URI>;
+								return updateVirtualCode?.(
+									URI.file(scriptId),
+									virtualCode,
+									newSnapshot,
+									ctx,
+								);
+							},
+							disposeVirtualCode(scriptId, virtualCode) {
+								return disposeVirtualCode?.(URI.file(scriptId), virtualCode);
+							},
+							...(isAssociatedFileOnly != null && {
+								isAssociatedFileOnly(scriptId, languageId): boolean {
+									return isAssociatedFileOnly(URI.file(scriptId), languageId);
+								},
+							}),
+							typescript,
+						};
+					if (languagePlugin.typescript != null) {
+						const { getServiceScript } = languagePlugin.typescript;
+						// getExtraServiceScripts() is not available in this use case.
+						delete languagePlugin.typescript.getExtraServiceScripts;
+						languagePlugin.typescript.getServiceScript = (root) => {
+							const script = getServiceScript(root);
+							if (script == null) {
+								return script;
+							}
+							return {
+								...script,
+								// Leading offset is useful for LanguageService [1], but we don't use it.
+								// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
+								// have to provide it ourselves.
+								//
+								// [1] https://github.com/volarjs/volar.js/discussions/188
+								// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
+								preventLeadingOffset: true,
+							};
+						};
+					}
+					return {
+						languagePlugins: [languagePlugin],
+						setup: (lang) => (volarLanguage = lang),
+					};
+				});
+
+				const program: ProxiedTSProgram = Reflect.apply(proxied, thisArg, args);
+
+				if (volarLanguage == null) {
+					throw new Error("Flint bug: volarLanguage is not defined");
+				}
+
+				if (program.__flintVolarLanguage != null) {
+					return program;
+				}
+
+				program.__flintVolarLanguage = volarLanguage;
+				return program;
+			},
+		}),
+);
+
+export interface AstroServices extends TypeScriptFileServices {
+	astroServices?: {
+		// codegen: VueCodegen;
+		// map: VolarMapper;
+		// sfc: RootNode;
+		// virtualCode: VueVirtualCode;
+		// // TODO: can we type MessageId?
+		// reportSfc: RuleReporter<string>;
+	};
+}
+
+export const astroLanguage = createLanguage<TSNodesByName, AstroServices>({
+	about: {
+		name: "Astro",
+	},
+	prepare: () => {
+		const tsLang = prepareTypeScriptBasedLanguage();
+
+		return {
+			prepareFromDisk: (filePathAbsolute) => {
+				return prepareAstroFile(
+					filePathAbsolute,
+					tsLang.createFromDisk(filePathAbsolute),
+				);
+			},
+			prepareFromVirtual: (filePathAbsolute, sourceText) => {
+				return prepareAstroFile(
+					filePathAbsolute,
+					tsLang.createFromVirtual(filePathAbsolute, sourceText),
+				);
+			},
+		};
+	},
+});
+
+function prepareAstroFile(
+	filePathAbsolute: string,
+	tsFile: TypeScriptBasedLanguageFile,
+): LanguagePreparedDefinition {
+	const { program, sourceFile, [Symbol.dispose]: onDispose } = tsFile;
+
+	// @ts-expect-error
+	const volarLanguage: VolarLanguage = program.__flintVolarLanguage;
+
+	if (volarLanguage == null) {
+		throw new Error(
+			"'typescript' package wasn't properly patched. Make sure you don't import 'typescript' before Flint.",
+		);
+	}
+
+	const sourceScript = volarLanguage.scripts.get(filePathAbsolute);
+	if (sourceScript == null) {
+		throw new Error("Expected sourceScript to be set");
+	}
+	if (sourceScript.languageId !== "astro") {
+		return prepareTypeScriptFile({
+			program,
+			sourceFile,
+			[Symbol.dispose]: onDispose,
+		});
+	}
+	if (sourceScript.generated == null) {
+		throw new Error("Expected sourceScript.generated to be set");
+	}
+	if (sourceScript.snapshot == null) {
+		throw new Error("Expected sourceScript.snapshot to be set");
+	}
+	if (sourceScript.generated.languagePlugin.typescript == null) {
+		throw new Error(
+			"Expected sourceScript.generated.languagePlugin.typescript to be set",
+		);
+	}
+
+	const sourceText = sourceScript.snapshot.getText(
+		0,
+		sourceScript.snapshot.getLength(),
+	);
+	const sourceTextWithLineMap: SourceFileWithLineMap = {
+		text: sourceText,
+	};
+	function normalizeSourceRange(
+		range: CharacterReportRange,
+	): NormalizedReportRangeObject {
+		return {
+			begin: getColumnAndLineOfPosition(sourceTextWithLineMap, range.begin),
+			end: getColumnAndLineOfPosition(sourceTextWithLineMap, range.end),
+		};
+	}
+
+	const serviceScript =
+		sourceScript.generated.languagePlugin.typescript.getServiceScript(
+			sourceScript.generated.root,
+		);
+	if (serviceScript == null) {
+		throw new Error("Expected serviceScript to exist");
+	}
+
+	const virtualCode = sourceScript.generated.root as AstroVirtualCode;
+	// const codegen = tsCodegen.get(virtualCode.sfc);
+	// if (codegen == null) {
+	// 	throw new Error("Expected codegen to exist");
+	// }
+
+	const map = volarLanguage.maps.get(serviceScript.code, sourceScript);
+	const sortedMappings = map.mappings.toSorted(
+		(a, b) => a.generatedOffsets[0] - b.generatedOffsets[0],
+	);
+
+	// const sfcAst = vueParse(sourceText, {
+	// 	comments: true,
+	// 	expressionPlugins: ["typescript"],
+	// 	parseMode: "html",
+	// 	// We ignore errors because virtual code already provides them,
+	// 	// and it also provides them with sourceText-based locations,
+	// 	// so we don't have to remap them. Oh, and it also contains errors from
+	// 	// other blocks rather than only <template> as well.
+	// 	// If we don't provide this callback, @vue/compiler-core will throw.
+	// 	onError: () => {},
+	// });
+
+	return {
+		file: {
+			...(onDispose != null && { [Symbol.dispose]: onDispose }),
+			getDiagnostics() {
+				return [
+					...ts.getPreEmitDiagnostics(program, sourceFile).map((diagnostic) =>
+						convertTypeScriptDiagnosticToLanguageFileDiagnostic({
+							...diagnostic,
+							// For some unknown reason, Volar doesn't set file.text to sourceText
+							// when preventLeadingOffset is true, so we have to do it ourselves
+							// https://github.com/volarjs/volar.js/blob/4a9d25d797d08d9c149bebf0f52ac5e172f4757d/packages/typescript/lib/node/transform.ts#L102
+							file: diagnostic.file
+								? {
+										fileName: diagnostic.file.fileName,
+										text: sourceText,
+									}
+								: diagnostic.file,
+						}),
+					),
+					// ...(virtualCode.vueSfc?.errors ?? []).map((e) => {
+					// 	const fileName = sourceFile.fileName.startsWith("./")
+					// 		? sourceFile.fileName.slice(2)
+					// 		: sourceFile.fileName.slice(process.cwd().length + 1);
+					// 	let code = "VUE";
+					// 	let loc = "";
+					// 	if ("code" in e) {
+					// 		// TODO: think about codes
+					// 		code += "999999" + e.code.toString();
+					// 		loc =
+					// 			e.loc != null
+					// 				? `:${e.loc?.start.line}:${e.loc?.start.column}`
+					// 				: "";
+					// 	}
+					// 	return {
+					// 		code,
+					// 		text: `${fileName}${loc} - ${code}: ${e.name} - ${e.message}`,
+					// 	};
+					// }),
+				];
+			},
+			async runRule(rule, options) {
+				const reports: NormalizedReport[] = [];
+				const context: RuleContext<string> & AstroServices = {
+					program,
+					report: (report) => {
+						const reportRange = translateRange(
+							map,
+							report.range.begin,
+							report.range.end,
+						);
+						if (reportRange == null) {
+							return;
+						}
+
+						const translatedReport: NormalizedReport = {
+							...report,
+							fix:
+								report.fix && !Array.isArray(report.fix)
+									? [report.fix]
+									: report.fix,
+							message: rule.messages[report.message],
+							range: normalizeSourceRange(reportRange),
+						};
+
+						for (const suggestion of translatedReport.suggestions ?? []) {
+							if (isSuggestionForFiles(suggestion)) {
+								throw new Error(
+									"TODO: vue - suggestions for multiple files are not yet supported",
+								);
+							}
+							const range = translateRange(
+								map,
+								suggestion.range.begin,
+								suggestion.range.end,
+							);
+							if (range == null) {
+								// TODO: maybe we should filter out these suggestions intead of erroring?
+								throw new Error("Suggestion range overlaps with virtual code");
+							}
+							suggestion.range = range;
+						}
+
+						reports.push(translatedReport);
+					},
+					sourceFile,
+					typeChecker: program.getTypeChecker(),
+					// vueServices: {
+					// 	codegen,
+					// 	map,
+					// 	reportSfc: (report: RuleReport) => {
+					// 		reports.push({
+					// 			...report,
+					// 			fix:
+					// 				report.fix && !Array.isArray(report.fix)
+					// 					? [report.fix]
+					// 					: report.fix,
+					// 			message: rule.messages[report.message],
+					// 			range: normalizeSourceRange(report.range),
+					// 		});
+					// 	},
+					// 	sfc: sfcAst,
+					// 	virtualCode,
+					// },
+				};
+
+				const runtime = await rule.setup(context, options);
+
+				if (runtime?.visitors) {
+					const { visitors } = runtime;
+					let lastMappingIdx = 0;
+					const visit = (node: ts.Node) => {
+						visitors[NodeSyntaxKinds[node.kind]]?.(node, context);
+
+						node.forEachChild(visit);
+					};
+					// Visit only statements that have a mapping to the source code
+					// to avoid doing extra work
+					Statements: for (const statement of sourceFile.statements) {
+						while (true) {
+							const currentMapping = sortedMappings[lastMappingIdx];
+							if (currentMapping == null) {
+								break Statements;
+							}
+							const currentMappingLength =
+								currentMapping.generatedLengths?.[0] ??
+								currentMapping.lengths[0];
+							if (
+								currentMappingLength === 0 ||
+								statement.pos >=
+									currentMapping.generatedOffsets[0] + currentMappingLength
+							) {
+								lastMappingIdx++;
+								continue;
+							}
+							if (statement.end <= currentMapping.generatedOffsets[0]) {
+								continue Statements;
+							}
+							break;
+						}
+
+						visit(statement);
+					}
+					visit(sourceFile.endOfFileToken);
+				}
+
+				await runtime?.teardown?.();
+
+				return reports;
+			},
+		},
+	};
+}
+
+function translateRange(
+	map: VolarMapper,
+	serviceBegin: number,
+	serviceEnd: number,
+): null | { begin: number; end: number } {
+	for (const [begin, end] of map.toSourceRange(
+		serviceBegin,
+		serviceEnd,
+		true,
+	)) {
+		if (begin === end) {
+			continue;
+		}
+		return { begin, end };
+	}
+	return null;
+}
diff --git a/packages/astro-language/src/rules/anyReturns.test.ts b/packages/astro-language/src/rules/anyReturns.test.ts
new file mode 100644
index 000000000..2fcb5d49b
--- /dev/null
+++ b/packages/astro-language/src/rules/anyReturns.test.ts
@@ -0,0 +1,40 @@
+import rule from "../../../ts/lib/rules/anyReturns.js";
+import { astroLanguage } from "../index.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(astroLanguage.createRule(rule), {
+	invalid: [
+		{
+			code: `
+---
+type bar = 1
+function foo() {
+	return 1 as any
+}
+---
+			`,
+			snapshot: `
+---
+type bar = 1
+function foo() {
+	return 1 as any
+	~~~~~~~~~~~~~~~
+	Unsafe return of a value of type \`any\`.
+}
+---
+			`,
+		},
+	],
+	valid: [
+		{
+			code: `
+---
+type bar = 1
+function foo() {
+	return 1
+}
+---
+		`,
+		},
+	],
+});
diff --git a/packages/astro-language/src/rules/ruleTester.ts b/packages/astro-language/src/rules/ruleTester.ts
new file mode 100644
index 000000000..80b290b77
--- /dev/null
+++ b/packages/astro-language/src/rules/ruleTester.ts
@@ -0,0 +1,14 @@
+import path from "node:path";
+
+import { RuleTester } from "@flint.fyi/rule-tester";
+import { describe, it } from "vitest";
+
+const fileName = path.join(import.meta.dirname, "file.astro");
+
+export const ruleTester = new RuleTester({
+	describe,
+	it,
+	defaults: {
+		fileName,
+	},
+});
diff --git a/packages/astro-language/tsconfig.json b/packages/astro-language/tsconfig.json
new file mode 100644
index 000000000..55ddcc02e
--- /dev/null
+++ b/packages/astro-language/tsconfig.json
@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"outDir": "lib",
+		"rootDir": "src"
+	},
+	"extends": "../../tsconfig.base.json",
+	"include": ["src"],
+	"references": [
+		{ "path": "../core" },
+		{ "path": "../ts" },
+		{ "path": "../rule-tester" }
+	]
+}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 4aff08115..789c15ad3 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -20,6 +20,7 @@ export * from "./types/about.js";
 export * from "./types/cache.js";
 export * from "./types/changes.js";
 export * from "./types/configs.js";
+export * from "./types/context.js";
 export * from "./types/directives.js";
 export * from "./types/formatting.js";
 export * from "./types/languages.js";
diff --git a/packages/core/src/ts-patch/install-patch-hooks.ts b/packages/core/src/ts-patch/install-patch-hooks.ts
index baa624242..4fb6e6207 100644
--- a/packages/core/src/ts-patch/install-patch-hooks.ts
+++ b/packages/core/src/ts-patch/install-patch-hooks.ts
@@ -11,14 +11,14 @@ registerHooks({
 		if (
 			url !== typescriptUrl ||
 			next.source == null ||
-			typeof next.source !== "string"
+			!(next.source instanceof Buffer)
 		) {
 			return next;
 		}
 
 		return {
 			...next,
-			source: transformTscContent(next.source),
+			source: transformTscContent(next.source.toString()),
 		};
 	},
 });
diff --git a/packages/ts/src/index.ts b/packages/ts/src/index.ts
index d801bbae1..cc4b80ff5 100644
--- a/packages/ts/src/index.ts
+++ b/packages/ts/src/index.ts
@@ -16,6 +16,7 @@ export {
 	TypeScriptBasedLanguageFile,
 	TypeScriptBasedLanguageFileFactoryDefinition,
 } from "./prepareTypeScriptBasedLanguage.js";
+export { prepareTypeScriptFile } from "./prepareTypeScriptFile.js";
 export { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
 export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
 export { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
diff --git a/packages/vue-language/package.json b/packages/vue-language/package.json
new file mode 100644
index 000000000..27f3491b2
--- /dev/null
+++ b/packages/vue-language/package.json
@@ -0,0 +1,38 @@
+{
+	"name": "@flint.fyi/vue-language",
+	"version": "0.0.1",
+	"description": "[Experimental] TypeScript language plugin for Flint.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/JoshuaKGoldberg/flint",
+		"directory": "packages/ts"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "JoshuaKGoldberg",
+		"email": "npm@joshuakgoldberg.com"
+	},
+	"type": "module",
+	"main": "./lib/index.js",
+	"dependencies": {
+		"@flint.fyi/core": "workspace:",
+		"@flint.fyi/ts": "workspace:",
+		"@volar/language-core": "2.4.27",
+		"@volar/typescript": "2.4.27",
+		"@vue/compiler-dom": "^3.5.0",
+		"@vue/language-core": "3.2.1",
+		"ts-api-utils": "^2.1.0",
+		"typescript": ">=5.9.3"
+	},
+	"devDependencies": {
+		"@flint.fyi/rule-tester": "workspace:",
+		"vue": "~3.5.26"
+	},
+	"engines": {
+		"node": ">=24.0.0"
+	},
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	}
+}
diff --git a/packages/vue-language/src/index.ts b/packages/vue-language/src/index.ts
new file mode 100644
index 000000000..87a1724fa
--- /dev/null
+++ b/packages/vue-language/src/index.ts
@@ -0,0 +1,2 @@
+export { vueLanguage, vueWrapRules } from "./language.js";
+export * from "./plugin.js";
diff --git a/packages/vue-language/src/language.ts b/packages/vue-language/src/language.ts
new file mode 100644
index 000000000..f4d9d2489
--- /dev/null
+++ b/packages/vue-language/src/language.ts
@@ -0,0 +1,492 @@
+import {
+	CharacterReportRange,
+	createLanguage,
+	DirectivesCollector,
+	getColumnAndLineOfPosition,
+	isSuggestionForFiles,
+	LanguagePreparedDefinition,
+	NormalizedReport,
+	NormalizedReportRangeObject,
+	RuleContext,
+	RuleReport,
+	RuleReporter,
+	setTSExtraSupportedExtensions,
+	setTSProgramCreationProxy,
+	SourceFileWithLineMap,
+} from "@flint.fyi/core";
+import {
+	Language as VolarLanguage,
+	Mapper as VolarMapper,
+} from "@volar/language-core";
+import {
+	parse as vueParse,
+	NodeTypes,
+	RootNode,
+	TemplateChildNode,
+} from "@vue/compiler-dom";
+import {
+	createVueLanguagePlugin,
+	createParsedCommandLine as createVueParsedCommandLine,
+	createParsedCommandLineByJson as createVueParsedCommandLineByJson,
+	tsCodegen,
+	VueCompilerOptions,
+	VueVirtualCode,
+} from "@vue/language-core";
+// for LanguagePlugin interface augmentation
+import "@volar/typescript";
+import {
+	collectTypeScriptFileCacheImpacts,
+	convertTypeScriptDiagnosticToLanguageFileDiagnostic,
+	extractDirectivesFromTypeScriptFile,
+	NodeSyntaxKinds,
+	prepareTypeScriptBasedLanguage,
+	prepareTypeScriptFile,
+	TSNodesByName,
+	TypeScriptBasedLanguageFile,
+	TypeScriptFileServices,
+} from "@flint.fyi/ts";
+import { proxyCreateProgram } from "@volar/typescript/lib/node/proxyCreateProgram.js";
+import ts from "typescript";
+
+type ProxiedTSProgram = ts.Program & {
+	__flintVolarLanguage?: undefined | VolarLanguage<string>;
+};
+
+// TODO: css
+
+setTSExtraSupportedExtensions([".vue"]);
+setTSProgramCreationProxy(
+	(ts, createProgram) =>
+		new Proxy(function () {} as unknown as typeof createProgram, {
+			apply(target, thisArg, args) {
+				let volarLanguage = null as null | VolarLanguage<string>;
+				let vueCompilerOptions = null as null | VueCompilerOptions;
+				const proxied = proxyCreateProgram(ts, createProgram, (ts, options) => {
+					const { configFilePath } = options.options;
+					vueCompilerOptions = (
+						typeof configFilePath === "string"
+							? createVueParsedCommandLine(
+									ts,
+									ts.sys,
+									configFilePath.replaceAll("\\", "/"),
+								)
+							: createVueParsedCommandLineByJson(
+									ts,
+									ts.sys,
+									(options.host ?? ts.sys).getCurrentDirectory(),
+									{},
+								)
+					).vueOptions;
+					const vueLanguagePlugin = createVueLanguagePlugin<string>(
+						ts,
+						options.options,
+						vueCompilerOptions,
+						(id) => id,
+					);
+					if (vueLanguagePlugin.typescript != null) {
+						const { getServiceScript } = vueLanguagePlugin.typescript;
+						vueLanguagePlugin.typescript.getServiceScript = (root) => {
+							const script = getServiceScript(root);
+							if (script == null) {
+								return script;
+							}
+							return {
+								...script,
+								// Leading offset is useful for LanguageService [1], but we don't use it.
+								// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
+								// have to provide it ourselves.
+								//
+								// [1] https://github.com/volarjs/volar.js/discussions/188
+								// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
+								preventLeadingOffset: true,
+							};
+						};
+					}
+					return {
+						languagePlugins: [vueLanguagePlugin],
+						setup: (lang) => (volarLanguage = lang),
+					};
+				});
+
+				const program: ProxiedTSProgram = Reflect.apply(proxied, thisArg, args);
+
+				if (volarLanguage == null) {
+					throw new Error("Flint bug: volarLanguage is not defined");
+				}
+				if (vueCompilerOptions == null) {
+					throw new Error("Flint bug: vueCompilerOptions is not defined");
+				}
+
+				if (program.__flintVolarLanguage != null) {
+					return program;
+				}
+
+				program.__flintVolarLanguage = volarLanguage;
+				return program;
+			},
+		}),
+);
+
+export interface VueServices extends TypeScriptFileServices {
+	vueServices?: {
+		codegen: VueCodegen;
+		map: VolarMapper;
+		sfc: RootNode;
+		virtualCode: VueVirtualCode;
+		// TODO: can we type MessageId?
+		reportSfc: RuleReporter<string>;
+	};
+}
+
+type VueCodegen = typeof tsCodegen extends WeakMap<any, infer V> ? V : never;
+
+export const vueLanguage = createLanguage<TSNodesByName, VueServices>({
+	about: {
+		name: "Vue.js",
+	},
+	prepare: () => {
+		const tsLang = prepareTypeScriptBasedLanguage();
+
+		return {
+			prepareFromDisk: (filePathAbsolute) => {
+				return prepareVueFile(
+					filePathAbsolute,
+					tsLang.createFromDisk(filePathAbsolute),
+				);
+			},
+			prepareFromVirtual: (filePathAbsolute, sourceText) => {
+				return prepareVueFile(
+					filePathAbsolute,
+					tsLang.createFromVirtual(filePathAbsolute, sourceText),
+				);
+			},
+		};
+	},
+});
+
+function translateRange(
+	map: VolarMapper,
+	serviceBegin: number,
+	serviceEnd: number,
+): null | { begin: number; end: number } {
+	for (const [begin, end] of map.toSourceRange(
+		serviceBegin,
+		serviceEnd,
+		true,
+	)) {
+		if (begin === end) {
+			continue;
+		}
+		return { begin, end };
+	}
+	return null;
+}
+
+// TODO:
+// export function vueWrapRules(
+// 	...rules: AnyLevelDeep<ConfigRuleDefinition>[]
+// ): AnyRule[] {
+// 	return Array.from(
+// 		computeRulesWithOptions(flatten(rules))
+// 			.keys()
+// 			.map((rule) => vueLanguage.createRule(rule)),
+// 	);
+// }
+
+function prepareVueFile(
+	filePathAbsolute: string,
+	tsFile: TypeScriptBasedLanguageFile,
+): LanguagePreparedDefinition {
+	const { program, sourceFile, [Symbol.dispose]: onDispose } = tsFile;
+
+	// @ts-expect-error
+	const volarLanguage: VolarLanguage = program.__flintVolarLanguage;
+
+	if (volarLanguage == null) {
+		throw new Error(
+			"'typescript' package wasn't properly patched. Make sure you don't import 'typescript' before Flint.",
+		);
+	}
+
+	const sourceScript = volarLanguage.scripts.get(filePathAbsolute);
+	if (sourceScript == null) {
+		throw new Error("Expected sourceScript to be set");
+	}
+	if (sourceScript.languageId !== "vue") {
+		return prepareTypeScriptFile({
+			program,
+			sourceFile,
+			[Symbol.dispose]: onDispose,
+		});
+	}
+	if (sourceScript.generated == null) {
+		throw new Error("Expected sourceScript.generated to be set");
+	}
+	if (sourceScript.snapshot == null) {
+		throw new Error("Expected sourceScript.snapshot to be set");
+	}
+	if (sourceScript.generated.languagePlugin.typescript == null) {
+		throw new Error(
+			"Expected sourceScript.generated.languagePlugin.typescript to be set",
+		);
+	}
+
+	const sourceText = sourceScript.snapshot.getText(
+		0,
+		sourceScript.snapshot.getLength(),
+	);
+	const sourceTextWithLineMap: SourceFileWithLineMap = {
+		text: sourceText,
+	};
+	function normalizeSourceRange(
+		range: CharacterReportRange,
+	): NormalizedReportRangeObject {
+		return {
+			begin: getColumnAndLineOfPosition(sourceTextWithLineMap, range.begin),
+			end: getColumnAndLineOfPosition(sourceTextWithLineMap, range.end),
+		};
+	}
+
+	const serviceScript =
+		sourceScript.generated.languagePlugin.typescript.getServiceScript(
+			sourceScript.generated.root,
+		);
+	if (serviceScript == null) {
+		throw new Error("Expected serviceScript to exist");
+	}
+
+	const virtualCode = sourceScript.generated.root as VueVirtualCode;
+	const codegen = tsCodegen.get(virtualCode.sfc);
+	if (codegen == null) {
+		throw new Error("Expected codegen to exist");
+	}
+
+	const map = volarLanguage.maps.get(serviceScript.code, sourceScript);
+	const sortedMappings = map.mappings.toSorted(
+		(a, b) => a.generatedOffsets[0] - b.generatedOffsets[0],
+	);
+
+	const sfcAst = vueParse(sourceText, {
+		comments: true,
+		expressionPlugins: ["typescript"],
+		parseMode: "html",
+		// We ignore errors because virtual code already provides them,
+		// and it also provides them with sourceText-based locations,
+		// so we don't have to remap them. Oh, and it also contains errors from
+		// other blocks rather than only <template> as well.
+		// If we don't provide this callback, @vue/compiler-core will throw.
+		onError: () => {},
+	});
+
+	// TODO: extract directives from other blocks too
+
+	const directives: {
+		range: NormalizedReportRangeObject;
+		selection: string;
+		type: string;
+	}[] = [];
+	function visitTemplate(elem: TemplateChildNode) {
+		if (elem.type === NodeTypes.ELEMENT) {
+			elem.children.forEach(visitTemplate);
+			return;
+		}
+		if (elem.type !== NodeTypes.COMMENT) {
+			return;
+		}
+		const match = /\s*flint-(\S+)(?:\s+(.+))?/.exec(elem.content);
+		if (match == null) {
+			return;
+		}
+		const [, type, selection] = match;
+		directives.push({
+			range: {
+				begin: {
+					column: elem.loc.start.column - 1,
+					line: elem.loc.start.line - 1,
+					raw: elem.loc.start.offset,
+				},
+				end: {
+					column: elem.loc.end.column - 1,
+					line: elem.loc.end.line - 1,
+					raw: elem.loc.end.offset,
+				},
+			},
+			selection,
+			type,
+		});
+	}
+	sfcAst.children.forEach(visitTemplate);
+
+	for (const d of extractDirectivesFromTypeScriptFile(sourceFile)) {
+		const range = translateRange(map, d.range.begin.raw, d.range.end.raw);
+		if (range != null) {
+			directives.push({
+				...d,
+				range: normalizeSourceRange(range),
+			});
+		}
+	}
+
+	const directivesCollector = new DirectivesCollector(
+		sfcAst.children.find((c) => c.type !== NodeTypes.COMMENT)?.loc.start
+			.offset ?? sourceText.length,
+	);
+	directives.sort((a, b) => a.range.begin.raw - b.range.begin.raw);
+	for (const { range, selection, type } of directives) {
+		directivesCollector.add(range, selection, type);
+	}
+
+	return {
+		...directivesCollector.collect(),
+		file: {
+			...(onDispose != null && { [Symbol.dispose]: onDispose }),
+			cache: collectTypeScriptFileCacheImpacts(program, sourceFile),
+			getDiagnostics() {
+				return [
+					...ts.getPreEmitDiagnostics(program, sourceFile).map((diagnostic) =>
+						convertTypeScriptDiagnosticToLanguageFileDiagnostic({
+							...diagnostic,
+							// For some unknown reason, Volar doesn't set file.text to sourceText
+							// when preventLeadingOffset is true, so we have to do it ourselves
+							// https://github.com/volarjs/volar.js/blob/4a9d25d797d08d9c149bebf0f52ac5e172f4757d/packages/typescript/lib/node/transform.ts#L102
+							file: diagnostic.file
+								? {
+										fileName: diagnostic.file.fileName,
+										text: sourceText,
+									}
+								: diagnostic.file,
+						}),
+					),
+					...(virtualCode.vueSfc?.errors ?? []).map((e) => {
+						const fileName = sourceFile.fileName.startsWith("./")
+							? sourceFile.fileName.slice(2)
+							: sourceFile.fileName.slice(process.cwd().length + 1);
+						let code = "VUE";
+						let loc = "";
+						if ("code" in e) {
+							// TODO: think about codes
+							code += "999999" + e.code.toString();
+							loc =
+								e.loc != null
+									? `:${e.loc?.start.line}:${e.loc?.start.column}`
+									: "";
+						}
+						return {
+							code,
+							text: `${fileName}${loc} - ${code}: ${e.name} - ${e.message}`,
+						};
+					}),
+				];
+			},
+			async runRule(rule, options) {
+				const reports: NormalizedReport[] = [];
+				const context: RuleContext<string> & VueServices = {
+					program,
+					report: (report) => {
+						const reportRange = translateRange(
+							map,
+							report.range.begin,
+							report.range.end,
+						);
+						if (reportRange == null) {
+							return;
+						}
+
+						const translatedReport: NormalizedReport = {
+							...report,
+							fix:
+								report.fix && !Array.isArray(report.fix)
+									? [report.fix]
+									: report.fix,
+							message: rule.messages[report.message],
+							range: normalizeSourceRange(reportRange),
+						};
+
+						for (const suggestion of translatedReport.suggestions ?? []) {
+							if (isSuggestionForFiles(suggestion)) {
+								throw new Error(
+									"TODO: vue - suggestions for multiple files are not yet supported",
+								);
+							}
+							const range = translateRange(
+								map,
+								suggestion.range.begin,
+								suggestion.range.end,
+							);
+							if (range == null) {
+								// TODO: maybe we should filter out these suggestions intead of erroring?
+								throw new Error("Suggestion range overlaps with virtual code");
+							}
+							suggestion.range = range;
+						}
+
+						reports.push(translatedReport);
+					},
+					sourceFile,
+					typeChecker: program.getTypeChecker(),
+					vueServices: {
+						codegen,
+						map,
+						reportSfc: (report: RuleReport) => {
+							reports.push({
+								...report,
+								fix:
+									report.fix && !Array.isArray(report.fix)
+										? [report.fix]
+										: report.fix,
+								message: rule.messages[report.message],
+								range: normalizeSourceRange(report.range),
+							});
+						},
+						sfc: sfcAst,
+						virtualCode,
+					},
+				};
+
+				const runtime = await rule.setup(context, options);
+
+				if (runtime?.visitors) {
+					const { visitors } = runtime;
+					let lastMappingIdx = 0;
+					const visit = (node: ts.Node) => {
+						visitors[NodeSyntaxKinds[node.kind]]?.(node, context);
+
+						node.forEachChild(visit);
+					};
+					// Visit only statements that have a mapping to the source code
+					// to avoid doing extra work
+					Statements: for (const statement of sourceFile.statements) {
+						while (true) {
+							const currentMapping = sortedMappings[lastMappingIdx];
+							if (currentMapping == null) {
+								break Statements;
+							}
+							const currentMappingLength =
+								currentMapping.generatedLengths?.[0] ??
+								currentMapping.lengths[0];
+							if (
+								currentMappingLength === 0 ||
+								statement.pos >=
+									currentMapping.generatedOffsets[0] + currentMappingLength
+							) {
+								lastMappingIdx++;
+								continue;
+							}
+							if (statement.end <= currentMapping.generatedOffsets[0]) {
+								continue Statements;
+							}
+							break;
+						}
+
+						visit(statement);
+					}
+					visit(sourceFile.endOfFileToken);
+				}
+
+				await runtime?.teardown?.();
+
+				return reports;
+			},
+		},
+	};
+}
diff --git a/packages/vue-language/src/plugin.ts b/packages/vue-language/src/plugin.ts
new file mode 100644
index 000000000..fdc733c77
--- /dev/null
+++ b/packages/vue-language/src/plugin.ts
@@ -0,0 +1,13 @@
+import { createPlugin } from "@flint.fyi/core";
+import { ts as tsPlugin } from "@flint.fyi/ts";
+
+import asyncComputed from "./rules/asyncComputed.js";
+import vForKey from "./rules/vForKey.js";
+
+export const vue = createPlugin({
+	files: {
+		all: [tsPlugin.files.all, "**/*.vue"],
+	},
+	name: "vue",
+	rules: [asyncComputed, vForKey],
+});
diff --git a/packages/vue-language/src/rules/MyComponent.vue b/packages/vue-language/src/rules/MyComponent.vue
new file mode 100644
index 000000000..a2abf7c27
--- /dev/null
+++ b/packages/vue-language/src/rules/MyComponent.vue
@@ -0,0 +1,5 @@
+<script lang="ts" setup>
+defineProps<{ foo: () => string }>();
+</script>
+
+<template>Hello!</template>
diff --git a/packages/vue-language/src/rules/anyReturns.test.ts b/packages/vue-language/src/rules/anyReturns.test.ts
new file mode 100644
index 000000000..9f0ec17e3
--- /dev/null
+++ b/packages/vue-language/src/rules/anyReturns.test.ts
@@ -0,0 +1,98 @@
+import rule from "../../../ts/lib/rules/anyReturns.js";
+import { vueLanguage } from "../language.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(vueLanguage.createRule(rule), {
+	invalid: [
+		{
+			code: `
+<script lang="ts" setup>
+	function foo() {
+		return 1 as any
+	}
+</script>
+			`,
+			snapshot: `
+<script lang="ts" setup>
+	function foo() {
+		return 1 as any
+		~~~~~~~~~~~~~~~
+		Unsafe return of a value of type \`any\`.
+	}
+</script>
+			`,
+		},
+		{
+			code: `
+<script lang="ts" setup>
+	import MyComponent from './MyComponent.vue'
+
+	const foo = 1 as any
+</script>
+
+<template>
+	<MyComponent :foo="() => foo"/>
+</template>
+			`,
+			snapshot: `
+<script lang="ts" setup>
+	import MyComponent from './MyComponent.vue'
+
+	const foo = 1 as any
+</script>
+
+<template>
+	<MyComponent :foo="() => foo"/>
+	                         ~~~
+	                         Unsafe return of a value of type \`any\`.
+</template>
+			`,
+		},
+		{
+			code: `
+<script lang="ts" setup>
+	import MyComponent from './MyComponent.vue'
+
+	const foo = 1
+</script>
+
+<template>
+	<MyComponent :foo="() => [
+		foo,
+		foo,
+	] as any"/>
+</template>
+			`,
+			snapshot: `
+<script lang="ts" setup>
+	import MyComponent from './MyComponent.vue'
+
+	const foo = 1
+</script>
+
+<template>
+	<MyComponent :foo="() => [
+	                         ~
+	                         Unsafe return of a value of type \`any\`.
+		foo,
+		~~~~
+		foo,
+		~~~~
+	] as any"/>
+	~~~~~~~~
+</template>
+			`,
+		},
+	],
+	valid: [
+		`
+<script lang="ts" setup>
+	import MyComponent from './MyComponent.vue'
+
+	function foo() {
+		return MyComponent
+	}
+</script>
+		`,
+	],
+});
diff --git a/packages/vue-language/src/rules/asyncComputed.test.ts b/packages/vue-language/src/rules/asyncComputed.test.ts
new file mode 100644
index 000000000..313227e4f
--- /dev/null
+++ b/packages/vue-language/src/rules/asyncComputed.test.ts
@@ -0,0 +1,414 @@
+import path from "node:path";
+
+import rule from "./asyncComputed.js";
+import { ruleTester } from "./ruleTester.js";
+
+// TODO: the default file.ts path is packages/vfs/file.ts, so imports from
+// the vue package cannot be resolved, because vue is located in packages/vue/node_modules
+const tsFileName = path.join(import.meta.dirname, "file.ts");
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+import { computed } from 'vue'
+
+computed(async () => 'hello')
+			`,
+			fileName: tsFileName,
+			snapshot: `
+import { computed } from 'vue'
+
+computed(async () => 'hello')
+         ~~~~~~~~~~~~~~~~~~~
+         Asynchronous functions in computed properties can lead to loss of reactivity.
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed(async () => 'hello')
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed(async () => 'hello')
+	         ~~~~~~~~~~~~~~~~~~~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed(async () => 'hello', {
+		onTrack(e) {
+			debugger
+		}
+	})
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed(async () => 'hello', {
+	         ~~~~~~~~~~~~~~~~~~~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+		onTrack(e) {
+			debugger
+		}
+	})
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	async function foo() { return 'hello' }
+
+	computed(foo)
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	async function foo() { return 'hello' }
+
+	computed(foo)
+	         ~~~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed(() => {
+		return fetch('https://example.com')
+	})
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed(() => {
+	         ~~~~~~~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+		return fetch('https://example.com')
+		~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+	})
+	~
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	class MyPromise<T> extends Promise<T> {}
+	declare function fn(): MyPromise<string>
+
+	computed(fn)
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	class MyPromise<T> extends Promise<T> {}
+	declare function fn(): MyPromise<string>
+
+	computed(fn)
+	         ~~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	declare function fn(): number | ({ foo: number } & Promise<string>)
+
+	computed(fn)
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	declare function fn(): number | ({ foo: number } & Promise<string>)
+
+	computed(fn)
+	         ~~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed({
+		get: () => fetch('https://example.com'),
+		set: v => {},
+	})
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed({
+	         ~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+		get: () => fetch('https://example.com'),
+		~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+		set: v => {},
+		~~~~~~~~~~~~~
+	})
+	~
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed({
+		get: () => fetch('https://example.com'),
+		set: v => {},
+	}, {
+		onTrack(e) {
+			debugger
+		}
+	})
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed({
+	         ~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+		get: () => fetch('https://example.com'),
+		~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+		set: v => {},
+		~~~~~~~~~~~~~
+	}, {
+	~
+		onTrack(e) {
+			debugger
+		}
+	})
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	declare const getterAndSetter: {
+		get: () => Promise<string> | string
+		set: (v: string) => void
+	}
+
+	computed(getterAndSetter)
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	declare const getterAndSetter: {
+		get: () => Promise<string> | string
+		set: (v: string) => void
+	}
+
+	computed(getterAndSetter)
+	         ~~~~~~~~~~~~~~~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+</script>
+			`,
+		},
+		{
+			code: `
+<script lang="ts">
+	import { computed } from 'vue'
+</script>
+
+<script setup lang="ts">
+	computed(async () => 'hello')
+</script>
+			`,
+			snapshot: `
+<script lang="ts">
+	import { computed } from 'vue'
+</script>
+
+<script setup lang="ts">
+	computed(async () => 'hello')
+	         ~~~~~~~~~~~~~~~~~~~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+</script>
+			`,
+		},
+		{
+			code: `
+<script lang="ts">
+	import { computed } from 'vue'
+
+	computed(async () => 'hello')
+</script>
+
+<script setup lang="ts">
+</script>
+			`,
+			snapshot: `
+<script lang="ts">
+	import { computed } from 'vue'
+
+	computed(async () => 'hello')
+	         ~~~~~~~~~~~~~~~~~~~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+</script>
+
+<script setup lang="ts">
+</script>
+			`,
+		},
+		{
+			// TODO: volar sets different ScriptKind depending on <script> lang,
+			// it doesn't work with current prepareFromVirtual
+			code: `
+<script>
+	import { computed } from 'vue'
+</script>
+
+<script setup>
+	computed(async () => 'hello')
+</script>
+			`,
+			skip: true,
+			snapshot: `
+<script>
+	import { computed } from 'vue'
+</script>
+
+<script setup>
+	computed(async () => 'hello')
+	         ~~~~~~~~~~~~~~~~~~~
+	         Asynchronous functions in computed properties can lead to loss of reactivity.
+</script>
+			`,
+		},
+	],
+	valid: [
+		// invalid computed
+		`
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed()
+</script>
+		`,
+		// invalid computed
+		`
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed('hello')
+</script>
+		`,
+		`
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed(() => 'hello')
+</script>
+		`,
+		`
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed(() => {
+		return 'hello'
+	})
+</script>
+		`,
+		`
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed(function comp() {
+		return 'hello'
+	})
+</script>
+		`,
+		`
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	declare function comp(): string
+
+	computed(comp)
+</script>
+		`,
+		`
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed({
+		get: () => 'hello',
+		set: v => {}
+	})
+</script>
+		`,
+		`
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	computed({
+		get: () => 'hello',
+		set: (v: number) => {}
+	})
+</script>
+		`,
+		`
+<script setup lang="ts">
+	import { computed } from 'vue'
+
+	declare const getterAndSetter: {
+		get: () => string
+		set: (v: string) => void
+	}
+
+	computed(getterAndSetter)
+</script>
+		`,
+		`
+<script setup lang="ts">
+	computed(async () => 'hello')
+</script>
+		`,
+	],
+});
diff --git a/packages/vue-language/src/rules/asyncComputed.ts b/packages/vue-language/src/rules/asyncComputed.ts
new file mode 100644
index 000000000..0a2f8b67c
--- /dev/null
+++ b/packages/vue-language/src/rules/asyncComputed.ts
@@ -0,0 +1,93 @@
+import * as tsutils from "ts-api-utils";
+import ts from "typescript";
+
+import { isPromiseLike } from "../../../ts/lib/rules/utils/builtinSymbolLikes.js";
+import { isTypeRecursive } from "../../../ts/lib/rules/utils/isTypeRecursive.js";
+import { vueLanguage } from "../language.js";
+
+export default vueLanguage.createRule({
+	about: {
+		description: "Reports asynchronous functions in computed properties.",
+		id: "asyncComputed",
+		preset: "logical",
+	},
+	messages: {
+		async: {
+			primary:
+				"Asynchronous functions in computed properties can lead to loss of reactivity.",
+			secondary: [
+				"Computed properties must be synchronous to maintain the reactive data flow.",
+				"Using async functions can cause computed properties to return promises, disrupting the reactivity system.",
+			],
+			suggestions: [
+				"Consider using watches for asynchronous operations instead of computed properties.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				CallExpression(node: ts.CallExpression) {
+					if (!isComputed(context.typeChecker, node)) {
+						return;
+					}
+
+					const type = context.typeChecker.getTypeAtLocation(node);
+					if (!tsutils.isTypeReference(type)) {
+						return;
+					}
+
+					// declare function computed<T, S>(...): ...
+					const [getterType] = context.typeChecker.getTypeArguments(type);
+					if (getterType == null) {
+						return;
+					}
+
+					if (
+						!isTypeRecursive(getterType, (type) =>
+							isPromiseLike(context.program, type),
+						)
+					) {
+						return;
+					}
+
+					const reportNode = node.arguments[0] ?? node.expression;
+
+					context.report({
+						message: "async",
+						range: {
+							begin: reportNode.getStart(context.sourceFile),
+							end: reportNode.getEnd(),
+						},
+					});
+				},
+			},
+		};
+	},
+});
+
+function isComputed(
+	typeChecker: ts.TypeChecker,
+	node: ts.CallExpression,
+): boolean {
+	const callee = node.expression;
+	if (!ts.isIdentifier(callee) || callee.text !== "computed") {
+		return false;
+	}
+
+	const type = typeChecker.getTypeAtLocation(callee);
+
+	if (type.symbol?.declarations == null) {
+		return false;
+	}
+
+	for (const decl of type.symbol.declarations) {
+		if (
+			decl.getSourceFile().fileName.includes("/node_modules/@vue/reactivity/")
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
diff --git a/packages/vue-language/src/rules/debuggerStatements.test.ts b/packages/vue-language/src/rules/debuggerStatements.test.ts
new file mode 100644
index 000000000..bfb627df8
--- /dev/null
+++ b/packages/vue-language/src/rules/debuggerStatements.test.ts
@@ -0,0 +1,78 @@
+import rule from "../../../ts/lib/rules/debuggerStatements.js";
+import { vueLanguage } from "../language.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(vueLanguage.createRule(rule), {
+	invalid: [
+		{
+			code: `
+<script lang="ts" setup>
+	debugger;
+</script>
+			`,
+			snapshot: `
+<script lang="ts" setup>
+	debugger;
+	~~~~~~~~~
+	Debugger statements should not be used in production code.
+</script>
+			`,
+			suggestions: [
+				{
+					id: "removeDebugger",
+					updated: `
+<script lang="ts" setup>
+\t
+</script>
+			`,
+				},
+			],
+		},
+		{
+			code: `
+<template>
+	<button @click="event => {
+		debugger
+		console.log(event)
+	}">
+		Hello
+	</button>
+</template>
+			`,
+			snapshot: `
+<template>
+	<button @click="event => {
+		debugger
+		~~~~~~~~
+		Debugger statements should not be used in production code.
+		console.log(event)
+	}">
+		Hello
+	</button>
+</template>
+			`,
+			suggestions: [
+				{
+					id: "removeDebugger",
+					updated: `
+<template>
+	<button @click="event => {
+\t\t
+		console.log(event)
+	}">
+		Hello
+	</button>
+</template>
+			`,
+				},
+			],
+		},
+	],
+	valid: [
+		`
+<script lang="ts" setup>
+	hello
+</script>
+		`,
+	],
+});
diff --git a/packages/vue-language/src/rules/fixture.ts b/packages/vue-language/src/rules/fixture.ts
new file mode 100644
index 000000000..bb1843d11
--- /dev/null
+++ b/packages/vue-language/src/rules/fixture.ts
@@ -0,0 +1 @@
+export const foo = 1;
diff --git a/packages/vue-language/src/rules/ruleTester.ts b/packages/vue-language/src/rules/ruleTester.ts
new file mode 100644
index 000000000..72429d246
--- /dev/null
+++ b/packages/vue-language/src/rules/ruleTester.ts
@@ -0,0 +1,14 @@
+import path from "node:path";
+
+import { RuleTester } from "@flint.fyi/rule-tester";
+import { describe, it } from "vitest";
+
+const fileName = path.join(import.meta.dirname, "file.vue");
+
+export const ruleTester = new RuleTester({
+	describe,
+	it,
+	defaults: {
+		fileName,
+	},
+});
diff --git a/packages/vue-language/src/rules/scriptSetupExports.test.ts b/packages/vue-language/src/rules/scriptSetupExports.test.ts
new file mode 100644
index 000000000..32b1a2e22
--- /dev/null
+++ b/packages/vue-language/src/rules/scriptSetupExports.test.ts
@@ -0,0 +1,285 @@
+import path from "node:path";
+
+import { ruleTester } from "./ruleTester.js";
+import rule from "./scriptSetupExports.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+<script setup lang="ts">
+	export const foo = 1
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	export const foo = 1
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	type foo = 1
+
+	export { foo }
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	type foo = 1
+
+	export { foo }
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	type foo = 1
+
+	export { foo }
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	type foo = 1
+
+	export { foo }
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	type foo = 1
+	type bar = 2
+
+	export { type bar, foo }
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	type foo = 1
+	type bar = 2
+
+	export { type bar, foo }
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	type foo = 1
+	type bar = 2
+
+	export { type bar, type foo }
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	type foo = 1
+	type bar = 2
+
+	export { type bar, type foo }
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	const foo = 1
+
+	export { foo }
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	const foo = 1
+
+	export { foo }
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	export { foo } from './fixture'
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	export { foo } from './fixture'
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	export * from './fixture'
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	export * from './fixture'
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script lang="ts">
+	export const foo = 1
+</script>
+
+<script setup lang="ts">
+	import { } from './fixture'
+	
+	export const bar = 2
+</script>
+			`,
+			snapshot: `
+<script lang="ts">
+	export const foo = 1
+</script>
+
+<script setup lang="ts">
+	import { } from './fixture'
+	
+	export const bar = 2
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	export enum foo { a, b }
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	export enum foo { a, b }
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	export class foo {}
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	export class foo {}
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	export namespace foo {}
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	export namespace foo {}
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	export function foo() {}
+</script>
+			`,
+			snapshot: `
+<script setup lang="ts">
+	export function foo() {}
+	~~~~~~
+	\`<script setup>\` cannot contain ES module exports.
+</script>
+			`,
+		},
+	],
+	valid: [
+		`
+<script setup lang="ts">
+	const foo = 1
+</script>
+		`,
+		`
+<script setup lang="ts">
+	export type foo = 1
+</script>
+		`,
+		`
+<script setup lang="ts">
+	type foo = 1
+
+	export type { foo }
+</script>
+		`,
+		`
+<script lang="ts">
+	export const foo = 1
+</script>
+		`,
+		// second script setup is not checked (it's vue error)
+		`
+<script setup lang="ts">
+</script>
+
+<script setup lang="ts">
+	export const foo = 1
+</script>
+		`,
+		`
+<script setup lang="ts">
+	export declare const foo: number
+</script>
+		`,
+		`
+<script setup lang="ts">
+	export declare enum foo { a, b }
+</script>
+		`,
+		`
+<script setup lang="ts">
+	export declare class foo {}
+</script>
+		`,
+		`
+<script setup lang="ts">
+	export declare namespace foo {}
+</script>
+		`,
+		`
+<script setup lang="ts">
+	export declare function foo(): void
+</script>
+		`,
+	],
+});
diff --git a/packages/vue-language/src/rules/scriptSetupExports.ts b/packages/vue-language/src/rules/scriptSetupExports.ts
new file mode 100644
index 000000000..66ecf501b
--- /dev/null
+++ b/packages/vue-language/src/rules/scriptSetupExports.ts
@@ -0,0 +1,79 @@
+import * as tsutils from "ts-api-utils";
+import ts from "typescript";
+
+import { vueLanguage } from "../language.js";
+
+export default vueLanguage.createRule({
+	about: {
+		description:
+			"Reports use of ES module exports inside a <script setup> block.",
+		id: "scriptSetupExports",
+		preset: "logical",
+	},
+	messages: {
+		forbidden: {
+			primary: "`<script setup>` cannot contain ES module exports.",
+			secondary: [
+				"In `<script setup>`, all variables are automatically scoped and exposed to the template without needing exports.",
+				"Using `export` breaks the compilation model and results in build-time errors or unexpected behavior.",
+			],
+			suggestions: [
+				"Remove the `export` and declare the value normally inside `<script setup>`.",
+				"If you need to export something from the SFC, move the export to a separate `<script>` block.",
+			],
+		},
+	},
+	setup(context) {
+		const { vueServices } = context;
+		if (vueServices == null) {
+			return undefined;
+		}
+
+		const { scriptSetup } = vueServices.virtualCode.sfc;
+		if (scriptSetup == null) {
+			return undefined;
+		}
+
+		const reportExport = (exportKeywordStart: number) => {
+			exportKeywordStart += scriptSetup.startTagEnd;
+			vueServices.reportSfc({
+				message: "forbidden",
+				range: {
+					begin: exportKeywordStart,
+					end: exportKeywordStart + "export".length,
+				},
+			});
+		};
+
+		// https://github.com/vuejs/core/blob/25ebe3a42cd80ac0256355c2740a0258cdd7419d/packages/compiler-sfc/src/compileScript.ts#L675-L686
+		// `export = ...` and `export default ...` are reported by vue-tsc
+		for (const statement of scriptSetup.ast.statements) {
+			if (ts.isExportDeclaration(statement) && !statement.isTypeOnly) {
+				reportExport(statement.getStart(scriptSetup.ast));
+			} else if (
+				(ts.isVariableStatement(statement) ||
+					ts.isEnumDeclaration(statement) ||
+					ts.isClassDeclaration(statement) ||
+					ts.isModuleDeclaration(statement) ||
+					ts.isFunctionDeclaration(statement)) &&
+				statement.modifiers != null
+			) {
+				let exportToken: null | ts.ExportKeyword = null;
+				let hasDeclare = false;
+				for (const m of statement.modifiers) {
+					if (tsutils.isDeclareKeyword(m)) {
+						hasDeclare = true;
+						break;
+					}
+					exportToken ??= tsutils.isExportKeyword(m) ? m : null;
+				}
+
+				if (!hasDeclare && exportToken != null) {
+					reportExport(exportToken.getStart(scriptSetup.ast));
+				}
+			}
+		}
+
+		return undefined;
+	},
+});
diff --git a/packages/vue-language/src/rules/vForKey.test.ts b/packages/vue-language/src/rules/vForKey.test.ts
new file mode 100644
index 000000000..574d1c084
--- /dev/null
+++ b/packages/vue-language/src/rules/vForKey.test.ts
@@ -0,0 +1,464 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./vForKey.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+<template>
+	<template v-for="item in [1, 2]"></template>
+</template>
+			`,
+			snapshot: `
+<template>
+	<template v-for="item in [1, 2]"></template>
+	          ~~~~~
+	          Elements using v-for must include a unique :key to ensure correct reactivity and DOM stability.
+</template>
+			`,
+		},
+		{
+			code: `
+<template>
+	<div v-for="item in [1, 2]"></div>
+</template>
+			`,
+			snapshot: `
+<template>
+	<div v-for="item in [1, 2]"></div>
+	     ~~~~~
+	     Elements using v-for must include a unique :key to ensure correct reactivity and DOM stability.
+</template>
+			`,
+		},
+		{
+			code: `
+<template>
+	<div v-for="item in [1, 2]">
+		<p></p>
+	</div>
+</template>
+			`,
+			snapshot: `
+<template>
+	<div v-for="item in [1, 2]">
+	     ~~~~~
+	     Elements using v-for must include a unique :key to ensure correct reactivity and DOM stability.
+		<p></p>
+	</div>
+</template>
+			`,
+		},
+		{
+			code: `
+<template>
+	<template v-for="item in [1, 2]">
+		<p></p>
+	</template>
+</template>
+			`,
+			snapshot: `
+<template>
+	<template v-for="item in [1, 2]">
+	          ~~~~~
+	          Elements using v-for must include a unique :key to ensure correct reactivity and DOM stability.
+		<p></p>
+	</template>
+</template>
+			`,
+		},
+		{
+			code: `
+<template>
+	<div>
+		<img v-for="item in [1, 2]"/>
+	</div>
+</template>
+			`,
+			snapshot: `
+<template>
+	<div>
+		<img v-for="item in [1, 2]"/>
+		     ~~~~~
+		     Elements using v-for must include a unique :key to ensure correct reactivity and DOM stability.
+	</div>
+</template>
+			`,
+		},
+		{
+			code: `
+<template>
+	<div v-if="true">
+		<img v-for="item in [1, 2]"/>
+	</div>
+</template>
+			`,
+			snapshot: `
+<template>
+	<div v-if="true">
+		<img v-for="item in [1, 2]"/>
+		     ~~~~~
+		     Elements using v-for must include a unique :key to ensure correct reactivity and DOM stability.
+	</div>
+</template>
+			`,
+		},
+		{
+			code: `
+<template>
+	<div v-if="true"></div>
+	<div v-else>
+		<img v-for="item in [1, 2]"/>
+	</div>
+</template>
+			`,
+			snapshot: `
+<template>
+	<div v-if="true"></div>
+	<div v-else>
+		<img v-for="item in [1, 2]"/>
+		     ~~~~~
+		     Elements using v-for must include a unique :key to ensure correct reactivity and DOM stability.
+	</div>
+</template>
+			`,
+		},
+		{
+			code: `
+<template>
+	<div v-for="i in [1, 2]" :key="i">
+		<img v-for="item in [1, 2]"/>
+	</div>
+</template>
+			`,
+			snapshot: `
+<template>
+	<div v-for="i in [1, 2]" :key="i">
+		<img v-for="item in [1, 2]"/>
+		     ~~~~~
+		     Elements using v-for must include a unique :key to ensure correct reactivity and DOM stability.
+	</div>
+</template>
+			`,
+		},
+		{
+			code: `
+<script setup lang="ts">
+	declare const key: number
+</script>
+
+<template>
+	<div 
+		v-for="item in ['a', 'b']"
+		:key="key"
+	></div>
+</template>
+		},
+			`,
+			snapshot: `
+<script setup lang="ts">
+	declare const key: number
+</script>
+
+<template>
+	<div 
+		v-for="item in ['a', 'b']"
+		:key="key"
+		      ~~~
+		      The :key on this v-for element does not reference the iteration variable.
+	></div>
+</template>
+		},
+			`,
+		},
+		{
+			code: `
+<template>
+	<div 
+		v-for="(item, i) in ['a', 'b']"
+		:key="(i => i)(5)"
+	></div>
+</template>
+		},
+			`,
+			snapshot: `
+<template>
+	<div 
+		v-for="(item, i) in ['a', 'b']"
+		:key="(i => i)(5)"
+		      ~~~~~~~~~~~
+		      The :key on this v-for element does not reference the iteration variable.
+	></div>
+</template>
+		},
+			`,
+		},
+		{
+			code: `
+<template>
+	<div 
+		v-for="(item, key, i) in { foo: 'bar' }"o
+		:key="5"
+	></div>
+</template>
+			`,
+			snapshot: `
+<template>
+	<div 
+		v-for="(item, key, i) in { foo: 'bar' }"o
+		:key="5"
+		      ~
+		      The :key on this v-for element does not reference the iteration variable.
+	></div>
+</template>
+			`,
+		},
+		{
+			code: `
+<template>
+	<div 
+		v-for="item in [1, 2]"
+		key=item
+	></div>
+</template>
+			`,
+			snapshot: `
+<template>
+	<div 
+		v-for="item in [1, 2]"
+		key=item
+		    ~~~~
+		    Static key values prevent Vue from tracking changes in v-for lists.
+	></div>
+</template>
+			`,
+		},
+		{
+			code: `
+<template>
+	<div 
+		v-for="item in [1, 2]"
+		key='item'
+	></div>
+</template>
+			`,
+			snapshot: `
+<template>
+	<div 
+		v-for="item in [1, 2]"
+		key='item'
+		     ~~~~
+		     Static key values prevent Vue from tracking changes in v-for lists.
+	></div>
+</template>
+			`,
+		},
+		{
+			code: `
+<template>
+	<div 
+		v-for="item in [1, 2]"
+		key="item"
+	></div>
+</template>
+			`,
+			snapshot: `
+<template>
+	<div 
+		v-for="item in [1, 2]"
+		key="item"
+		     ~~~~
+		     Static key values prevent Vue from tracking changes in v-for lists.
+	></div>
+</template>
+			`,
+		},
+		{
+			code: `
+<script lang="ts" setup>
+	const key = 5
+</script>
+
+<template>
+	<div 
+		v-for="item in [1, 2]"
+		:key
+	></div>
+</template>
+			`,
+			snapshot: `
+<script lang="ts" setup>
+	const key = 5
+</script>
+
+<template>
+	<div 
+		v-for="item in [1, 2]"
+		:key
+		~~~~
+		The :key on this v-for element does not reference the iteration variable.
+	></div>
+</template>
+			`,
+		},
+		{
+			code: `
+<script lang="ts" setup>
+	const key = 5
+</script>
+
+<template>
+	<div 
+		v-for="item in [1, 2]"
+		v-bind:key
+	></div>
+</template>
+			`,
+			snapshot: `
+<script lang="ts" setup>
+	const key = 5
+</script>
+
+<template>
+	<div 
+		v-for="item in [1, 2]"
+		v-bind:key
+		~~~~~~~~~~
+		The :key on this v-for element does not reference the iteration variable.
+	></div>
+</template>
+			`,
+		},
+	],
+	valid: [
+		`
+<template>
+	<template
+		v-for="item in [1, 2]"
+		:key="item"
+	>
+	</template>
+</template>
+		`,
+		`
+<template>
+	<div
+		v-for="item in [1, 2]"
+		:key="item"
+	>
+	</div>
+</template>
+		`,
+		`
+<template>
+	<div
+		v-for="item in [1, 2]"
+		:key="item"
+	>
+		<p></p>
+	</div>
+</template>
+		`,
+		`
+<template>
+	<template
+		v-for="item in [1, 2]"
+		:key="item"
+	>
+		<p></p>
+	</template>
+</template>
+		`,
+		`
+<template>
+	<div
+		v-for="item in [1, 2]"
+		:key="item"
+		class="foo"
+	>
+		<p></p>
+	</div>
+</template>
+		`,
+		`
+<template>
+	<div 
+		v-for="/* */ item in ['a', 'b']"
+		:key="/* */ item"
+	></div>
+</template>
+		`,
+		`
+<template>
+	<div 
+		v-for="(item, i) in ['a', 'b']"
+		:key="i"
+	></div>
+</template>
+		`,
+		`
+<template>
+	<div 
+		v-for="(item, i) in ['a', 'b']"
+		:key="'key-' + i"
+	></div>
+</template>
+		`,
+		`
+<template>
+	<div 
+		v-for="({ data }, i) in [{ data: { foo: '123' }}]"
+		:key="data.foo"
+	></div>
+</template>
+		`,
+		`
+<template>
+	<div
+		v-for="(item, key, i) in { foo: 'bar' }"
+		:key="i"
+	></div>
+</template>
+		`,
+		`
+<template>
+	<div
+		v-for="n in 10"
+		:key="n"
+	></div>
+</template>
+		`,
+		`
+<template>
+	<div
+		v-for="n in 10"
+		key
+	></div>
+</template>
+		`,
+		`
+<script setup lang="ts">
+	const key = 5
+</script>
+
+<template>
+	<div
+		v-for="key in 10"
+		:key
+	></div>
+</template>
+		`,
+		`
+<script setup lang="ts">
+	const key = 5
+</script>
+
+<template>
+	<div
+		v-for="key in 10"
+		v-bind:key
+	></div>
+</template>
+		`,
+	],
+});
diff --git a/packages/vue-language/src/rules/vForKey.ts b/packages/vue-language/src/rules/vForKey.ts
new file mode 100644
index 000000000..5f78038a7
--- /dev/null
+++ b/packages/vue-language/src/rules/vForKey.ts
@@ -0,0 +1,261 @@
+import { CharacterReportRange } from "@flint.fyi/core";
+import { Mapper as VolarMapper } from "@volar/language-core";
+import * as vue from "@vue/compiler-dom";
+import ts from "typescript";
+
+import { vueLanguage } from "../language.js";
+
+export default vueLanguage.createRule({
+	about: {
+		description: "Reports v-for directives without a valid key binding.",
+		id: "vForKey",
+		preset: "logical",
+	},
+	messages: {
+		invalidKey: {
+			primary:
+				"The :key on this v-for element does not reference the iteration variable.",
+			secondary: [
+				"Keys must uniquely identify each item in the v-for loop to maintain object constancy.",
+				"Using values unrelated to the loop can still lead to rendering issues during reordering.",
+			],
+			suggestions: [
+				"Bind the :key to something derived from the v-for item, like item.id or the index if no unique identifier exists.",
+			],
+		},
+		missingKey: {
+			primary:
+				"Elements using v-for must include a unique :key to ensure correct reactivity and DOM stability.",
+			secondary: [
+				"A missing :key can cause unpredictable updates during rendering optimizations.",
+				"Without a key, Vue may reuse or reorder elements incorrectly, which breaks expected behavior in transitions and stateful components.",
+			],
+			suggestions: [
+				"Always provide a unique :key based on the v-for item, such as an id.",
+			],
+		},
+		staticKey: {
+			primary:
+				"Static key values prevent Vue from tracking changes in v-for lists.",
+			secondary: [
+				'Using key="literal" means every item in the v-for shares the same key, which prevents Vue from tracking list updates correctly.',
+				"This blocks proper reactivity, leading to stale DOM content and skipped updates.",
+			],
+			suggestions: [
+				"Replace the static key with a dynamic and unique :key derived from the v-for item, such as item.id.",
+			],
+		},
+	},
+	setup(context) {
+		const { vueServices } = context;
+		if (vueServices == null) {
+			return {};
+		}
+		const { sfc } = vueServices;
+		const templateBlock = sfc.children.find(
+			(c): c is vue.ElementNode =>
+				c.type === vue.NodeTypes.ELEMENT && c.tag === "template",
+		);
+		if (templateBlock == null) {
+			return {};
+		}
+
+		const propValueRange = (propValue: vue.TextNode) => {
+			const strip = propValue.loc.source === propValue.content ? 0 : 1;
+			return {
+				begin: propValue.loc.start.offset + strip,
+				end: propValue.loc.end.offset - strip,
+			};
+		};
+
+		const checkFor = (
+			forDirective: vue.DirectiveNode,
+			forParseResult: vue.ForParseResult,
+			keyProp: null | vue.AttributeNode | vue.DirectiveNode,
+		) => {
+			if (keyProp == null) {
+				vueServices.reportSfc({
+					message: "missingKey",
+					range: {
+						begin: forDirective.loc.start.offset,
+						end: forDirective.loc.start.offset + "v-for".length,
+					},
+				});
+				return;
+			}
+			if (keyProp.type === vue.NodeTypes.ATTRIBUTE) {
+				if (keyProp.value == null) {
+					return; // TS error
+				}
+				vueServices.reportSfc({
+					message: "staticKey",
+					range: propValueRange(keyProp.value),
+				});
+				return;
+			}
+
+			if (keyProp.arg == null) {
+				throw new Error("Expected keyProp.arg to be non-null");
+			}
+
+			let reportRange: CharacterReportRange;
+			let valueRange: CharacterReportRange;
+
+			if (keyProp.exp == null) {
+				// :key
+				reportRange = {
+					begin: keyProp.loc.start.offset,
+					end: keyProp.loc.end.offset,
+				};
+				const generatedLocations = Array.from(
+					vueServices.map.toGeneratedLocation(keyProp.arg.loc.start.offset),
+				).filter(([, m]) => m.lengths[0] > 0);
+
+				// |key|: |key|
+				//        ^^^^^
+				// |key|: __VLS_ctx.|key|
+				//                  ^^^^^
+				const valueMapping = generatedLocations[1][1];
+
+				valueRange = {
+					begin: valueMapping.generatedOffsets[0],
+					end: valueMapping.generatedOffsets[0] + valueMapping.lengths[0],
+				};
+			} else {
+				reportRange = {
+					begin: keyProp.exp.loc.start.offset,
+					end: keyProp.exp.loc.end.offset,
+				};
+
+				const valueBegin = toGeneratedLocation(
+					vueServices.map,
+					keyProp.exp.loc.start.offset,
+				);
+				if (valueBegin == null) {
+					// Bug in vue/language-tools: virtual code is not generated for <template :key="">
+					// https://github.com/vuejs/language-tools/issues/4539
+					// Blocked on:
+					// https://github.com/vuejs/core/issues/11322 -> https://github.com/vuejs/core/pull/11323
+					return;
+				}
+
+				valueRange = {
+					begin: valueBegin,
+					end: toGeneratedLocationOrThrow(
+						vueServices.map,
+						keyProp.exp.loc.end.offset,
+					),
+				};
+			}
+
+			const loopVariableRanges = [
+				forParseResult.value,
+				forParseResult.key,
+				forParseResult.index,
+			]
+				.filter((v) => v != null)
+				.map((v) => ({
+					begin: toGeneratedLocationOrThrow(
+						vueServices.map,
+						v.loc.start.offset,
+					),
+					end: toGeneratedLocationOrThrow(vueServices.map, v.loc.end.offset),
+				}));
+
+			// TODO(perf): use ScopeManager instead
+			// https://github.com/JoshuaKGoldberg/flint/issues/400
+			const find = (current: ts.Node) => {
+				const currentBegin = current.getStart(context.sourceFile);
+				const currentEnd = current.getEnd();
+				if (currentBegin > valueRange.end || currentEnd <= valueRange.begin) {
+					return false;
+				}
+				if (
+					currentBegin >= valueRange.begin &&
+					currentEnd <= valueRange.end &&
+					ts.isIdentifier(current)
+				) {
+					const symbol = context.typeChecker.getSymbolAtLocation(current);
+					if (symbol?.valueDeclaration == null) {
+						return false;
+					}
+					const declStart = symbol.valueDeclaration.getStart(
+						context.sourceFile,
+					);
+					const declEnd = symbol.valueDeclaration.getEnd();
+
+					return loopVariableRanges.some(
+						({ begin, end }) => declStart >= begin && declEnd <= end,
+					);
+				}
+
+				return current.getChildren(context.sourceFile).some(find);
+			};
+
+			if (!find(context.sourceFile)) {
+				vueServices.reportSfc({
+					message: "invalidKey",
+					range: reportRange,
+				});
+			}
+		};
+
+		function visitTag(node: vue.TemplateChildNode) {
+			if (node.type === vue.NodeTypes.ELEMENT) {
+				let forDirective: null | vue.DirectiveNode = null;
+				let forParseResult: null | vue.ForParseResult = null;
+				let keyProp: null | vue.AttributeNode | vue.DirectiveNode = null;
+
+				for (const prop of node.props) {
+					if (
+						prop.type === vue.NodeTypes.DIRECTIVE &&
+						prop.name === "for" &&
+						prop.forParseResult != null
+					) {
+						forDirective = prop;
+						forParseResult = prop.forParseResult;
+					} else if (
+						prop.type === vue.NodeTypes.DIRECTIVE &&
+						prop.name === "bind" &&
+						vue.isStaticArgOf(prop.arg, "key")
+					) {
+						keyProp = prop;
+					} else if (
+						prop.type === vue.NodeTypes.ATTRIBUTE &&
+						prop.name === "key"
+					) {
+						keyProp = prop;
+					}
+				}
+
+				if (forDirective != null && forParseResult != null) {
+					checkFor(forDirective, forParseResult, keyProp);
+				}
+
+				node.children.forEach(visitTag);
+			}
+		}
+		templateBlock.children.forEach(visitTag);
+
+		return {};
+	},
+});
+
+function toGeneratedLocation(
+	map: VolarMapper,
+	sourceLocation: number,
+): number | undefined {
+	return Array.from(map.toGeneratedLocation(sourceLocation))?.[0]?.[0];
+}
+function toGeneratedLocationOrThrow(
+	map: VolarMapper,
+	sourceLocation: number,
+): number {
+	const generated = toGeneratedLocation(map, sourceLocation);
+	if (generated == null) {
+		throw new Error(
+			`Could not map source location ${sourceLocation} to generated location`,
+		);
+	}
+	return generated;
+}
diff --git a/packages/vue-language/tsconfig.json b/packages/vue-language/tsconfig.json
new file mode 100644
index 000000000..55ddcc02e
--- /dev/null
+++ b/packages/vue-language/tsconfig.json
@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"outDir": "lib",
+		"rootDir": "src"
+	},
+	"extends": "../../tsconfig.base.json",
+	"include": ["src"],
+	"references": [
+		{ "path": "../core" },
+		{ "path": "../ts" },
+		{ "path": "../rule-tester" }
+	]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 13b4f58c4..7314d0e87 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -131,6 +131,37 @@ importers:
         specifier: 4.2.0
         version: 4.2.0
 
+  packages/astro-language:
+    dependencies:
+      '@astrojs/language-server':
+        specifier: ^2.16.2
+        version: 2.16.2(prettier-plugin-astro@0.14.1)(prettier@3.7.4)(typescript@5.9.3)
+      '@flint.fyi/core':
+        specifier: 'workspace:'
+        version: link:../core
+      '@flint.fyi/ts':
+        specifier: 'workspace:'
+        version: link:../ts
+      '@volar/language-core':
+        specifier: 2.4.27
+        version: 2.4.27
+      '@volar/typescript':
+        specifier: 2.4.27
+        version: 2.4.27
+      ts-api-utils:
+        specifier: ^2.1.0
+        version: 2.1.0(typescript@5.9.3)
+      typescript:
+        specifier: '>=5.9.3'
+        version: 5.9.3
+      vscode-uri:
+        specifier: ^3.1.0
+        version: 3.1.0
+    devDependencies:
+      '@flint.fyi/rule-tester':
+        specifier: 'workspace:'
+        version: link:../rule-tester
+
   packages/cli:
     dependencies:
       '@flint.fyi/core':
@@ -562,6 +593,40 @@ importers:
 
   packages/utils: {}
 
+  packages/vue-language:
+    dependencies:
+      '@flint.fyi/core':
+        specifier: 'workspace:'
+        version: link:../core
+      '@flint.fyi/ts':
+        specifier: 'workspace:'
+        version: link:../ts
+      '@volar/language-core':
+        specifier: 2.4.27
+        version: 2.4.27
+      '@volar/typescript':
+        specifier: 2.4.27
+        version: 2.4.27
+      '@vue/compiler-dom':
+        specifier: ^3.5.0
+        version: 3.5.26
+      '@vue/language-core':
+        specifier: 3.2.1
+        version: 3.2.1
+      ts-api-utils:
+        specifier: ^2.1.0
+        version: 2.1.0(typescript@5.9.3)
+      typescript:
+        specifier: '>=5.9.3'
+        version: 5.9.3
+    devDependencies:
+      '@flint.fyi/rule-tester':
+        specifier: 'workspace:'
+        version: link:../rule-tester
+      vue:
+        specifier: ~3.5.26
+        version: 3.5.26(typescript@5.9.3)
+
   packages/yaml:
     dependencies:
       '@flint.fyi/core':
@@ -609,6 +674,18 @@ packages:
       prettier-plugin-astro:
         optional: true
 
+  '@astrojs/language-server@2.16.2':
+    resolution: {integrity: sha512-J3hVx/mFi3FwEzKf8ExYXQNERogD6RXswtbU+TyrxoXRBiQoBO5ooo7/lRWJ+rlUKUd7+rziMPI9jYB7TRlh0w==}
+    hasBin: true
+    peerDependencies:
+      prettier: ^3.0.0
+      prettier-plugin-astro: '>=0.11.0'
+    peerDependenciesMeta:
+      prettier:
+        optional: true
+      prettier-plugin-astro:
+        optional: true
+
   '@astrojs/markdown-remark@6.3.6':
     resolution: {integrity: sha512-bwylYktCTsLMVoCOEHbn2GSUA3c5KT/qilekBKA3CBng0bo1TYjNZPr761vxumRk9kJGqTOtU+fgCAp5Vwokug==}
 
@@ -1030,6 +1107,9 @@ packages:
   '@emmetio/css-parser@0.4.0':
     resolution: {integrity: sha512-z7wkxRSZgrQHXVzObGkXG+Vmj3uRlpM11oCZ9pbaz0nFejvCDmAiNDpY75+wgXOcffKpj4rzGtwGaZxfJKsJxw==}
 
+  '@emmetio/css-parser@0.4.1':
+    resolution: {integrity: sha512-2bC6m0MV/voF4CTZiAbG5MWKbq5EBmDPKu9Sb7s7nVcEzNQlrZP6mFFFlIaISM8X6514H9shWMme1fCm8cWAfQ==}
+
   '@emmetio/html-matcher@1.3.0':
     resolution: {integrity: sha512-NTbsvppE5eVyBMuyGfVu2CRrLvo7J4YHb6t9sBFLyY03WYhXET37qA4zOYUjBWFCRHO7pS1B9khERtY0f5JXPQ==}
 
@@ -2077,6 +2157,9 @@ packages:
   '@volar/language-core@2.4.23':
     resolution: {integrity: sha512-hEEd5ET/oSmBC6pi1j6NaNYRWoAiDhINbT8rmwtINugR39loROSlufGdYMF9TaKGfz+ViGs1Idi3mAhnuPcoGQ==}
 
+  '@volar/language-core@2.4.27':
+    resolution: {integrity: sha512-DjmjBWZ4tJKxfNC1F6HyYERNHPYS7L7OPFyCrestykNdUZMFYzI9WTyvwPcaNaHlrEUwESHYsfEw3isInncZxQ==}
+
   '@volar/language-server@2.4.23':
     resolution: {integrity: sha512-k0iO+tybMGMMyrNdWOxgFkP0XJTdbH0w+WZlM54RzJU3WZSjHEupwL30klpM7ep4FO6qyQa03h+VcGHD4Q8gEg==}
 
@@ -2086,15 +2169,53 @@ packages:
   '@volar/source-map@2.4.23':
     resolution: {integrity: sha512-Z1Uc8IB57Lm6k7q6KIDu/p+JWtf3xsXJqAX/5r18hYOTpJyBn0KXUR8oTJ4WFYOcDzWC9n3IflGgHowx6U6z9Q==}
 
+  '@volar/source-map@2.4.27':
+    resolution: {integrity: sha512-ynlcBReMgOZj2i6po+qVswtDUeeBRCTgDurjMGShbm8WYZgJ0PA4RmtebBJ0BCYol1qPv3GQF6jK7C9qoVc7lg==}
+
   '@volar/typescript@2.4.23':
     resolution: {integrity: sha512-lAB5zJghWxVPqfcStmAP1ZqQacMpe90UrP5RJ3arDyrhy4aCUQqmxPPLB2PWDKugvylmO41ljK7vZ+t6INMTag==}
 
+  '@volar/typescript@2.4.27':
+    resolution: {integrity: sha512-eWaYCcl/uAPInSK2Lze6IqVWaBu/itVqR5InXcHXFyles4zO++Mglt3oxdgj75BDcv1Knr9Y93nowS8U3wqhxg==}
+
   '@vscode/emmet-helper@2.11.0':
     resolution: {integrity: sha512-QLxjQR3imPZPQltfbWRnHU6JecWTF1QSWhx3GAKQpslx7y3Dp6sIIXhKjiUJ/BR9FX8PVthjr9PD6pNwOJfAzw==}
 
   '@vscode/l10n@0.0.18':
     resolution: {integrity: sha512-KYSIHVmslkaCDyw013pphY+d7x1qV8IZupYfeIfzNA+nsaWHbn5uPuQRvdRFsa9zFzGeudPuoGoZ1Op4jrJXIQ==}
 
+  '@vue/compiler-core@3.5.26':
+    resolution: {integrity: sha512-vXyI5GMfuoBCnv5ucIT7jhHKl55Y477yxP6fc4eUswjP8FG3FFVFd41eNDArR+Uk3QKn2Z85NavjaxLxOC19/w==}
+
+  '@vue/compiler-dom@3.5.26':
+    resolution: {integrity: sha512-y1Tcd3eXs834QjswshSilCBnKGeQjQXB6PqFn/1nxcQw4pmG42G8lwz+FZPAZAby6gZeHSt/8LMPfZ4Rb+Bd/A==}
+
+  '@vue/compiler-sfc@3.5.26':
+    resolution: {integrity: sha512-egp69qDTSEZcf4bGOSsprUr4xI73wfrY5oRs6GSgXFTiHrWj4Y3X5Ydtip9QMqiCMCPVwLglB9GBxXtTadJ3mA==}
+
+  '@vue/compiler-ssr@3.5.26':
+    resolution: {integrity: sha512-lZT9/Y0nSIRUPVvapFJEVDbEXruZh2IYHMk2zTtEgJSlP5gVOqeWXH54xDKAaFS4rTnDeDBQUYDtxKyoW9FwDw==}
+
+  '@vue/language-core@3.2.1':
+    resolution: {integrity: sha512-g6oSenpnGMtpxHGAwKuu7HJJkNZpemK/zg3vZzZbJ6cnnXq1ssxuNrXSsAHYM3NvH8p4IkTw+NLmuxyeYz4r8A==}
+
+  '@vue/reactivity@3.5.26':
+    resolution: {integrity: sha512-9EnYB1/DIiUYYnzlnUBgwU32NNvLp/nhxLXeWRhHUEeWNTn1ECxX8aGO7RTXeX6PPcxe3LLuNBFoJbV4QZ+CFQ==}
+
+  '@vue/runtime-core@3.5.26':
+    resolution: {integrity: sha512-xJWM9KH1kd201w5DvMDOwDHYhrdPTrAatn56oB/LRG4plEQeZRQLw0Bpwih9KYoqmzaxF0OKSn6swzYi84e1/Q==}
+
+  '@vue/runtime-dom@3.5.26':
+    resolution: {integrity: sha512-XLLd/+4sPC2ZkN/6+V4O4gjJu6kSDbHAChvsyWgm1oGbdSO3efvGYnm25yCjtFm/K7rrSDvSfPDgN1pHgS4VNQ==}
+
+  '@vue/server-renderer@3.5.26':
+    resolution: {integrity: sha512-TYKLXmrwWKSodyVuO1WAubucd+1XlLg4set0YoV+Hu8Lo79mp/YMwWV5mC5FgtsDxX3qo1ONrxFaTP1OQgy1uA==}
+    peerDependencies:
+      vue: 3.5.26
+
+  '@vue/shared@3.5.26':
+    resolution: {integrity: sha512-7Z6/y3uFI5PRoKeorTOSXKcDj0MSasfNNltcslbFrPpcw6aXRUALq4IfJlaTRspiWIUOEZbrpM+iQGmCOiWe4A==}
+
   acorn-jsx@5.3.2:
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
@@ -2105,12 +2226,23 @@ packages:
     engines: {node: '>=0.4.0'}
     hasBin: true
 
+  ajv-draft-04@1.0.0:
+    resolution: {integrity: sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw==}
+    peerDependencies:
+      ajv: ^8.5.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
   ajv@6.12.6:
     resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
 
   ajv@8.17.1:
     resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==}
 
+  alien-signals@3.1.2:
+    resolution: {integrity: sha512-d9dYqZTS90WLiU0I5c6DHj/HcKkF8ZyGN3G5x8wSbslulz70KOxaqCT0hQCo9KOyhVqzqGojvNdJXoTumZOtcw==}
+
   ansi-align@3.0.1:
     resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==}
 
@@ -2624,6 +2756,10 @@ packages:
     resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==}
     engines: {node: '>=0.12'}
 
+  entities@7.0.0:
+    resolution: {integrity: sha512-FDWG5cmEYf2Z00IkYRhbFrwIwvdFKH07uV8dvNy0omp/Qb1xcyCWp2UDtcwJF4QZZvk0sLudP6/hAu42TaqVhQ==}
+    engines: {node: '>=0.12'}
+
   env-paths@3.0.0:
     resolution: {integrity: sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -4709,6 +4845,14 @@ packages:
       '@volar/language-service':
         optional: true
 
+  volar-service-css@0.0.67:
+    resolution: {integrity: sha512-zV7C6enn9T9tuvQ6iSUyYEs34iPXR69Pf9YYWpbFYPWzVs22w96BtE8p04XYXbmjU6unt5oFt+iLL77bMB5fhA==}
+    peerDependencies:
+      '@volar/language-service': ~2.4.0
+    peerDependenciesMeta:
+      '@volar/language-service':
+        optional: true
+
   volar-service-emmet@0.0.62:
     resolution: {integrity: sha512-U4dxWDBWz7Pi4plpbXf4J4Z/ss6kBO3TYrACxWNsE29abu75QzVS0paxDDhI6bhqpbDFXlpsDhZ9aXVFpnfGRQ==}
     peerDependencies:
@@ -4717,6 +4861,14 @@ packages:
       '@volar/language-service':
         optional: true
 
+  volar-service-emmet@0.0.67:
+    resolution: {integrity: sha512-UDBL5x7KptmuJZNCCXMlCndMhFult/tj+9jXq3FH1ZGS1E4M/1U5hC06pg1c6e4kn+vnR6bqmvX0vIhL4f98+A==}
+    peerDependencies:
+      '@volar/language-service': ~2.4.0
+    peerDependenciesMeta:
+      '@volar/language-service':
+        optional: true
+
   volar-service-html@0.0.62:
     resolution: {integrity: sha512-Zw01aJsZRh4GTGUjveyfEzEqpULQUdQH79KNEiKVYHZyuGtdBRYCHlrus1sueSNMxwwkuF5WnOHfvBzafs8yyQ==}
     peerDependencies:
@@ -4725,6 +4877,14 @@ packages:
       '@volar/language-service':
         optional: true
 
+  volar-service-html@0.0.67:
+    resolution: {integrity: sha512-ljREMF79JbcjNvObiv69HK2HCl5UT7WTD10zi6CRFUHMbPfiF2UZ42HGLsEGSzaHGZz6H4IFjSS/qfENRLUviQ==}
+    peerDependencies:
+      '@volar/language-service': ~2.4.0
+    peerDependenciesMeta:
+      '@volar/language-service':
+        optional: true
+
   volar-service-prettier@0.0.62:
     resolution: {integrity: sha512-h2yk1RqRTE+vkYZaI9KYuwpDfOQRrTEMvoHol0yW4GFKc75wWQRrb5n/5abDrzMPrkQbSip8JH2AXbvrRtYh4w==}
     peerDependencies:
@@ -4736,6 +4896,17 @@ packages:
       prettier:
         optional: true
 
+  volar-service-prettier@0.0.67:
+    resolution: {integrity: sha512-B4KnPJPNWFTkEDa6Fn08i5PpO6T1CecmLLTFZoXz2eI4Fxwba/3nDaaVSsEP7e/vEe+U5YqV9fBzayJT71G5xg==}
+    peerDependencies:
+      '@volar/language-service': ~2.4.0
+      prettier: ^2.2 || ^3.0
+    peerDependenciesMeta:
+      '@volar/language-service':
+        optional: true
+      prettier:
+        optional: true
+
   volar-service-typescript-twoslash-queries@0.0.62:
     resolution: {integrity: sha512-KxFt4zydyJYYI0kFAcWPTh4u0Ha36TASPZkAnNY784GtgajerUqM80nX/W1d0wVhmcOFfAxkVsf/Ed+tiYU7ng==}
     peerDependencies:
@@ -4744,6 +4915,14 @@ packages:
       '@volar/language-service':
         optional: true
 
+  volar-service-typescript-twoslash-queries@0.0.67:
+    resolution: {integrity: sha512-LD2R7WivDYp1SPgZrxx/0222xVTitDjm36oKo5+bfYG5kEgnw+BOPVHdwmvpJKg/RfssfxDI1ouwD4XkEDEfbA==}
+    peerDependencies:
+      '@volar/language-service': ~2.4.0
+    peerDependenciesMeta:
+      '@volar/language-service':
+        optional: true
+
   volar-service-typescript@0.0.62:
     resolution: {integrity: sha512-p7MPi71q7KOsH0eAbZwPBiKPp9B2+qrdHAd6VY5oTo9BUXatsOAdakTm9Yf0DUj6uWBAaOT01BSeVOPwucMV1g==}
     peerDependencies:
@@ -4752,6 +4931,14 @@ packages:
       '@volar/language-service':
         optional: true
 
+  volar-service-typescript@0.0.67:
+    resolution: {integrity: sha512-rfQBy36Rm1PU9vLWHk8BYJ4r2j/CI024vocJcH4Nb6K2RTc2Irmw6UOVY5DdGiPRV5r+e10wLMK5njj/EcL8sA==}
+    peerDependencies:
+      '@volar/language-service': ~2.4.0
+    peerDependenciesMeta:
+      '@volar/language-service':
+        optional: true
+
   volar-service-yaml@0.0.62:
     resolution: {integrity: sha512-k7gvv7sk3wa+nGll3MaSKyjwQsJjIGCHFjVkl3wjaSP2nouKyn9aokGmqjrl39mi88Oy49giog2GkZH526wjig==}
     peerDependencies:
@@ -4760,12 +4947,23 @@ packages:
       '@volar/language-service':
         optional: true
 
+  volar-service-yaml@0.0.67:
+    resolution: {integrity: sha512-jkdP/RF6wPIXEE3Ktnd81oJPn7aAvnVSiaqQHThC2Hrvo6xd9pEcqtbBUI+YfqVgvcMtXAkbtNO61K2GPhAiuA==}
+    peerDependencies:
+      '@volar/language-service': ~2.4.0
+    peerDependenciesMeta:
+      '@volar/language-service':
+        optional: true
+
   vscode-css-languageservice@6.3.7:
     resolution: {integrity: sha512-5TmXHKllPzfkPhW4UE9sODV3E0bIOJPOk+EERKllf2SmAczjfTmYeq5txco+N3jpF8KIZ6loj/JptpHBQuVQRA==}
 
   vscode-html-languageservice@5.5.1:
     resolution: {integrity: sha512-/ZdEtsZ3OiFSyL00kmmu7crFV9KwWR+MgpzjsxO60DQH7sIfHZM892C/E4iDd11EKocr+NYuvOA4Y7uc3QzLEA==}
 
+  vscode-html-languageservice@5.6.1:
+    resolution: {integrity: sha512-5Mrqy5CLfFZUgkyhNZLA1Ye5g12Cb/v6VM7SxUzZUaRKWMDz4md+y26PrfRTSU0/eQAl3XpO9m2og+GGtDMuaA==}
+
   vscode-json-languageservice@4.1.8:
     resolution: {integrity: sha512-0vSpg6Xd9hfV+eZAaYN63xVVMOTmJ4GgHxXnkLCh+9RsQBkWKIghzLhW2B9ebfG+LQQg8uLtsQ2aUKjTgE+QOg==}
     engines: {npm: '>=7.0.0'}
@@ -4807,6 +5005,14 @@ packages:
   vscode-uri@3.1.0:
     resolution: {integrity: sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==}
 
+  vue@3.5.26:
+    resolution: {integrity: sha512-SJ/NTccVyAoNUJmkM9KUqPcYlY+u8OVL1X5EW9RIs3ch5H2uERxyyIUI4MRxVCSOiEcupX9xNGde1tL9ZKpimA==}
+    peerDependencies:
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+
   walk-up-path@4.0.0:
     resolution: {integrity: sha512-3hu+tD8YzSLGuFYtPRb48vdhKMi0KQV5sn+uWr8+7dMEq/2G/dtLrdDinkLjqq5TIbIBjYJ4Ax/n3YiaW7QM8A==}
     engines: {node: 20 || >=22}
@@ -4866,6 +5072,10 @@ packages:
     resolution: {integrity: sha512-N47AqBDCMQmh6mBLmI6oqxryHRzi33aPFPsJhYy3VTUGCdLHYjGh4FZzpUjRlphaADBBkDmnkM/++KNIOHi5Rw==}
     hasBin: true
 
+  yaml-language-server@1.19.2:
+    resolution: {integrity: sha512-9F3myNmJzUN/679jycdMxqtydPSDRAarSj3wPiF7pchEPnO9Dg07Oc+gIYLqXR4L+g+FSEVXXv2+mr54StLFOg==}
+    hasBin: true
+
   yaml-unist-parser@3.1.0:
     resolution: {integrity: sha512-hkwsdPLFBV6Vs40Mw5A11gzN9f9AiN8g72D8fXxfqnrW/AYY8/d7Yphx780UMzREcH7aRuHYAyQj9AwrI4E4xg==}
     engines: {node: '>= 14'}
@@ -4874,6 +5084,11 @@ packages:
     resolution: {integrity: sha512-CBKFWExMn46Foo4cldiChEzn7S7SRV+wqiluAb6xmueD/fGyRHIhX8m14vVGgeFWjN540nKCNVj6P21eQjgTuA==}
     engines: {node: '>= 14'}
 
+  yaml@2.7.1:
+    resolution: {integrity: sha512-10ULxpnOCQXxJvBgxsn9ptjq6uviG/htZKk9veJGhlqn3w/DxQ631zFF+nlQXLwmImeS5amR2dl2U8sg6U9jsQ==}
+    engines: {node: '>= 14'}
+    hasBin: true
+
   yaml@2.8.2:
     resolution: {integrity: sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==}
     engines: {node: '>= 14.6'}
@@ -4958,7 +5173,7 @@ snapshots:
       '@astrojs/yaml2ts': 0.2.2
       '@jridgewell/sourcemap-codec': 1.5.5
       '@volar/kit': 2.4.23(typescript@5.9.3)
-      '@volar/language-core': 2.4.23
+      '@volar/language-core': 2.4.27
       '@volar/language-server': 2.4.23
       '@volar/language-service': 2.4.23
       fast-glob: 3.3.3
@@ -4978,6 +5193,32 @@ snapshots:
     transitivePeerDependencies:
       - typescript
 
+  '@astrojs/language-server@2.16.2(prettier-plugin-astro@0.14.1)(prettier@3.7.4)(typescript@5.9.3)':
+    dependencies:
+      '@astrojs/compiler': 2.13.0
+      '@astrojs/yaml2ts': 0.2.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@volar/kit': 2.4.23(typescript@5.9.3)
+      '@volar/language-core': 2.4.27
+      '@volar/language-server': 2.4.23
+      '@volar/language-service': 2.4.23
+      fast-glob: 3.3.3
+      muggle-string: 0.4.1
+      volar-service-css: 0.0.67(@volar/language-service@2.4.23)
+      volar-service-emmet: 0.0.67(@volar/language-service@2.4.23)
+      volar-service-html: 0.0.67(@volar/language-service@2.4.23)
+      volar-service-prettier: 0.0.67(@volar/language-service@2.4.23)(prettier@3.7.4)
+      volar-service-typescript: 0.0.67(@volar/language-service@2.4.23)
+      volar-service-typescript-twoslash-queries: 0.0.67(@volar/language-service@2.4.23)
+      volar-service-yaml: 0.0.67(@volar/language-service@2.4.23)
+      vscode-html-languageservice: 5.6.1
+      vscode-uri: 3.1.0
+    optionalDependencies:
+      prettier: 3.7.4
+      prettier-plugin-astro: 0.14.1
+    transitivePeerDependencies:
+      - typescript
+
   '@astrojs/markdown-remark@6.3.6':
     dependencies:
       '@astrojs/internal-helpers': 0.7.2
@@ -5623,6 +5864,11 @@ snapshots:
       '@emmetio/stream-reader': 2.2.0
       '@emmetio/stream-reader-utils': 0.1.0
 
+  '@emmetio/css-parser@0.4.1':
+    dependencies:
+      '@emmetio/stream-reader': 2.2.0
+      '@emmetio/stream-reader-utils': 0.1.0
+
   '@emmetio/html-matcher@1.3.0':
     dependencies:
       '@emmetio/scanner': 1.0.4
@@ -6617,6 +6863,10 @@ snapshots:
     dependencies:
       '@volar/source-map': 2.4.23
 
+  '@volar/language-core@2.4.27':
+    dependencies:
+      '@volar/source-map': 2.4.27
+
   '@volar/language-server@2.4.23':
     dependencies:
       '@volar/language-core': 2.4.23
@@ -6638,12 +6888,20 @@ snapshots:
 
   '@volar/source-map@2.4.23': {}
 
+  '@volar/source-map@2.4.27': {}
+
   '@volar/typescript@2.4.23':
     dependencies:
       '@volar/language-core': 2.4.23
       path-browserify: 1.0.1
       vscode-uri: 3.1.0
 
+  '@volar/typescript@2.4.27':
+    dependencies:
+      '@volar/language-core': 2.4.27
+      path-browserify: 1.0.1
+      vscode-uri: 3.1.0
+
   '@vscode/emmet-helper@2.11.0':
     dependencies:
       emmet: 2.4.11
@@ -6654,12 +6912,80 @@ snapshots:
 
   '@vscode/l10n@0.0.18': {}
 
+  '@vue/compiler-core@3.5.26':
+    dependencies:
+      '@babel/parser': 7.28.5
+      '@vue/shared': 3.5.26
+      entities: 7.0.0
+      estree-walker: 2.0.2
+      source-map-js: 1.2.1
+
+  '@vue/compiler-dom@3.5.26':
+    dependencies:
+      '@vue/compiler-core': 3.5.26
+      '@vue/shared': 3.5.26
+
+  '@vue/compiler-sfc@3.5.26':
+    dependencies:
+      '@babel/parser': 7.28.5
+      '@vue/compiler-core': 3.5.26
+      '@vue/compiler-dom': 3.5.26
+      '@vue/compiler-ssr': 3.5.26
+      '@vue/shared': 3.5.26
+      estree-walker: 2.0.2
+      magic-string: 0.30.21
+      postcss: 8.5.6
+      source-map-js: 1.2.1
+
+  '@vue/compiler-ssr@3.5.26':
+    dependencies:
+      '@vue/compiler-dom': 3.5.26
+      '@vue/shared': 3.5.26
+
+  '@vue/language-core@3.2.1':
+    dependencies:
+      '@volar/language-core': 2.4.27
+      '@vue/compiler-dom': 3.5.26
+      '@vue/shared': 3.5.26
+      alien-signals: 3.1.2
+      muggle-string: 0.4.1
+      path-browserify: 1.0.1
+      picomatch: 4.0.3
+
+  '@vue/reactivity@3.5.26':
+    dependencies:
+      '@vue/shared': 3.5.26
+
+  '@vue/runtime-core@3.5.26':
+    dependencies:
+      '@vue/reactivity': 3.5.26
+      '@vue/shared': 3.5.26
+
+  '@vue/runtime-dom@3.5.26':
+    dependencies:
+      '@vue/reactivity': 3.5.26
+      '@vue/runtime-core': 3.5.26
+      '@vue/shared': 3.5.26
+      csstype: 3.2.3
+
+  '@vue/server-renderer@3.5.26(vue@3.5.26(typescript@5.9.3))':
+    dependencies:
+      '@vue/compiler-ssr': 3.5.26
+      '@vue/shared': 3.5.26
+      vue: 3.5.26(typescript@5.9.3)
+
+  '@vue/shared@3.5.26': {}
+
   acorn-jsx@5.3.2(acorn@8.15.0):
     dependencies:
       acorn: 8.15.0
 
   acorn@8.15.0: {}
 
+  ajv-draft-04@1.0.0(ajv@8.17.1):
+    optionalDependencies:
+      ajv: 8.17.1
+
   ajv@6.12.6:
     dependencies:
       fast-deep-equal: 3.1.3
@@ -6674,6 +7000,8 @@ snapshots:
       json-schema-traverse: 1.0.0
       require-from-string: 2.0.2
 
+  alien-signals@3.1.2: {}
+
   ansi-align@3.0.1:
     dependencies:
       string-width: 4.2.3
@@ -7249,6 +7577,8 @@ snapshots:
 
   entities@6.0.1: {}
 
+  entities@7.0.0: {}
+
   env-paths@3.0.0: {}
 
   environment@1.1.0: {}
@@ -9899,6 +10229,14 @@ snapshots:
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
+  volar-service-css@0.0.67(@volar/language-service@2.4.23):
+    dependencies:
+      vscode-css-languageservice: 6.3.7
+      vscode-languageserver-textdocument: 1.0.12
+      vscode-uri: 3.1.0
+    optionalDependencies:
+      '@volar/language-service': 2.4.23
+
   volar-service-emmet@0.0.62(@volar/language-service@2.4.23):
     dependencies:
       '@emmetio/css-parser': 0.4.0
@@ -9908,6 +10246,15 @@ snapshots:
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
+  volar-service-emmet@0.0.67(@volar/language-service@2.4.23):
+    dependencies:
+      '@emmetio/css-parser': 0.4.1
+      '@emmetio/html-matcher': 1.3.0
+      '@vscode/emmet-helper': 2.11.0
+      vscode-uri: 3.1.0
+    optionalDependencies:
+      '@volar/language-service': 2.4.23
+
   volar-service-html@0.0.62(@volar/language-service@2.4.23):
     dependencies:
       vscode-html-languageservice: 5.5.1
@@ -9916,6 +10263,14 @@ snapshots:
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
+  volar-service-html@0.0.67(@volar/language-service@2.4.23):
+    dependencies:
+      vscode-html-languageservice: 5.6.1
+      vscode-languageserver-textdocument: 1.0.12
+      vscode-uri: 3.1.0
+    optionalDependencies:
+      '@volar/language-service': 2.4.23
+
   volar-service-prettier@0.0.62(@volar/language-service@2.4.23)(prettier@3.7.4):
     dependencies:
       vscode-uri: 3.1.0
@@ -9923,12 +10278,25 @@ snapshots:
       '@volar/language-service': 2.4.23
       prettier: 3.7.4
 
+  volar-service-prettier@0.0.67(@volar/language-service@2.4.23)(prettier@3.7.4):
+    dependencies:
+      vscode-uri: 3.1.0
+    optionalDependencies:
+      '@volar/language-service': 2.4.23
+      prettier: 3.7.4
+
   volar-service-typescript-twoslash-queries@0.0.62(@volar/language-service@2.4.23):
     dependencies:
       vscode-uri: 3.1.0
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
+  volar-service-typescript-twoslash-queries@0.0.67(@volar/language-service@2.4.23):
+    dependencies:
+      vscode-uri: 3.1.0
+    optionalDependencies:
+      '@volar/language-service': 2.4.23
+
   volar-service-typescript@0.0.62(@volar/language-service@2.4.23):
     dependencies:
       path-browserify: 1.0.1
@@ -9940,6 +10308,17 @@ snapshots:
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
+  volar-service-typescript@0.0.67(@volar/language-service@2.4.23):
+    dependencies:
+      path-browserify: 1.0.1
+      semver: 7.7.3
+      typescript-auto-import-cache: 0.3.6
+      vscode-languageserver-textdocument: 1.0.12
+      vscode-nls: 5.2.0
+      vscode-uri: 3.1.0
+    optionalDependencies:
+      '@volar/language-service': 2.4.23
+
   volar-service-yaml@0.0.62(@volar/language-service@2.4.23):
     dependencies:
       vscode-uri: 3.1.0
@@ -9947,6 +10326,13 @@ snapshots:
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
+  volar-service-yaml@0.0.67(@volar/language-service@2.4.23):
+    dependencies:
+      vscode-uri: 3.1.0
+      yaml-language-server: 1.19.2
+    optionalDependencies:
+      '@volar/language-service': 2.4.23
+
   vscode-css-languageservice@6.3.7:
     dependencies:
       '@vscode/l10n': 0.0.18
@@ -9961,6 +10347,13 @@ snapshots:
       vscode-languageserver-types: 3.17.5
       vscode-uri: 3.1.0
 
+  vscode-html-languageservice@5.6.1:
+    dependencies:
+      '@vscode/l10n': 0.0.18
+      vscode-languageserver-textdocument: 1.0.12
+      vscode-languageserver-types: 3.17.5
+      vscode-uri: 3.1.0
+
   vscode-json-languageservice@4.1.8:
     dependencies:
       jsonc-parser: 3.3.1
@@ -10001,6 +10394,16 @@ snapshots:
 
   vscode-uri@3.1.0: {}
 
+  vue@3.5.26(typescript@5.9.3):
+    dependencies:
+      '@vue/compiler-dom': 3.5.26
+      '@vue/compiler-sfc': 3.5.26
+      '@vue/runtime-dom': 3.5.26
+      '@vue/server-renderer': 3.5.26(vue@3.5.26(typescript@5.9.3))
+      '@vue/shared': 3.5.26
+    optionalDependencies:
+      typescript: 5.9.3
+
   walk-up-path@4.0.0: {}
 
   web-namespaces@2.0.1: {}
@@ -10062,12 +10465,29 @@ snapshots:
     optionalDependencies:
       prettier: 2.8.7
 
+  yaml-language-server@1.19.2:
+    dependencies:
+      '@vscode/l10n': 0.0.18
+      ajv: 8.17.1
+      ajv-draft-04: 1.0.0(ajv@8.17.1)
+      lodash: 4.17.21
+      prettier: 3.7.4
+      request-light: 0.5.8
+      vscode-json-languageservice: 4.1.8
+      vscode-languageserver: 9.0.1
+      vscode-languageserver-textdocument: 1.0.12
+      vscode-languageserver-types: 3.17.5
+      vscode-uri: 3.1.0
+      yaml: 2.7.1
+
   yaml-unist-parser@3.1.0:
     dependencies:
       yaml: 2.8.2
 
   yaml@2.2.2: {}
 
+  yaml@2.7.1: {}
+
   yaml@2.8.2: {}
 
   yargs-parser@21.1.1: {}
diff --git a/tsconfig.json b/tsconfig.json
index 36146589a..9c87f23ea 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -5,6 +5,7 @@
 	"extends": "./tsconfig.base.json",
 	"include": ["./*.ts"],
 	"references": [
+		{ "path": "./packages/astro-language" },
 		{ "path": "./packages/comparisons" },
 		{ "path": "./packages/core" },
 		{ "path": "./packages/cli" },
@@ -24,6 +25,7 @@
 		{ "path": "./packages/plugin-spelling" },
 		{ "path": "./packages/text" },
 		{ "path": "./packages/ts" },
+		{ "path": "./packages/vue-language" },
 		{ "path": "./packages/yaml" }
 	]
 }

From 4222a5bc1346c9cafd78544537f0a00141df3353 Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Tue, 30 Dec 2025 14:40:19 +0300
Subject: [PATCH 02/11] wip

---
 package.json                                  |    3 +
 .../core/src/host/createFSBackedLinterHost.ts |   65 +
 packages/core/src/host/createVFSLinterHost.ts |  162 ++
 packages/core/src/host/normalizePath.ts       |    5 +
 packages/core/src/index.ts                    |    4 +
 packages/core/src/languages/createLanguage.ts |   17 +-
 packages/core/src/languages/makeDisposable.ts |    2 +-
 packages/core/src/running/lintFile.ts         |    2 +-
 packages/core/src/types/host.ts               |   31 +
 packages/core/src/types/languages.ts          |   13 +-
 packages/json/src/language.ts                 |   11 +-
 packages/md/src/language.ts                   |    9 +-
 .../plugin-browser/src/rules/ruleTester.ts    |    7 +-
 .../src/rules/blobReadingMethods.ts           |    2 +-
 packages/plugin-node/src/rules/ruleTester.ts  |    7 +-
 packages/rule-tester/src/RuleTester.ts        |   88 +-
 packages/rule-tester/src/host.ts              |   49 +
 packages/rule-tester/src/index.ts             |    1 +
 packages/rule-tester/src/runTestCaseRule.ts   |    4 +-
 packages/rule-tester/src/types.ts             |    1 +
 packages/text/src/language.ts                 |   11 +-
 packages/ts/src/language.ts                   |   18 +-
 .../ts/src/prepareTypeScriptBasedLanguage.ts  |  185 ++-
 .../ts/src/rules/functionNewCalls.test.ts     |   10 +
 .../ts/src/rules/globalAssignments.test.ts    |    8 +
 packages/ts/src/rules/ruleTester.ts           |    3 +-
 .../ts/src/rules/undefinedVariables.test.ts   |   16 +-
 packages/ts/src/typescriptUtilities.ts        | 1476 +++++++++++++++++
 packages/yaml/src/language.ts                 |    9 +-
 ...cript-eslint__project-service@8.50.1.patch |   41 +
 pnpm-lock.yaml                                |   11 +-
 31 files changed, 2132 insertions(+), 139 deletions(-)
 create mode 100644 packages/core/src/host/createFSBackedLinterHost.ts
 create mode 100644 packages/core/src/host/createVFSLinterHost.ts
 create mode 100644 packages/core/src/host/normalizePath.ts
 create mode 100644 packages/core/src/types/host.ts
 create mode 100644 packages/rule-tester/src/host.ts
 create mode 100644 packages/ts/src/typescriptUtilities.ts
 create mode 100644 patches/@typescript-eslint__project-service@8.50.1.patch

diff --git a/package.json b/package.json
index 5b1df5518..360c264a2 100644
--- a/package.json
+++ b/package.json
@@ -84,6 +84,9 @@
 			"read-package-up": "12.0.0",
 			"read-pkg": "10.0.0",
 			"unicorn-magic": "0.4.0"
+		},
+		"patchedDependencies": {
+			"@typescript-eslint/project-service@8.50.1": "patches/@typescript-eslint__project-service@8.50.1.patch"
 		}
 	}
 }
diff --git a/packages/core/src/host/createFSBackedLinterHost.ts b/packages/core/src/host/createFSBackedLinterHost.ts
new file mode 100644
index 000000000..4662cffd5
--- /dev/null
+++ b/packages/core/src/host/createFSBackedLinterHost.ts
@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+import { LinterHost, LinterHostDirectoryEntry } from "../types/host.js";
+import { normalizePath } from "./normalizePath.js";
+
+export function createFSBackedLinterHost(cwd: string): LinterHost {
+	cwd = normalizePath(cwd);
+
+	return {
+		getCurrentDirectory() {
+			return cwd;
+		},
+		stat(pathAbsolute) {
+			try {
+				const stat = fs.statSync(pathAbsolute);
+				if (stat.isDirectory()) {
+					return "directory";
+				}
+				if (stat.isFile()) {
+					return "file";
+				}
+			} catch {}
+			return undefined;
+		},
+		readDirectory(directoryPathAbsolute) {
+			const result: LinterHostDirectoryEntry[] = [];
+			const dirents = fs.readdirSync(directoryPathAbsolute, {
+				withFileTypes: true,
+			});
+
+			for (let entry of dirents) {
+				let stat = entry as Pick<typeof entry, "isFile" | "isDirectory">;
+				if (entry.isSymbolicLink()) {
+					try {
+						stat = fs.statSync(path.join(directoryPathAbsolute, entry.name));
+					} catch {
+						continue;
+					}
+				}
+				if (stat.isDirectory()) {
+					result.push({ type: "directory", name: entry.name });
+				}
+				if (stat.isFile()) {
+					result.push({ type: "file", name: entry.name });
+				}
+			}
+
+			return result;
+		},
+		readFile(filePathAbsolute) {
+			return fs.readFileSync(filePathAbsolute, "utf8");
+		},
+		// TODO
+		watchFile(filePathAbsolute, callback) {
+			return {
+				[Symbol.dispose]() {},
+			};
+		},
+		watchDirectory(directoryPathAbsolute, recursive, callback) {
+			return {
+				[Symbol.dispose]() {},
+			};
+		},
+	};
+}
diff --git a/packages/core/src/host/createVFSLinterHost.ts b/packages/core/src/host/createVFSLinterHost.ts
new file mode 100644
index 000000000..426bea87b
--- /dev/null
+++ b/packages/core/src/host/createVFSLinterHost.ts
@@ -0,0 +1,162 @@
+import path from "node:path";
+import {
+	LinterHost,
+	LinterHostDirectoryEntry,
+	LinterHostDirectoryWatcher,
+	LinterHostFileWatcher,
+	LinterHostFileWatcherEvent,
+	VFSLinterHost,
+} from "../types/host.js";
+import { normalizePath } from "./normalizePath.js";
+
+export function createVFSLinterHost(
+	cwd: string,
+	baseHost?: LinterHost,
+): VFSLinterHost {
+	cwd = normalizePath(cwd);
+	const fileMap = new Map<string, string>();
+	const fileWatchers = new Map<string, Set<LinterHostFileWatcher>>();
+	const directoryWatchers = new Map<string, Set<LinterHostDirectoryWatcher>>();
+	const recursiveDirectoryWatchers = new Map<
+		string,
+		Set<LinterHostDirectoryWatcher>
+	>();
+	function watchEvent(
+		normalizedFilePathAbsolute: string,
+		fileEvent: LinterHostFileWatcherEvent,
+	) {
+		for (const watcher of fileWatchers.get(normalizedFilePathAbsolute) ?? []) {
+			watcher(fileEvent);
+		}
+		let slashIdx = normalizedFilePathAbsolute.lastIndexOf("/");
+		if (slashIdx < 0) {
+			return;
+		}
+		let directoryPathAbsolute = normalizedFilePathAbsolute.slice(0, slashIdx);
+		for (const watcher of directoryWatchers.get(directoryPathAbsolute) ?? []) {
+			watcher(normalizedFilePathAbsolute);
+		}
+		do {
+			directoryPathAbsolute = directoryPathAbsolute.slice(0, slashIdx);
+			for (const watcher of recursiveDirectoryWatchers.get(
+				directoryPathAbsolute,
+			) ?? []) {
+				watcher(normalizedFilePathAbsolute);
+			}
+		} while ((slashIdx = directoryPathAbsolute.lastIndexOf("/")) >= 0);
+	}
+	return {
+		getCurrentDirectory() {
+			return cwd;
+		},
+		stat(pathAbsolute) {
+			pathAbsolute = normalizePath(pathAbsolute);
+			for (const filePath of fileMap.keys()) {
+				if (pathAbsolute === filePath) {
+					return "file";
+				}
+				if (filePath.startsWith(pathAbsolute + "/")) {
+					return "directory";
+				}
+			}
+			return baseHost?.stat(pathAbsolute);
+		},
+		readFile(filePathAbsolute) {
+			filePathAbsolute = normalizePath(filePathAbsolute);
+			return (
+				fileMap.get(filePathAbsolute) ?? baseHost?.readFile(filePathAbsolute)
+			);
+		},
+		readDirectory(directoryPathAbsolute) {
+			directoryPathAbsolute = normalizePath(directoryPathAbsolute) + "/";
+			const result = new Map<string, LinterHostDirectoryEntry>();
+
+			for (let filePath of fileMap.keys()) {
+				if (!filePath.startsWith(directoryPathAbsolute)) {
+					continue;
+				}
+				filePath = filePath.slice(directoryPathAbsolute.length);
+				const slashIndex = filePath.indexOf("/");
+				let dirent: LinterHostDirectoryEntry = {
+					type: "file",
+					name: filePath,
+				};
+				if (slashIndex >= 0) {
+					dirent = {
+						type: "directory",
+						name: filePath.slice(0, slashIndex),
+					};
+				}
+				if (!result.get(dirent.name)) {
+					result.set(dirent.name, dirent);
+				}
+			}
+
+			return [
+				...result.values(),
+				...(baseHost?.readDirectory(directoryPathAbsolute) ?? []),
+			];
+		},
+		watchFile(filePathAbsolute, callback) {
+			filePathAbsolute = normalizePath(filePathAbsolute);
+			let watchers = fileWatchers.get(filePathAbsolute);
+			if (watchers == null) {
+				watchers = new Set();
+				fileWatchers.set(filePathAbsolute, watchers);
+			}
+			watchers.add(callback);
+			const baseWatcher = baseHost?.watchFile(filePathAbsolute, callback);
+			return {
+				[Symbol.dispose]() {
+					watchers.delete(callback);
+					if (watchers.size === 0) {
+						fileWatchers.delete(filePathAbsolute);
+					}
+					baseWatcher?.[Symbol.dispose]();
+				},
+			};
+		},
+		watchDirectory(directoryPathAbsolute, recursive, callback) {
+			directoryPathAbsolute = normalizePath(directoryPathAbsolute);
+			const collection = recursive
+				? recursiveDirectoryWatchers
+				: directoryWatchers;
+			let watchers = collection.get(directoryPathAbsolute);
+			if (watchers == null) {
+				watchers = new Set();
+				collection.set(directoryPathAbsolute, watchers);
+			}
+			watchers.add(callback);
+			const baseWatcher = baseHost?.watchDirectory(
+				directoryPathAbsolute,
+				recursive,
+				callback,
+			);
+			return {
+				[Symbol.dispose]() {
+					watchers.delete(callback);
+					if (watchers.size === 0) {
+						collection.delete(directoryPathAbsolute);
+					}
+					baseWatcher?.[Symbol.dispose]();
+				},
+			};
+		},
+		vfsUpsertFile(filePathAbsolute, content) {
+			filePathAbsolute = normalizePath(filePathAbsolute);
+			const fileEvent = fileMap.has(filePathAbsolute) ? "changed" : "created";
+			fileMap.set(filePathAbsolute, content);
+			watchEvent(filePathAbsolute, fileEvent);
+		},
+		vfsDeleteFile(filePathAbsolute) {
+			filePathAbsolute = normalizePath(filePathAbsolute);
+			if (!fileMap.delete(filePathAbsolute)) {
+				return;
+			}
+			watchEvent(filePathAbsolute, "deleted");
+		},
+		vfsListFiles() {
+			return fileMap;
+		},
+	};
+}
diff --git a/packages/core/src/host/normalizePath.ts b/packages/core/src/host/normalizePath.ts
new file mode 100644
index 000000000..7fe823659
--- /dev/null
+++ b/packages/core/src/host/normalizePath.ts
@@ -0,0 +1,5 @@
+import { normalize } from "node:path";
+
+export function normalizePath(path: string): string {
+	return normalize(path).replaceAll("\\", "/");
+}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 789c15ad3..2166954fc 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -16,6 +16,9 @@ export {
 	setTSExtraSupportedExtensions,
 	setTSProgramCreationProxy,
 } from "./ts-patch/proxy-program.js";
+export { createVFSLinterHost } from "./host/createVFSLinterHost.js";
+export { createFSBackedLinterHost } from "./host/createFSBackedLinterHost.js";
+export { normalizePath } from "./host/normalizePath.js";
 export * from "./types/about.js";
 export * from "./types/cache.js";
 export * from "./types/changes.js";
@@ -23,6 +26,7 @@ export * from "./types/configs.js";
 export * from "./types/context.js";
 export * from "./types/directives.js";
 export * from "./types/formatting.js";
+export * from "./types/host.js";
 export * from "./types/languages.js";
 export * from "./types/linting.js";
 export * from "./types/modes.js";
diff --git a/packages/core/src/languages/createLanguage.ts b/packages/core/src/languages/createLanguage.ts
index fdeffb113..f9616c71e 100644
--- a/packages/core/src/languages/createLanguage.ts
+++ b/packages/core/src/languages/createLanguage.ts
@@ -23,29 +23,20 @@ export function createLanguage<AstNodesByName, ContextServices extends object>(
 			};
 		}) as CreateRule<AstNodesByName, ContextServices>,
 
-		prepare() {
+		prepare(host) {
 			log(
 				"Preparing file factory for language: %s",
 				languageDefinition.about.name,
 			);
 
-			const fileFactoryDefinition = languageDefinition.prepare();
+			const fileFactoryDefinition = languageDefinition.prepare(host);
 
 			log("Prepared file factory.");
 
 			const fileFactory = makeDisposable({
 				...fileFactoryDefinition,
-				prepareFromDisk: (filePathAbsolute: string) => {
-					const { file, ...rest } =
-						fileFactoryDefinition.prepareFromDisk(filePathAbsolute);
-
-					return {
-						file: makeDisposable(file),
-						...rest,
-					};
-				},
-				prepareFromVirtual: (filePathAbsolute: string, sourceText: string) => {
-					const { file, ...rest } = fileFactoryDefinition.prepareFromVirtual(
+				prepareFile: (filePathAbsolute: string, sourceText: string) => {
+					const { file, ...rest } = fileFactoryDefinition.prepareFile(
 						filePathAbsolute,
 						sourceText,
 					);
diff --git a/packages/core/src/languages/makeDisposable.ts b/packages/core/src/languages/makeDisposable.ts
index 52a06686b..5ef2d7a31 100644
--- a/packages/core/src/languages/makeDisposable.ts
+++ b/packages/core/src/languages/makeDisposable.ts
@@ -1,10 +1,10 @@
 export function makeDisposable<T extends object>(obj: T): Disposable & T {
 	return {
-		...obj,
 		[Symbol.dispose]:
 			() =>
 			// Intentionally empty to satisfy the Disposable interface.
 			// eslint-disable-next-line @typescript-eslint/no-empty-function
 			() => {},
+		...obj,
 	};
 }
diff --git a/packages/core/src/running/lintFile.ts b/packages/core/src/running/lintFile.ts
index 9841e7d41..49c960f2d 100644
--- a/packages/core/src/running/lintFile.ts
+++ b/packages/core/src/running/lintFile.ts
@@ -28,7 +28,7 @@ export async function lintFile(
 	const reports: FileReport[] = [];
 
 	const languageFiles = new CachedFactory((language: AnyLanguage) =>
-		languageFactories.get(language).prepareFromDisk(filePathAbsolute),
+		languageFactories.get(language).prepareFile(filePathAbsolute),
 	);
 	const rulesWithOptions = computeRulesWithOptions(filePath, useDefinitions);
 
diff --git a/packages/core/src/types/host.ts b/packages/core/src/types/host.ts
new file mode 100644
index 000000000..5ef7f0374
--- /dev/null
+++ b/packages/core/src/types/host.ts
@@ -0,0 +1,31 @@
+export interface LinterHostDirectoryEntry {
+	type: "file" | "directory";
+	name: string;
+}
+
+export type LinterHostFileWatcherEvent = "created" | "changed" | "deleted";
+export type LinterHostFileWatcher = (event: LinterHostFileWatcherEvent) => void;
+
+export type LinterHostDirectoryWatcher = (filePathAbsolute: string) => void;
+
+export interface LinterHost {
+	getCurrentDirectory(): string;
+	stat(pathAbsolute: string): "file" | "directory" | undefined;
+	readFile(filePathAbsolute: string): string | undefined;
+	readDirectory(directoryPathAbsolute: string): LinterHostDirectoryEntry[];
+	watchFile(
+		filePathAbsolute: string,
+		callback: LinterHostFileWatcher,
+	): Disposable;
+	watchDirectory(
+		directoryPathAbsolute: string,
+		recursive: boolean,
+		callback: LinterHostDirectoryWatcher,
+	): Disposable;
+}
+
+export interface VFSLinterHost extends LinterHost {
+	vfsUpsertFile(filePathAbsolute: string, content: string): void;
+	vfsDeleteFile(filePathAbsolute: string): void;
+	vfsListFiles(): ReadonlyMap<string, string>;
+}
diff --git a/packages/core/src/types/languages.ts b/packages/core/src/types/languages.ts
index 275461178..a0c727a81 100644
--- a/packages/core/src/types/languages.ts
+++ b/packages/core/src/types/languages.ts
@@ -1,4 +1,5 @@
 import { CommentDirective } from "./directives.js";
+import { LinterHost } from "./host.js";
 import { PromiseOrSync } from "./promises.js";
 import { FileReport, NormalizedReport } from "./reports.js";
 import {
@@ -43,7 +44,6 @@ export interface Language<
 	ContextServices extends object,
 > extends LanguageDefinition {
 	createRule: CreateRule<AstNodesByName, ContextServices>;
-	prepare(): LanguageFileFactory;
 }
 
 export interface LanguageAbout {
@@ -62,7 +62,7 @@ export interface LanguageFileDiagnostic {
  */
 export interface LanguageDefinition {
 	about: LanguageAbout;
-	prepare(): LanguageFileFactoryDefinition;
+	prepare(host: LinterHost): LanguageFileFactoryDefinition;
 }
 
 export interface LanguageFileCacheImpacts {
@@ -105,11 +105,7 @@ export interface LanguageFileDefinition extends Partial<Disposable> {
  * Creates wrappers around files to be linted.
  */
 export interface LanguageFileFactory extends Disposable {
-	prepareFromDisk(filePathAbsolute: string): LanguagePrepared;
-	prepareFromVirtual(
-		filePathAbsolute: string,
-		sourceText: string,
-	): LanguagePrepared;
+	prepareFile(filePathAbsolute: string, sourceText: string): LanguagePrepared;
 }
 
 /**
@@ -125,8 +121,7 @@ export interface LanguagePrepared {
  * Internal definition of how to create wrappers around files to be linted.
  */
 export interface LanguageFileFactoryDefinition extends Partial<Disposable> {
-	prepareFromDisk(filePathAbsolute: string): LanguagePreparedDefinition;
-	prepareFromVirtual(
+	prepareFile(
 		filePathAbsolute: string,
 		sourceText: string,
 	): LanguagePreparedDefinition;
diff --git a/packages/json/src/language.ts b/packages/json/src/language.ts
index 6b0284a0c..0b9db62b9 100644
--- a/packages/json/src/language.ts
+++ b/packages/json/src/language.ts
@@ -1,5 +1,4 @@
 import { createLanguage } from "@flint.fyi/core";
-import fsSync from "node:fs";
 import * as ts from "typescript";
 
 import { createTypeScriptJsonFile } from "./createJsonFile.js";
@@ -16,15 +15,7 @@ export const jsonLanguage = createLanguage<TSNodesByName, JsonServices>({
 	},
 	prepare: () => {
 		return {
-			prepareFromDisk: (filePathAbsolute) => {
-				return {
-					file: createTypeScriptJsonFile(
-						filePathAbsolute,
-						fsSync.readFileSync(filePathAbsolute, "utf8"),
-					),
-				};
-			},
-			prepareFromVirtual: (filePathAbsolute, sourceText) => {
+			prepareFile: (filePathAbsolute, sourceText) => {
 				return {
 					file: createTypeScriptJsonFile(filePathAbsolute, sourceText),
 				};
diff --git a/packages/md/src/language.ts b/packages/md/src/language.ts
index cee52cc71..d3dc2fc36 100644
--- a/packages/md/src/language.ts
+++ b/packages/md/src/language.ts
@@ -1,7 +1,6 @@
 import type * as mdast from "mdast";
 
 import { createLanguage } from "@flint.fyi/core";
-import fsSync from "node:fs";
 
 import { createMarkdownFile } from "./createMarkdownFile.js";
 import { MarkdownNodesByName, WithPosition } from "./nodes.js";
@@ -20,13 +19,7 @@ export const markdownLanguage = createLanguage<
 	},
 	prepare: () => {
 		return {
-			prepareFromDisk: (filePathAbsolute) => {
-				const sourceText = fsSync.readFileSync(filePathAbsolute, "utf8");
-				const { languageFile, root } = createMarkdownFile(sourceText);
-
-				return prepareMarkdownFile(languageFile, root, sourceText);
-			},
-			prepareFromVirtual: (filePathAbsolute, sourceText) => {
+			prepareFile: (filePathAbsolute, sourceText) => {
 				const { languageFile, root } = createMarkdownFile(sourceText);
 
 				return prepareMarkdownFile(languageFile, root, sourceText);
diff --git a/packages/plugin-browser/src/rules/ruleTester.ts b/packages/plugin-browser/src/rules/ruleTester.ts
index 14a239398..1096e1c4d 100644
--- a/packages/plugin-browser/src/rules/ruleTester.ts
+++ b/packages/plugin-browser/src/rules/ruleTester.ts
@@ -1,8 +1,13 @@
-import { RuleTester } from "@flint.fyi/rule-tester";
+import { createRuleTesterTSHost, RuleTester } from "@flint.fyi/rule-tester";
 import { describe, it } from "vitest";
 
 export const ruleTester = new RuleTester({
 	defaults: { fileName: "file.ts" },
 	describe,
 	it,
+	host: createRuleTesterTSHost(import.meta.dirname, {
+		defaultCompilerOptions: {
+			lib: ["esnext", "DOM"],
+		},
+	}),
 });
diff --git a/packages/plugin-node/src/rules/blobReadingMethods.ts b/packages/plugin-node/src/rules/blobReadingMethods.ts
index 68eccc8c7..13302fcd4 100644
--- a/packages/plugin-node/src/rules/blobReadingMethods.ts
+++ b/packages/plugin-node/src/rules/blobReadingMethods.ts
@@ -52,7 +52,7 @@ export default typescriptLanguage.createRule({
 					const methodName = node.expression.name.text;
 					if (
 						!blobReadingMethods.has(methodName) ||
-						!isGlobalDeclaration(node.expression.name, typeChecker)
+						!isGlobalDeclaration(receiver.expression, typeChecker)
 					) {
 						return;
 					}
diff --git a/packages/plugin-node/src/rules/ruleTester.ts b/packages/plugin-node/src/rules/ruleTester.ts
index 14a239398..461a9c4ce 100644
--- a/packages/plugin-node/src/rules/ruleTester.ts
+++ b/packages/plugin-node/src/rules/ruleTester.ts
@@ -1,8 +1,13 @@
-import { RuleTester } from "@flint.fyi/rule-tester";
+import { createRuleTesterTSHost, RuleTester } from "@flint.fyi/rule-tester";
 import { describe, it } from "vitest";
 
 export const ruleTester = new RuleTester({
 	defaults: { fileName: "file.ts" },
 	describe,
 	it,
+	host: createRuleTesterTSHost(import.meta.dirname, {
+		defaultCompilerOptions: {
+			types: ["node"],
+		},
+	}),
 });
diff --git a/packages/rule-tester/src/RuleTester.ts b/packages/rule-tester/src/RuleTester.ts
index d6e03eff0..6399c3e85 100644
--- a/packages/rule-tester/src/RuleTester.ts
+++ b/packages/rule-tester/src/RuleTester.ts
@@ -1,18 +1,22 @@
+import path from "node:path";
 import {
 	AnyLanguage,
 	AnyOptionalSchema,
 	AnyRule,
+	createFSBackedLinterHost,
+	createVFSLinterHost,
 	InferredObject,
 	LanguageFileFactory,
+	LinterHost,
 	RuleAbout,
+	VFSLinterHost,
 } from "@flint.fyi/core";
 import { CachedFactory } from "cached-factory";
 import assert from "node:assert/strict";
 
 import { createReportSnapshot } from "./createReportSnapshot.js";
-import { normalizeTestCase } from "./normalizeTestCase.js";
+import { normalizeTestCase, TestCaseNormalized } from "./normalizeTestCase.js";
 import { resolveReportedSuggestions } from "./resolveReportedSuggestions.js";
-import { runTestCaseRule } from "./runTestCaseRule.js";
 import { InvalidTestCase, TestCase, ValidTestCase } from "./types.js";
 
 export interface RuleTesterOptions {
@@ -24,6 +28,7 @@ export interface RuleTesterOptions {
 	only?: TesterSetupIt;
 	scope?: Record<string, unknown>;
 	skip?: TesterSetupIt;
+	host?: LinterHost | undefined;
 }
 
 export interface TestCases<Options extends object | undefined> {
@@ -41,9 +46,17 @@ export type TesterSetupIt = (
 	setup: () => Promise<void>,
 ) => void;
 
+interface TestCaseRuleConfiguration<
+	OptionsSchema extends AnyOptionalSchema | undefined,
+> {
+	options?: InferredObject<OptionsSchema>;
+	rule: AnyRule<RuleAbout, OptionsSchema>;
+}
+
 export class RuleTester {
 	#fileFactories: CachedFactory<AnyLanguage, LanguageFileFactory>;
-	#testerOptions: Required<RuleTesterOptions>;
+	#linterHost: VFSLinterHost;
+	#testerOptions: Required<Omit<RuleTesterOptions, "host">>;
 
 	constructor({
 		defaults,
@@ -52,9 +65,15 @@ export class RuleTester {
 		only,
 		scope = globalThis,
 		skip,
-	}: RuleTesterOptions = {}) {
+		host,
+	}: RuleTesterOptions) {
+		this.#linterHost = createVFSLinterHost(
+			host?.getCurrentDirectory() ?? process.cwd(),
+			host,
+		);
+
 		this.#fileFactories = new CachedFactory((language: AnyLanguage) =>
-			language.prepare(),
+			language.prepare(this.#linterHost),
 		);
 
 		it = defaultTo(it, scope, "it");
@@ -101,6 +120,37 @@ export class RuleTester {
 		});
 	}
 
+	#runTestCaseRule<OptionsSchema extends AnyOptionalSchema | undefined>(
+		{ options, rule }: Required<TestCaseRuleConfiguration<OptionsSchema>>,
+		{ code, fileName, files }: TestCaseNormalized,
+	) {
+		const preparedLanguage = this.#fileFactories
+			// TODO: How to make types more permissive around assignability?
+			// See AnyRule's any
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+			.get(rule.language);
+		for (const oldFile of this.#linterHost.vfsListFiles().keys()) {
+			this.#linterHost.vfsDeleteFile(oldFile);
+		}
+		for (const [name, content] of Object.entries({
+			...files,
+			[fileName]: code,
+		})) {
+			const filePath = path.resolve(
+				this.#linterHost.getCurrentDirectory(),
+				name,
+			);
+			this.#linterHost.vfsUpsertFile(filePath, content);
+		}
+		const filePath = path.resolve(
+			this.#linterHost.getCurrentDirectory(),
+			fileName,
+		);
+		using file = preparedLanguage.prepareFile(filePath, code).file;
+
+		return file.runRule(rule, options as InferredObject<OptionsSchema>);
+	}
+
 	#itInvalidCase<OptionsSchema extends AnyOptionalSchema | undefined>(
 		rule: AnyRule<RuleAbout, OptionsSchema>,
 		testCase: InvalidTestCase<InferredObject<OptionsSchema>>,
@@ -111,8 +161,7 @@ export class RuleTester {
 		);
 
 		this.#itTestCase(testCaseNormalized, async () => {
-			const reports = await runTestCaseRule(
-				this.#fileFactories,
+			const reports = await this.#runTestCaseRule(
 				{
 					// TODO: Figure out a way around the type assertion...
 					options: testCase.options ?? ({} as InferredObject<OptionsSchema>),
@@ -132,7 +181,7 @@ export class RuleTester {
 		});
 	}
 
-	#itTestCase(testCase: TestCase, setup: () => Promise<void>) {
+	#itTestCase(testCase: TestCaseNormalized, setup: () => Promise<void>) {
 		let test = testCase.only
 			? this.#testerOptions.only
 			: this.#testerOptions.it;
@@ -145,7 +194,25 @@ export class RuleTester {
 			}
 		}
 
-		test(testCase.code, setup);
+		test(
+			"files" in testCase
+				? JSON.stringify(
+						{ [testCase.fileName]: testCase.code, ...testCase.files },
+						null,
+						2,
+					)
+				: testCase.code,
+			() => {
+				if (testCase.files != null) {
+					assert.notEqual(
+						Object.keys(testCase.files),
+						0,
+						'"files" must have at least one file',
+					);
+				}
+				return setup();
+			},
+		);
 	}
 
 	#itValidCase<OptionsSchema extends AnyOptionalSchema | undefined>(
@@ -160,8 +227,7 @@ export class RuleTester {
 		);
 
 		this.#itTestCase(testCaseNormalized, async () => {
-			const reports = await runTestCaseRule(
-				this.#fileFactories,
+			const reports = await this.#runTestCaseRule(
 				{
 					// TODO: Figure out a way around the type assertion...
 					options: (testCase.options ?? {}) as InferredObject<OptionsSchema>,
diff --git a/packages/rule-tester/src/host.ts b/packages/rule-tester/src/host.ts
new file mode 100644
index 000000000..77c9ee060
--- /dev/null
+++ b/packages/rule-tester/src/host.ts
@@ -0,0 +1,49 @@
+import path from "node:path";
+import { createFSBackedLinterHost, createVFSLinterHost } from "@flint.fyi/core";
+
+export interface RuleTesterTSHostOptions {
+	defaultCompilerOptions?: Record<string, unknown>;
+}
+
+export function createRuleTesterTSHost(
+	dirname: string,
+	opts: RuleTesterTSHostOptions = {},
+) {
+	const fsHost = createFSBackedLinterHost(dirname);
+	const overlay = createVFSLinterHost(dirname, {
+		...fsHost,
+		stat(pathAbsolute) {
+			if (pathAbsolute.endsWith("tsconfig.json")) {
+				return undefined;
+			}
+			return fsHost.stat(pathAbsolute);
+		},
+	});
+	overlay.vfsUpsertFile(
+		path.join(dirname, "tsconfig.base.json"),
+		JSON.stringify(
+			{
+				compilerOptions: {
+					strict: true,
+					lib: ["esnext"],
+					target: "esnext",
+					types: [],
+					...opts.defaultCompilerOptions,
+				},
+			},
+			null,
+			2,
+		),
+	);
+	overlay.vfsUpsertFile(
+		path.join(dirname, "tsconfig.json"),
+		JSON.stringify(
+			{
+				extends: "./tsconfig.base.json",
+			},
+			null,
+			2,
+		),
+	);
+	return overlay;
+}
diff --git a/packages/rule-tester/src/index.ts b/packages/rule-tester/src/index.ts
index 619891ce8..5777c5152 100644
--- a/packages/rule-tester/src/index.ts
+++ b/packages/rule-tester/src/index.ts
@@ -1,2 +1,3 @@
 export { RuleTester } from "./RuleTester.js";
 export type * from "./types.js";
+export * from "./host.js";
diff --git a/packages/rule-tester/src/runTestCaseRule.ts b/packages/rule-tester/src/runTestCaseRule.ts
index 0e794f5b0..dcf37b2a8 100644
--- a/packages/rule-tester/src/runTestCaseRule.ts
+++ b/packages/rule-tester/src/runTestCaseRule.ts
@@ -4,6 +4,7 @@ import {
 	AnyRule,
 	InferredObject,
 	LanguageFileFactory,
+	LinterHost,
 	RuleAbout,
 } from "@flint.fyi/core";
 import { CachedFactory } from "cached-factory";
@@ -21,6 +22,7 @@ export function runTestCaseRule<
 	OptionsSchema extends AnyOptionalSchema | undefined,
 >(
 	fileFactories: CachedFactory<AnyLanguage, LanguageFileFactory>,
+	linterHost: LinterHost,
 	{ options, rule }: Required<TestCaseRuleConfiguration<OptionsSchema>>,
 	{ code, fileName }: TestCaseNormalized,
 ) {
@@ -29,7 +31,7 @@ export function runTestCaseRule<
 		// See AnyRule's any
 		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
 		.get(rule.language)
-		.prepareFromVirtual(fileName, code).file;
+		.prepareFile(fileName, code).file;
 
 	return file.runRule(rule, options as InferredObject<OptionsSchema>);
 }
diff --git a/packages/rule-tester/src/types.ts b/packages/rule-tester/src/types.ts
index 824714756..a93b2cc2f 100644
--- a/packages/rule-tester/src/types.ts
+++ b/packages/rule-tester/src/types.ts
@@ -11,6 +11,7 @@ export interface TestCase<
 > {
 	code: string;
 	fileName?: string;
+	files?: Record<string, string>;
 
 	/**
 	 * Run only this test case. Useful for debugging.
diff --git a/packages/text/src/language.ts b/packages/text/src/language.ts
index 222cf488b..6143fa8a3 100644
--- a/packages/text/src/language.ts
+++ b/packages/text/src/language.ts
@@ -1,5 +1,4 @@
 import { createLanguage } from "@flint.fyi/core";
-import fsSync from "node:fs";
 
 import { createTextFile } from "./createTextFile.js";
 import { TextNodes, TextServices } from "./types.js";
@@ -10,15 +9,7 @@ export const textLanguage = createLanguage<TextNodes, TextServices>({
 	},
 	prepare: () => {
 		return {
-			prepareFromDisk: (filePathAbsolute) => {
-				return {
-					file: createTextFile(
-						filePathAbsolute,
-						fsSync.readFileSync(filePathAbsolute, "utf8"),
-					),
-				};
-			},
-			prepareFromVirtual: (filePathAbsolute, sourceText) => {
+			prepareFile: (filePathAbsolute, sourceText) => {
 				return {
 					file: createTextFile(filePathAbsolute, sourceText),
 				};
diff --git a/packages/ts/src/language.ts b/packages/ts/src/language.ts
index c753aa2fa..6d2dd2c20 100644
--- a/packages/ts/src/language.ts
+++ b/packages/ts/src/language.ts
@@ -18,18 +18,18 @@ export const typescriptLanguage = createLanguage<
 	about: {
 		name: "TypeScript",
 	},
-	prepare: () => {
-		const lang = prepareTypeScriptBasedLanguage();
+	prepare: (host) => {
+		const lang = prepareTypeScriptBasedLanguage(host);
 
 		return {
-			prepareFromDisk(filePathAbsolute) {
-				return prepareTypeScriptFile(lang.createFromDisk(filePathAbsolute));
-			},
-			prepareFromVirtual(filePathAbsolute, sourceText) {
-				return prepareTypeScriptFile(
-					lang.createFromVirtual(filePathAbsolute, sourceText),
-				);
+			prepareFile(filePathAbsolute) {
+				return prepareTypeScriptFile(lang.createFile(filePathAbsolute));
 			},
+			// prepareFromVirtual(filePathAbsolute, sourceText) {
+			// 	return prepareTypeScriptFile(
+			// 		lang.createFromVirtual(filePathAbsolute, sourceText),
+			// 	);
+			// },
 		};
 	},
 });
diff --git a/packages/ts/src/prepareTypeScriptBasedLanguage.ts b/packages/ts/src/prepareTypeScriptBasedLanguage.ts
index ff428d37d..3b4d6d387 100644
--- a/packages/ts/src/prepareTypeScriptBasedLanguage.ts
+++ b/packages/ts/src/prepareTypeScriptBasedLanguage.ts
@@ -1,16 +1,13 @@
 import { createProjectService } from "@typescript-eslint/project-service";
-import {
-	createFSBackedSystem,
-	createVirtualTypeScriptEnvironment,
-} from "@typescript/vfs";
 import { CachedFactory } from "cached-factory";
 import { debugForFile } from "debug-for-file";
 import path from "path";
 import * as ts from "typescript";
 
 import { createTypeScriptFileFromProjectService } from "./createTypeScriptFileFromProjectService.js";
+import { LinterHost } from "@flint.fyi/core";
+import { matchFiles } from "./typescriptUtilities.js";
 
-const projectRoot = path.join(import.meta.dirname, "../..");
 const log = debugForFile(import.meta.filename);
 
 export interface TypeScriptBasedLanguageFile extends Partial<Disposable> {
@@ -19,28 +16,121 @@ export interface TypeScriptBasedLanguageFile extends Partial<Disposable> {
 }
 
 export interface TypeScriptBasedLanguageFileFactoryDefinition {
-	createFromDisk(filePathAbsolute: string): TypeScriptBasedLanguageFile;
-	createFromVirtual(
-		filePathAbsolute: string,
-		sourceText: string,
-	): TypeScriptBasedLanguageFile;
+	createFile(filePathAbsolute: string): TypeScriptBasedLanguageFile;
 }
 
-export function prepareTypeScriptBasedLanguage(): TypeScriptBasedLanguageFileFactoryDefinition {
-	const { service } = createProjectService();
-	const seenPrograms = new Set<ts.Program>();
-
-	const environments = new CachedFactory((filePathAbsolute: string) => {
-		const system = createFSBackedSystem(
-			new Map([[filePathAbsolute, "// ..."]]),
-			projectRoot,
-			ts,
-		);
+function notImplemented(methodName: string): any {
+	throw new Error(
+		`Flint bug: ts.System's method '${methodName}' is not implemented.`,
+	);
+}
 
-		return createVirtualTypeScriptEnvironment(system, [filePathAbsolute], ts, {
-			skipLibCheck: true,
-			target: ts.ScriptTarget.ESNext,
-		});
+export function prepareTypeScriptBasedLanguage(
+	host: LinterHost,
+): TypeScriptBasedLanguageFileFactoryDefinition {
+	const { service } = createProjectService({
+		host: {
+			...ts.sys,
+			args: [],
+			write() {
+				notImplemented("write");
+			},
+			writeFile() {
+				notImplemented("writeFile");
+			},
+			createDirectory() {
+				notImplemented("createDirectory");
+			},
+			exit() {
+				notImplemented("exit");
+			},
+			readFile(filePath) {
+				return host.readFile(
+					path.resolve(host.getCurrentDirectory(), filePath),
+				);
+			},
+			directoryExists(directoryPath) {
+				return (
+					host.stat(path.resolve(host.getCurrentDirectory(), directoryPath)) ===
+					"directory"
+				);
+			},
+			fileExists(filePath) {
+				return (
+					host.stat(path.resolve(host.getCurrentDirectory(), filePath)) ===
+					"file"
+				);
+			},
+			readDirectory(directoryPath, extensions, excludes, includes, depth) {
+				return matchFiles(
+					directoryPath,
+					extensions,
+					excludes,
+					includes,
+					ts.sys.useCaseSensitiveFileNames,
+					host.getCurrentDirectory(),
+					depth,
+					(directoryPath) => {
+						const files: string[] = [];
+						const directories: string[] = [];
+						for (const dirent of host.readDirectory(
+							path.resolve(host.getCurrentDirectory(), directoryPath),
+						)) {
+							if (dirent.type === "file") {
+								files.push(dirent.name);
+							} else if (dirent.type === "directory") {
+								directories.push(dirent.name);
+							}
+						}
+						return { files, directories };
+					},
+					ts.sys.realpath ?? ((path) => path),
+				);
+			},
+			setImmediate,
+			setTimeout,
+			clearImmediate,
+			clearTimeout,
+			watchFile(filePath, callback) {
+				const watcher = host.watchFile(
+					path.resolve(host.getCurrentDirectory(), filePath),
+					(event) => {
+						let eventKind: ts.FileWatcherEventKind;
+						switch (event) {
+							case "created":
+								eventKind = ts.FileWatcherEventKind.Created;
+								break;
+							case "changed":
+								eventKind = ts.FileWatcherEventKind.Changed;
+								break;
+							case "deleted":
+								eventKind = ts.FileWatcherEventKind.Deleted;
+								break;
+						}
+						callback(filePath, eventKind);
+					},
+				);
+				return {
+					close() {
+						watcher[Symbol.dispose]();
+					},
+				};
+			},
+			watchDirectory(directoryPath, callback, recursive = false) {
+				const watcher = host.watchDirectory(
+					path.resolve(host.getCurrentDirectory(), directoryPath),
+					recursive,
+					(filePathAbsolute) => {
+						callback(filePathAbsolute);
+					},
+				);
+				return {
+					close() {
+						watcher[Symbol.dispose]();
+					},
+				};
+			},
+		},
 	});
 
 	const servicePrograms = new CachedFactory((filePathAbsolute: string) => {
@@ -76,10 +166,34 @@ export function prepareTypeScriptBasedLanguage(): TypeScriptBasedLanguageFileFac
 	});
 
 	return {
-		createFromDisk: (filePathAbsolute) => {
-			const program = servicePrograms.get(filePathAbsolute);
-
-			seenPrograms.add(program);
+		createFile: (filePathAbsolute) => {
+			log("Opening client file:", filePathAbsolute);
+			service.openClientFile(filePathAbsolute); //, host.readFile(filePathAbsolute))
+
+			log("Retrieving client services:", filePathAbsolute);
+			const scriptInfo = service.getScriptInfo(filePathAbsolute);
+			if (!scriptInfo) {
+				throw new Error(
+					`Could not find script info for file: ${filePathAbsolute}`,
+				);
+			}
+
+			const defaultProject = service.getDefaultProjectForFile(
+				scriptInfo.fileName,
+				true,
+			);
+			if (!defaultProject) {
+				throw new Error(
+					`Could not find default project for file: ${filePathAbsolute}`,
+				);
+			}
+
+			const program = defaultProject.getLanguageService(true).getProgram();
+			if (!program) {
+				throw new Error(
+					`Could not retrieve program for file: ${filePathAbsolute}`,
+				);
+			}
 
 			return createTypeScriptFileFromProjectService(
 				filePathAbsolute,
@@ -87,20 +201,5 @@ export function prepareTypeScriptBasedLanguage(): TypeScriptBasedLanguageFileFac
 				service,
 			);
 		},
-		createFromVirtual: (filePathAbsolute, sourceText) => {
-			const environment = environments.get(filePathAbsolute);
-			environment.updateFile(filePathAbsolute, sourceText);
-			/* eslint-disable @typescript-eslint/no-non-null-assertion */
-			const sourceFile = environment.getSourceFile(filePathAbsolute)!;
-			const program = environment.languageService.getProgram()!;
-			/* eslint-enable @typescript-eslint/no-non-null-assertion */
-
-			seenPrograms.add(program);
-
-			return {
-				program,
-				sourceFile,
-			};
-		},
 	};
 }
diff --git a/packages/ts/src/rules/functionNewCalls.test.ts b/packages/ts/src/rules/functionNewCalls.test.ts
index 712131d78..6aba948ee 100644
--- a/packages/ts/src/rules/functionNewCalls.test.ts
+++ b/packages/ts/src/rules/functionNewCalls.test.ts
@@ -1,6 +1,14 @@
 import rule from "./functionNewCalls.js";
 import { ruleTester } from "./ruleTester.js";
 
+const tsconfigWithDomLib = {
+	"tsconfig.json": `{
+	"extends": "./tsconfig.base.json",
+	"compilerOptions": {
+		"lib": ["esnext", "DOM"]
+	}
+}`,
+};
 ruleTester.describe(rule, {
 	invalid: [
 		{
@@ -67,6 +75,7 @@ const fn = globalThis.Function("return 1");
 			code: `
 const fn = new window.Function("return 1");
 `,
+			files: tsconfigWithDomLib,
 			snapshot: `
 const fn = new window.Function("return 1");
                ~~~~~~~~~~~~~~~
@@ -77,6 +86,7 @@ const fn = new window.Function("return 1");
 			code: `
 const fn = window.Function("return 1");
 `,
+			files: tsconfigWithDomLib,
 			snapshot: `
 const fn = window.Function("return 1");
            ~~~~~~~~~~~~~~~
diff --git a/packages/ts/src/rules/globalAssignments.test.ts b/packages/ts/src/rules/globalAssignments.test.ts
index 967d00c15..c5413b254 100644
--- a/packages/ts/src/rules/globalAssignments.test.ts
+++ b/packages/ts/src/rules/globalAssignments.test.ts
@@ -107,6 +107,14 @@ Read-only global variables should not be reassigned or modified.
 			code: `
 window = {};
 `,
+			files: {
+				"tsconfig.json": `{
+	"extends": "./tsconfig.base.json",
+	"compilerOptions": {
+		"lib": ["esnext", "DOM"]
+	}
+}`,
+			},
 			snapshot: `
 window = {};
 ~~~~~~
diff --git a/packages/ts/src/rules/ruleTester.ts b/packages/ts/src/rules/ruleTester.ts
index 14a239398..6cc8becb7 100644
--- a/packages/ts/src/rules/ruleTester.ts
+++ b/packages/ts/src/rules/ruleTester.ts
@@ -1,8 +1,9 @@
-import { RuleTester } from "@flint.fyi/rule-tester";
+import { createRuleTesterTSHost, RuleTester } from "@flint.fyi/rule-tester";
 import { describe, it } from "vitest";
 
 export const ruleTester = new RuleTester({
 	defaults: { fileName: "file.ts" },
 	describe,
 	it,
+	host: createRuleTesterTSHost(import.meta.dirname),
 });
diff --git a/packages/ts/src/rules/undefinedVariables.test.ts b/packages/ts/src/rules/undefinedVariables.test.ts
index b447caeba..e529f5998 100644
--- a/packages/ts/src/rules/undefinedVariables.test.ts
+++ b/packages/ts/src/rules/undefinedVariables.test.ts
@@ -5,12 +5,12 @@ ruleTester.describe(rule, {
 	invalid: [
 		{
 			code: `
-console.log(undefinedVar);
+undefinedVar;
 `,
 			snapshot: `
-console.log(undefinedVar);
-            ~~~~~~~~~~~~
-            Variable 'undefinedVar' is used but was never defined.
+undefinedVar;
+~~~~~~~~~~~~
+Variable 'undefinedVar' is used but was never defined.
 `,
 		},
 		{
@@ -67,15 +67,15 @@ const result = first + second;
 		},
 	],
 	valid: [
-		`const value = 5; console.log(value);`,
+		`const value = 5; value;`,
 		`function test(parameter: number) { return parameter; }`,
 		`let count = 0; count++;`,
-		`const obj = { prop: 1 }; console.log(obj.prop);`,
+		`const obj = { prop: 1 }; obj.prop;`,
 		`typeof undefinedVar === "undefined"`,
 		`const obj = {}; const { prop } = obj;`,
 		`function fn() { return 1; } fn();`,
 		`class MyClass {} const instance = new MyClass();`,
-		`import { value } from "module"; console.log(value);`,
-		`const array = [1, 2, 3]; array.forEach(item => console.log(item));`,
+		`import { value } from "module"; value;`,
+		`const array = [1, 2, 3]; array.forEach(item => item);`,
 	],
 });
diff --git a/packages/ts/src/typescriptUtilities.ts b/packages/ts/src/typescriptUtilities.ts
new file mode 100644
index 000000000..15cb78995
--- /dev/null
+++ b/packages/ts/src/typescriptUtilities.ts
@@ -0,0 +1,1476 @@
+interface FileSystemEntries {
+	readonly files: readonly string[];
+	readonly directories: readonly string[];
+}
+
+const directorySeparator = "/";
+const altDirectorySeparator = "\\";
+const urlSchemeSeparator = "://";
+const backslashRegExp = /\\/g;
+
+function getFileUrlVolumeSeparatorEnd(url: string, start: number) {
+	const ch0 = url.charCodeAt(start);
+	if (ch0 === CharacterCodes.colon) {
+		return start + 1;
+	}
+	if (
+		ch0 === CharacterCodes.percent &&
+		url.charCodeAt(start + 1) === CharacterCodes._3
+	) {
+		const ch2 = url.charCodeAt(start + 2);
+		if (ch2 === CharacterCodes.a || ch2 === CharacterCodes.A) {
+			return start + 3;
+		}
+	}
+	return -1;
+}
+
+function normalizeSlashes(path: string): string {
+	return path.includes("\\")
+		? path.replace(backslashRegExp, directorySeparator)
+		: path;
+}
+
+function getRootLength(path: string): number {
+	const rootLength = getEncodedRootLength(path);
+	return rootLength < 0 ? ~rootLength : rootLength;
+}
+
+const enum CharacterCodes {
+	EOF = -1,
+	nullCharacter = 0,
+	maxAsciiCharacter = 0x7f,
+
+	lineFeed = 0x0a, // \n
+	carriageReturn = 0x0d, // \r
+	lineSeparator = 0x2028,
+	paragraphSeparator = 0x2029,
+	nextLine = 0x0085,
+
+	// Unicode 3.0 space characters
+	space = 0x0020, // " "
+	nonBreakingSpace = 0x00a0, //
+	enQuad = 0x2000,
+	emQuad = 0x2001,
+	enSpace = 0x2002,
+	emSpace = 0x2003,
+	threePerEmSpace = 0x2004,
+	fourPerEmSpace = 0x2005,
+	sixPerEmSpace = 0x2006,
+	figureSpace = 0x2007,
+	punctuationSpace = 0x2008,
+	thinSpace = 0x2009,
+	hairSpace = 0x200a,
+	zeroWidthSpace = 0x200b,
+	narrowNoBreakSpace = 0x202f,
+	ideographicSpace = 0x3000,
+	mathematicalSpace = 0x205f,
+	ogham = 0x1680,
+
+	// Unicode replacement character produced when a byte sequence is invalid
+	replacementCharacter = 0xfffd,
+
+	_ = 0x5f,
+	$ = 0x24,
+
+	_0 = 0x30,
+	_1 = 0x31,
+	_2 = 0x32,
+	_3 = 0x33,
+	_4 = 0x34,
+	_5 = 0x35,
+	_6 = 0x36,
+	_7 = 0x37,
+	_8 = 0x38,
+	_9 = 0x39,
+
+	a = 0x61,
+	b = 0x62,
+	c = 0x63,
+	d = 0x64,
+	e = 0x65,
+	f = 0x66,
+	g = 0x67,
+	h = 0x68,
+	i = 0x69,
+	j = 0x6a,
+	k = 0x6b,
+	l = 0x6c,
+	m = 0x6d,
+	n = 0x6e,
+	o = 0x6f,
+	p = 0x70,
+	q = 0x71,
+	r = 0x72,
+	s = 0x73,
+	t = 0x74,
+	u = 0x75,
+	v = 0x76,
+	w = 0x77,
+	x = 0x78,
+	y = 0x79,
+	z = 0x7a,
+
+	A = 0x41,
+	B = 0x42,
+	C = 0x43,
+	D = 0x44,
+	E = 0x45,
+	F = 0x46,
+	G = 0x47,
+	H = 0x48,
+	I = 0x49,
+	J = 0x4a,
+	K = 0x4b,
+	L = 0x4c,
+	M = 0x4d,
+	N = 0x4e,
+	O = 0x4f,
+	P = 0x50,
+	Q = 0x51,
+	R = 0x52,
+	S = 0x53,
+	T = 0x54,
+	U = 0x55,
+	V = 0x56,
+	W = 0x57,
+	X = 0x58,
+	Y = 0x59,
+	Z = 0x5a,
+
+	ampersand = 0x26, // &
+	asterisk = 0x2a, // *
+	at = 0x40, // @
+	backslash = 0x5c, // \
+	backtick = 0x60, // `
+	bar = 0x7c, // |
+	caret = 0x5e, // ^
+	closeBrace = 0x7d, // }
+	closeBracket = 0x5d, // ]
+	closeParen = 0x29, // )
+	colon = 0x3a, // :
+	comma = 0x2c, // ,
+	dot = 0x2e, // .
+	doubleQuote = 0x22, // "
+	equals = 0x3d, // =
+	exclamation = 0x21, // !
+	greaterThan = 0x3e, // >
+	hash = 0x23, // #
+	lessThan = 0x3c, // <
+	minus = 0x2d, // -
+	openBrace = 0x7b, // {
+	openBracket = 0x5b, // [
+	openParen = 0x28, // (
+	percent = 0x25, // %
+	plus = 0x2b, // +
+	question = 0x3f, // ?
+	semicolon = 0x3b, // ;
+	singleQuote = 0x27, // '
+	slash = 0x2f, // /
+	tilde = 0x7e, // ~
+
+	backspace = 0x08, // \b
+	formFeed = 0x0c, // \f
+	byteOrderMark = 0xfeff,
+	tab = 0x09, // \t
+	verticalTab = 0x0b, // \v
+}
+
+function isVolumeCharacter(charCode: number) {
+	return (
+		(charCode >= CharacterCodes.a && charCode <= CharacterCodes.z) ||
+		(charCode >= CharacterCodes.A && charCode <= CharacterCodes.Z)
+	);
+}
+
+function getEncodedRootLength(path: string): number {
+	if (!path) {
+		return 0;
+	}
+	const ch0 = path.charCodeAt(0);
+
+	// POSIX or UNC
+	if (ch0 === CharacterCodes.slash || ch0 === CharacterCodes.backslash) {
+		if (path.charCodeAt(1) !== ch0) {
+			return 1;
+		} // POSIX: "/" (or non-normalized "\")
+
+		const p1 = path.indexOf(
+			ch0 === CharacterCodes.slash ? directorySeparator : altDirectorySeparator,
+			2,
+		);
+		if (p1 < 0) {
+			return path.length;
+		} // UNC: "//server" or "\\server"
+
+		return p1 + 1; // UNC: "//server/" or "\\server\"
+	}
+
+	// DOS
+	if (isVolumeCharacter(ch0) && path.charCodeAt(1) === CharacterCodes.colon) {
+		const ch2 = path.charCodeAt(2);
+		if (ch2 === CharacterCodes.slash || ch2 === CharacterCodes.backslash) {
+			return 3;
+		} // DOS: "c:/" or "c:\"
+		if (path.length === 2) {
+			return 2;
+		} // DOS: "c:" (but not "c:d")
+	}
+
+	// URL
+	const schemeEnd = path.indexOf(urlSchemeSeparator);
+	if (schemeEnd !== -1) {
+		const authorityStart = schemeEnd + urlSchemeSeparator.length;
+		const authorityEnd = path.indexOf(directorySeparator, authorityStart);
+		if (authorityEnd !== -1) {
+			// URL: "file:///", "file://server/", "file://server/path"
+			// For local "file" URLs, include the leading DOS volume (if present).
+			// Per https://www.ietf.org/rfc/rfc1738.txt, a host of "" or "localhost" is a
+			// special case interpreted as "the machine from which the URL is being interpreted".
+			const scheme = path.slice(0, schemeEnd);
+			const authority = path.slice(authorityStart, authorityEnd);
+			if (
+				scheme === "file" &&
+				(authority === "" || authority === "localhost") &&
+				isVolumeCharacter(path.charCodeAt(authorityEnd + 1))
+			) {
+				const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(
+					path,
+					authorityEnd + 2,
+				);
+				if (volumeSeparatorEnd !== -1) {
+					if (path.charCodeAt(volumeSeparatorEnd) === CharacterCodes.slash) {
+						// URL: "file:///c:/", "file://localhost/c:/", "file:///c%3a/", "file://localhost/c%3a/"
+						return ~(volumeSeparatorEnd + 1);
+					}
+					if (volumeSeparatorEnd === path.length) {
+						// URL: "file:///c:", "file://localhost/c:", "file:///c$3a", "file://localhost/c%3a"
+						// but not "file:///c:d" or "file:///c%3ad"
+						return ~volumeSeparatorEnd;
+					}
+				}
+			}
+			return ~(authorityEnd + 1); // URL: "file://server/", "http://server/"
+		}
+		return ~path.length; // URL: "file://server", "http://server"
+	}
+
+	// relative
+	return 0;
+}
+
+function isAnyDirectorySeparator(charCode: number): boolean {
+	return (
+		charCode === CharacterCodes.slash || charCode === CharacterCodes.backslash
+	);
+}
+
+function hasTrailingDirectorySeparator(path: string): boolean {
+	return (
+		path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1))
+	);
+}
+
+type Path = string & { __pathBrand: any };
+
+function ensureTrailingDirectorySeparator(path: Path): Path;
+function ensureTrailingDirectorySeparator(path: string): string;
+function ensureTrailingDirectorySeparator(path: string) {
+	if (!hasTrailingDirectorySeparator(path)) {
+		return path + directorySeparator;
+	}
+
+	return path;
+}
+
+function combinePaths(path: string, ...paths: (string | undefined)[]): string {
+	if (path) {
+		path = normalizeSlashes(path);
+	}
+	for (let relativePath of paths) {
+		if (!relativePath) {
+			continue;
+		}
+		relativePath = normalizeSlashes(relativePath);
+		if (!path || getRootLength(relativePath) !== 0) {
+			path = relativePath;
+		} else {
+			path = ensureTrailingDirectorySeparator(path) + relativePath;
+		}
+	}
+	return path;
+}
+
+function getNormalizedAbsolutePath(
+	path: string,
+	currentDirectory: string | undefined,
+): string {
+	let rootLength = getRootLength(path);
+	if (rootLength === 0 && currentDirectory) {
+		path = combinePaths(currentDirectory, path);
+		rootLength = getRootLength(path);
+	} else {
+		// combinePaths normalizes slashes, so not necessary in the other branch
+		path = normalizeSlashes(path);
+	}
+
+	const simpleNormalized = simpleNormalizePath(path);
+	if (simpleNormalized !== undefined) {
+		return simpleNormalized.length > rootLength
+			? removeTrailingDirectorySeparator(simpleNormalized)
+			: simpleNormalized;
+	}
+
+	const length = path.length;
+	const root = path.substring(0, rootLength);
+	// `normalized` is only initialized once `path` is determined to be non-normalized
+	let normalized;
+	let index = rootLength;
+	let segmentStart = index;
+	let normalizedUpTo = index;
+	let seenNonDotDotSegment = rootLength !== 0;
+	while (index < length) {
+		// At beginning of segment
+		segmentStart = index;
+		let ch = path.charCodeAt(index);
+		while (ch === CharacterCodes.slash && index + 1 < length) {
+			index++;
+			ch = path.charCodeAt(index);
+		}
+		if (index > segmentStart) {
+			// Seen superfluous separator
+			normalized ??= path.substring(0, segmentStart - 1);
+			segmentStart = index;
+		}
+		// Past any superfluous separators
+		let segmentEnd = path.indexOf(directorySeparator, index + 1);
+		if (segmentEnd === -1) {
+			segmentEnd = length;
+		}
+		const segmentLength = segmentEnd - segmentStart;
+		if (segmentLength === 1 && path.charCodeAt(index) === CharacterCodes.dot) {
+			// "." segment (skip)
+			normalized ??= path.substring(0, normalizedUpTo);
+		} else if (
+			segmentLength === 2 &&
+			path.charCodeAt(index) === CharacterCodes.dot &&
+			path.charCodeAt(index + 1) === CharacterCodes.dot
+		) {
+			// ".." segment
+			if (!seenNonDotDotSegment) {
+				if (normalized !== undefined) {
+					normalized += normalized.length === rootLength ? ".." : "/..";
+				} else {
+					normalizedUpTo = index + 2;
+				}
+			} else if (normalized === undefined) {
+				if (normalizedUpTo - 2 >= 0) {
+					normalized = path.substring(
+						0,
+						Math.max(
+							rootLength,
+							path.lastIndexOf(directorySeparator, normalizedUpTo - 2),
+						),
+					);
+				} else {
+					normalized = path.substring(0, normalizedUpTo);
+				}
+			} else {
+				const lastSlash = normalized.lastIndexOf(directorySeparator);
+				if (lastSlash !== -1) {
+					normalized = normalized.substring(0, Math.max(rootLength, lastSlash));
+				} else {
+					normalized = root;
+				}
+				if (normalized.length === rootLength) {
+					seenNonDotDotSegment = rootLength !== 0;
+				}
+			}
+		} else if (normalized !== undefined) {
+			if (normalized.length !== rootLength) {
+				normalized += directorySeparator;
+			}
+			seenNonDotDotSegment = true;
+			normalized += path.substring(segmentStart, segmentEnd);
+		} else {
+			seenNonDotDotSegment = true;
+			normalizedUpTo = segmentEnd;
+		}
+		index = segmentEnd + 1;
+	}
+	return (
+		normalized ??
+		(length > rootLength ? removeTrailingDirectorySeparator(path) : path)
+	);
+}
+
+function removeTrailingDirectorySeparator(path: Path): Path;
+function removeTrailingDirectorySeparator(path: string): string;
+function removeTrailingDirectorySeparator(path: string) {
+	if (hasTrailingDirectorySeparator(path)) {
+		return path.substr(0, path.length - 1);
+	}
+
+	return path;
+}
+
+function normalizePath(path: string): string {
+	path = normalizeSlashes(path);
+	let normalized = simpleNormalizePath(path);
+	if (normalized !== undefined) {
+		return normalized;
+	}
+	normalized = getNormalizedAbsolutePath(path, "");
+	return normalized && hasTrailingDirectorySeparator(path)
+		? ensureTrailingDirectorySeparator(normalized)
+		: normalized;
+}
+
+const relativePathSegmentRegExp = /\/\/|(?:^|\/)\.\.?(?:$|\/)/;
+
+function simpleNormalizePath(path: string): string | undefined {
+	// Most paths don't require normalization
+	if (!relativePathSegmentRegExp.test(path)) {
+		return path;
+	}
+	// Some paths only require cleanup of `/./` or leading `./`
+	let simplified = path.replace(/\/\.\//g, "/");
+	if (simplified.startsWith("./")) {
+		simplified = simplified.slice(2);
+	}
+	if (simplified !== path) {
+		path = simplified;
+		if (!relativePathSegmentRegExp.test(path)) {
+			return path;
+		}
+	}
+	return undefined;
+}
+
+interface FileMatcherPatterns {
+	/** One pattern for each "include" spec. */
+	includeFilePatterns: readonly string[] | undefined;
+	/** One pattern matching one of any of the "include" specs. */
+	includeFilePattern: string | undefined;
+	includeDirectoryPattern: string | undefined;
+	excludePattern: string | undefined;
+	basePaths: readonly string[];
+}
+
+function map<T, U>(array: readonly T[], f: (x: T, i: number) => U): U[];
+function map<T, U>(
+	array: readonly T[] | undefined,
+	f: (x: T, i: number) => U,
+): U[] | undefined;
+function map<T, U>(
+	array: readonly T[] | undefined,
+	f: (x: T, i: number) => U,
+): U[] | undefined {
+	let result: U[] | undefined;
+	if (array !== undefined) {
+		result = [];
+		for (let i = 0; i < array.length; i++) {
+			result.push(f(array[i], i));
+		}
+	}
+	return result;
+}
+
+function getRegularExpressionsForWildcards(
+	specs: readonly string[] | undefined,
+	basePath: string,
+	usage: "files" | "directories" | "exclude",
+): readonly string[] | undefined {
+	if (specs === undefined || specs.length === 0) {
+		return undefined;
+	}
+
+	return flatMap(
+		specs,
+		(spec) =>
+			spec &&
+			getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]),
+	);
+}
+
+interface WildcardMatcher {
+	singleAsteriskRegexFragment: string;
+	doubleAsteriskRegexFragment: string;
+	replaceWildcardCharacter: (match: string) => string;
+}
+
+const commonPackageFolders: readonly string[] = [
+	"node_modules",
+	"bower_components",
+	"jspm_packages",
+];
+
+const implicitExcludePathRegexPattern = `(?!(?:${commonPackageFolders.join("|")})(?:/|$))`;
+
+function replaceWildcardCharacter(
+	match: string,
+	singleAsteriskRegexFragment: string,
+) {
+	return match === "*"
+		? singleAsteriskRegexFragment
+		: match === "?"
+			? "[^/]"
+			: "\\" + match;
+}
+
+const filesMatcher: WildcardMatcher = {
+	/**
+	 * Matches any single directory segment unless it is the last segment and a .min.js file
+	 * Breakdown:
+	 *  [^./]                   # matches everything up to the first . character (excluding directory separators)
+	 *  (\\.(?!min\\.js$))?     # matches . characters but not if they are part of the .min.js file extension
+	 */
+	singleAsteriskRegexFragment: "(?:[^./]|(?:\\.(?!min\\.js$))?)*",
+	/**
+	 * Regex for the ** wildcard. Matches any number of subdirectories. When used for including
+	 * files or directories, does not match subdirectories that start with a . character
+	 */
+	doubleAsteriskRegexFragment: `(?:/${implicitExcludePathRegexPattern}[^/.][^/]*)*?`,
+	replaceWildcardCharacter: (match) =>
+		replaceWildcardCharacter(match, filesMatcher.singleAsteriskRegexFragment),
+};
+
+const directoriesMatcher: WildcardMatcher = {
+	singleAsteriskRegexFragment: "[^/]*",
+	/**
+	 * Regex for the ** wildcard. Matches any number of subdirectories. When used for including
+	 * files or directories, does not match subdirectories that start with a . character
+	 */
+	doubleAsteriskRegexFragment: `(?:/${implicitExcludePathRegexPattern}[^/.][^/]*)*?`,
+	replaceWildcardCharacter: (match) =>
+		replaceWildcardCharacter(
+			match,
+			directoriesMatcher.singleAsteriskRegexFragment,
+		),
+};
+
+const excludeMatcher: WildcardMatcher = {
+	singleAsteriskRegexFragment: "[^/]*",
+	doubleAsteriskRegexFragment: "(?:/.+?)?",
+	replaceWildcardCharacter: (match) =>
+		replaceWildcardCharacter(match, excludeMatcher.singleAsteriskRegexFragment),
+};
+
+const wildcardMatchers = {
+	files: filesMatcher,
+	directories: directoriesMatcher,
+	exclude: excludeMatcher,
+};
+
+function append<T extends {}>(to: T[], value: T | undefined): T[];
+function append<T extends {}>(to: T[] | undefined, value: T): T[];
+function append<T extends {}>(
+	to: T[] | undefined,
+	value: T | undefined,
+): T[] | undefined;
+function append<T extends {}>(
+	to: T[] | undefined,
+	value: T | undefined,
+): T[] | undefined {
+	if (value === undefined) {
+		return to;
+	}
+	if (to === undefined) {
+		return [value];
+	}
+	to.push(value);
+	return to;
+}
+
+function flatMap<T, U extends {}>(
+	array: readonly T[] | undefined,
+	mapfn: (x: T, i: number) => U | readonly U[] | undefined,
+): readonly U[] {
+	let result: U[] | undefined;
+	if (array !== undefined) {
+		for (let i = 0; i < array.length; i++) {
+			const v = mapfn(array[i], i);
+			if (v) {
+				if (isArray(v)) {
+					result = addRange(result, v);
+				} else {
+					result = append(result, v);
+				}
+			}
+		}
+	}
+	return result ?? emptyArray;
+}
+
+type PathPathComponents = Path[] & { __pathComponensBrand: any };
+
+function getPathComponents(path: Path): PathPathComponents;
+function getPathComponents(path: string, currentDirectory?: string): string[];
+function getPathComponents(path: string, currentDirectory = "") {
+	path = combinePaths(currentDirectory, path);
+	return pathComponents(path, getRootLength(path));
+}
+
+function lastOrUndefined<T>(array: readonly T[] | undefined): T | undefined {
+	return array === undefined || array.length === 0
+		? undefined
+		: array[array.length - 1];
+}
+
+function pathComponents(path: string, rootLength: number) {
+	const root = path.substring(0, rootLength);
+	const rest = path.substring(rootLength).split(directorySeparator);
+	if (rest.length && !lastOrUndefined(rest)) {
+		rest.pop();
+	}
+	return [root, ...rest];
+}
+
+function getNormalizedPathComponents(
+	path: string,
+	currentDirectory: string | undefined,
+): string[] {
+	return reducePathComponents(getPathComponents(path, currentDirectory));
+}
+
+function some<T>(array: readonly T[] | undefined): array is readonly T[];
+function some<T>(
+	array: readonly T[] | undefined,
+	predicate: (value: T) => boolean,
+): boolean;
+function some<T>(
+	array: readonly T[] | undefined,
+	predicate?: (value: T) => boolean,
+): boolean {
+	if (array !== undefined) {
+		if (predicate !== undefined) {
+			for (let i = 0; i < array.length; i++) {
+				if (predicate(array[i])) {
+					return true;
+				}
+			}
+		} else {
+			return array.length > 0;
+		}
+	}
+	return false;
+}
+
+function reducePathComponents(components: readonly string[]): string[] {
+	if (!some(components)) {
+		return [];
+	}
+	const reduced = [components[0]];
+	for (let i = 1; i < components.length; i++) {
+		const component = components[i];
+		if (!component) {
+			continue;
+		}
+		if (component === ".") {
+			continue;
+		}
+		if (component === "..") {
+			if (reduced.length > 1) {
+				if (reduced[reduced.length - 1] !== "..") {
+					reduced.pop();
+					continue;
+				}
+			} else if (reduced[0]) {
+				continue;
+			}
+		}
+		reduced.push(component);
+	}
+	return reduced;
+}
+
+function last<T>(array: readonly T[]): T {
+	return array[array.length - 1];
+}
+
+function isImplicitGlob(lastPathComponent: string): boolean {
+	return !/[.*?]/.test(lastPathComponent);
+}
+
+const reservedCharacterPattern = /[^\w\s/]/g;
+
+function getSubPatternFromSpec(
+	spec: string,
+	basePath: string,
+	usage: "files" | "directories" | "exclude",
+	{
+		singleAsteriskRegexFragment,
+		doubleAsteriskRegexFragment,
+		replaceWildcardCharacter,
+	}: WildcardMatcher = wildcardMatchers[usage],
+): string | undefined {
+	let subpattern = "";
+	let hasWrittenComponent = false;
+	const components = getNormalizedPathComponents(spec, basePath);
+	const lastComponent = last(components);
+	if (usage !== "exclude" && lastComponent === "**") {
+		return undefined;
+	}
+
+	// getNormalizedPathComponents includes the separator for the root component.
+	// We need to remove to create our regex correctly.
+	components[0] = removeTrailingDirectorySeparator(components[0]);
+
+	if (isImplicitGlob(lastComponent)) {
+		components.push("**", "*");
+	}
+
+	let optionalCount = 0;
+	for (let component of components) {
+		if (component === "**") {
+			subpattern += doubleAsteriskRegexFragment;
+		} else {
+			if (usage === "directories") {
+				subpattern += "(?:";
+				optionalCount++;
+			}
+
+			if (hasWrittenComponent) {
+				subpattern += directorySeparator;
+			}
+
+			if (usage !== "exclude") {
+				let componentPattern = "";
+				// The * and ? wildcards should not match directories or files that start with . if they
+				// appear first in a component. Dotted directories and files can be included explicitly
+				// like so: **/.*/.*
+				if (component.charCodeAt(0) === CharacterCodes.asterisk) {
+					componentPattern += "(?:[^./]" + singleAsteriskRegexFragment + ")?";
+					component = component.substr(1);
+				} else if (component.charCodeAt(0) === CharacterCodes.question) {
+					componentPattern += "[^./]";
+					component = component.substr(1);
+				}
+
+				componentPattern += component.replace(
+					reservedCharacterPattern,
+					replaceWildcardCharacter,
+				);
+
+				// Patterns should not include subfolders like node_modules unless they are
+				// explicitly included as part of the path.
+				//
+				// As an optimization, if the component pattern is the same as the component,
+				// then there definitely were no wildcard characters and we do not need to
+				// add the exclusion pattern.
+				if (componentPattern !== component) {
+					subpattern += implicitExcludePathRegexPattern;
+				}
+
+				subpattern += componentPattern;
+			} else {
+				subpattern += component.replace(
+					reservedCharacterPattern,
+					replaceWildcardCharacter,
+				);
+			}
+		}
+
+		hasWrittenComponent = true;
+	}
+
+	while (optionalCount > 0) {
+		subpattern += ")?";
+		optionalCount--;
+	}
+
+	return subpattern;
+}
+
+function getRegularExpressionForWildcard(
+	specs: readonly string[] | undefined,
+	basePath: string,
+	usage: "files" | "directories" | "exclude",
+): string | undefined {
+	const patterns = getRegularExpressionsForWildcards(specs, basePath, usage);
+	if (!patterns || !patterns.length) {
+		return undefined;
+	}
+
+	const pattern = patterns.map((pattern) => `(?:${pattern})`).join("|");
+	// If excluding, match "foo/bar/baz...", but if including, only allow "foo".
+	const terminator = usage === "exclude" ? "(?:$|/)" : "$";
+	return `^(?:${pattern})${terminator}`;
+}
+
+function isRootedDiskPath(path: string): boolean {
+	return getEncodedRootLength(path) > 0;
+}
+
+function indexOfAnyCharCode(
+	text: string,
+	charCodes: readonly number[],
+	start?: number,
+): number {
+	for (let i = start ?? 0; i < text.length; i++) {
+		if (contains(charCodes, text.charCodeAt(i))) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+type EqualityComparer<T> = (a: T, b: T) => boolean;
+
+function contains<T>(
+	array: readonly T[] | undefined,
+	value: T,
+	equalityComparer: EqualityComparer<T> = equateValues,
+): boolean {
+	if (array !== undefined) {
+		for (let i = 0; i < array.length; i++) {
+			if (equalityComparer(array[i], value)) {
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+const wildcardCharCodes = [CharacterCodes.asterisk, CharacterCodes.question];
+
+function startsWith(
+	str: string,
+	prefix: string,
+	ignoreCase?: boolean,
+): boolean {
+	return ignoreCase
+		? equateStringsCaseInsensitive(str.slice(0, prefix.length), prefix)
+		: str.lastIndexOf(prefix, 0) === 0;
+}
+
+function getBaseFileName(path: string): string;
+function getBaseFileName(
+	path: string,
+	extensions: string | readonly string[],
+	ignoreCase: boolean,
+): string;
+function getBaseFileName(
+	path: string,
+	extensions?: string | readonly string[],
+	ignoreCase?: boolean,
+) {
+	path = normalizeSlashes(path);
+
+	// if the path provided is itself the root, then it has not file name.
+	const rootLength = getRootLength(path);
+	if (rootLength === path.length) {
+		return "";
+	}
+
+	// return the trailing portion of the path starting after the last (non-terminal) directory
+	// separator but not including any trailing directory separator.
+	path = removeTrailingDirectorySeparator(path);
+	const name = path.slice(
+		Math.max(getRootLength(path), path.lastIndexOf(directorySeparator) + 1),
+	);
+	const extension =
+		extensions !== undefined && ignoreCase !== undefined
+			? getAnyExtensionFromPath(name, extensions, ignoreCase)
+			: undefined;
+	return extension ? name.slice(0, name.length - extension.length) : name;
+}
+
+function tryGetExtensionFromPath(
+	path: string,
+	extension: string,
+	stringEqualityComparer: (a: string, b: string) => boolean,
+) {
+	if (!startsWith(extension, ".")) {
+		extension = "." + extension;
+	}
+	if (
+		path.length >= extension.length &&
+		path.charCodeAt(path.length - extension.length) === CharacterCodes.dot
+	) {
+		const pathExtension = path.slice(path.length - extension.length);
+		if (stringEqualityComparer(pathExtension, extension)) {
+			return pathExtension;
+		}
+	}
+}
+
+function getAnyExtensionFromPathWorker(
+	path: string,
+	extensions: string | readonly string[],
+	stringEqualityComparer: (a: string, b: string) => boolean,
+) {
+	if (typeof extensions === "string") {
+		return (
+			tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || ""
+		);
+	}
+	for (const extension of extensions) {
+		const result = tryGetExtensionFromPath(
+			path,
+			extension,
+			stringEqualityComparer,
+		);
+		if (result) {
+			return result;
+		}
+	}
+	return "";
+}
+
+function equateValues<T>(a: T, b: T): boolean {
+	return a === b;
+}
+
+function equateStringsCaseSensitive(a: string, b: string): boolean {
+	return equateValues(a, b);
+}
+
+function getAnyExtensionFromPath(path: string): string;
+function getAnyExtensionFromPath(
+	path: string,
+	extensions: string | readonly string[],
+	ignoreCase: boolean,
+): string;
+function getAnyExtensionFromPath(
+	path: string,
+	extensions?: string | readonly string[],
+	ignoreCase?: boolean,
+): string {
+	// Retrieves any string from the final "." onwards from a base file name.
+	// Unlike extensionFromPath, which throws an exception on unrecognized extensions.
+	if (extensions) {
+		return getAnyExtensionFromPathWorker(
+			removeTrailingDirectorySeparator(path),
+			extensions,
+			ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive,
+		);
+	}
+	const baseFileName = getBaseFileName(path);
+	const extensionIndex = baseFileName.lastIndexOf(".");
+	if (extensionIndex >= 0) {
+		return baseFileName.substring(extensionIndex);
+	}
+	return "";
+}
+
+function hasExtension(fileName: string): boolean {
+	return getBaseFileName(fileName).includes(".");
+}
+
+function getIncludeBasePath(absolute: string): string {
+	const wildcardOffset = indexOfAnyCharCode(absolute, wildcardCharCodes);
+	if (wildcardOffset < 0) {
+		// No "*" or "?" in the path
+		return !hasExtension(absolute)
+			? absolute
+			: removeTrailingDirectorySeparator(getDirectoryPath(absolute));
+	}
+	return absolute.substring(
+		0,
+		absolute.lastIndexOf(directorySeparator, wildcardOffset),
+	);
+}
+
+function getDirectoryPath(path: Path): Path;
+function getDirectoryPath(path: string): string;
+function getDirectoryPath(path: string): string {
+	path = normalizeSlashes(path);
+
+	// If the path provided is itself the root, then return it.
+	const rootLength = getRootLength(path);
+	if (rootLength === path.length) {
+		return path;
+	}
+
+	// return the leading portion of the path up to the last (non-terminal) directory separator
+	// but not including any trailing directory separator.
+	path = removeTrailingDirectorySeparator(path);
+	return path.slice(
+		0,
+		Math.max(rootLength, path.lastIndexOf(directorySeparator)),
+	);
+}
+
+function compareStringsCaseInsensitive(a: string, b: string): Comparison {
+	if (a === b) {
+		return Comparison.EqualTo;
+	}
+	if (a === undefined) {
+		return Comparison.LessThan;
+	}
+	if (b === undefined) {
+		return Comparison.GreaterThan;
+	}
+	a = a.toUpperCase();
+	b = b.toUpperCase();
+	return a < b
+		? Comparison.LessThan
+		: a > b
+			? Comparison.GreaterThan
+			: Comparison.EqualTo;
+}
+
+function getStringComparer(
+	ignoreCase?: boolean,
+): typeof compareStringsCaseInsensitive {
+	return ignoreCase
+		? compareStringsCaseInsensitive
+		: compareStringsCaseSensitive;
+}
+
+function every<T, U extends T>(
+	array: readonly T[],
+	callback: (element: T, index: number) => element is U,
+): array is readonly U[];
+function every<T, U extends T>(
+	array: readonly T[] | undefined,
+	callback: (element: T, index: number) => element is U,
+): array is readonly U[] | undefined;
+function every<T>(
+	array: readonly T[] | undefined,
+	callback: (element: T, index: number) => boolean,
+): boolean;
+function every<T>(
+	array: readonly T[] | undefined,
+	callback: (element: T, index: number) => boolean,
+): boolean {
+	if (array !== undefined) {
+		for (let i = 0; i < array.length; i++) {
+			if (!callback(array[i], i)) {
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+function containsPath(
+	parent: string,
+	child: string,
+	ignoreCase?: boolean,
+): boolean;
+function containsPath(
+	parent: string,
+	child: string,
+	currentDirectory: string,
+	ignoreCase?: boolean,
+): boolean;
+function containsPath(
+	parent: string,
+	child: string,
+	currentDirectory?: string | boolean,
+	ignoreCase?: boolean,
+) {
+	if (typeof currentDirectory === "string") {
+		parent = combinePaths(currentDirectory, parent);
+		child = combinePaths(currentDirectory, child);
+	} else if (typeof currentDirectory === "boolean") {
+		ignoreCase = currentDirectory;
+	}
+	if (parent === undefined || child === undefined) {
+		return false;
+	}
+	if (parent === child) {
+		return true;
+	}
+	const parentComponents = reducePathComponents(getPathComponents(parent));
+	const childComponents = reducePathComponents(getPathComponents(child));
+	if (childComponents.length < parentComponents.length) {
+		return false;
+	}
+
+	const componentEqualityComparer = ignoreCase
+		? equateStringsCaseInsensitive
+		: equateStringsCaseSensitive;
+	for (let i = 0; i < parentComponents.length; i++) {
+		const equalityComparer =
+			i === 0 ? equateStringsCaseInsensitive : componentEqualityComparer;
+		if (!equalityComparer(parentComponents[i], childComponents[i])) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function getBasePaths(
+	path: string,
+	includes: readonly string[] | undefined,
+	useCaseSensitiveFileNames: boolean,
+): string[] {
+	// Storage for our results in the form of literal paths (e.g. the paths as written by the user).
+	const basePaths: string[] = [path];
+
+	if (includes) {
+		// Storage for literal base paths amongst the include patterns.
+		const includeBasePaths: string[] = [];
+		for (const include of includes) {
+			// We also need to check the relative paths by converting them to absolute and normalizing
+			// in case they escape the base path (e.g "..\somedirectory")
+			const absolute: string = isRootedDiskPath(include)
+				? include
+				: normalizePath(combinePaths(path, include));
+			// Append the literal and canonical candidate base paths.
+			includeBasePaths.push(getIncludeBasePath(absolute));
+		}
+
+		// Sort the offsets array using either the literal or canonical path representations.
+		includeBasePaths.sort(getStringComparer(!useCaseSensitiveFileNames));
+
+		// Iterate over each include base path and include unique base paths that are not a
+		// subpath of an existing base path
+		for (const includeBasePath of includeBasePaths) {
+			if (
+				every(
+					basePaths,
+					(basePath) =>
+						!containsPath(
+							basePath,
+							includeBasePath,
+							path,
+							!useCaseSensitiveFileNames,
+						),
+				)
+			) {
+				basePaths.push(includeBasePath);
+			}
+		}
+	}
+
+	return basePaths;
+}
+
+function getFileMatcherPatterns(
+	path: string,
+	excludes: readonly string[] | undefined,
+	includes: readonly string[] | undefined,
+	useCaseSensitiveFileNames: boolean,
+	currentDirectory: string,
+): FileMatcherPatterns {
+	path = normalizePath(path);
+	currentDirectory = normalizePath(currentDirectory);
+	const absolutePath = combinePaths(currentDirectory, path);
+
+	return {
+		includeFilePatterns: map(
+			getRegularExpressionsForWildcards(includes, absolutePath, "files"),
+			(pattern) => `^${pattern}$`,
+		),
+		includeFilePattern: getRegularExpressionForWildcard(
+			includes,
+			absolutePath,
+			"files",
+		),
+		includeDirectoryPattern: getRegularExpressionForWildcard(
+			includes,
+			absolutePath,
+			"directories",
+		),
+		excludePattern: getRegularExpressionForWildcard(
+			excludes,
+			absolutePath,
+			"exclude",
+		),
+		basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames),
+	};
+}
+
+function getRegexFromPattern(
+	pattern: string,
+	useCaseSensitiveFileNames: boolean,
+): RegExp {
+	return new RegExp(pattern, useCaseSensitiveFileNames ? "" : "i");
+}
+
+type GetCanonicalFileName = (fileName: string) => string;
+function identity<T>(x: T): T {
+	return x;
+}
+function toLowerCase(x: string) {
+	return x.toLowerCase();
+}
+const fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_. ]+/g;
+function toFileNameLowerCase(x: string): string {
+	return fileNameLowerCaseRegExp.test(x)
+		? x.replace(fileNameLowerCaseRegExp, toLowerCase)
+		: x;
+}
+
+function createGetCanonicalFileName(
+	useCaseSensitiveFileNames: boolean,
+): GetCanonicalFileName {
+	return useCaseSensitiveFileNames ? identity : toFileNameLowerCase;
+}
+function isArray(value: any): value is readonly unknown[] {
+	// See: https://github.com/microsoft/TypeScript/issues/17002
+	return Array.isArray(value);
+}
+
+function toOffset(array: readonly any[], offset: number) {
+	return offset < 0 ? array.length + offset : offset;
+}
+
+function addRange<T>(
+	to: T[],
+	from: readonly T[] | undefined,
+	start?: number,
+	end?: number,
+): T[];
+function addRange<T>(
+	to: T[] | undefined,
+	from: readonly T[] | undefined,
+	start?: number,
+	end?: number,
+): T[] | undefined;
+function addRange<T>(
+	to: T[] | undefined,
+	from: readonly T[] | undefined,
+	start?: number,
+	end?: number,
+): T[] | undefined {
+	if (from === undefined || from.length === 0) {
+		return to;
+	}
+	if (to === undefined) {
+		return from.slice(start, end);
+	}
+	start = start === undefined ? 0 : toOffset(from, start);
+	end = end === undefined ? from.length : toOffset(from, end);
+	for (let i = start; i < end && i < from.length; i++) {
+		if (from[i] !== undefined) {
+			to.push(from[i]);
+		}
+	}
+	return to;
+}
+
+function flatten<T>(
+	array: T[][] | readonly (T | readonly T[] | undefined)[],
+): T[] {
+	const result = [];
+	for (let i = 0; i < array.length; i++) {
+		const v = array[i];
+		if (v) {
+			if (isArray(v)) {
+				addRange(result, v);
+			} else {
+				result.push(v);
+			}
+		}
+	}
+	return result;
+}
+
+type Comparer<T> = (a: T, b: T) => Comparison;
+
+const enum Comparison {
+	LessThan = -1,
+	EqualTo = 0,
+	GreaterThan = 1,
+}
+
+interface SortedReadonlyArray<T> extends ReadonlyArray<T> {
+	" __sortedArrayBrand": any;
+}
+
+const emptyArray = [] as never[];
+
+function toSorted<T>(
+	array: readonly T[],
+	comparer?: Comparer<T>,
+): SortedReadonlyArray<T> {
+	return (array.length === 0
+		? emptyArray
+		: array.slice().sort(comparer)) as readonly T[] as SortedReadonlyArray<T>;
+}
+
+function compareComparableValues(
+	a: string | undefined,
+	b: string | undefined,
+): Comparison;
+function compareComparableValues(
+	a: number | undefined,
+	b: number | undefined,
+): Comparison;
+function compareComparableValues(
+	a: string | number | undefined,
+	b: string | number | undefined,
+) {
+	return a === b
+		? Comparison.EqualTo
+		: a === undefined
+			? Comparison.LessThan
+			: b === undefined
+				? Comparison.GreaterThan
+				: a < b
+					? Comparison.LessThan
+					: Comparison.GreaterThan;
+}
+
+function compareStringsCaseSensitive(
+	a: string | undefined,
+	b: string | undefined,
+): Comparison {
+	return compareComparableValues(a, b);
+}
+
+function equateStringsCaseInsensitive(a: string, b: string): boolean {
+	return (
+		a === b ||
+		(a !== undefined && b !== undefined && a.toUpperCase() === b.toUpperCase())
+	);
+}
+
+function endsWith(str: string, suffix: string, ignoreCase?: boolean): boolean {
+	const expectedPos = str.length - suffix.length;
+	return (
+		expectedPos >= 0 &&
+		(ignoreCase
+			? equateStringsCaseInsensitive(str.slice(expectedPos), suffix)
+			: str.indexOf(suffix, expectedPos) === expectedPos)
+	);
+}
+
+function fileExtensionIs(path: string, extension: string): boolean {
+	return path.length > extension.length && endsWith(path, extension);
+}
+
+function fileExtensionIsOneOf(
+	path: string,
+	extensions: readonly string[],
+): boolean {
+	for (const extension of extensions) {
+		if (fileExtensionIs(path, extension)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function findIndex<T>(
+	array: readonly T[] | undefined,
+	predicate: (element: T, index: number) => boolean,
+	startIndex?: number,
+): number {
+	if (array === undefined) {
+		return -1;
+	}
+	for (let i = startIndex ?? 0; i < array.length; i++) {
+		if (predicate(array[i], i)) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+export function matchFiles(
+	path: string,
+	extensions: readonly string[] | undefined,
+	excludes: readonly string[] | undefined,
+	includes: readonly string[] | undefined,
+	useCaseSensitiveFileNames: boolean,
+	currentDirectory: string,
+	depth: number | undefined,
+	getFileSystemEntries: (path: string) => FileSystemEntries,
+	realpath: (path: string) => string,
+): string[] {
+	path = normalizePath(path);
+	currentDirectory = normalizePath(currentDirectory);
+
+	const patterns = getFileMatcherPatterns(
+		path,
+		excludes,
+		includes,
+		useCaseSensitiveFileNames,
+		currentDirectory,
+	);
+
+	const includeFileRegexes =
+		patterns.includeFilePatterns &&
+		patterns.includeFilePatterns.map((pattern) =>
+			getRegexFromPattern(pattern, useCaseSensitiveFileNames),
+		);
+	const includeDirectoryRegex =
+		patterns.includeDirectoryPattern &&
+		getRegexFromPattern(
+			patterns.includeDirectoryPattern,
+			useCaseSensitiveFileNames,
+		);
+	const excludeRegex =
+		patterns.excludePattern &&
+		getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames);
+
+	// Associate an array of results with each include regex. This keeps results in order of the "include" order.
+	// If there are no "includes", then just put everything in results[0].
+	const results: string[][] = includeFileRegexes
+		? includeFileRegexes.map(() => [])
+		: [[]];
+	const visited = new Map<string, true>();
+	const toCanonical = createGetCanonicalFileName(useCaseSensitiveFileNames);
+	for (const basePath of patterns.basePaths) {
+		visitDirectory(basePath, combinePaths(currentDirectory, basePath), depth);
+	}
+
+	return flatten(results);
+
+	function visitDirectory(
+		path: string,
+		absolutePath: string,
+		depth: number | undefined,
+	) {
+		const canonicalPath = toCanonical(realpath(absolutePath));
+		if (visited.has(canonicalPath)) {
+			return;
+		}
+		visited.set(canonicalPath, true);
+		const { files, directories } = getFileSystemEntries(path);
+
+		for (const current of toSorted<string>(
+			files,
+			compareStringsCaseSensitive,
+		)) {
+			const name = combinePaths(path, current);
+			const absoluteName = combinePaths(absolutePath, current);
+			if (extensions && !fileExtensionIsOneOf(name, extensions)) {
+				continue;
+			}
+			if (excludeRegex && excludeRegex.test(absoluteName)) {
+				continue;
+			}
+			if (!includeFileRegexes) {
+				results[0].push(name);
+			} else {
+				const includeIndex = findIndex(includeFileRegexes, (re) =>
+					re.test(absoluteName),
+				);
+				if (includeIndex !== -1) {
+					results[includeIndex].push(name);
+				}
+			}
+		}
+
+		if (depth !== undefined) {
+			depth--;
+			if (depth === 0) {
+				return;
+			}
+		}
+
+		for (const current of toSorted<string>(
+			directories,
+			compareStringsCaseSensitive,
+		)) {
+			const name = combinePaths(path, current);
+			const absoluteName = combinePaths(absolutePath, current);
+			if (
+				(!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
+				(!excludeRegex || !excludeRegex.test(absoluteName))
+			) {
+				visitDirectory(name, absoluteName, depth);
+			}
+		}
+	}
+}
diff --git a/packages/yaml/src/language.ts b/packages/yaml/src/language.ts
index 59289d139..81ab3e445 100644
--- a/packages/yaml/src/language.ts
+++ b/packages/yaml/src/language.ts
@@ -1,7 +1,6 @@
 import type * as yamlParser from "yaml-unist-parser";
 
 import { createLanguage } from "@flint.fyi/core";
-import fsSync from "node:fs";
 
 import { createYamlFile } from "./createYamlFile.js";
 import { YamlNodesByName } from "./nodes.js";
@@ -17,13 +16,7 @@ export const yamlLanguage = createLanguage<YamlNodesByName, YamlServices>({
 	},
 	prepare: () => {
 		return {
-			prepareFromDisk: (filePathAbsolute) => {
-				const sourceText = fsSync.readFileSync(filePathAbsolute, "utf8");
-				const { languageFile, root } = createYamlFile(sourceText);
-
-				return prepareYamlFile(languageFile, root, sourceText);
-			},
-			prepareFromVirtual: (filePathAbsolute, sourceText) => {
+			prepareFile: (filePathAbsolute, sourceText) => {
 				const { languageFile, root } = createYamlFile(sourceText);
 
 				return prepareYamlFile(languageFile, root, sourceText);
diff --git a/patches/@typescript-eslint__project-service@8.50.1.patch b/patches/@typescript-eslint__project-service@8.50.1.patch
new file mode 100644
index 000000000..4fb2f5df4
--- /dev/null
+++ b/patches/@typescript-eslint__project-service@8.50.1.patch
@@ -0,0 +1,41 @@
+diff --git a/dist/createProjectService.d.ts b/dist/createProjectService.d.ts
+index 4a3aafa6dbab7af0af17fc038b516b40cb133576..0d1ee005c79fa1a04c9821fc101180721175d831 100644
+--- a/dist/createProjectService.d.ts
++++ b/dist/createProjectService.d.ts
+@@ -41,6 +41,7 @@ export interface CreateProjectServiceSettings {
+      * Root directory for the tsconfig.json file, if not the current directory.
+      */
+     tsconfigRootDir?: string;
++		host?: ts.server.ServerHost
+ }
+ /**
+  * Creates a new Project Service instance, as well as metadata on its creation.
+diff --git a/dist/createProjectService.js b/dist/createProjectService.js
+index 43ddcebe435eaecb159877d8008161abfddf96a5..b04f3e467dc8d09fe5fd23e669089e17815a55b3 100644
+--- a/dist/createProjectService.js
++++ b/dist/createProjectService.js
+@@ -31,7 +31,7 @@ const createStubFileWatcher = () => ({
+  * service.openClientFile('index.ts');
+  * ```
+  */
+-function createProjectService({ jsDocParsingMode, options: optionsRaw = {}, tsconfigRootDir, } = {}) {
++function createProjectService({ jsDocParsingMode, options: optionsRaw = {}, tsconfigRootDir, host = tsserver.sys } = {}) {
+     const options = {
+         defaultProject: 'tsconfig.json',
+         ...optionsRaw,
+@@ -45,7 +45,6 @@ function createProjectService({ jsDocParsingMode, options: optionsRaw = {}, tsco
+     // there's a whole separate update pass in maybeInvalidateProgram at the bottom of getWatchProgramsForProjects
+     // (this "goes nuclear on TypeScript")
+     const system = {
+-        ...tsserver.sys,
+         clearImmediate,
+         clearTimeout,
+         setImmediate,
+@@ -62,6 +61,7 @@ function createProjectService({ jsDocParsingMode, options: optionsRaw = {}, tsco
+                 module: undefined,
+             }),
+         }),
++        ...host,
+     };
+     const logger = {
+         close: doNothing,
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7314d0e87..af43108c3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -9,6 +9,11 @@ overrides:
   read-pkg: 10.0.0
   unicorn-magic: 0.4.0
 
+patchedDependencies:
+  '@typescript-eslint/project-service@8.50.1':
+    hash: cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c
+    path: patches/@typescript-eslint__project-service@8.50.1.patch
+
 importers:
 
   .:
@@ -574,7 +579,7 @@ importers:
         version: link:../rule-tester
       '@typescript-eslint/project-service':
         specifier: ^8.46.2
-        version: 8.50.1(typescript@5.9.3)
+        version: 8.50.1(patch_hash=cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c)(typescript@5.9.3)
       '@typescript/vfs':
         specifier: ^1.6.1
         version: 1.6.1(typescript@5.9.3)
@@ -6674,7 +6679,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/project-service@8.50.1(typescript@5.9.3)':
+  '@typescript-eslint/project-service@8.50.1(patch_hash=cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c)(typescript@5.9.3)':
     dependencies:
       '@typescript-eslint/tsconfig-utils': 8.50.1(typescript@5.9.3)
       '@typescript-eslint/types': 8.50.1
@@ -6734,7 +6739,7 @@ snapshots:
 
   '@typescript-eslint/typescript-estree@8.50.1(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/project-service': 8.50.1(typescript@5.9.3)
+      '@typescript-eslint/project-service': 8.50.1(patch_hash=cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c)(typescript@5.9.3)
       '@typescript-eslint/tsconfig-utils': 8.50.1(typescript@5.9.3)
       '@typescript-eslint/types': 8.50.1
       '@typescript-eslint/visitor-keys': 8.50.1

From bf753248bcfbf01864b8fc67d677e01348fc0565 Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Tue, 30 Dec 2025 17:43:14 +0300
Subject: [PATCH 03/11] OMG IT WORKS!!!!!!!!!!!!!!!!

---
 packages/core/src/index.ts                    |   3 +-
 packages/rule-tester/src/host.ts              |   1 +
 packages/ts/package.json                      |   2 +
 packages/ts/src/language.ts                   | 147 +++++++++++++-
 packages/vue-language/src/language.ts         | 184 ++++++++++--------
 .../vue-language/src/rules/MyComponent.vue    |   5 -
 .../vue-language/src/rules/anyReturns.test.ts |  19 +-
 .../src/rules/asyncComputed.test.ts           |  26 +--
 packages/vue-language/src/rules/fixture.ts    |   1 -
 packages/vue-language/src/rules/ruleTester.ts |   9 +-
 .../src/rules/scriptSetupExports.test.ts      |   9 +-
 pnpm-lock.yaml                                |   6 +
 12 files changed, 292 insertions(+), 120 deletions(-)
 delete mode 100644 packages/vue-language/src/rules/MyComponent.vue
 delete mode 100644 packages/vue-language/src/rules/fixture.ts

diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 2166954fc..0b687a6b0 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -20,6 +20,7 @@ export { createVFSLinterHost } from "./host/createVFSLinterHost.js";
 export { createFSBackedLinterHost } from "./host/createFSBackedLinterHost.js";
 export { normalizePath } from "./host/normalizePath.js";
 export * from "./types/about.js";
+export * from "./types/arrays.js";
 export * from "./types/cache.js";
 export * from "./types/changes.js";
 export * from "./types/configs.js";
@@ -35,6 +36,6 @@ export * from "./types/ranges.js";
 export * from "./types/reports.js";
 export * from "./types/rules.js";
 export * from "./types/shapes.js";
-export { binarySearch } from "./utils/arrays.js";
+export { binarySearch, flatten } from "./utils/arrays.js";
 export * from "./utils/getColumnAndLineOfPosition.js";
 export * from "./utils/predicates.js";
diff --git a/packages/rule-tester/src/host.ts b/packages/rule-tester/src/host.ts
index 77c9ee060..bdc9402c5 100644
--- a/packages/rule-tester/src/host.ts
+++ b/packages/rule-tester/src/host.ts
@@ -28,6 +28,7 @@ export function createRuleTesterTSHost(
 					lib: ["esnext"],
 					target: "esnext",
 					types: [],
+					moduleResolution: "bundler",
 					...opts.defaultCompilerOptions,
 				},
 			},
diff --git a/packages/ts/package.json b/packages/ts/package.json
index 32404c2bc..f64c29ea6 100644
--- a/packages/ts/package.json
+++ b/packages/ts/package.json
@@ -19,6 +19,8 @@
 		"@flint.fyi/rule-tester": "workspace:",
 		"@typescript-eslint/project-service": "^8.46.2",
 		"@typescript/vfs": "^1.6.1",
+		"@volar/language-core": "2.4.27",
+		"@volar/typescript": "2.4.27",
 		"cached-factory": "^0.1.0",
 		"debug-for-file": "^0.2.0",
 		"ts-api-utils": "^2.1.0",
diff --git a/packages/ts/src/language.ts b/packages/ts/src/language.ts
index 6d2dd2c20..134ca48a1 100644
--- a/packages/ts/src/language.ts
+++ b/packages/ts/src/language.ts
@@ -1,9 +1,28 @@
-import { createLanguage } from "@flint.fyi/core";
+import {
+	AnyLevelDeep,
+	AnyRuleDefinition,
+	flatten,
+	createLanguage,
+	Language,
+	setTSProgramCreationProxy,
+	LanguagePreparedDefinition,
+} from "@flint.fyi/core";
 import * as ts from "typescript";
+import {
+	LanguagePlugin as VolarLanguagePlugin,
+	Language as VolarLanguage,
+} from "@volar/language-core";
 
 import { TSNodesByName } from "./nodes.js";
-import { prepareTypeScriptBasedLanguage } from "./prepareTypeScriptBasedLanguage.js";
+import {
+	prepareTypeScriptBasedLanguage,
+	TypeScriptBasedLanguageFile,
+} from "./prepareTypeScriptBasedLanguage.js";
 import { prepareTypeScriptFile } from "./prepareTypeScriptFile.js";
+import { proxyCreateProgram } from "@volar/typescript/lib/node/proxyCreateProgram.js";
+
+// for LanguagePlugin interface augmentation
+import "@volar/typescript";
 
 export interface TypeScriptFileServices {
 	program: ts.Program;
@@ -11,6 +30,81 @@ export interface TypeScriptFileServices {
 	typeChecker: ts.TypeChecker;
 }
 
+type VolarLanguagePluginInitializer = (
+	ts: typeof import("typescript"),
+	options: ts.CreateProgramOptions,
+) => {
+	languagePlugins: AnyLevelDeep<VolarLanguagePlugin<string>>;
+	prepareFile: (
+		filePathAbsolute: string,
+		tsFile: TypeScriptBasedLanguageFile,
+	) => LanguagePreparedDefinition;
+};
+const volarLanguagePluginInitializers =
+	new Set<VolarLanguagePluginInitializer>();
+
+type ProxiedTSProgram = ts.Program & {
+	__flintVolarLanguage?: undefined | VolarLanguage<string>;
+};
+
+setTSProgramCreationProxy(
+	(ts, createProgram) =>
+		new Proxy(function () {} as unknown as typeof createProgram, {
+			apply(target, thisArg, args) {
+				let volarLanguage = null as null | VolarLanguage<string>;
+				const proxied = proxyCreateProgram(ts, createProgram, (ts, options) => {
+					const languagePlugins = Array.from(volarLanguagePluginInitializers)
+						.map((initializer) => initializer(ts, options))
+						.map(({ languagePlugins, prepareFile }) =>
+							flatten(languagePlugins).map((plugin) => {
+								plugin.__flintPrepareFile = prepareFile;
+								if (plugin.typescript == null) {
+									return plugin;
+								}
+
+								const { getServiceScript } = plugin.typescript;
+								plugin.typescript.getServiceScript = (root) => {
+									const script = getServiceScript(root);
+									if (script == null) {
+										return script;
+									}
+									return {
+										...script,
+										// Leading offset is useful for LanguageService [1], but we don't use it.
+										// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
+										// have to provide it ourselves.
+										//
+										// [1] https://github.com/volarjs/volar.js/discussions/188
+										// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
+										preventLeadingOffset: true,
+									};
+								};
+
+								return plugin;
+							}),
+						);
+					return {
+						languagePlugins: flatten(languagePlugins),
+						setup: (lang) => (volarLanguage = lang),
+					};
+				});
+
+				const program: ProxiedTSProgram = Reflect.apply(proxied, thisArg, args);
+
+				if (volarLanguage == null) {
+					throw new Error("Flint bug: volarLanguage is not defined");
+				}
+
+				if (program.__flintVolarLanguage != null) {
+					return program;
+				}
+
+				program.__flintVolarLanguage = volarLanguage;
+				return program;
+			},
+		}),
+);
+
 export const typescriptLanguage = createLanguage<
 	TSNodesByName,
 	TypeScriptFileServices
@@ -23,13 +117,50 @@ export const typescriptLanguage = createLanguage<
 
 		return {
 			prepareFile(filePathAbsolute) {
-				return prepareTypeScriptFile(lang.createFile(filePathAbsolute));
+				const tsFile = lang.createFile(filePathAbsolute);
+
+				const volarLanguage = (tsFile.program as ProxiedTSProgram)
+					.__flintVolarLanguage;
+
+				if (volarLanguage != null) {
+					const sourceScript = volarLanguage.scripts.get(
+						tsFile.sourceFile.fileName,
+					);
+
+					if (sourceScript != null) {
+						const prepareFile =
+							sourceScript.generated?.languagePlugin?.__flintPrepareFile;
+						if (prepareFile != null) {
+							return prepareFile(filePathAbsolute, tsFile);
+						}
+					}
+				}
+
+				return prepareTypeScriptFile(tsFile);
 			},
-			// prepareFromVirtual(filePathAbsolute, sourceText) {
-			// 	return prepareTypeScriptFile(
-			// 		lang.createFromVirtual(filePathAbsolute, sourceText),
-			// 	);
-			// },
 		};
 	},
 });
+
+export function createTypeScriptBasedLanguage<
+	AstNodesByName,
+	ContextServices extends object,
+>(initializer: VolarLanguagePluginInitializer) {
+	volarLanguagePluginInitializers.add(initializer);
+	const language: Language<AstNodesByName, ContextServices> = {
+		createRule: (ruleDefinition: AnyRuleDefinition) => {
+			return {
+				...ruleDefinition,
+				language: typescriptLanguage,
+			};
+		},
+
+		prepare(host) {
+			throw new Error(
+				"Flint bug: TypeScript based language should never be prepared",
+			);
+		},
+	};
+
+	return language;
+}
diff --git a/packages/vue-language/src/language.ts b/packages/vue-language/src/language.ts
index f4d9d2489..fa225e506 100644
--- a/packages/vue-language/src/language.ts
+++ b/packages/vue-language/src/language.ts
@@ -32,11 +32,10 @@ import {
 	VueCompilerOptions,
 	VueVirtualCode,
 } from "@vue/language-core";
-// for LanguagePlugin interface augmentation
-import "@volar/typescript";
 import {
 	collectTypeScriptFileCacheImpacts,
 	convertTypeScriptDiagnosticToLanguageFileDiagnostic,
+	createTypeScriptBasedLanguage,
 	extractDirectivesFromTypeScriptFile,
 	NodeSyntaxKinds,
 	prepareTypeScriptBasedLanguage,
@@ -45,87 +44,82 @@ import {
 	TypeScriptBasedLanguageFile,
 	TypeScriptFileServices,
 } from "@flint.fyi/ts";
-import { proxyCreateProgram } from "@volar/typescript/lib/node/proxyCreateProgram.js";
 import ts from "typescript";
 
-type ProxiedTSProgram = ts.Program & {
-	__flintVolarLanguage?: undefined | VolarLanguage<string>;
-};
-
 // TODO: css
 
 setTSExtraSupportedExtensions([".vue"]);
-setTSProgramCreationProxy(
-	(ts, createProgram) =>
-		new Proxy(function () {} as unknown as typeof createProgram, {
-			apply(target, thisArg, args) {
-				let volarLanguage = null as null | VolarLanguage<string>;
-				let vueCompilerOptions = null as null | VueCompilerOptions;
-				const proxied = proxyCreateProgram(ts, createProgram, (ts, options) => {
-					const { configFilePath } = options.options;
-					vueCompilerOptions = (
-						typeof configFilePath === "string"
-							? createVueParsedCommandLine(
-									ts,
-									ts.sys,
-									configFilePath.replaceAll("\\", "/"),
-								)
-							: createVueParsedCommandLineByJson(
-									ts,
-									ts.sys,
-									(options.host ?? ts.sys).getCurrentDirectory(),
-									{},
-								)
-					).vueOptions;
-					const vueLanguagePlugin = createVueLanguagePlugin<string>(
-						ts,
-						options.options,
-						vueCompilerOptions,
-						(id) => id,
-					);
-					if (vueLanguagePlugin.typescript != null) {
-						const { getServiceScript } = vueLanguagePlugin.typescript;
-						vueLanguagePlugin.typescript.getServiceScript = (root) => {
-							const script = getServiceScript(root);
-							if (script == null) {
-								return script;
-							}
-							return {
-								...script,
-								// Leading offset is useful for LanguageService [1], but we don't use it.
-								// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
-								// have to provide it ourselves.
-								//
-								// [1] https://github.com/volarjs/volar.js/discussions/188
-								// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
-								preventLeadingOffset: true,
-							};
-						};
-					}
-					return {
-						languagePlugins: [vueLanguagePlugin],
-						setup: (lang) => (volarLanguage = lang),
-					};
-				});
-
-				const program: ProxiedTSProgram = Reflect.apply(proxied, thisArg, args);
-
-				if (volarLanguage == null) {
-					throw new Error("Flint bug: volarLanguage is not defined");
-				}
-				if (vueCompilerOptions == null) {
-					throw new Error("Flint bug: vueCompilerOptions is not defined");
-				}
-
-				if (program.__flintVolarLanguage != null) {
-					return program;
-				}
-
-				program.__flintVolarLanguage = volarLanguage;
-				return program;
-			},
-		}),
-);
+// setTSProgramCreationProxy(
+// 	(ts, createProgram) =>
+// 		new Proxy(function () {} as unknown as typeof createProgram, {
+// 			apply(target, thisArg, args) {
+// 				let volarLanguage = null as null | VolarLanguage<string>;
+// 				let vueCompilerOptions = null as null | VueCompilerOptions;
+// 				const proxied = proxyCreateProgram(ts, createProgram, (ts, options) => {
+// 					const { configFilePath } = options.options;
+// 					vueCompilerOptions = (
+// 						typeof configFilePath === "string"
+// 							? createVueParsedCommandLine(
+// 									ts,
+// 									ts.sys,
+// 									configFilePath.replaceAll("\\", "/"),
+// 								)
+// 							: createVueParsedCommandLineByJson(
+// 									ts,
+// 									ts.sys,
+// 									(options.host ?? ts.sys).getCurrentDirectory(),
+// 									{},
+// 								)
+// 					).vueOptions;
+// 					const vueLanguagePlugin = createVueLanguagePlugin<string>(
+// 						ts,
+// 						options.options,
+// 						vueCompilerOptions,
+// 						(id) => id,
+// 					);
+// 					if (vueLanguagePlugin.typescript != null) {
+// 						const { getServiceScript } = vueLanguagePlugin.typescript;
+// 						vueLanguagePlugin.typescript.getServiceScript = (root) => {
+// 							const script = getServiceScript(root);
+// 							if (script == null) {
+// 								return script;
+// 							}
+// 							return {
+// 								...script,
+// 								// Leading offset is useful for LanguageService [1], but we don't use it.
+// 								// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
+// 								// have to provide it ourselves.
+// 								//
+// 								// [1] https://github.com/volarjs/volar.js/discussions/188
+// 								// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
+// 								preventLeadingOffset: true,
+// 							};
+// 						};
+// 					}
+// 					return {
+// 						languagePlugins: [vueLanguagePlugin],
+// 						setup: (lang) => (volarLanguage = lang),
+// 					};
+// 				});
+//
+// 				const program: ProxiedTSProgram = Reflect.apply(proxied, thisArg, args);
+//
+// 				if (volarLanguage == null) {
+// 					throw new Error("Flint bug: volarLanguage is not defined");
+// 				}
+// 				if (vueCompilerOptions == null) {
+// 					throw new Error("Flint bug: vueCompilerOptions is not defined");
+// 				}
+//
+// 				if (program.__flintVolarLanguage != null) {
+// 					return program;
+// 				}
+//
+// 				program.__flintVolarLanguage = volarLanguage;
+// 				return program;
+// 			},
+// 		}),
+// );
 
 export interface VueServices extends TypeScriptFileServices {
 	vueServices?: {
@@ -140,7 +134,39 @@ export interface VueServices extends TypeScriptFileServices {
 
 type VueCodegen = typeof tsCodegen extends WeakMap<any, infer V> ? V : never;
 
-export const vueLanguage = createLanguage<TSNodesByName, VueServices>({
+export const vueLanguage = createTypeScriptBasedLanguage<
+	TSNodesByName,
+	VueServices
+>((ts, options) => {
+	const { configFilePath } = options.options;
+	const vueCompilerOptions = (
+		typeof configFilePath === "string"
+			? createVueParsedCommandLine(
+					ts,
+					ts.sys,
+					configFilePath.replaceAll("\\", "/"),
+				)
+			: createVueParsedCommandLineByJson(
+					ts,
+					ts.sys,
+					(options.host ?? ts.sys).getCurrentDirectory(),
+					{},
+				)
+	).vueOptions;
+	return {
+		languagePlugins: createVueLanguagePlugin(
+			ts,
+			options.options,
+			vueCompilerOptions,
+			(id) => id,
+		),
+		prepareFile(filePathAbsolute, tsFile) {
+			return prepareVueFile(filePathAbsolute, tsFile);
+		},
+	};
+});
+
+export const _vueLanguage = createLanguage<TSNodesByName, VueServices>({
 	about: {
 		name: "Vue.js",
 	},
diff --git a/packages/vue-language/src/rules/MyComponent.vue b/packages/vue-language/src/rules/MyComponent.vue
deleted file mode 100644
index a2abf7c27..000000000
--- a/packages/vue-language/src/rules/MyComponent.vue
+++ /dev/null
@@ -1,5 +0,0 @@
-<script lang="ts" setup>
-defineProps<{ foo: () => string }>();
-</script>
-
-<template>Hello!</template>
diff --git a/packages/vue-language/src/rules/anyReturns.test.ts b/packages/vue-language/src/rules/anyReturns.test.ts
index 9f0ec17e3..13da4698a 100644
--- a/packages/vue-language/src/rules/anyReturns.test.ts
+++ b/packages/vue-language/src/rules/anyReturns.test.ts
@@ -2,6 +2,16 @@ import rule from "../../../ts/lib/rules/anyReturns.js";
 import { vueLanguage } from "../language.js";
 import { ruleTester } from "./ruleTester.js";
 
+const myComponentFixture = {
+	"MyComponent.vue": `
+<script lang="ts" setup>
+defineProps<{ foo: () => string }>();
+</script>
+
+<template>Hello!</template>
+	`,
+};
+
 ruleTester.describe(vueLanguage.createRule(rule), {
 	invalid: [
 		{
@@ -34,6 +44,7 @@ ruleTester.describe(vueLanguage.createRule(rule), {
 	<MyComponent :foo="() => foo"/>
 </template>
 			`,
+			files: myComponentFixture,
 			snapshot: `
 <script lang="ts" setup>
 	import MyComponent from './MyComponent.vue'
@@ -63,6 +74,7 @@ ruleTester.describe(vueLanguage.createRule(rule), {
 	] as any"/>
 </template>
 			`,
+			files: myComponentFixture,
 			snapshot: `
 <script lang="ts" setup>
 	import MyComponent from './MyComponent.vue'
@@ -85,7 +97,8 @@ ruleTester.describe(vueLanguage.createRule(rule), {
 		},
 	],
 	valid: [
-		`
+		{
+			code: `
 <script lang="ts" setup>
 	import MyComponent from './MyComponent.vue'
 
@@ -93,6 +106,8 @@ ruleTester.describe(vueLanguage.createRule(rule), {
 		return MyComponent
 	}
 </script>
-		`,
+			`,
+			files: myComponentFixture,
+		},
 	],
 });
diff --git a/packages/vue-language/src/rules/asyncComputed.test.ts b/packages/vue-language/src/rules/asyncComputed.test.ts
index 313227e4f..1fb0e94c8 100644
--- a/packages/vue-language/src/rules/asyncComputed.test.ts
+++ b/packages/vue-language/src/rules/asyncComputed.test.ts
@@ -1,12 +1,6 @@
-import path from "node:path";
-
 import rule from "./asyncComputed.js";
 import { ruleTester } from "./ruleTester.js";
 
-// TODO: the default file.ts path is packages/vfs/file.ts, so imports from
-// the vue package cannot be resolved, because vue is located in packages/vue/node_modules
-const tsFileName = path.join(import.meta.dirname, "file.ts");
-
 ruleTester.describe(rule, {
 	invalid: [
 		{
@@ -15,7 +9,7 @@ import { computed } from 'vue'
 
 computed(async () => 'hello')
 			`,
-			fileName: tsFileName,
+			fileName: "file.ts",
 			snapshot: `
 import { computed } from 'vue'
 
@@ -96,7 +90,7 @@ computed(async () => 'hello')
 	import { computed } from 'vue'
 
 	computed(() => {
-		return fetch('https://example.com')
+		return Promise.resolve()
 	})
 </script>
 			`,
@@ -107,8 +101,8 @@ computed(async () => 'hello')
 	computed(() => {
 	         ~~~~~~~
 	         Asynchronous functions in computed properties can lead to loss of reactivity.
-		return fetch('https://example.com')
-		~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+		return Promise.resolve()
+		~~~~~~~~~~~~~~~~~~~~~~~~
 	})
 	~
 </script>
@@ -166,7 +160,7 @@ computed(async () => 'hello')
 	import { computed } from 'vue'
 
 	computed({
-		get: () => fetch('https://example.com'),
+		get: () => Promise.resolve(),
 		set: v => {},
 	})
 </script>
@@ -178,8 +172,8 @@ computed(async () => 'hello')
 	computed({
 	         ~
 	         Asynchronous functions in computed properties can lead to loss of reactivity.
-		get: () => fetch('https://example.com'),
-		~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+		get: () => Promise.resolve(),
+		~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 		set: v => {},
 		~~~~~~~~~~~~~
 	})
@@ -193,7 +187,7 @@ computed(async () => 'hello')
 	import { computed } from 'vue'
 
 	computed({
-		get: () => fetch('https://example.com'),
+		get: () => Promise.resolve(),
 		set: v => {},
 	}, {
 		onTrack(e) {
@@ -209,8 +203,8 @@ computed(async () => 'hello')
 	computed({
 	         ~
 	         Asynchronous functions in computed properties can lead to loss of reactivity.
-		get: () => fetch('https://example.com'),
-		~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+		get: () => Promise.resolve(),
+		~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 		set: v => {},
 		~~~~~~~~~~~~~
 	}, {
diff --git a/packages/vue-language/src/rules/fixture.ts b/packages/vue-language/src/rules/fixture.ts
deleted file mode 100644
index bb1843d11..000000000
--- a/packages/vue-language/src/rules/fixture.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const foo = 1;
diff --git a/packages/vue-language/src/rules/ruleTester.ts b/packages/vue-language/src/rules/ruleTester.ts
index 72429d246..9cb6066a8 100644
--- a/packages/vue-language/src/rules/ruleTester.ts
+++ b/packages/vue-language/src/rules/ruleTester.ts
@@ -1,14 +1,11 @@
-import path from "node:path";
-
-import { RuleTester } from "@flint.fyi/rule-tester";
+import { createRuleTesterTSHost, RuleTester } from "@flint.fyi/rule-tester";
 import { describe, it } from "vitest";
 
-const fileName = path.join(import.meta.dirname, "file.vue");
-
 export const ruleTester = new RuleTester({
 	describe,
 	it,
 	defaults: {
-		fileName,
+		fileName: "file.vue",
 	},
+	host: createRuleTesterTSHost(import.meta.dirname),
 });
diff --git a/packages/vue-language/src/rules/scriptSetupExports.test.ts b/packages/vue-language/src/rules/scriptSetupExports.test.ts
index 32b1a2e22..5222b9057 100644
--- a/packages/vue-language/src/rules/scriptSetupExports.test.ts
+++ b/packages/vue-language/src/rules/scriptSetupExports.test.ts
@@ -1,8 +1,10 @@
-import path from "node:path";
-
 import { ruleTester } from "./ruleTester.js";
 import rule from "./scriptSetupExports.js";
 
+const fixture = {
+	"fixture.ts": `export const foo = 1`,
+};
+
 ruleTester.describe(rule, {
 	invalid: [
 		{
@@ -119,6 +121,7 @@ ruleTester.describe(rule, {
 	export { foo } from './fixture'
 </script>
 			`,
+			files: fixture,
 			snapshot: `
 <script setup lang="ts">
 	export { foo } from './fixture'
@@ -133,6 +136,7 @@ ruleTester.describe(rule, {
 	export * from './fixture'
 </script>
 			`,
+			files: fixture,
 			snapshot: `
 <script setup lang="ts">
 	export * from './fixture'
@@ -153,6 +157,7 @@ ruleTester.describe(rule, {
 	export const bar = 2
 </script>
 			`,
+			files: fixture,
 			snapshot: `
 <script lang="ts">
 	export const foo = 1
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index af43108c3..d8e22c289 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -583,6 +583,12 @@ importers:
       '@typescript/vfs':
         specifier: ^1.6.1
         version: 1.6.1(typescript@5.9.3)
+      '@volar/language-core':
+        specifier: 2.4.27
+        version: 2.4.27
+      '@volar/typescript':
+        specifier: 2.4.27
+        version: 2.4.27
       cached-factory:
         specifier: ^0.1.0
         version: 0.1.0

From 6a0df365356a99bad1e6f15cfcd36da041464850 Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Tue, 30 Dec 2025 18:15:45 +0300
Subject: [PATCH 04/11] move things around

---
 packages/ts/src/language.ts           | 227 ++++++++++-
 packages/vue-language/src/language.ts | 561 ++++++++------------------
 2 files changed, 395 insertions(+), 393 deletions(-)

diff --git a/packages/ts/src/language.ts b/packages/ts/src/language.ts
index 134ca48a1..0b4d475bd 100644
--- a/packages/ts/src/language.ts
+++ b/packages/ts/src/language.ts
@@ -6,11 +6,26 @@ import {
 	Language,
 	setTSProgramCreationProxy,
 	LanguagePreparedDefinition,
+	RuleReporter,
+	LanguageFileCacheImpacts,
+	LanguageDiagnostics,
+	CommentDirective,
+	NormalizedReport,
+	RuleContext,
+	FileReport,
+	SourceFileWithLineMap,
+	CharacterReportRange,
+	NormalizedReportRangeObject,
+	getColumnAndLineOfPosition,
+	RuleReport,
+	isSuggestionForFiles,
 } from "@flint.fyi/core";
 import * as ts from "typescript";
 import {
 	LanguagePlugin as VolarLanguagePlugin,
 	Language as VolarLanguage,
+	Mapper as VolarMapper,
+	SourceScript as VolarSourceScript,
 } from "@volar/language-core";
 
 import { TSNodesByName } from "./nodes.js";
@@ -23,6 +38,7 @@ import { proxyCreateProgram } from "@volar/typescript/lib/node/proxyCreateProgra
 
 // for LanguagePlugin interface augmentation
 import "@volar/typescript";
+import { NodeSyntaxKinds } from "./createTypeScriptFileFromProgram.js";
 
 export interface TypeScriptFileServices {
 	program: ts.Program;
@@ -38,7 +54,18 @@ type VolarLanguagePluginInitializer = (
 	prepareFile: (
 		filePathAbsolute: string,
 		tsFile: TypeScriptBasedLanguageFile,
-	) => LanguagePreparedDefinition;
+		sourceScript: VolarSourceScript<string> & {
+			generated: NonNullable<VolarSourceScript<string>["generated"]>;
+		},
+	) => {
+		directives?: CommentDirective[];
+		reports?: FileReport[];
+		cache?: LanguageFileCacheImpacts;
+		getDiagnostics?(): LanguageDiagnostics;
+		extraContext?: (
+			reportTranslated: RuleReporter<string>,
+		) => Record<string, unknown>;
+	};
 };
 const volarLanguagePluginInitializers =
 	new Set<VolarLanguagePluginInitializer>();
@@ -130,8 +157,184 @@ export const typescriptLanguage = createLanguage<
 					if (sourceScript != null) {
 						const prepareFile =
 							sourceScript.generated?.languagePlugin?.__flintPrepareFile;
-						if (prepareFile != null) {
-							return prepareFile(filePathAbsolute, tsFile);
+						if (sourceScript.generated != null && prepareFile != null) {
+							if (sourceScript.snapshot == null) {
+								throw new Error("Expected sourceScript.snapshot to be set");
+							}
+							if (sourceScript.generated.languagePlugin.typescript == null) {
+								throw new Error(
+									"Expected sourceScript.generated.languagePlugin.typescript to be set",
+								);
+							}
+
+							const sourceText = sourceScript.snapshot.getText(
+								0,
+								sourceScript.snapshot.getLength(),
+							);
+							const sourceTextWithLineMap: SourceFileWithLineMap = {
+								text: sourceText,
+							};
+							function normalizeSourceRange(
+								range: CharacterReportRange,
+							): NormalizedReportRangeObject {
+								return {
+									begin: getColumnAndLineOfPosition(
+										sourceTextWithLineMap,
+										range.begin,
+									),
+									end: getColumnAndLineOfPosition(
+										sourceTextWithLineMap,
+										range.end,
+									),
+								};
+							}
+
+							const serviceScript =
+								sourceScript.generated.languagePlugin.typescript.getServiceScript(
+									sourceScript.generated.root,
+								);
+							if (serviceScript == null) {
+								throw new Error("Expected serviceScript to exist");
+							}
+
+							const map = volarLanguage.maps.get(
+								serviceScript.code,
+								sourceScript,
+							);
+							const sortedMappings = map.mappings.toSorted(
+								(a, b) => a.generatedOffsets[0] - b.generatedOffsets[0],
+							);
+							const {
+								directives,
+								reports,
+								extraContext,
+								getDiagnostics,
+								cache,
+							} = (
+								prepareFile as ReturnType<VolarLanguagePluginInitializer>["prepareFile"]
+							)(filePathAbsolute, tsFile, sourceScript);
+
+							return {
+								directives,
+								reports,
+								file: {
+									cache,
+									getDiagnostics,
+									async runRule(rule, options) {
+										const reports: NormalizedReport[] = [];
+										const context = {
+											program: tsFile.program,
+											sourceFile: tsFile.sourceFile,
+											typeChecker: tsFile.program.getTypeChecker(),
+											report: (report) => {
+												const reportRange = translateRange(
+													map,
+													report.range.begin,
+													report.range.end,
+												);
+												if (reportRange == null) {
+													return;
+												}
+
+												const translatedReport: NormalizedReport = {
+													...report,
+													fix:
+														report.fix && !Array.isArray(report.fix)
+															? [report.fix]
+															: report.fix,
+													message: rule.messages[report.message],
+													range: normalizeSourceRange(reportRange),
+												};
+
+												for (const suggestion of translatedReport.suggestions ??
+													[]) {
+													if (isSuggestionForFiles(suggestion)) {
+														throw new Error(
+															"TODO: vue - suggestions for multiple files are not yet supported",
+														);
+													}
+													const range = translateRange(
+														map,
+														suggestion.range.begin,
+														suggestion.range.end,
+													);
+													if (range == null) {
+														// TODO: maybe we should filter out these suggestions intead of erroring?
+														throw new Error(
+															"Suggestion range overlaps with virtual code",
+														);
+													}
+													suggestion.range = range;
+												}
+
+												reports.push(translatedReport);
+											},
+											...extraContext?.((report: RuleReport) => {
+												reports.push({
+													...report,
+													fix:
+														report.fix && !Array.isArray(report.fix)
+															? [report.fix]
+															: report.fix,
+													message: rule.messages[report.message],
+													range: normalizeSourceRange(report.range),
+												});
+											}),
+										} satisfies TypeScriptFileServices & RuleContext<string>;
+
+										const runtime = await rule.setup(context, options);
+
+										if (runtime?.visitors) {
+											const { visitors } = runtime;
+											let lastMappingIdx = 0;
+											const visit = (node: ts.Node) => {
+												visitors[NodeSyntaxKinds[node.kind]]?.(node, context);
+
+												node.forEachChild(visit);
+											};
+											// Visit only statements that have a mapping to the source code
+											// to avoid doing extra work
+											Statements: for (const statement of tsFile.sourceFile
+												.statements) {
+												while (true) {
+													const currentMapping = sortedMappings[lastMappingIdx];
+													if (currentMapping == null) {
+														break Statements;
+													}
+													const currentMappingLength =
+														currentMapping.generatedLengths?.[0] ??
+														currentMapping.lengths[0];
+													if (
+														currentMappingLength === 0 ||
+														statement.pos >=
+															currentMapping.generatedOffsets[0] +
+																currentMappingLength
+													) {
+														lastMappingIdx++;
+														continue;
+													}
+													if (
+														statement.end <= currentMapping.generatedOffsets[0]
+													) {
+														continue Statements;
+													}
+													break;
+												}
+
+												visit(statement);
+											}
+											visit(tsFile.sourceFile.endOfFileToken);
+										}
+
+										await runtime?.teardown?.();
+
+										return reports;
+									},
+									[Symbol.dispose]() {
+										tsFile[Symbol.dispose]?.();
+									},
+								},
+							};
 						}
 					}
 				}
@@ -164,3 +367,21 @@ export function createTypeScriptBasedLanguage<
 
 	return language;
 }
+
+export function translateRange(
+	map: VolarMapper,
+	serviceBegin: number,
+	serviceEnd: number,
+): null | { begin: number; end: number } {
+	for (const [begin, end] of map.toSourceRange(
+		serviceBegin,
+		serviceEnd,
+		true,
+	)) {
+		if (begin === end) {
+			continue;
+		}
+		return { begin, end };
+	}
+	return null;
+}
diff --git a/packages/vue-language/src/language.ts b/packages/vue-language/src/language.ts
index fa225e506..5f9609aae 100644
--- a/packages/vue-language/src/language.ts
+++ b/packages/vue-language/src/language.ts
@@ -49,77 +49,6 @@ import ts from "typescript";
 // TODO: css
 
 setTSExtraSupportedExtensions([".vue"]);
-// setTSProgramCreationProxy(
-// 	(ts, createProgram) =>
-// 		new Proxy(function () {} as unknown as typeof createProgram, {
-// 			apply(target, thisArg, args) {
-// 				let volarLanguage = null as null | VolarLanguage<string>;
-// 				let vueCompilerOptions = null as null | VueCompilerOptions;
-// 				const proxied = proxyCreateProgram(ts, createProgram, (ts, options) => {
-// 					const { configFilePath } = options.options;
-// 					vueCompilerOptions = (
-// 						typeof configFilePath === "string"
-// 							? createVueParsedCommandLine(
-// 									ts,
-// 									ts.sys,
-// 									configFilePath.replaceAll("\\", "/"),
-// 								)
-// 							: createVueParsedCommandLineByJson(
-// 									ts,
-// 									ts.sys,
-// 									(options.host ?? ts.sys).getCurrentDirectory(),
-// 									{},
-// 								)
-// 					).vueOptions;
-// 					const vueLanguagePlugin = createVueLanguagePlugin<string>(
-// 						ts,
-// 						options.options,
-// 						vueCompilerOptions,
-// 						(id) => id,
-// 					);
-// 					if (vueLanguagePlugin.typescript != null) {
-// 						const { getServiceScript } = vueLanguagePlugin.typescript;
-// 						vueLanguagePlugin.typescript.getServiceScript = (root) => {
-// 							const script = getServiceScript(root);
-// 							if (script == null) {
-// 								return script;
-// 							}
-// 							return {
-// 								...script,
-// 								// Leading offset is useful for LanguageService [1], but we don't use it.
-// 								// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
-// 								// have to provide it ourselves.
-// 								//
-// 								// [1] https://github.com/volarjs/volar.js/discussions/188
-// 								// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
-// 								preventLeadingOffset: true,
-// 							};
-// 						};
-// 					}
-// 					return {
-// 						languagePlugins: [vueLanguagePlugin],
-// 						setup: (lang) => (volarLanguage = lang),
-// 					};
-// 				});
-//
-// 				const program: ProxiedTSProgram = Reflect.apply(proxied, thisArg, args);
-//
-// 				if (volarLanguage == null) {
-// 					throw new Error("Flint bug: volarLanguage is not defined");
-// 				}
-// 				if (vueCompilerOptions == null) {
-// 					throw new Error("Flint bug: vueCompilerOptions is not defined");
-// 				}
-//
-// 				if (program.__flintVolarLanguage != null) {
-// 					return program;
-// 				}
-//
-// 				program.__flintVolarLanguage = volarLanguage;
-// 				return program;
-// 			},
-// 		}),
-// );
 
 export interface VueServices extends TypeScriptFileServices {
 	vueServices?: {
@@ -160,34 +89,179 @@ export const vueLanguage = createTypeScriptBasedLanguage<
 			vueCompilerOptions,
 			(id) => id,
 		),
-		prepareFile(filePathAbsolute, tsFile) {
-			return prepareVueFile(filePathAbsolute, tsFile);
-		},
-	};
-});
+		prepareFile(filePathAbsolute, { program, sourceFile }, sourceScript) {
+			// @ts-expect-error
+			const volarLanguage: VolarLanguage = program.__flintVolarLanguage;
 
-export const _vueLanguage = createLanguage<TSNodesByName, VueServices>({
-	about: {
-		name: "Vue.js",
-	},
-	prepare: () => {
-		const tsLang = prepareTypeScriptBasedLanguage();
-
-		return {
-			prepareFromDisk: (filePathAbsolute) => {
-				return prepareVueFile(
-					filePathAbsolute,
-					tsLang.createFromDisk(filePathAbsolute),
+			if (volarLanguage == null) {
+				throw new Error(
+					"'typescript' package wasn't properly patched. Make sure you don't import 'typescript' before Flint.",
+				);
+			}
+
+			if (sourceScript.snapshot == null) {
+				throw new Error("Expected sourceScript.snapshot to be set");
+			}
+			if (sourceScript.generated.languagePlugin.typescript == null) {
+				throw new Error(
+					"Expected sourceScript.generated.languagePlugin.typescript to be set",
 				);
-			},
-			prepareFromVirtual: (filePathAbsolute, sourceText) => {
-				return prepareVueFile(
-					filePathAbsolute,
-					tsLang.createFromVirtual(filePathAbsolute, sourceText),
+			}
+
+			const sourceText = sourceScript.snapshot.getText(
+				0,
+				sourceScript.snapshot.getLength(),
+			);
+			const sourceTextWithLineMap: SourceFileWithLineMap = {
+				text: sourceText,
+			};
+			function normalizeSourceRange(
+				range: CharacterReportRange,
+			): NormalizedReportRangeObject {
+				return {
+					begin: getColumnAndLineOfPosition(sourceTextWithLineMap, range.begin),
+					end: getColumnAndLineOfPosition(sourceTextWithLineMap, range.end),
+				};
+			}
+
+			const serviceScript =
+				sourceScript.generated.languagePlugin.typescript.getServiceScript(
+					sourceScript.generated.root,
 				);
-			},
-		};
-	},
+			if (serviceScript == null) {
+				throw new Error("Expected serviceScript to exist");
+			}
+
+			const virtualCode = sourceScript.generated.root as VueVirtualCode;
+			const codegen = tsCodegen.get(virtualCode.sfc);
+			if (codegen == null) {
+				throw new Error("Expected codegen to exist");
+			}
+
+			const map = volarLanguage.maps.get(serviceScript.code, sourceScript);
+
+			const sfcAst = vueParse(sourceText, {
+				comments: true,
+				expressionPlugins: ["typescript"],
+				parseMode: "html",
+				// We ignore errors because virtual code already provides them,
+				// and it also provides them with sourceText-based locations,
+				// so we don't have to remap them. Oh, and it also contains errors from
+				// other blocks rather than only <template> as well.
+				// If we don't provide this callback, @vue/compiler-core will throw.
+				onError: () => {},
+			});
+
+			// TODO: extract directives from other blocks too
+
+			const directives: {
+				range: NormalizedReportRangeObject;
+				selection: string;
+				type: string;
+			}[] = [];
+			function visitTemplate(elem: TemplateChildNode) {
+				if (elem.type === NodeTypes.ELEMENT) {
+					elem.children.forEach(visitTemplate);
+					return;
+				}
+				if (elem.type !== NodeTypes.COMMENT) {
+					return;
+				}
+				const match = /\s*flint-(\S+)(?:\s+(.+))?/.exec(elem.content);
+				if (match == null) {
+					return;
+				}
+				const [, type, selection] = match;
+				directives.push({
+					range: {
+						begin: {
+							column: elem.loc.start.column - 1,
+							line: elem.loc.start.line - 1,
+							raw: elem.loc.start.offset,
+						},
+						end: {
+							column: elem.loc.end.column - 1,
+							line: elem.loc.end.line - 1,
+							raw: elem.loc.end.offset,
+						},
+					},
+					selection,
+					type,
+				});
+			}
+			sfcAst.children.forEach(visitTemplate);
+
+			for (const d of extractDirectivesFromTypeScriptFile(sourceFile)) {
+				const range = translateRange(map, d.range.begin.raw, d.range.end.raw);
+				if (range != null) {
+					directives.push({
+						...d,
+						range: normalizeSourceRange(range),
+					});
+				}
+			}
+
+			const directivesCollector = new DirectivesCollector(
+				sfcAst.children.find((c) => c.type !== NodeTypes.COMMENT)?.loc.start
+					.offset ?? sourceText.length,
+			);
+			directives.sort((a, b) => a.range.begin.raw - b.range.begin.raw);
+			for (const { range, selection, type } of directives) {
+				directivesCollector.add(range, selection, type);
+			}
+
+			return {
+				...directivesCollector.collect(),
+				cache: collectTypeScriptFileCacheImpacts(program, sourceFile),
+				getDiagnostics() {
+					return [
+						...ts.getPreEmitDiagnostics(program, sourceFile).map((diagnostic) =>
+							convertTypeScriptDiagnosticToLanguageFileDiagnostic({
+								...diagnostic,
+								// For some unknown reason, Volar doesn't set file.text to sourceText
+								// when preventLeadingOffset is true, so we have to do it ourselves
+								// https://github.com/volarjs/volar.js/blob/4a9d25d797d08d9c149bebf0f52ac5e172f4757d/packages/typescript/lib/node/transform.ts#L102
+								file: diagnostic.file
+									? {
+											fileName: diagnostic.file.fileName,
+											text: sourceText,
+										}
+									: diagnostic.file,
+							}),
+						),
+						...(virtualCode.vueSfc?.errors ?? []).map((e) => {
+							const fileName = sourceFile.fileName.startsWith("./")
+								? sourceFile.fileName.slice(2)
+								: sourceFile.fileName.slice(process.cwd().length + 1);
+							let code = "VUE";
+							let loc = "";
+							if ("code" in e) {
+								// TODO: think about codes
+								code += "999999" + e.code.toString();
+								loc =
+									e.loc != null
+										? `:${e.loc?.start.line}:${e.loc?.start.column}`
+										: "";
+							}
+							return {
+								code,
+								text: `${fileName}${loc} - ${code}: ${e.name} - ${e.message}`,
+							};
+						}),
+					];
+				},
+				extraContext: (reportTranslated) => ({
+					vueServices: {
+						codegen,
+						map,
+						reportSfc: reportTranslated,
+						sfc: sfcAst,
+						virtualCode,
+					},
+				}),
+			};
+		},
+	};
 });
 
 function translateRange(
@@ -222,297 +296,4 @@ function translateRange(
 function prepareVueFile(
 	filePathAbsolute: string,
 	tsFile: TypeScriptBasedLanguageFile,
-): LanguagePreparedDefinition {
-	const { program, sourceFile, [Symbol.dispose]: onDispose } = tsFile;
-
-	// @ts-expect-error
-	const volarLanguage: VolarLanguage = program.__flintVolarLanguage;
-
-	if (volarLanguage == null) {
-		throw new Error(
-			"'typescript' package wasn't properly patched. Make sure you don't import 'typescript' before Flint.",
-		);
-	}
-
-	const sourceScript = volarLanguage.scripts.get(filePathAbsolute);
-	if (sourceScript == null) {
-		throw new Error("Expected sourceScript to be set");
-	}
-	if (sourceScript.languageId !== "vue") {
-		return prepareTypeScriptFile({
-			program,
-			sourceFile,
-			[Symbol.dispose]: onDispose,
-		});
-	}
-	if (sourceScript.generated == null) {
-		throw new Error("Expected sourceScript.generated to be set");
-	}
-	if (sourceScript.snapshot == null) {
-		throw new Error("Expected sourceScript.snapshot to be set");
-	}
-	if (sourceScript.generated.languagePlugin.typescript == null) {
-		throw new Error(
-			"Expected sourceScript.generated.languagePlugin.typescript to be set",
-		);
-	}
-
-	const sourceText = sourceScript.snapshot.getText(
-		0,
-		sourceScript.snapshot.getLength(),
-	);
-	const sourceTextWithLineMap: SourceFileWithLineMap = {
-		text: sourceText,
-	};
-	function normalizeSourceRange(
-		range: CharacterReportRange,
-	): NormalizedReportRangeObject {
-		return {
-			begin: getColumnAndLineOfPosition(sourceTextWithLineMap, range.begin),
-			end: getColumnAndLineOfPosition(sourceTextWithLineMap, range.end),
-		};
-	}
-
-	const serviceScript =
-		sourceScript.generated.languagePlugin.typescript.getServiceScript(
-			sourceScript.generated.root,
-		);
-	if (serviceScript == null) {
-		throw new Error("Expected serviceScript to exist");
-	}
-
-	const virtualCode = sourceScript.generated.root as VueVirtualCode;
-	const codegen = tsCodegen.get(virtualCode.sfc);
-	if (codegen == null) {
-		throw new Error("Expected codegen to exist");
-	}
-
-	const map = volarLanguage.maps.get(serviceScript.code, sourceScript);
-	const sortedMappings = map.mappings.toSorted(
-		(a, b) => a.generatedOffsets[0] - b.generatedOffsets[0],
-	);
-
-	const sfcAst = vueParse(sourceText, {
-		comments: true,
-		expressionPlugins: ["typescript"],
-		parseMode: "html",
-		// We ignore errors because virtual code already provides them,
-		// and it also provides them with sourceText-based locations,
-		// so we don't have to remap them. Oh, and it also contains errors from
-		// other blocks rather than only <template> as well.
-		// If we don't provide this callback, @vue/compiler-core will throw.
-		onError: () => {},
-	});
-
-	// TODO: extract directives from other blocks too
-
-	const directives: {
-		range: NormalizedReportRangeObject;
-		selection: string;
-		type: string;
-	}[] = [];
-	function visitTemplate(elem: TemplateChildNode) {
-		if (elem.type === NodeTypes.ELEMENT) {
-			elem.children.forEach(visitTemplate);
-			return;
-		}
-		if (elem.type !== NodeTypes.COMMENT) {
-			return;
-		}
-		const match = /\s*flint-(\S+)(?:\s+(.+))?/.exec(elem.content);
-		if (match == null) {
-			return;
-		}
-		const [, type, selection] = match;
-		directives.push({
-			range: {
-				begin: {
-					column: elem.loc.start.column - 1,
-					line: elem.loc.start.line - 1,
-					raw: elem.loc.start.offset,
-				},
-				end: {
-					column: elem.loc.end.column - 1,
-					line: elem.loc.end.line - 1,
-					raw: elem.loc.end.offset,
-				},
-			},
-			selection,
-			type,
-		});
-	}
-	sfcAst.children.forEach(visitTemplate);
-
-	for (const d of extractDirectivesFromTypeScriptFile(sourceFile)) {
-		const range = translateRange(map, d.range.begin.raw, d.range.end.raw);
-		if (range != null) {
-			directives.push({
-				...d,
-				range: normalizeSourceRange(range),
-			});
-		}
-	}
-
-	const directivesCollector = new DirectivesCollector(
-		sfcAst.children.find((c) => c.type !== NodeTypes.COMMENT)?.loc.start
-			.offset ?? sourceText.length,
-	);
-	directives.sort((a, b) => a.range.begin.raw - b.range.begin.raw);
-	for (const { range, selection, type } of directives) {
-		directivesCollector.add(range, selection, type);
-	}
-
-	return {
-		...directivesCollector.collect(),
-		file: {
-			...(onDispose != null && { [Symbol.dispose]: onDispose }),
-			cache: collectTypeScriptFileCacheImpacts(program, sourceFile),
-			getDiagnostics() {
-				return [
-					...ts.getPreEmitDiagnostics(program, sourceFile).map((diagnostic) =>
-						convertTypeScriptDiagnosticToLanguageFileDiagnostic({
-							...diagnostic,
-							// For some unknown reason, Volar doesn't set file.text to sourceText
-							// when preventLeadingOffset is true, so we have to do it ourselves
-							// https://github.com/volarjs/volar.js/blob/4a9d25d797d08d9c149bebf0f52ac5e172f4757d/packages/typescript/lib/node/transform.ts#L102
-							file: diagnostic.file
-								? {
-										fileName: diagnostic.file.fileName,
-										text: sourceText,
-									}
-								: diagnostic.file,
-						}),
-					),
-					...(virtualCode.vueSfc?.errors ?? []).map((e) => {
-						const fileName = sourceFile.fileName.startsWith("./")
-							? sourceFile.fileName.slice(2)
-							: sourceFile.fileName.slice(process.cwd().length + 1);
-						let code = "VUE";
-						let loc = "";
-						if ("code" in e) {
-							// TODO: think about codes
-							code += "999999" + e.code.toString();
-							loc =
-								e.loc != null
-									? `:${e.loc?.start.line}:${e.loc?.start.column}`
-									: "";
-						}
-						return {
-							code,
-							text: `${fileName}${loc} - ${code}: ${e.name} - ${e.message}`,
-						};
-					}),
-				];
-			},
-			async runRule(rule, options) {
-				const reports: NormalizedReport[] = [];
-				const context: RuleContext<string> & VueServices = {
-					program,
-					report: (report) => {
-						const reportRange = translateRange(
-							map,
-							report.range.begin,
-							report.range.end,
-						);
-						if (reportRange == null) {
-							return;
-						}
-
-						const translatedReport: NormalizedReport = {
-							...report,
-							fix:
-								report.fix && !Array.isArray(report.fix)
-									? [report.fix]
-									: report.fix,
-							message: rule.messages[report.message],
-							range: normalizeSourceRange(reportRange),
-						};
-
-						for (const suggestion of translatedReport.suggestions ?? []) {
-							if (isSuggestionForFiles(suggestion)) {
-								throw new Error(
-									"TODO: vue - suggestions for multiple files are not yet supported",
-								);
-							}
-							const range = translateRange(
-								map,
-								suggestion.range.begin,
-								suggestion.range.end,
-							);
-							if (range == null) {
-								// TODO: maybe we should filter out these suggestions intead of erroring?
-								throw new Error("Suggestion range overlaps with virtual code");
-							}
-							suggestion.range = range;
-						}
-
-						reports.push(translatedReport);
-					},
-					sourceFile,
-					typeChecker: program.getTypeChecker(),
-					vueServices: {
-						codegen,
-						map,
-						reportSfc: (report: RuleReport) => {
-							reports.push({
-								...report,
-								fix:
-									report.fix && !Array.isArray(report.fix)
-										? [report.fix]
-										: report.fix,
-								message: rule.messages[report.message],
-								range: normalizeSourceRange(report.range),
-							});
-						},
-						sfc: sfcAst,
-						virtualCode,
-					},
-				};
-
-				const runtime = await rule.setup(context, options);
-
-				if (runtime?.visitors) {
-					const { visitors } = runtime;
-					let lastMappingIdx = 0;
-					const visit = (node: ts.Node) => {
-						visitors[NodeSyntaxKinds[node.kind]]?.(node, context);
-
-						node.forEachChild(visit);
-					};
-					// Visit only statements that have a mapping to the source code
-					// to avoid doing extra work
-					Statements: for (const statement of sourceFile.statements) {
-						while (true) {
-							const currentMapping = sortedMappings[lastMappingIdx];
-							if (currentMapping == null) {
-								break Statements;
-							}
-							const currentMappingLength =
-								currentMapping.generatedLengths?.[0] ??
-								currentMapping.lengths[0];
-							if (
-								currentMappingLength === 0 ||
-								statement.pos >=
-									currentMapping.generatedOffsets[0] + currentMappingLength
-							) {
-								lastMappingIdx++;
-								continue;
-							}
-							if (statement.end <= currentMapping.generatedOffsets[0]) {
-								continue Statements;
-							}
-							break;
-						}
-
-						visit(statement);
-					}
-					visit(sourceFile.endOfFileToken);
-				}
-
-				await runtime?.teardown?.();
-
-				return reports;
-			},
-		},
-	};
-}
+): LanguagePreparedDefinition;

From 4974ab440031d1094157ce049eda869ca322968c Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Tue, 30 Dec 2025 20:28:46 +0300
Subject: [PATCH 05/11] wip

---
 packages/rule-tester/src/runTestCaseRule.ts | 38 ---------------------
 packages/ts/package.json                    |  1 +
 packages/ts/src/language.ts                 |  3 +-
 packages/ts/tsconfig.json                   |  6 +++-
 packages/vue-language/package.json          |  1 +
 packages/vue-language/src/language.ts       |  3 +-
 packages/vue-language/tsconfig.json         |  3 +-
 pnpm-lock.yaml                              |  6 ++++
 8 files changed, 17 insertions(+), 44 deletions(-)
 delete mode 100644 packages/rule-tester/src/runTestCaseRule.ts

diff --git a/packages/rule-tester/src/runTestCaseRule.ts b/packages/rule-tester/src/runTestCaseRule.ts
deleted file mode 100644
index 10305f1e7..000000000
--- a/packages/rule-tester/src/runTestCaseRule.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import type { PromiseOrSync } from "@flint.fyi/utils";
-
-import {
-	AnyLanguage,
-	AnyOptionalSchema,
-	AnyRule,
-	InferredObject,
-	LanguageFileFactory,
-	type NormalizedReport,
-	RuleAbout,
-} from "@flint.fyi/core";
-import { CachedFactory } from "cached-factory";
-
-import { TestCaseNormalized } from "./normalizeTestCase.js";
-
-export interface TestCaseRuleConfiguration<
-	OptionsSchema extends AnyOptionalSchema | undefined,
-> {
-	options?: InferredObject<OptionsSchema>;
-	rule: AnyRule<RuleAbout, OptionsSchema>;
-}
-
-export function runTestCaseRule<
-	OptionsSchema extends AnyOptionalSchema | undefined,
->(
-	fileFactories: CachedFactory<AnyLanguage, LanguageFileFactory>,
-	{ options, rule }: Required<TestCaseRuleConfiguration<OptionsSchema>>,
-	{ code, fileName }: TestCaseNormalized,
-): PromiseOrSync<NormalizedReport[]> {
-	using file = fileFactories
-		// TODO: How to make types more permissive around assignability?
-		// See AnyRule's any
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		.get(rule.language)
-		.prepareFromVirtual(fileName, code).file;
-
-	return file.runRule(rule, options as InferredObject<OptionsSchema>);
-}
diff --git a/packages/ts/package.json b/packages/ts/package.json
index 8006bdd32..915a64f25 100644
--- a/packages/ts/package.json
+++ b/packages/ts/package.json
@@ -23,6 +23,7 @@
 	],
 	"dependencies": {
 		"@flint.fyi/core": "workspace:",
+		"@flint.fyi/ts-patch": "workspace:",
 		"@typescript-eslint/project-service": "^8.46.2",
 		"@typescript/vfs": "^1.6.1",
 		"@volar/language-core": "2.4.27",
diff --git a/packages/ts/src/language.ts b/packages/ts/src/language.ts
index 0b4d475bd..d6d5a22f1 100644
--- a/packages/ts/src/language.ts
+++ b/packages/ts/src/language.ts
@@ -4,8 +4,6 @@ import {
 	flatten,
 	createLanguage,
 	Language,
-	setTSProgramCreationProxy,
-	LanguagePreparedDefinition,
 	RuleReporter,
 	LanguageFileCacheImpacts,
 	LanguageDiagnostics,
@@ -20,6 +18,7 @@ import {
 	RuleReport,
 	isSuggestionForFiles,
 } from "@flint.fyi/core";
+import { setTSProgramCreationProxy } from "@flint.fyi/ts-patch";
 import * as ts from "typescript";
 import {
 	LanguagePlugin as VolarLanguagePlugin,
diff --git a/packages/ts/tsconfig.json b/packages/ts/tsconfig.json
index 1c093e614..f3c1c93ae 100644
--- a/packages/ts/tsconfig.json
+++ b/packages/ts/tsconfig.json
@@ -5,5 +5,9 @@
 	},
 	"extends": "../../tsconfig.base.json",
 	"include": ["src"],
-	"references": [{ "path": "../core" }, { "path": "../rule-tester" }]
+	"references": [
+		{ "path": "../core" },
+		{ "path": "../rule-tester" },
+		{ "path": "../ts-patch" }
+	]
 }
diff --git a/packages/vue-language/package.json b/packages/vue-language/package.json
index 27f3491b2..ee5e31fa5 100644
--- a/packages/vue-language/package.json
+++ b/packages/vue-language/package.json
@@ -17,6 +17,7 @@
 	"dependencies": {
 		"@flint.fyi/core": "workspace:",
 		"@flint.fyi/ts": "workspace:",
+		"@flint.fyi/ts-patch": "workspace:",
 		"@volar/language-core": "2.4.27",
 		"@volar/typescript": "2.4.27",
 		"@vue/compiler-dom": "^3.5.0",
diff --git a/packages/vue-language/src/language.ts b/packages/vue-language/src/language.ts
index 5f9609aae..70010b932 100644
--- a/packages/vue-language/src/language.ts
+++ b/packages/vue-language/src/language.ts
@@ -10,10 +10,9 @@ import {
 	RuleContext,
 	RuleReport,
 	RuleReporter,
-	setTSExtraSupportedExtensions,
-	setTSProgramCreationProxy,
 	SourceFileWithLineMap,
 } from "@flint.fyi/core";
+import { setTSExtraSupportedExtensions } from "@flint.fyi/ts-patch";
 import {
 	Language as VolarLanguage,
 	Mapper as VolarMapper,
diff --git a/packages/vue-language/tsconfig.json b/packages/vue-language/tsconfig.json
index 55ddcc02e..a1fdca4f8 100644
--- a/packages/vue-language/tsconfig.json
+++ b/packages/vue-language/tsconfig.json
@@ -8,6 +8,7 @@
 	"references": [
 		{ "path": "../core" },
 		{ "path": "../ts" },
-		{ "path": "../rule-tester" }
+		{ "path": "../rule-tester" },
+		{ "path": "../ts-patch" }
 	]
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 453209150..a31e49f3b 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -588,6 +588,9 @@ importers:
       '@flint.fyi/core':
         specifier: 'workspace:'
         version: link:../core
+      '@flint.fyi/ts-patch':
+        specifier: 'workspace:'
+        version: link:../ts-patch
       '@typescript-eslint/project-service':
         specifier: ^8.46.2
         version: 8.50.1(patch_hash=cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c)(typescript@5.9.3)
@@ -639,6 +642,9 @@ importers:
       '@flint.fyi/ts':
         specifier: 'workspace:'
         version: link:../ts
+      '@flint.fyi/ts-patch':
+        specifier: 'workspace:'
+        version: link:../ts-patch
       '@volar/language-core':
         specifier: 2.4.27
         version: 2.4.27

From a3545b8421d7c2ee134eeea8e87f163090812f1d Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Wed, 31 Dec 2025 13:18:53 +0300
Subject: [PATCH 06/11] patch fs instead of copying TypeScript source code

---
 .../ts/src/prepareTypeScriptBasedLanguage.ts  |  140 +-
 packages/ts/src/typescriptUtilities.ts        | 1476 -----------------
 2 files changed, 77 insertions(+), 1539 deletions(-)
 delete mode 100644 packages/ts/src/typescriptUtilities.ts

diff --git a/packages/ts/src/prepareTypeScriptBasedLanguage.ts b/packages/ts/src/prepareTypeScriptBasedLanguage.ts
index 56c755cb5..5faa7f569 100644
--- a/packages/ts/src/prepareTypeScriptBasedLanguage.ts
+++ b/packages/ts/src/prepareTypeScriptBasedLanguage.ts
@@ -2,11 +2,12 @@ import { createProjectService } from "@typescript-eslint/project-service";
 import { CachedFactory } from "cached-factory";
 import { debugForFile } from "debug-for-file";
 import path from "node:path";
+import fs from "node:fs";
+import assert from "node:assert/strict";
 import * as ts from "typescript";
 
 import { createTypeScriptFileFromProjectService } from "./createTypeScriptFileFromProjectService.js";
 import { LinterHost } from "@flint.fyi/core";
-import { matchFiles } from "./typescriptUtilities.js";
 
 const log = debugForFile(import.meta.filename);
 
@@ -25,6 +26,18 @@ function notImplemented(methodName: string): any {
 	);
 }
 
+// https://github.com/nodejs/node/blob/7b7f693a98da060e19f2ec12fb99997d5d5524f9/deps/uv/include/uv.h#L1260-L1269
+const UV_DIRENT_TYPE = {
+	UV_DIRENT_UNKNOWN: 0,
+	UV_DIRENT_FILE: 1,
+	UV_DIRENT_DIR: 1,
+};
+
+const DirentCtor = fs.Dirent as {
+	// https://github.com/nodejs/node/blob/7b7f693a98da060e19f2ec12fb99997d5d5524f9/lib/internal/fs/utils.js#L160
+	new (name: string, type: number, parentPath: string): fs.Dirent;
+};
+
 export function prepareTypeScriptBasedLanguage(
 	host: LinterHost,
 ): TypeScriptBasedLanguageFileFactoryDefinition {
@@ -61,31 +74,55 @@ export function prepareTypeScriptBasedLanguage(
 					"file"
 				);
 			},
-			readDirectory(directoryPath, extensions, excludes, includes, depth) {
-				return matchFiles(
-					directoryPath,
-					extensions,
-					excludes,
-					includes,
-					ts.sys.useCaseSensitiveFileNames,
-					host.getCurrentDirectory(),
-					depth,
-					(directoryPath) => {
-						const files: string[] = [];
-						const directories: string[] = [];
-						for (const dirent of host.readDirectory(
-							path.resolve(host.getCurrentDirectory(), directoryPath),
-						)) {
-							if (dirent.type === "file") {
-								files.push(dirent.name);
-							} else if (dirent.type === "directory") {
-								directories.push(dirent.name);
-							}
-						}
-						return { files, directories };
-					},
-					ts.sys.realpath ?? ((path) => path),
-				);
+			readDirectory(directoryPath, extensions, exclude, include, depth) {
+				const originalCwd = process.cwd;
+				process.cwd = () => host.getCurrentDirectory();
+				const originalReadDirSync = fs.readdirSync;
+				// @ts-expect-error - TypeScript doesn't understand that the overloads do match up.
+				const patchedReaddirSync: typeof fs.readdirSync = (
+					readPath,
+					options,
+				) => {
+					assert.deepEqual(
+						options,
+						{ withFileTypes: true },
+						"Flint bug: ts.sys.readDirectory passed unexpected options to fs.readdirSync",
+					);
+					assert.ok(
+						typeof readPath === "string",
+						"Flint bug: ts.sys.readDirectory passed unexpected path to fs.readdirSync",
+					);
+					fs.readdirSync = originalReadDirSync;
+					try {
+						return host
+							.readDirectory(readPath)
+							.map(
+								(dirent) =>
+									new DirentCtor(
+										dirent.name,
+										dirent.type === "file"
+											? UV_DIRENT_TYPE.UV_DIRENT_FILE
+											: UV_DIRENT_TYPE.UV_DIRENT_DIR,
+										readPath,
+									),
+							);
+					} finally {
+						fs.readdirSync = patchedReaddirSync;
+					}
+				};
+				fs.readdirSync = patchedReaddirSync;
+				try {
+					return ts.sys.readDirectory(
+						directoryPath,
+						extensions,
+						exclude,
+						include,
+						depth,
+					);
+				} finally {
+					process.cwd = originalCwd;
+					fs.readdirSync = originalReadDirSync;
+				}
 			},
 			setImmediate,
 			setTimeout,
@@ -133,42 +170,10 @@ export function prepareTypeScriptBasedLanguage(
 		},
 	});
 
-	const servicePrograms = new CachedFactory((filePathAbsolute: string) => {
-		log("Opening client file:", filePathAbsolute);
-		service.openClientFile(filePathAbsolute);
-
-		log("Retrieving client services:", filePathAbsolute);
-		const scriptInfo = service.getScriptInfo(filePathAbsolute);
-		if (!scriptInfo) {
-			throw new Error(
-				`Could not find script info for file: ${filePathAbsolute}`,
-			);
-		}
-
-		const defaultProject = service.getDefaultProjectForFile(
-			scriptInfo.fileName,
-			true,
-		);
-		if (!defaultProject) {
-			throw new Error(
-				`Could not find default project for file: ${filePathAbsolute}`,
-			);
-		}
-
-		const program = defaultProject.getLanguageService(true).getProgram();
-		if (!program) {
-			throw new Error(
-				`Could not retrieve program for file: ${filePathAbsolute}`,
-			);
-		}
-
-		return program;
-	});
-
 	return {
 		createFile: (filePathAbsolute) => {
 			log("Opening client file:", filePathAbsolute);
-			service.openClientFile(filePathAbsolute); //, host.readFile(filePathAbsolute))
+			service.openClientFile(filePathAbsolute);
 
 			log("Retrieving client services:", filePathAbsolute);
 			const scriptInfo = service.getScriptInfo(filePathAbsolute);
@@ -195,11 +200,20 @@ export function prepareTypeScriptBasedLanguage(
 				);
 			}
 
-			return createTypeScriptFileFromProjectService(
-				filePathAbsolute,
+			const sourceFile = program.getSourceFile(filePathAbsolute);
+			if (!sourceFile) {
+				throw new Error(
+					`Could not retrieve source file for: ${filePathAbsolute}`,
+				);
+			}
+
+			return {
 				program,
-				service,
-			);
+				sourceFile,
+				[Symbol.dispose]() {
+					service.closeClientFile(filePathAbsolute);
+				},
+			};
 		},
 	};
 }
diff --git a/packages/ts/src/typescriptUtilities.ts b/packages/ts/src/typescriptUtilities.ts
deleted file mode 100644
index 15cb78995..000000000
--- a/packages/ts/src/typescriptUtilities.ts
+++ /dev/null
@@ -1,1476 +0,0 @@
-interface FileSystemEntries {
-	readonly files: readonly string[];
-	readonly directories: readonly string[];
-}
-
-const directorySeparator = "/";
-const altDirectorySeparator = "\\";
-const urlSchemeSeparator = "://";
-const backslashRegExp = /\\/g;
-
-function getFileUrlVolumeSeparatorEnd(url: string, start: number) {
-	const ch0 = url.charCodeAt(start);
-	if (ch0 === CharacterCodes.colon) {
-		return start + 1;
-	}
-	if (
-		ch0 === CharacterCodes.percent &&
-		url.charCodeAt(start + 1) === CharacterCodes._3
-	) {
-		const ch2 = url.charCodeAt(start + 2);
-		if (ch2 === CharacterCodes.a || ch2 === CharacterCodes.A) {
-			return start + 3;
-		}
-	}
-	return -1;
-}
-
-function normalizeSlashes(path: string): string {
-	return path.includes("\\")
-		? path.replace(backslashRegExp, directorySeparator)
-		: path;
-}
-
-function getRootLength(path: string): number {
-	const rootLength = getEncodedRootLength(path);
-	return rootLength < 0 ? ~rootLength : rootLength;
-}
-
-const enum CharacterCodes {
-	EOF = -1,
-	nullCharacter = 0,
-	maxAsciiCharacter = 0x7f,
-
-	lineFeed = 0x0a, // \n
-	carriageReturn = 0x0d, // \r
-	lineSeparator = 0x2028,
-	paragraphSeparator = 0x2029,
-	nextLine = 0x0085,
-
-	// Unicode 3.0 space characters
-	space = 0x0020, // " "
-	nonBreakingSpace = 0x00a0, //
-	enQuad = 0x2000,
-	emQuad = 0x2001,
-	enSpace = 0x2002,
-	emSpace = 0x2003,
-	threePerEmSpace = 0x2004,
-	fourPerEmSpace = 0x2005,
-	sixPerEmSpace = 0x2006,
-	figureSpace = 0x2007,
-	punctuationSpace = 0x2008,
-	thinSpace = 0x2009,
-	hairSpace = 0x200a,
-	zeroWidthSpace = 0x200b,
-	narrowNoBreakSpace = 0x202f,
-	ideographicSpace = 0x3000,
-	mathematicalSpace = 0x205f,
-	ogham = 0x1680,
-
-	// Unicode replacement character produced when a byte sequence is invalid
-	replacementCharacter = 0xfffd,
-
-	_ = 0x5f,
-	$ = 0x24,
-
-	_0 = 0x30,
-	_1 = 0x31,
-	_2 = 0x32,
-	_3 = 0x33,
-	_4 = 0x34,
-	_5 = 0x35,
-	_6 = 0x36,
-	_7 = 0x37,
-	_8 = 0x38,
-	_9 = 0x39,
-
-	a = 0x61,
-	b = 0x62,
-	c = 0x63,
-	d = 0x64,
-	e = 0x65,
-	f = 0x66,
-	g = 0x67,
-	h = 0x68,
-	i = 0x69,
-	j = 0x6a,
-	k = 0x6b,
-	l = 0x6c,
-	m = 0x6d,
-	n = 0x6e,
-	o = 0x6f,
-	p = 0x70,
-	q = 0x71,
-	r = 0x72,
-	s = 0x73,
-	t = 0x74,
-	u = 0x75,
-	v = 0x76,
-	w = 0x77,
-	x = 0x78,
-	y = 0x79,
-	z = 0x7a,
-
-	A = 0x41,
-	B = 0x42,
-	C = 0x43,
-	D = 0x44,
-	E = 0x45,
-	F = 0x46,
-	G = 0x47,
-	H = 0x48,
-	I = 0x49,
-	J = 0x4a,
-	K = 0x4b,
-	L = 0x4c,
-	M = 0x4d,
-	N = 0x4e,
-	O = 0x4f,
-	P = 0x50,
-	Q = 0x51,
-	R = 0x52,
-	S = 0x53,
-	T = 0x54,
-	U = 0x55,
-	V = 0x56,
-	W = 0x57,
-	X = 0x58,
-	Y = 0x59,
-	Z = 0x5a,
-
-	ampersand = 0x26, // &
-	asterisk = 0x2a, // *
-	at = 0x40, // @
-	backslash = 0x5c, // \
-	backtick = 0x60, // `
-	bar = 0x7c, // |
-	caret = 0x5e, // ^
-	closeBrace = 0x7d, // }
-	closeBracket = 0x5d, // ]
-	closeParen = 0x29, // )
-	colon = 0x3a, // :
-	comma = 0x2c, // ,
-	dot = 0x2e, // .
-	doubleQuote = 0x22, // "
-	equals = 0x3d, // =
-	exclamation = 0x21, // !
-	greaterThan = 0x3e, // >
-	hash = 0x23, // #
-	lessThan = 0x3c, // <
-	minus = 0x2d, // -
-	openBrace = 0x7b, // {
-	openBracket = 0x5b, // [
-	openParen = 0x28, // (
-	percent = 0x25, // %
-	plus = 0x2b, // +
-	question = 0x3f, // ?
-	semicolon = 0x3b, // ;
-	singleQuote = 0x27, // '
-	slash = 0x2f, // /
-	tilde = 0x7e, // ~
-
-	backspace = 0x08, // \b
-	formFeed = 0x0c, // \f
-	byteOrderMark = 0xfeff,
-	tab = 0x09, // \t
-	verticalTab = 0x0b, // \v
-}
-
-function isVolumeCharacter(charCode: number) {
-	return (
-		(charCode >= CharacterCodes.a && charCode <= CharacterCodes.z) ||
-		(charCode >= CharacterCodes.A && charCode <= CharacterCodes.Z)
-	);
-}
-
-function getEncodedRootLength(path: string): number {
-	if (!path) {
-		return 0;
-	}
-	const ch0 = path.charCodeAt(0);
-
-	// POSIX or UNC
-	if (ch0 === CharacterCodes.slash || ch0 === CharacterCodes.backslash) {
-		if (path.charCodeAt(1) !== ch0) {
-			return 1;
-		} // POSIX: "/" (or non-normalized "\")
-
-		const p1 = path.indexOf(
-			ch0 === CharacterCodes.slash ? directorySeparator : altDirectorySeparator,
-			2,
-		);
-		if (p1 < 0) {
-			return path.length;
-		} // UNC: "//server" or "\\server"
-
-		return p1 + 1; // UNC: "//server/" or "\\server\"
-	}
-
-	// DOS
-	if (isVolumeCharacter(ch0) && path.charCodeAt(1) === CharacterCodes.colon) {
-		const ch2 = path.charCodeAt(2);
-		if (ch2 === CharacterCodes.slash || ch2 === CharacterCodes.backslash) {
-			return 3;
-		} // DOS: "c:/" or "c:\"
-		if (path.length === 2) {
-			return 2;
-		} // DOS: "c:" (but not "c:d")
-	}
-
-	// URL
-	const schemeEnd = path.indexOf(urlSchemeSeparator);
-	if (schemeEnd !== -1) {
-		const authorityStart = schemeEnd + urlSchemeSeparator.length;
-		const authorityEnd = path.indexOf(directorySeparator, authorityStart);
-		if (authorityEnd !== -1) {
-			// URL: "file:///", "file://server/", "file://server/path"
-			// For local "file" URLs, include the leading DOS volume (if present).
-			// Per https://www.ietf.org/rfc/rfc1738.txt, a host of "" or "localhost" is a
-			// special case interpreted as "the machine from which the URL is being interpreted".
-			const scheme = path.slice(0, schemeEnd);
-			const authority = path.slice(authorityStart, authorityEnd);
-			if (
-				scheme === "file" &&
-				(authority === "" || authority === "localhost") &&
-				isVolumeCharacter(path.charCodeAt(authorityEnd + 1))
-			) {
-				const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(
-					path,
-					authorityEnd + 2,
-				);
-				if (volumeSeparatorEnd !== -1) {
-					if (path.charCodeAt(volumeSeparatorEnd) === CharacterCodes.slash) {
-						// URL: "file:///c:/", "file://localhost/c:/", "file:///c%3a/", "file://localhost/c%3a/"
-						return ~(volumeSeparatorEnd + 1);
-					}
-					if (volumeSeparatorEnd === path.length) {
-						// URL: "file:///c:", "file://localhost/c:", "file:///c$3a", "file://localhost/c%3a"
-						// but not "file:///c:d" or "file:///c%3ad"
-						return ~volumeSeparatorEnd;
-					}
-				}
-			}
-			return ~(authorityEnd + 1); // URL: "file://server/", "http://server/"
-		}
-		return ~path.length; // URL: "file://server", "http://server"
-	}
-
-	// relative
-	return 0;
-}
-
-function isAnyDirectorySeparator(charCode: number): boolean {
-	return (
-		charCode === CharacterCodes.slash || charCode === CharacterCodes.backslash
-	);
-}
-
-function hasTrailingDirectorySeparator(path: string): boolean {
-	return (
-		path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1))
-	);
-}
-
-type Path = string & { __pathBrand: any };
-
-function ensureTrailingDirectorySeparator(path: Path): Path;
-function ensureTrailingDirectorySeparator(path: string): string;
-function ensureTrailingDirectorySeparator(path: string) {
-	if (!hasTrailingDirectorySeparator(path)) {
-		return path + directorySeparator;
-	}
-
-	return path;
-}
-
-function combinePaths(path: string, ...paths: (string | undefined)[]): string {
-	if (path) {
-		path = normalizeSlashes(path);
-	}
-	for (let relativePath of paths) {
-		if (!relativePath) {
-			continue;
-		}
-		relativePath = normalizeSlashes(relativePath);
-		if (!path || getRootLength(relativePath) !== 0) {
-			path = relativePath;
-		} else {
-			path = ensureTrailingDirectorySeparator(path) + relativePath;
-		}
-	}
-	return path;
-}
-
-function getNormalizedAbsolutePath(
-	path: string,
-	currentDirectory: string | undefined,
-): string {
-	let rootLength = getRootLength(path);
-	if (rootLength === 0 && currentDirectory) {
-		path = combinePaths(currentDirectory, path);
-		rootLength = getRootLength(path);
-	} else {
-		// combinePaths normalizes slashes, so not necessary in the other branch
-		path = normalizeSlashes(path);
-	}
-
-	const simpleNormalized = simpleNormalizePath(path);
-	if (simpleNormalized !== undefined) {
-		return simpleNormalized.length > rootLength
-			? removeTrailingDirectorySeparator(simpleNormalized)
-			: simpleNormalized;
-	}
-
-	const length = path.length;
-	const root = path.substring(0, rootLength);
-	// `normalized` is only initialized once `path` is determined to be non-normalized
-	let normalized;
-	let index = rootLength;
-	let segmentStart = index;
-	let normalizedUpTo = index;
-	let seenNonDotDotSegment = rootLength !== 0;
-	while (index < length) {
-		// At beginning of segment
-		segmentStart = index;
-		let ch = path.charCodeAt(index);
-		while (ch === CharacterCodes.slash && index + 1 < length) {
-			index++;
-			ch = path.charCodeAt(index);
-		}
-		if (index > segmentStart) {
-			// Seen superfluous separator
-			normalized ??= path.substring(0, segmentStart - 1);
-			segmentStart = index;
-		}
-		// Past any superfluous separators
-		let segmentEnd = path.indexOf(directorySeparator, index + 1);
-		if (segmentEnd === -1) {
-			segmentEnd = length;
-		}
-		const segmentLength = segmentEnd - segmentStart;
-		if (segmentLength === 1 && path.charCodeAt(index) === CharacterCodes.dot) {
-			// "." segment (skip)
-			normalized ??= path.substring(0, normalizedUpTo);
-		} else if (
-			segmentLength === 2 &&
-			path.charCodeAt(index) === CharacterCodes.dot &&
-			path.charCodeAt(index + 1) === CharacterCodes.dot
-		) {
-			// ".." segment
-			if (!seenNonDotDotSegment) {
-				if (normalized !== undefined) {
-					normalized += normalized.length === rootLength ? ".." : "/..";
-				} else {
-					normalizedUpTo = index + 2;
-				}
-			} else if (normalized === undefined) {
-				if (normalizedUpTo - 2 >= 0) {
-					normalized = path.substring(
-						0,
-						Math.max(
-							rootLength,
-							path.lastIndexOf(directorySeparator, normalizedUpTo - 2),
-						),
-					);
-				} else {
-					normalized = path.substring(0, normalizedUpTo);
-				}
-			} else {
-				const lastSlash = normalized.lastIndexOf(directorySeparator);
-				if (lastSlash !== -1) {
-					normalized = normalized.substring(0, Math.max(rootLength, lastSlash));
-				} else {
-					normalized = root;
-				}
-				if (normalized.length === rootLength) {
-					seenNonDotDotSegment = rootLength !== 0;
-				}
-			}
-		} else if (normalized !== undefined) {
-			if (normalized.length !== rootLength) {
-				normalized += directorySeparator;
-			}
-			seenNonDotDotSegment = true;
-			normalized += path.substring(segmentStart, segmentEnd);
-		} else {
-			seenNonDotDotSegment = true;
-			normalizedUpTo = segmentEnd;
-		}
-		index = segmentEnd + 1;
-	}
-	return (
-		normalized ??
-		(length > rootLength ? removeTrailingDirectorySeparator(path) : path)
-	);
-}
-
-function removeTrailingDirectorySeparator(path: Path): Path;
-function removeTrailingDirectorySeparator(path: string): string;
-function removeTrailingDirectorySeparator(path: string) {
-	if (hasTrailingDirectorySeparator(path)) {
-		return path.substr(0, path.length - 1);
-	}
-
-	return path;
-}
-
-function normalizePath(path: string): string {
-	path = normalizeSlashes(path);
-	let normalized = simpleNormalizePath(path);
-	if (normalized !== undefined) {
-		return normalized;
-	}
-	normalized = getNormalizedAbsolutePath(path, "");
-	return normalized && hasTrailingDirectorySeparator(path)
-		? ensureTrailingDirectorySeparator(normalized)
-		: normalized;
-}
-
-const relativePathSegmentRegExp = /\/\/|(?:^|\/)\.\.?(?:$|\/)/;
-
-function simpleNormalizePath(path: string): string | undefined {
-	// Most paths don't require normalization
-	if (!relativePathSegmentRegExp.test(path)) {
-		return path;
-	}
-	// Some paths only require cleanup of `/./` or leading `./`
-	let simplified = path.replace(/\/\.\//g, "/");
-	if (simplified.startsWith("./")) {
-		simplified = simplified.slice(2);
-	}
-	if (simplified !== path) {
-		path = simplified;
-		if (!relativePathSegmentRegExp.test(path)) {
-			return path;
-		}
-	}
-	return undefined;
-}
-
-interface FileMatcherPatterns {
-	/** One pattern for each "include" spec. */
-	includeFilePatterns: readonly string[] | undefined;
-	/** One pattern matching one of any of the "include" specs. */
-	includeFilePattern: string | undefined;
-	includeDirectoryPattern: string | undefined;
-	excludePattern: string | undefined;
-	basePaths: readonly string[];
-}
-
-function map<T, U>(array: readonly T[], f: (x: T, i: number) => U): U[];
-function map<T, U>(
-	array: readonly T[] | undefined,
-	f: (x: T, i: number) => U,
-): U[] | undefined;
-function map<T, U>(
-	array: readonly T[] | undefined,
-	f: (x: T, i: number) => U,
-): U[] | undefined {
-	let result: U[] | undefined;
-	if (array !== undefined) {
-		result = [];
-		for (let i = 0; i < array.length; i++) {
-			result.push(f(array[i], i));
-		}
-	}
-	return result;
-}
-
-function getRegularExpressionsForWildcards(
-	specs: readonly string[] | undefined,
-	basePath: string,
-	usage: "files" | "directories" | "exclude",
-): readonly string[] | undefined {
-	if (specs === undefined || specs.length === 0) {
-		return undefined;
-	}
-
-	return flatMap(
-		specs,
-		(spec) =>
-			spec &&
-			getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]),
-	);
-}
-
-interface WildcardMatcher {
-	singleAsteriskRegexFragment: string;
-	doubleAsteriskRegexFragment: string;
-	replaceWildcardCharacter: (match: string) => string;
-}
-
-const commonPackageFolders: readonly string[] = [
-	"node_modules",
-	"bower_components",
-	"jspm_packages",
-];
-
-const implicitExcludePathRegexPattern = `(?!(?:${commonPackageFolders.join("|")})(?:/|$))`;
-
-function replaceWildcardCharacter(
-	match: string,
-	singleAsteriskRegexFragment: string,
-) {
-	return match === "*"
-		? singleAsteriskRegexFragment
-		: match === "?"
-			? "[^/]"
-			: "\\" + match;
-}
-
-const filesMatcher: WildcardMatcher = {
-	/**
-	 * Matches any single directory segment unless it is the last segment and a .min.js file
-	 * Breakdown:
-	 *  [^./]                   # matches everything up to the first . character (excluding directory separators)
-	 *  (\\.(?!min\\.js$))?     # matches . characters but not if they are part of the .min.js file extension
-	 */
-	singleAsteriskRegexFragment: "(?:[^./]|(?:\\.(?!min\\.js$))?)*",
-	/**
-	 * Regex for the ** wildcard. Matches any number of subdirectories. When used for including
-	 * files or directories, does not match subdirectories that start with a . character
-	 */
-	doubleAsteriskRegexFragment: `(?:/${implicitExcludePathRegexPattern}[^/.][^/]*)*?`,
-	replaceWildcardCharacter: (match) =>
-		replaceWildcardCharacter(match, filesMatcher.singleAsteriskRegexFragment),
-};
-
-const directoriesMatcher: WildcardMatcher = {
-	singleAsteriskRegexFragment: "[^/]*",
-	/**
-	 * Regex for the ** wildcard. Matches any number of subdirectories. When used for including
-	 * files or directories, does not match subdirectories that start with a . character
-	 */
-	doubleAsteriskRegexFragment: `(?:/${implicitExcludePathRegexPattern}[^/.][^/]*)*?`,
-	replaceWildcardCharacter: (match) =>
-		replaceWildcardCharacter(
-			match,
-			directoriesMatcher.singleAsteriskRegexFragment,
-		),
-};
-
-const excludeMatcher: WildcardMatcher = {
-	singleAsteriskRegexFragment: "[^/]*",
-	doubleAsteriskRegexFragment: "(?:/.+?)?",
-	replaceWildcardCharacter: (match) =>
-		replaceWildcardCharacter(match, excludeMatcher.singleAsteriskRegexFragment),
-};
-
-const wildcardMatchers = {
-	files: filesMatcher,
-	directories: directoriesMatcher,
-	exclude: excludeMatcher,
-};
-
-function append<T extends {}>(to: T[], value: T | undefined): T[];
-function append<T extends {}>(to: T[] | undefined, value: T): T[];
-function append<T extends {}>(
-	to: T[] | undefined,
-	value: T | undefined,
-): T[] | undefined;
-function append<T extends {}>(
-	to: T[] | undefined,
-	value: T | undefined,
-): T[] | undefined {
-	if (value === undefined) {
-		return to;
-	}
-	if (to === undefined) {
-		return [value];
-	}
-	to.push(value);
-	return to;
-}
-
-function flatMap<T, U extends {}>(
-	array: readonly T[] | undefined,
-	mapfn: (x: T, i: number) => U | readonly U[] | undefined,
-): readonly U[] {
-	let result: U[] | undefined;
-	if (array !== undefined) {
-		for (let i = 0; i < array.length; i++) {
-			const v = mapfn(array[i], i);
-			if (v) {
-				if (isArray(v)) {
-					result = addRange(result, v);
-				} else {
-					result = append(result, v);
-				}
-			}
-		}
-	}
-	return result ?? emptyArray;
-}
-
-type PathPathComponents = Path[] & { __pathComponensBrand: any };
-
-function getPathComponents(path: Path): PathPathComponents;
-function getPathComponents(path: string, currentDirectory?: string): string[];
-function getPathComponents(path: string, currentDirectory = "") {
-	path = combinePaths(currentDirectory, path);
-	return pathComponents(path, getRootLength(path));
-}
-
-function lastOrUndefined<T>(array: readonly T[] | undefined): T | undefined {
-	return array === undefined || array.length === 0
-		? undefined
-		: array[array.length - 1];
-}
-
-function pathComponents(path: string, rootLength: number) {
-	const root = path.substring(0, rootLength);
-	const rest = path.substring(rootLength).split(directorySeparator);
-	if (rest.length && !lastOrUndefined(rest)) {
-		rest.pop();
-	}
-	return [root, ...rest];
-}
-
-function getNormalizedPathComponents(
-	path: string,
-	currentDirectory: string | undefined,
-): string[] {
-	return reducePathComponents(getPathComponents(path, currentDirectory));
-}
-
-function some<T>(array: readonly T[] | undefined): array is readonly T[];
-function some<T>(
-	array: readonly T[] | undefined,
-	predicate: (value: T) => boolean,
-): boolean;
-function some<T>(
-	array: readonly T[] | undefined,
-	predicate?: (value: T) => boolean,
-): boolean {
-	if (array !== undefined) {
-		if (predicate !== undefined) {
-			for (let i = 0; i < array.length; i++) {
-				if (predicate(array[i])) {
-					return true;
-				}
-			}
-		} else {
-			return array.length > 0;
-		}
-	}
-	return false;
-}
-
-function reducePathComponents(components: readonly string[]): string[] {
-	if (!some(components)) {
-		return [];
-	}
-	const reduced = [components[0]];
-	for (let i = 1; i < components.length; i++) {
-		const component = components[i];
-		if (!component) {
-			continue;
-		}
-		if (component === ".") {
-			continue;
-		}
-		if (component === "..") {
-			if (reduced.length > 1) {
-				if (reduced[reduced.length - 1] !== "..") {
-					reduced.pop();
-					continue;
-				}
-			} else if (reduced[0]) {
-				continue;
-			}
-		}
-		reduced.push(component);
-	}
-	return reduced;
-}
-
-function last<T>(array: readonly T[]): T {
-	return array[array.length - 1];
-}
-
-function isImplicitGlob(lastPathComponent: string): boolean {
-	return !/[.*?]/.test(lastPathComponent);
-}
-
-const reservedCharacterPattern = /[^\w\s/]/g;
-
-function getSubPatternFromSpec(
-	spec: string,
-	basePath: string,
-	usage: "files" | "directories" | "exclude",
-	{
-		singleAsteriskRegexFragment,
-		doubleAsteriskRegexFragment,
-		replaceWildcardCharacter,
-	}: WildcardMatcher = wildcardMatchers[usage],
-): string | undefined {
-	let subpattern = "";
-	let hasWrittenComponent = false;
-	const components = getNormalizedPathComponents(spec, basePath);
-	const lastComponent = last(components);
-	if (usage !== "exclude" && lastComponent === "**") {
-		return undefined;
-	}
-
-	// getNormalizedPathComponents includes the separator for the root component.
-	// We need to remove to create our regex correctly.
-	components[0] = removeTrailingDirectorySeparator(components[0]);
-
-	if (isImplicitGlob(lastComponent)) {
-		components.push("**", "*");
-	}
-
-	let optionalCount = 0;
-	for (let component of components) {
-		if (component === "**") {
-			subpattern += doubleAsteriskRegexFragment;
-		} else {
-			if (usage === "directories") {
-				subpattern += "(?:";
-				optionalCount++;
-			}
-
-			if (hasWrittenComponent) {
-				subpattern += directorySeparator;
-			}
-
-			if (usage !== "exclude") {
-				let componentPattern = "";
-				// The * and ? wildcards should not match directories or files that start with . if they
-				// appear first in a component. Dotted directories and files can be included explicitly
-				// like so: **/.*/.*
-				if (component.charCodeAt(0) === CharacterCodes.asterisk) {
-					componentPattern += "(?:[^./]" + singleAsteriskRegexFragment + ")?";
-					component = component.substr(1);
-				} else if (component.charCodeAt(0) === CharacterCodes.question) {
-					componentPattern += "[^./]";
-					component = component.substr(1);
-				}
-
-				componentPattern += component.replace(
-					reservedCharacterPattern,
-					replaceWildcardCharacter,
-				);
-
-				// Patterns should not include subfolders like node_modules unless they are
-				// explicitly included as part of the path.
-				//
-				// As an optimization, if the component pattern is the same as the component,
-				// then there definitely were no wildcard characters and we do not need to
-				// add the exclusion pattern.
-				if (componentPattern !== component) {
-					subpattern += implicitExcludePathRegexPattern;
-				}
-
-				subpattern += componentPattern;
-			} else {
-				subpattern += component.replace(
-					reservedCharacterPattern,
-					replaceWildcardCharacter,
-				);
-			}
-		}
-
-		hasWrittenComponent = true;
-	}
-
-	while (optionalCount > 0) {
-		subpattern += ")?";
-		optionalCount--;
-	}
-
-	return subpattern;
-}
-
-function getRegularExpressionForWildcard(
-	specs: readonly string[] | undefined,
-	basePath: string,
-	usage: "files" | "directories" | "exclude",
-): string | undefined {
-	const patterns = getRegularExpressionsForWildcards(specs, basePath, usage);
-	if (!patterns || !patterns.length) {
-		return undefined;
-	}
-
-	const pattern = patterns.map((pattern) => `(?:${pattern})`).join("|");
-	// If excluding, match "foo/bar/baz...", but if including, only allow "foo".
-	const terminator = usage === "exclude" ? "(?:$|/)" : "$";
-	return `^(?:${pattern})${terminator}`;
-}
-
-function isRootedDiskPath(path: string): boolean {
-	return getEncodedRootLength(path) > 0;
-}
-
-function indexOfAnyCharCode(
-	text: string,
-	charCodes: readonly number[],
-	start?: number,
-): number {
-	for (let i = start ?? 0; i < text.length; i++) {
-		if (contains(charCodes, text.charCodeAt(i))) {
-			return i;
-		}
-	}
-	return -1;
-}
-
-type EqualityComparer<T> = (a: T, b: T) => boolean;
-
-function contains<T>(
-	array: readonly T[] | undefined,
-	value: T,
-	equalityComparer: EqualityComparer<T> = equateValues,
-): boolean {
-	if (array !== undefined) {
-		for (let i = 0; i < array.length; i++) {
-			if (equalityComparer(array[i], value)) {
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-const wildcardCharCodes = [CharacterCodes.asterisk, CharacterCodes.question];
-
-function startsWith(
-	str: string,
-	prefix: string,
-	ignoreCase?: boolean,
-): boolean {
-	return ignoreCase
-		? equateStringsCaseInsensitive(str.slice(0, prefix.length), prefix)
-		: str.lastIndexOf(prefix, 0) === 0;
-}
-
-function getBaseFileName(path: string): string;
-function getBaseFileName(
-	path: string,
-	extensions: string | readonly string[],
-	ignoreCase: boolean,
-): string;
-function getBaseFileName(
-	path: string,
-	extensions?: string | readonly string[],
-	ignoreCase?: boolean,
-) {
-	path = normalizeSlashes(path);
-
-	// if the path provided is itself the root, then it has not file name.
-	const rootLength = getRootLength(path);
-	if (rootLength === path.length) {
-		return "";
-	}
-
-	// return the trailing portion of the path starting after the last (non-terminal) directory
-	// separator but not including any trailing directory separator.
-	path = removeTrailingDirectorySeparator(path);
-	const name = path.slice(
-		Math.max(getRootLength(path), path.lastIndexOf(directorySeparator) + 1),
-	);
-	const extension =
-		extensions !== undefined && ignoreCase !== undefined
-			? getAnyExtensionFromPath(name, extensions, ignoreCase)
-			: undefined;
-	return extension ? name.slice(0, name.length - extension.length) : name;
-}
-
-function tryGetExtensionFromPath(
-	path: string,
-	extension: string,
-	stringEqualityComparer: (a: string, b: string) => boolean,
-) {
-	if (!startsWith(extension, ".")) {
-		extension = "." + extension;
-	}
-	if (
-		path.length >= extension.length &&
-		path.charCodeAt(path.length - extension.length) === CharacterCodes.dot
-	) {
-		const pathExtension = path.slice(path.length - extension.length);
-		if (stringEqualityComparer(pathExtension, extension)) {
-			return pathExtension;
-		}
-	}
-}
-
-function getAnyExtensionFromPathWorker(
-	path: string,
-	extensions: string | readonly string[],
-	stringEqualityComparer: (a: string, b: string) => boolean,
-) {
-	if (typeof extensions === "string") {
-		return (
-			tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || ""
-		);
-	}
-	for (const extension of extensions) {
-		const result = tryGetExtensionFromPath(
-			path,
-			extension,
-			stringEqualityComparer,
-		);
-		if (result) {
-			return result;
-		}
-	}
-	return "";
-}
-
-function equateValues<T>(a: T, b: T): boolean {
-	return a === b;
-}
-
-function equateStringsCaseSensitive(a: string, b: string): boolean {
-	return equateValues(a, b);
-}
-
-function getAnyExtensionFromPath(path: string): string;
-function getAnyExtensionFromPath(
-	path: string,
-	extensions: string | readonly string[],
-	ignoreCase: boolean,
-): string;
-function getAnyExtensionFromPath(
-	path: string,
-	extensions?: string | readonly string[],
-	ignoreCase?: boolean,
-): string {
-	// Retrieves any string from the final "." onwards from a base file name.
-	// Unlike extensionFromPath, which throws an exception on unrecognized extensions.
-	if (extensions) {
-		return getAnyExtensionFromPathWorker(
-			removeTrailingDirectorySeparator(path),
-			extensions,
-			ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive,
-		);
-	}
-	const baseFileName = getBaseFileName(path);
-	const extensionIndex = baseFileName.lastIndexOf(".");
-	if (extensionIndex >= 0) {
-		return baseFileName.substring(extensionIndex);
-	}
-	return "";
-}
-
-function hasExtension(fileName: string): boolean {
-	return getBaseFileName(fileName).includes(".");
-}
-
-function getIncludeBasePath(absolute: string): string {
-	const wildcardOffset = indexOfAnyCharCode(absolute, wildcardCharCodes);
-	if (wildcardOffset < 0) {
-		// No "*" or "?" in the path
-		return !hasExtension(absolute)
-			? absolute
-			: removeTrailingDirectorySeparator(getDirectoryPath(absolute));
-	}
-	return absolute.substring(
-		0,
-		absolute.lastIndexOf(directorySeparator, wildcardOffset),
-	);
-}
-
-function getDirectoryPath(path: Path): Path;
-function getDirectoryPath(path: string): string;
-function getDirectoryPath(path: string): string {
-	path = normalizeSlashes(path);
-
-	// If the path provided is itself the root, then return it.
-	const rootLength = getRootLength(path);
-	if (rootLength === path.length) {
-		return path;
-	}
-
-	// return the leading portion of the path up to the last (non-terminal) directory separator
-	// but not including any trailing directory separator.
-	path = removeTrailingDirectorySeparator(path);
-	return path.slice(
-		0,
-		Math.max(rootLength, path.lastIndexOf(directorySeparator)),
-	);
-}
-
-function compareStringsCaseInsensitive(a: string, b: string): Comparison {
-	if (a === b) {
-		return Comparison.EqualTo;
-	}
-	if (a === undefined) {
-		return Comparison.LessThan;
-	}
-	if (b === undefined) {
-		return Comparison.GreaterThan;
-	}
-	a = a.toUpperCase();
-	b = b.toUpperCase();
-	return a < b
-		? Comparison.LessThan
-		: a > b
-			? Comparison.GreaterThan
-			: Comparison.EqualTo;
-}
-
-function getStringComparer(
-	ignoreCase?: boolean,
-): typeof compareStringsCaseInsensitive {
-	return ignoreCase
-		? compareStringsCaseInsensitive
-		: compareStringsCaseSensitive;
-}
-
-function every<T, U extends T>(
-	array: readonly T[],
-	callback: (element: T, index: number) => element is U,
-): array is readonly U[];
-function every<T, U extends T>(
-	array: readonly T[] | undefined,
-	callback: (element: T, index: number) => element is U,
-): array is readonly U[] | undefined;
-function every<T>(
-	array: readonly T[] | undefined,
-	callback: (element: T, index: number) => boolean,
-): boolean;
-function every<T>(
-	array: readonly T[] | undefined,
-	callback: (element: T, index: number) => boolean,
-): boolean {
-	if (array !== undefined) {
-		for (let i = 0; i < array.length; i++) {
-			if (!callback(array[i], i)) {
-				return false;
-			}
-		}
-	}
-
-	return true;
-}
-
-function containsPath(
-	parent: string,
-	child: string,
-	ignoreCase?: boolean,
-): boolean;
-function containsPath(
-	parent: string,
-	child: string,
-	currentDirectory: string,
-	ignoreCase?: boolean,
-): boolean;
-function containsPath(
-	parent: string,
-	child: string,
-	currentDirectory?: string | boolean,
-	ignoreCase?: boolean,
-) {
-	if (typeof currentDirectory === "string") {
-		parent = combinePaths(currentDirectory, parent);
-		child = combinePaths(currentDirectory, child);
-	} else if (typeof currentDirectory === "boolean") {
-		ignoreCase = currentDirectory;
-	}
-	if (parent === undefined || child === undefined) {
-		return false;
-	}
-	if (parent === child) {
-		return true;
-	}
-	const parentComponents = reducePathComponents(getPathComponents(parent));
-	const childComponents = reducePathComponents(getPathComponents(child));
-	if (childComponents.length < parentComponents.length) {
-		return false;
-	}
-
-	const componentEqualityComparer = ignoreCase
-		? equateStringsCaseInsensitive
-		: equateStringsCaseSensitive;
-	for (let i = 0; i < parentComponents.length; i++) {
-		const equalityComparer =
-			i === 0 ? equateStringsCaseInsensitive : componentEqualityComparer;
-		if (!equalityComparer(parentComponents[i], childComponents[i])) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function getBasePaths(
-	path: string,
-	includes: readonly string[] | undefined,
-	useCaseSensitiveFileNames: boolean,
-): string[] {
-	// Storage for our results in the form of literal paths (e.g. the paths as written by the user).
-	const basePaths: string[] = [path];
-
-	if (includes) {
-		// Storage for literal base paths amongst the include patterns.
-		const includeBasePaths: string[] = [];
-		for (const include of includes) {
-			// We also need to check the relative paths by converting them to absolute and normalizing
-			// in case they escape the base path (e.g "..\somedirectory")
-			const absolute: string = isRootedDiskPath(include)
-				? include
-				: normalizePath(combinePaths(path, include));
-			// Append the literal and canonical candidate base paths.
-			includeBasePaths.push(getIncludeBasePath(absolute));
-		}
-
-		// Sort the offsets array using either the literal or canonical path representations.
-		includeBasePaths.sort(getStringComparer(!useCaseSensitiveFileNames));
-
-		// Iterate over each include base path and include unique base paths that are not a
-		// subpath of an existing base path
-		for (const includeBasePath of includeBasePaths) {
-			if (
-				every(
-					basePaths,
-					(basePath) =>
-						!containsPath(
-							basePath,
-							includeBasePath,
-							path,
-							!useCaseSensitiveFileNames,
-						),
-				)
-			) {
-				basePaths.push(includeBasePath);
-			}
-		}
-	}
-
-	return basePaths;
-}
-
-function getFileMatcherPatterns(
-	path: string,
-	excludes: readonly string[] | undefined,
-	includes: readonly string[] | undefined,
-	useCaseSensitiveFileNames: boolean,
-	currentDirectory: string,
-): FileMatcherPatterns {
-	path = normalizePath(path);
-	currentDirectory = normalizePath(currentDirectory);
-	const absolutePath = combinePaths(currentDirectory, path);
-
-	return {
-		includeFilePatterns: map(
-			getRegularExpressionsForWildcards(includes, absolutePath, "files"),
-			(pattern) => `^${pattern}$`,
-		),
-		includeFilePattern: getRegularExpressionForWildcard(
-			includes,
-			absolutePath,
-			"files",
-		),
-		includeDirectoryPattern: getRegularExpressionForWildcard(
-			includes,
-			absolutePath,
-			"directories",
-		),
-		excludePattern: getRegularExpressionForWildcard(
-			excludes,
-			absolutePath,
-			"exclude",
-		),
-		basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames),
-	};
-}
-
-function getRegexFromPattern(
-	pattern: string,
-	useCaseSensitiveFileNames: boolean,
-): RegExp {
-	return new RegExp(pattern, useCaseSensitiveFileNames ? "" : "i");
-}
-
-type GetCanonicalFileName = (fileName: string) => string;
-function identity<T>(x: T): T {
-	return x;
-}
-function toLowerCase(x: string) {
-	return x.toLowerCase();
-}
-const fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_. ]+/g;
-function toFileNameLowerCase(x: string): string {
-	return fileNameLowerCaseRegExp.test(x)
-		? x.replace(fileNameLowerCaseRegExp, toLowerCase)
-		: x;
-}
-
-function createGetCanonicalFileName(
-	useCaseSensitiveFileNames: boolean,
-): GetCanonicalFileName {
-	return useCaseSensitiveFileNames ? identity : toFileNameLowerCase;
-}
-function isArray(value: any): value is readonly unknown[] {
-	// See: https://github.com/microsoft/TypeScript/issues/17002
-	return Array.isArray(value);
-}
-
-function toOffset(array: readonly any[], offset: number) {
-	return offset < 0 ? array.length + offset : offset;
-}
-
-function addRange<T>(
-	to: T[],
-	from: readonly T[] | undefined,
-	start?: number,
-	end?: number,
-): T[];
-function addRange<T>(
-	to: T[] | undefined,
-	from: readonly T[] | undefined,
-	start?: number,
-	end?: number,
-): T[] | undefined;
-function addRange<T>(
-	to: T[] | undefined,
-	from: readonly T[] | undefined,
-	start?: number,
-	end?: number,
-): T[] | undefined {
-	if (from === undefined || from.length === 0) {
-		return to;
-	}
-	if (to === undefined) {
-		return from.slice(start, end);
-	}
-	start = start === undefined ? 0 : toOffset(from, start);
-	end = end === undefined ? from.length : toOffset(from, end);
-	for (let i = start; i < end && i < from.length; i++) {
-		if (from[i] !== undefined) {
-			to.push(from[i]);
-		}
-	}
-	return to;
-}
-
-function flatten<T>(
-	array: T[][] | readonly (T | readonly T[] | undefined)[],
-): T[] {
-	const result = [];
-	for (let i = 0; i < array.length; i++) {
-		const v = array[i];
-		if (v) {
-			if (isArray(v)) {
-				addRange(result, v);
-			} else {
-				result.push(v);
-			}
-		}
-	}
-	return result;
-}
-
-type Comparer<T> = (a: T, b: T) => Comparison;
-
-const enum Comparison {
-	LessThan = -1,
-	EqualTo = 0,
-	GreaterThan = 1,
-}
-
-interface SortedReadonlyArray<T> extends ReadonlyArray<T> {
-	" __sortedArrayBrand": any;
-}
-
-const emptyArray = [] as never[];
-
-function toSorted<T>(
-	array: readonly T[],
-	comparer?: Comparer<T>,
-): SortedReadonlyArray<T> {
-	return (array.length === 0
-		? emptyArray
-		: array.slice().sort(comparer)) as readonly T[] as SortedReadonlyArray<T>;
-}
-
-function compareComparableValues(
-	a: string | undefined,
-	b: string | undefined,
-): Comparison;
-function compareComparableValues(
-	a: number | undefined,
-	b: number | undefined,
-): Comparison;
-function compareComparableValues(
-	a: string | number | undefined,
-	b: string | number | undefined,
-) {
-	return a === b
-		? Comparison.EqualTo
-		: a === undefined
-			? Comparison.LessThan
-			: b === undefined
-				? Comparison.GreaterThan
-				: a < b
-					? Comparison.LessThan
-					: Comparison.GreaterThan;
-}
-
-function compareStringsCaseSensitive(
-	a: string | undefined,
-	b: string | undefined,
-): Comparison {
-	return compareComparableValues(a, b);
-}
-
-function equateStringsCaseInsensitive(a: string, b: string): boolean {
-	return (
-		a === b ||
-		(a !== undefined && b !== undefined && a.toUpperCase() === b.toUpperCase())
-	);
-}
-
-function endsWith(str: string, suffix: string, ignoreCase?: boolean): boolean {
-	const expectedPos = str.length - suffix.length;
-	return (
-		expectedPos >= 0 &&
-		(ignoreCase
-			? equateStringsCaseInsensitive(str.slice(expectedPos), suffix)
-			: str.indexOf(suffix, expectedPos) === expectedPos)
-	);
-}
-
-function fileExtensionIs(path: string, extension: string): boolean {
-	return path.length > extension.length && endsWith(path, extension);
-}
-
-function fileExtensionIsOneOf(
-	path: string,
-	extensions: readonly string[],
-): boolean {
-	for (const extension of extensions) {
-		if (fileExtensionIs(path, extension)) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-function findIndex<T>(
-	array: readonly T[] | undefined,
-	predicate: (element: T, index: number) => boolean,
-	startIndex?: number,
-): number {
-	if (array === undefined) {
-		return -1;
-	}
-	for (let i = startIndex ?? 0; i < array.length; i++) {
-		if (predicate(array[i], i)) {
-			return i;
-		}
-	}
-	return -1;
-}
-
-export function matchFiles(
-	path: string,
-	extensions: readonly string[] | undefined,
-	excludes: readonly string[] | undefined,
-	includes: readonly string[] | undefined,
-	useCaseSensitiveFileNames: boolean,
-	currentDirectory: string,
-	depth: number | undefined,
-	getFileSystemEntries: (path: string) => FileSystemEntries,
-	realpath: (path: string) => string,
-): string[] {
-	path = normalizePath(path);
-	currentDirectory = normalizePath(currentDirectory);
-
-	const patterns = getFileMatcherPatterns(
-		path,
-		excludes,
-		includes,
-		useCaseSensitiveFileNames,
-		currentDirectory,
-	);
-
-	const includeFileRegexes =
-		patterns.includeFilePatterns &&
-		patterns.includeFilePatterns.map((pattern) =>
-			getRegexFromPattern(pattern, useCaseSensitiveFileNames),
-		);
-	const includeDirectoryRegex =
-		patterns.includeDirectoryPattern &&
-		getRegexFromPattern(
-			patterns.includeDirectoryPattern,
-			useCaseSensitiveFileNames,
-		);
-	const excludeRegex =
-		patterns.excludePattern &&
-		getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames);
-
-	// Associate an array of results with each include regex. This keeps results in order of the "include" order.
-	// If there are no "includes", then just put everything in results[0].
-	const results: string[][] = includeFileRegexes
-		? includeFileRegexes.map(() => [])
-		: [[]];
-	const visited = new Map<string, true>();
-	const toCanonical = createGetCanonicalFileName(useCaseSensitiveFileNames);
-	for (const basePath of patterns.basePaths) {
-		visitDirectory(basePath, combinePaths(currentDirectory, basePath), depth);
-	}
-
-	return flatten(results);
-
-	function visitDirectory(
-		path: string,
-		absolutePath: string,
-		depth: number | undefined,
-	) {
-		const canonicalPath = toCanonical(realpath(absolutePath));
-		if (visited.has(canonicalPath)) {
-			return;
-		}
-		visited.set(canonicalPath, true);
-		const { files, directories } = getFileSystemEntries(path);
-
-		for (const current of toSorted<string>(
-			files,
-			compareStringsCaseSensitive,
-		)) {
-			const name = combinePaths(path, current);
-			const absoluteName = combinePaths(absolutePath, current);
-			if (extensions && !fileExtensionIsOneOf(name, extensions)) {
-				continue;
-			}
-			if (excludeRegex && excludeRegex.test(absoluteName)) {
-				continue;
-			}
-			if (!includeFileRegexes) {
-				results[0].push(name);
-			} else {
-				const includeIndex = findIndex(includeFileRegexes, (re) =>
-					re.test(absoluteName),
-				);
-				if (includeIndex !== -1) {
-					results[includeIndex].push(name);
-				}
-			}
-		}
-
-		if (depth !== undefined) {
-			depth--;
-			if (depth === 0) {
-				return;
-			}
-		}
-
-		for (const current of toSorted<string>(
-			directories,
-			compareStringsCaseSensitive,
-		)) {
-			const name = combinePaths(path, current);
-			const absoluteName = combinePaths(absolutePath, current);
-			if (
-				(!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
-				(!excludeRegex || !excludeRegex.test(absoluteName))
-			) {
-				visitDirectory(name, absoluteName, depth);
-			}
-		}
-	}
-}

From ea15be0a4179ead6b6d0e79d31637b5ed3e9e23c Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Wed, 31 Dec 2025 19:39:42 +0300
Subject: [PATCH 07/11] new package @flint.fyi/volar-language

---
 .../createTypeScriptFileFromProjectService.ts |  20 -
 packages/ts/src/createTypeScriptServerHost.ts | 148 ++++++
 packages/ts/src/index.ts                      |   7 +-
 packages/ts/src/language.ts                   | 432 ++++--------------
 .../src/openTypeScriptFileInProjectService.ts |  51 +++
 .../ts/src/prepareTypeScriptBasedLanguage.ts  | 219 ---------
 packages/ts/src/prepareTypeScriptFile.ts      |  14 -
 packages/volar-language/package.json          |  34 ++
 packages/volar-language/src/index.ts          | 431 +++++++++++++++++
 packages/volar-language/tsconfig.json         |  13 +
 packages/vue-language/package.json            |   1 +
 packages/vue-language/src/language.ts         | 338 +++++---------
 packages/vue-language/tsconfig.json           |   3 +-
 pnpm-lock.yaml                                |  24 +
 tsconfig.json                                 |   1 +
 15 files changed, 896 insertions(+), 840 deletions(-)
 delete mode 100644 packages/ts/src/createTypeScriptFileFromProjectService.ts
 create mode 100644 packages/ts/src/createTypeScriptServerHost.ts
 create mode 100644 packages/ts/src/openTypeScriptFileInProjectService.ts
 delete mode 100644 packages/ts/src/prepareTypeScriptBasedLanguage.ts
 delete mode 100644 packages/ts/src/prepareTypeScriptFile.ts
 create mode 100644 packages/volar-language/package.json
 create mode 100644 packages/volar-language/src/index.ts
 create mode 100644 packages/volar-language/tsconfig.json

diff --git a/packages/ts/src/createTypeScriptFileFromProjectService.ts b/packages/ts/src/createTypeScriptFileFromProjectService.ts
deleted file mode 100644
index 940cf4ac6..000000000
--- a/packages/ts/src/createTypeScriptFileFromProjectService.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import * as ts from "typescript";
-
-export function createTypeScriptFileFromProjectService(
-	filePathAbsolute: string,
-	program: ts.Program,
-	service: ts.server.ProjectService,
-) {
-	const sourceFile = program.getSourceFile(filePathAbsolute);
-	if (!sourceFile) {
-		throw new Error(`Could not retrieve source file for: ${filePathAbsolute}`);
-	}
-
-	return {
-		program,
-		sourceFile,
-		[Symbol.dispose]() {
-			service.closeClientFile(filePathAbsolute);
-		},
-	};
-}
diff --git a/packages/ts/src/createTypeScriptServerHost.ts b/packages/ts/src/createTypeScriptServerHost.ts
new file mode 100644
index 000000000..bc5468e7d
--- /dev/null
+++ b/packages/ts/src/createTypeScriptServerHost.ts
@@ -0,0 +1,148 @@
+import { LinterHost } from "@flint.fyi/core";
+import ts from "typescript";
+import fs from "node:fs";
+import path from "node:path";
+import assert from "node:assert/strict";
+
+function notImplemented(methodName: string): any {
+	throw new Error(
+		`Flint bug: ts.System's method '${methodName}' is not implemented.`,
+	);
+}
+
+// https://github.com/nodejs/node/blob/7b7f693a98da060e19f2ec12fb99997d5d5524f9/deps/uv/include/uv.h#L1260-L1269
+const UV_DIRENT_TYPE = {
+	UV_DIRENT_UNKNOWN: 0,
+	UV_DIRENT_FILE: 1,
+	UV_DIRENT_DIR: 1,
+};
+
+const DirentCtor = fs.Dirent as {
+	// https://github.com/nodejs/node/blob/7b7f693a98da060e19f2ec12fb99997d5d5524f9/lib/internal/fs/utils.js#L160
+	new (name: string, type: number, parentPath: string): fs.Dirent;
+};
+
+export function createTypeScriptServerHost(
+	host: LinterHost,
+): ts.server.ServerHost {
+	return {
+		...ts.sys,
+		args: [],
+		write() {
+			notImplemented("write");
+		},
+		writeFile() {
+			notImplemented("writeFile");
+		},
+		createDirectory() {
+			notImplemented("createDirectory");
+		},
+		exit() {
+			notImplemented("exit");
+		},
+		readFile(filePath) {
+			return host.readFile(path.resolve(host.getCurrentDirectory(), filePath));
+		},
+		directoryExists(directoryPath) {
+			return (
+				host.stat(path.resolve(host.getCurrentDirectory(), directoryPath)) ===
+				"directory"
+			);
+		},
+		fileExists(filePath) {
+			return (
+				host.stat(path.resolve(host.getCurrentDirectory(), filePath)) === "file"
+			);
+		},
+		readDirectory(directoryPath, extensions, exclude, include, depth) {
+			const originalCwd = process.cwd;
+			process.cwd = () => host.getCurrentDirectory();
+			const originalReadDirSync = fs.readdirSync;
+			// @ts-expect-error - TypeScript doesn't understand that the overloads do match up.
+			const patchedReaddirSync: typeof fs.readdirSync = (readPath, options) => {
+				assert.deepEqual(
+					options,
+					{ withFileTypes: true },
+					"Flint bug: ts.sys.readDirectory passed unexpected options to fs.readdirSync",
+				);
+				assert.ok(
+					typeof readPath === "string",
+					"Flint bug: ts.sys.readDirectory passed unexpected path to fs.readdirSync",
+				);
+				try {
+					fs.readdirSync = originalReadDirSync;
+					return host
+						.readDirectory(path.resolve(host.getCurrentDirectory(), readPath))
+						.map(
+							(dirent) =>
+								new DirentCtor(
+									dirent.name,
+									dirent.type === "file"
+										? UV_DIRENT_TYPE.UV_DIRENT_FILE
+										: UV_DIRENT_TYPE.UV_DIRENT_DIR,
+									readPath,
+								),
+						);
+				} finally {
+					fs.readdirSync = patchedReaddirSync;
+				}
+			};
+			fs.readdirSync = patchedReaddirSync;
+			try {
+				return ts.sys.readDirectory(
+					directoryPath,
+					extensions,
+					exclude,
+					include,
+					depth,
+				);
+			} finally {
+				process.cwd = originalCwd;
+				fs.readdirSync = originalReadDirSync;
+			}
+		},
+		setImmediate,
+		setTimeout,
+		clearImmediate,
+		clearTimeout,
+		watchFile(filePath, callback) {
+			const watcher = host.watchFile(
+				path.resolve(host.getCurrentDirectory(), filePath),
+				(event) => {
+					let eventKind: ts.FileWatcherEventKind;
+					switch (event) {
+						case "created":
+							eventKind = ts.FileWatcherEventKind.Created;
+							break;
+						case "changed":
+							eventKind = ts.FileWatcherEventKind.Changed;
+							break;
+						case "deleted":
+							eventKind = ts.FileWatcherEventKind.Deleted;
+							break;
+					}
+					callback(filePath, eventKind);
+				},
+			);
+			return {
+				close() {
+					watcher[Symbol.dispose]();
+				},
+			};
+		},
+		watchDirectory(directoryPath, callback, recursive = false) {
+			const watcher = host.watchDirectory(
+				path.resolve(host.getCurrentDirectory(), directoryPath),
+				recursive,
+				(filePathAbsolute) => {
+					callback(filePathAbsolute);
+				},
+			);
+			return {
+				close() {
+					watcher[Symbol.dispose]();
+				},
+			};
+		},
+	};
+}
diff --git a/packages/ts/src/index.ts b/packages/ts/src/index.ts
index cc4b80ff5..e55dd03cc 100644
--- a/packages/ts/src/index.ts
+++ b/packages/ts/src/index.ts
@@ -11,12 +11,7 @@ export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { TSNodesByName } from "./nodes.js";
 export { ts } from "./plugin.js";
-export {
-	prepareTypeScriptBasedLanguage,
-	TypeScriptBasedLanguageFile,
-	TypeScriptBasedLanguageFileFactoryDefinition,
-} from "./prepareTypeScriptBasedLanguage.js";
-export { prepareTypeScriptFile } from "./prepareTypeScriptFile.js";
+export { DisposableTypeScriptFile } from "./openTypeScriptFileInProjectService.js";
 export { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
 export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
 export { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
diff --git a/packages/ts/src/language.ts b/packages/ts/src/language.ts
index d6d5a22f1..1613a2b14 100644
--- a/packages/ts/src/language.ts
+++ b/packages/ts/src/language.ts
@@ -1,43 +1,17 @@
-import {
-	AnyLevelDeep,
-	AnyRuleDefinition,
-	flatten,
-	createLanguage,
-	Language,
-	RuleReporter,
-	LanguageFileCacheImpacts,
-	LanguageDiagnostics,
-	CommentDirective,
-	NormalizedReport,
-	RuleContext,
-	FileReport,
-	SourceFileWithLineMap,
-	CharacterReportRange,
-	NormalizedReportRangeObject,
-	getColumnAndLineOfPosition,
-	RuleReport,
-	isSuggestionForFiles,
-} from "@flint.fyi/core";
-import { setTSProgramCreationProxy } from "@flint.fyi/ts-patch";
+import { createLanguage, LanguagePreparedDefinition } from "@flint.fyi/core";
 import * as ts from "typescript";
-import {
-	LanguagePlugin as VolarLanguagePlugin,
-	Language as VolarLanguage,
-	Mapper as VolarMapper,
-	SourceScript as VolarSourceScript,
-} from "@volar/language-core";
+import path from "node:path";
+import assert from "node:assert/strict";
 
 import { TSNodesByName } from "./nodes.js";
+import { createProjectService } from "@typescript-eslint/project-service";
+import { createTypeScriptServerHost } from "./createTypeScriptServerHost.js";
+import { parseDirectivesFromTypeScriptFile } from "./directives/parseDirectivesFromTypeScriptFile.js";
 import {
-	prepareTypeScriptBasedLanguage,
-	TypeScriptBasedLanguageFile,
-} from "./prepareTypeScriptBasedLanguage.js";
-import { prepareTypeScriptFile } from "./prepareTypeScriptFile.js";
-import { proxyCreateProgram } from "@volar/typescript/lib/node/proxyCreateProgram.js";
-
-// for LanguagePlugin interface augmentation
-import "@volar/typescript";
-import { NodeSyntaxKinds } from "./createTypeScriptFileFromProgram.js";
+	DisposableTypeScriptFile,
+	openTypeScriptFileInProjectService,
+} from "./openTypeScriptFileInProjectService.js";
+import { createTypeScriptFileFromProgram } from "./createTypeScriptFileFromProgram.js";
 
 export interface TypeScriptFileServices {
 	program: ts.Program;
@@ -45,91 +19,40 @@ export interface TypeScriptFileServices {
 	typeChecker: ts.TypeChecker;
 }
 
-type VolarLanguagePluginInitializer = (
-	ts: typeof import("typescript"),
-	options: ts.CreateProgramOptions,
-) => {
-	languagePlugins: AnyLevelDeep<VolarLanguagePlugin<string>>;
-	prepareFile: (
-		filePathAbsolute: string,
-		tsFile: TypeScriptBasedLanguageFile,
-		sourceScript: VolarSourceScript<string> & {
-			generated: NonNullable<VolarSourceScript<string>["generated"]>;
-		},
-	) => {
-		directives?: CommentDirective[];
-		reports?: FileReport[];
-		cache?: LanguageFileCacheImpacts;
-		getDiagnostics?(): LanguageDiagnostics;
-		extraContext?: (
-			reportTranslated: RuleReporter<string>,
-		) => Record<string, unknown>;
-	};
-};
-const volarLanguagePluginInitializers =
-	new Set<VolarLanguagePluginInitializer>();
-
-type ProxiedTSProgram = ts.Program & {
-	__flintVolarLanguage?: undefined | VolarLanguage<string>;
-};
-
-setTSProgramCreationProxy(
-	(ts, createProgram) =>
-		new Proxy(function () {} as unknown as typeof createProgram, {
-			apply(target, thisArg, args) {
-				let volarLanguage = null as null | VolarLanguage<string>;
-				const proxied = proxyCreateProgram(ts, createProgram, (ts, options) => {
-					const languagePlugins = Array.from(volarLanguagePluginInitializers)
-						.map((initializer) => initializer(ts, options))
-						.map(({ languagePlugins, prepareFile }) =>
-							flatten(languagePlugins).map((plugin) => {
-								plugin.__flintPrepareFile = prepareFile;
-								if (plugin.typescript == null) {
-									return plugin;
-								}
-
-								const { getServiceScript } = plugin.typescript;
-								plugin.typescript.getServiceScript = (root) => {
-									const script = getServiceScript(root);
-									if (script == null) {
-										return script;
-									}
-									return {
-										...script,
-										// Leading offset is useful for LanguageService [1], but we don't use it.
-										// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
-										// have to provide it ourselves.
-										//
-										// [1] https://github.com/volarjs/volar.js/discussions/188
-										// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
-										preventLeadingOffset: true,
-									};
-								};
-
-								return plugin;
-							}),
-						);
-					return {
-						languagePlugins: flatten(languagePlugins),
-						setup: (lang) => (volarLanguage = lang),
-					};
-				});
-
-				const program: ProxiedTSProgram = Reflect.apply(proxied, thisArg, args);
-
-				if (volarLanguage == null) {
-					throw new Error("Flint bug: volarLanguage is not defined");
-				}
-
-				if (program.__flintVolarLanguage != null) {
-					return program;
-				}
+let volarPrepareFile:
+	| ((
+			filePathAbsolute: string,
+			tsFile: DisposableTypeScriptFile,
+	  ) => LanguagePreparedDefinition)
+	| null;
+export function setVolarPrepareFile(
+	prepare: NonNullable<typeof volarPrepareFile>,
+) {
+	assert.ok(
+		volarPrepareFile == null,
+		`setVolarPrepareFile was called twice. Please ensure that you don't have two copies of @flint.fyi/volar-language in you dependency tree.`,
+	);
+	volarPrepareFile = prepare;
+}
 
-				program.__flintVolarLanguage = volarLanguage;
-				return program;
-			},
-		}),
-);
+function isTypeScriptCoreSupportedExtension(extname: string) {
+	switch (extname) {
+		case ".ts":
+		case ".tsx":
+		case ".d.ts":
+		case ".js":
+		case ".jsx":
+		case ".cts":
+		case ".d.cts":
+		case ".cjs":
+		case ".mts":
+		case ".d.mts":
+		case ".mjs":
+			return true;
+		default:
+			return false;
+	}
+}
 
 export const typescriptLanguage = createLanguage<
 	TSNodesByName,
@@ -139,248 +62,53 @@ export const typescriptLanguage = createLanguage<
 		name: "TypeScript",
 	},
 	prepare: (host) => {
-		const lang = prepareTypeScriptBasedLanguage(host);
+		const { service } = createProjectService({
+			host: createTypeScriptServerHost(host),
+		});
 
 		return {
 			prepareFile(filePathAbsolute) {
-				const tsFile = lang.createFile(filePathAbsolute);
-
-				const volarLanguage = (tsFile.program as ProxiedTSProgram)
-					.__flintVolarLanguage;
-
-				if (volarLanguage != null) {
-					const sourceScript = volarLanguage.scripts.get(
-						tsFile.sourceFile.fileName,
-					);
-
-					if (sourceScript != null) {
-						const prepareFile =
-							sourceScript.generated?.languagePlugin?.__flintPrepareFile;
-						if (sourceScript.generated != null && prepareFile != null) {
-							if (sourceScript.snapshot == null) {
-								throw new Error("Expected sourceScript.snapshot to be set");
-							}
-							if (sourceScript.generated.languagePlugin.typescript == null) {
-								throw new Error(
-									"Expected sourceScript.generated.languagePlugin.typescript to be set",
-								);
-							}
+				const tsFile = openTypeScriptFileInProjectService(
+					service,
+					filePathAbsolute,
+				);
 
-							const sourceText = sourceScript.snapshot.getText(
-								0,
-								sourceScript.snapshot.getLength(),
-							);
-							const sourceTextWithLineMap: SourceFileWithLineMap = {
-								text: sourceText,
-							};
-							function normalizeSourceRange(
-								range: CharacterReportRange,
-							): NormalizedReportRangeObject {
-								return {
-									begin: getColumnAndLineOfPosition(
-										sourceTextWithLineMap,
-										range.begin,
-									),
-									end: getColumnAndLineOfPosition(
-										sourceTextWithLineMap,
-										range.end,
-									),
-								};
-							}
+				const fileExtension = path.extname(tsFile.sourceFile.fileName);
 
-							const serviceScript =
-								sourceScript.generated.languagePlugin.typescript.getServiceScript(
-									sourceScript.generated.root,
-								);
-							if (serviceScript == null) {
-								throw new Error("Expected serviceScript to exist");
-							}
-
-							const map = volarLanguage.maps.get(
-								serviceScript.code,
-								sourceScript,
-							);
-							const sortedMappings = map.mappings.toSorted(
-								(a, b) => a.generatedOffsets[0] - b.generatedOffsets[0],
-							);
-							const {
-								directives,
-								reports,
-								extraContext,
-								getDiagnostics,
-								cache,
-							} = (
-								prepareFile as ReturnType<VolarLanguagePluginInitializer>["prepareFile"]
-							)(filePathAbsolute, tsFile, sourceScript);
-
-							return {
-								directives,
-								reports,
-								file: {
-									cache,
-									getDiagnostics,
-									async runRule(rule, options) {
-										const reports: NormalizedReport[] = [];
-										const context = {
-											program: tsFile.program,
-											sourceFile: tsFile.sourceFile,
-											typeChecker: tsFile.program.getTypeChecker(),
-											report: (report) => {
-												const reportRange = translateRange(
-													map,
-													report.range.begin,
-													report.range.end,
-												);
-												if (reportRange == null) {
-													return;
-												}
-
-												const translatedReport: NormalizedReport = {
-													...report,
-													fix:
-														report.fix && !Array.isArray(report.fix)
-															? [report.fix]
-															: report.fix,
-													message: rule.messages[report.message],
-													range: normalizeSourceRange(reportRange),
-												};
-
-												for (const suggestion of translatedReport.suggestions ??
-													[]) {
-													if (isSuggestionForFiles(suggestion)) {
-														throw new Error(
-															"TODO: vue - suggestions for multiple files are not yet supported",
-														);
-													}
-													const range = translateRange(
-														map,
-														suggestion.range.begin,
-														suggestion.range.end,
-													);
-													if (range == null) {
-														// TODO: maybe we should filter out these suggestions intead of erroring?
-														throw new Error(
-															"Suggestion range overlaps with virtual code",
-														);
-													}
-													suggestion.range = range;
-												}
-
-												reports.push(translatedReport);
-											},
-											...extraContext?.((report: RuleReport) => {
-												reports.push({
-													...report,
-													fix:
-														report.fix && !Array.isArray(report.fix)
-															? [report.fix]
-															: report.fix,
-													message: rule.messages[report.message],
-													range: normalizeSourceRange(report.range),
-												});
-											}),
-										} satisfies TypeScriptFileServices & RuleContext<string>;
-
-										const runtime = await rule.setup(context, options);
-
-										if (runtime?.visitors) {
-											const { visitors } = runtime;
-											let lastMappingIdx = 0;
-											const visit = (node: ts.Node) => {
-												visitors[NodeSyntaxKinds[node.kind]]?.(node, context);
-
-												node.forEachChild(visit);
-											};
-											// Visit only statements that have a mapping to the source code
-											// to avoid doing extra work
-											Statements: for (const statement of tsFile.sourceFile
-												.statements) {
-												while (true) {
-													const currentMapping = sortedMappings[lastMappingIdx];
-													if (currentMapping == null) {
-														break Statements;
-													}
-													const currentMappingLength =
-														currentMapping.generatedLengths?.[0] ??
-														currentMapping.lengths[0];
-													if (
-														currentMappingLength === 0 ||
-														statement.pos >=
-															currentMapping.generatedOffsets[0] +
-																currentMappingLength
-													) {
-														lastMappingIdx++;
-														continue;
-													}
-													if (
-														statement.end <= currentMapping.generatedOffsets[0]
-													) {
-														continue Statements;
-													}
-													break;
-												}
-
-												visit(statement);
-											}
-											visit(tsFile.sourceFile.endOfFileToken);
-										}
-
-										await runtime?.teardown?.();
+				if (isTypeScriptCoreSupportedExtension(fileExtension)) {
+					return {
+						...parseDirectivesFromTypeScriptFile(tsFile.sourceFile),
+						file: {
+							[Symbol.dispose]: tsFile[Symbol.dispose],
+							...createTypeScriptFileFromProgram(
+								tsFile.program,
+								tsFile.sourceFile,
+							),
+						},
+					};
+				}
 
-										return reports;
-									},
-									[Symbol.dispose]() {
-										tsFile[Symbol.dispose]?.();
-									},
-								},
-							};
-						}
+				if (volarPrepareFile == null) {
+					let message = "Unknown extension.";
+					switch (fileExtension) {
+						case ".astro":
+							message = "Did you install @flint.fyi/astro?";
+							break;
+						case ".mdx":
+							message = "Did you install @flint.fyi/mdx?";
+							break;
+						case ".vue":
+							message = "Did you install @flint.fyi/vue?";
+							break;
 					}
+
+					throw new Error(
+						`Cannot process ${tsFile.sourceFile.fileName}. ${message}`,
+					);
 				}
 
-				return prepareTypeScriptFile(tsFile);
+				return volarPrepareFile(filePathAbsolute, tsFile);
 			},
 		};
 	},
 });
-
-export function createTypeScriptBasedLanguage<
-	AstNodesByName,
-	ContextServices extends object,
->(initializer: VolarLanguagePluginInitializer) {
-	volarLanguagePluginInitializers.add(initializer);
-	const language: Language<AstNodesByName, ContextServices> = {
-		createRule: (ruleDefinition: AnyRuleDefinition) => {
-			return {
-				...ruleDefinition,
-				language: typescriptLanguage,
-			};
-		},
-
-		prepare(host) {
-			throw new Error(
-				"Flint bug: TypeScript based language should never be prepared",
-			);
-		},
-	};
-
-	return language;
-}
-
-export function translateRange(
-	map: VolarMapper,
-	serviceBegin: number,
-	serviceEnd: number,
-): null | { begin: number; end: number } {
-	for (const [begin, end] of map.toSourceRange(
-		serviceBegin,
-		serviceEnd,
-		true,
-	)) {
-		if (begin === end) {
-			continue;
-		}
-		return { begin, end };
-	}
-	return null;
-}
diff --git a/packages/ts/src/openTypeScriptFileInProjectService.ts b/packages/ts/src/openTypeScriptFileInProjectService.ts
new file mode 100644
index 000000000..909cd1ead
--- /dev/null
+++ b/packages/ts/src/openTypeScriptFileInProjectService.ts
@@ -0,0 +1,51 @@
+import { debugForFile } from "debug-for-file";
+import ts from "typescript";
+
+const log = debugForFile(import.meta.filename);
+
+export interface DisposableTypeScriptFile extends Disposable {
+	program: ts.Program;
+	sourceFile: ts.SourceFile;
+}
+
+export function openTypeScriptFileInProjectService(
+	service: ts.server.ProjectService,
+	filePathAbsolute: string,
+): DisposableTypeScriptFile {
+	log("Opening client file:", filePathAbsolute);
+	service.openClientFile(filePathAbsolute);
+
+	log("Retrieving client services:", filePathAbsolute);
+	const scriptInfo = service.getScriptInfo(filePathAbsolute);
+	if (!scriptInfo) {
+		throw new Error(`Could not find script info for file: ${filePathAbsolute}`);
+	}
+
+	const defaultProject = service.getDefaultProjectForFile(
+		scriptInfo.fileName,
+		true,
+	);
+	if (!defaultProject) {
+		throw new Error(
+			`Could not find default project for file: ${filePathAbsolute}`,
+		);
+	}
+
+	const program = defaultProject.getLanguageService(true).getProgram();
+	if (!program) {
+		throw new Error(`Could not retrieve program for file: ${filePathAbsolute}`);
+	}
+
+	const sourceFile = program.getSourceFile(filePathAbsolute);
+	if (!sourceFile) {
+		throw new Error(`Could not retrieve source file for: ${filePathAbsolute}`);
+	}
+
+	return {
+		program,
+		sourceFile,
+		[Symbol.dispose]() {
+			service.closeClientFile(filePathAbsolute);
+		},
+	};
+}
diff --git a/packages/ts/src/prepareTypeScriptBasedLanguage.ts b/packages/ts/src/prepareTypeScriptBasedLanguage.ts
deleted file mode 100644
index 5faa7f569..000000000
--- a/packages/ts/src/prepareTypeScriptBasedLanguage.ts
+++ /dev/null
@@ -1,219 +0,0 @@
-import { createProjectService } from "@typescript-eslint/project-service";
-import { CachedFactory } from "cached-factory";
-import { debugForFile } from "debug-for-file";
-import path from "node:path";
-import fs from "node:fs";
-import assert from "node:assert/strict";
-import * as ts from "typescript";
-
-import { createTypeScriptFileFromProjectService } from "./createTypeScriptFileFromProjectService.js";
-import { LinterHost } from "@flint.fyi/core";
-
-const log = debugForFile(import.meta.filename);
-
-export interface TypeScriptBasedLanguageFile extends Partial<Disposable> {
-	program: ts.Program;
-	sourceFile: ts.SourceFile;
-}
-
-export interface TypeScriptBasedLanguageFileFactoryDefinition {
-	createFile(filePathAbsolute: string): TypeScriptBasedLanguageFile;
-}
-
-function notImplemented(methodName: string): any {
-	throw new Error(
-		`Flint bug: ts.System's method '${methodName}' is not implemented.`,
-	);
-}
-
-// https://github.com/nodejs/node/blob/7b7f693a98da060e19f2ec12fb99997d5d5524f9/deps/uv/include/uv.h#L1260-L1269
-const UV_DIRENT_TYPE = {
-	UV_DIRENT_UNKNOWN: 0,
-	UV_DIRENT_FILE: 1,
-	UV_DIRENT_DIR: 1,
-};
-
-const DirentCtor = fs.Dirent as {
-	// https://github.com/nodejs/node/blob/7b7f693a98da060e19f2ec12fb99997d5d5524f9/lib/internal/fs/utils.js#L160
-	new (name: string, type: number, parentPath: string): fs.Dirent;
-};
-
-export function prepareTypeScriptBasedLanguage(
-	host: LinterHost,
-): TypeScriptBasedLanguageFileFactoryDefinition {
-	const { service } = createProjectService({
-		host: {
-			...ts.sys,
-			args: [],
-			write() {
-				notImplemented("write");
-			},
-			writeFile() {
-				notImplemented("writeFile");
-			},
-			createDirectory() {
-				notImplemented("createDirectory");
-			},
-			exit() {
-				notImplemented("exit");
-			},
-			readFile(filePath) {
-				return host.readFile(
-					path.resolve(host.getCurrentDirectory(), filePath),
-				);
-			},
-			directoryExists(directoryPath) {
-				return (
-					host.stat(path.resolve(host.getCurrentDirectory(), directoryPath)) ===
-					"directory"
-				);
-			},
-			fileExists(filePath) {
-				return (
-					host.stat(path.resolve(host.getCurrentDirectory(), filePath)) ===
-					"file"
-				);
-			},
-			readDirectory(directoryPath, extensions, exclude, include, depth) {
-				const originalCwd = process.cwd;
-				process.cwd = () => host.getCurrentDirectory();
-				const originalReadDirSync = fs.readdirSync;
-				// @ts-expect-error - TypeScript doesn't understand that the overloads do match up.
-				const patchedReaddirSync: typeof fs.readdirSync = (
-					readPath,
-					options,
-				) => {
-					assert.deepEqual(
-						options,
-						{ withFileTypes: true },
-						"Flint bug: ts.sys.readDirectory passed unexpected options to fs.readdirSync",
-					);
-					assert.ok(
-						typeof readPath === "string",
-						"Flint bug: ts.sys.readDirectory passed unexpected path to fs.readdirSync",
-					);
-					fs.readdirSync = originalReadDirSync;
-					try {
-						return host
-							.readDirectory(readPath)
-							.map(
-								(dirent) =>
-									new DirentCtor(
-										dirent.name,
-										dirent.type === "file"
-											? UV_DIRENT_TYPE.UV_DIRENT_FILE
-											: UV_DIRENT_TYPE.UV_DIRENT_DIR,
-										readPath,
-									),
-							);
-					} finally {
-						fs.readdirSync = patchedReaddirSync;
-					}
-				};
-				fs.readdirSync = patchedReaddirSync;
-				try {
-					return ts.sys.readDirectory(
-						directoryPath,
-						extensions,
-						exclude,
-						include,
-						depth,
-					);
-				} finally {
-					process.cwd = originalCwd;
-					fs.readdirSync = originalReadDirSync;
-				}
-			},
-			setImmediate,
-			setTimeout,
-			clearImmediate,
-			clearTimeout,
-			watchFile(filePath, callback) {
-				const watcher = host.watchFile(
-					path.resolve(host.getCurrentDirectory(), filePath),
-					(event) => {
-						let eventKind: ts.FileWatcherEventKind;
-						switch (event) {
-							case "created":
-								eventKind = ts.FileWatcherEventKind.Created;
-								break;
-							case "changed":
-								eventKind = ts.FileWatcherEventKind.Changed;
-								break;
-							case "deleted":
-								eventKind = ts.FileWatcherEventKind.Deleted;
-								break;
-						}
-						callback(filePath, eventKind);
-					},
-				);
-				return {
-					close() {
-						watcher[Symbol.dispose]();
-					},
-				};
-			},
-			watchDirectory(directoryPath, callback, recursive = false) {
-				const watcher = host.watchDirectory(
-					path.resolve(host.getCurrentDirectory(), directoryPath),
-					recursive,
-					(filePathAbsolute) => {
-						callback(filePathAbsolute);
-					},
-				);
-				return {
-					close() {
-						watcher[Symbol.dispose]();
-					},
-				};
-			},
-		},
-	});
-
-	return {
-		createFile: (filePathAbsolute) => {
-			log("Opening client file:", filePathAbsolute);
-			service.openClientFile(filePathAbsolute);
-
-			log("Retrieving client services:", filePathAbsolute);
-			const scriptInfo = service.getScriptInfo(filePathAbsolute);
-			if (!scriptInfo) {
-				throw new Error(
-					`Could not find script info for file: ${filePathAbsolute}`,
-				);
-			}
-
-			const defaultProject = service.getDefaultProjectForFile(
-				scriptInfo.fileName,
-				true,
-			);
-			if (!defaultProject) {
-				throw new Error(
-					`Could not find default project for file: ${filePathAbsolute}`,
-				);
-			}
-
-			const program = defaultProject.getLanguageService(true).getProgram();
-			if (!program) {
-				throw new Error(
-					`Could not retrieve program for file: ${filePathAbsolute}`,
-				);
-			}
-
-			const sourceFile = program.getSourceFile(filePathAbsolute);
-			if (!sourceFile) {
-				throw new Error(
-					`Could not retrieve source file for: ${filePathAbsolute}`,
-				);
-			}
-
-			return {
-				program,
-				sourceFile,
-				[Symbol.dispose]() {
-					service.closeClientFile(filePathAbsolute);
-				},
-			};
-		},
-	};
-}
diff --git a/packages/ts/src/prepareTypeScriptFile.ts b/packages/ts/src/prepareTypeScriptFile.ts
deleted file mode 100644
index e2a294ad9..000000000
--- a/packages/ts/src/prepareTypeScriptFile.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { createTypeScriptFileFromProgram } from "./createTypeScriptFileFromProgram.js";
-import { parseDirectivesFromTypeScriptFile } from "./directives/parseDirectivesFromTypeScriptFile.js";
-import { TypeScriptBasedLanguageFile } from "./prepareTypeScriptBasedLanguage.js";
-
-export function prepareTypeScriptFile(file: TypeScriptBasedLanguageFile) {
-	const { program, sourceFile, [Symbol.dispose]: onDispose } = file;
-	return {
-		...parseDirectivesFromTypeScriptFile(sourceFile),
-		file: {
-			...(onDispose != null && { [Symbol.dispose]: onDispose }),
-			...createTypeScriptFileFromProgram(program, sourceFile),
-		},
-	};
-}
diff --git a/packages/volar-language/package.json b/packages/volar-language/package.json
new file mode 100644
index 000000000..3f124bb5c
--- /dev/null
+++ b/packages/volar-language/package.json
@@ -0,0 +1,34 @@
+{
+	"name": "@flint.fyi/volar-language",
+	"version": "0.0.1",
+	"description": "[Experimental] TypeScript language plugin for Flint.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/JoshuaKGoldberg/flint",
+		"directory": "packages/ts"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "JoshuaKGoldberg",
+		"email": "npm@joshuakgoldberg.com"
+	},
+	"type": "module",
+	"exports": {
+		".": "./lib/index.js"
+	},
+	"dependencies": {
+		"@flint.fyi/core": "workspace:",
+		"@flint.fyi/ts": "workspace:",
+		"@flint.fyi/ts-patch": "workspace:",
+		"@volar/language-core": "2.4.27",
+		"@volar/typescript": "2.4.27",
+		"typescript": ">=5.9.3"
+	},
+	"engines": {
+		"node": ">=24.0.0"
+	},
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	}
+}
diff --git a/packages/volar-language/src/index.ts b/packages/volar-language/src/index.ts
new file mode 100644
index 000000000..e92e29b29
--- /dev/null
+++ b/packages/volar-language/src/index.ts
@@ -0,0 +1,431 @@
+import {
+	AnyLevelDeep,
+	flatten,
+	RuleReporter,
+	LanguageFileCacheImpacts,
+	LanguageDiagnostics,
+	FileReport,
+	SourceFileWithLineMap,
+	CharacterReportRange,
+	NormalizedReportRangeObject,
+	getColumnAndLineOfPosition,
+	NormalizedReport,
+	RuleContext,
+	isSuggestionForFiles,
+	Language,
+	AnyRuleDefinition,
+	CreateRule,
+	DirectivesCollector,
+} from "@flint.fyi/core";
+import assert from "node:assert/strict";
+import { setTSProgramCreationProxy } from "@flint.fyi/ts-patch";
+import { proxyCreateProgram } from "@volar/typescript/lib/node/proxyCreateProgram.js";
+// for LanguagePlugin interface augmentation
+import "@volar/typescript";
+import ts from "typescript";
+
+import {
+	convertTypeScriptDiagnosticToLanguageFileDiagnostic,
+	DisposableTypeScriptFile,
+	extractDirectivesFromTypeScriptFile,
+	ExtractedDirective,
+	NodeSyntaxKinds,
+	setVolarPrepareFile,
+	TSNodesByName,
+	TypeScriptFileServices,
+	typescriptLanguage,
+} from "@flint.fyi/ts";
+
+import {
+	LanguagePlugin as VolarLanguagePlugin,
+	Language as VolarLanguage,
+	Mapper as VolarMapper,
+	SourceScript as VolarSourceScript,
+} from "@volar/language-core";
+import { TypeScriptServiceScript as VolarTypeScriptServiceScript } from "@volar/typescript";
+
+type VolarLanguagePluginInitializer<ContextServices extends object> = (
+	ts: typeof import("typescript"),
+	options: ts.CreateProgramOptions,
+) => {
+	languagePlugins: AnyLevelDeep<VolarLanguagePlugin<string>>;
+	prepareFile: VolarBasedLanguagePrepareFile<ContextServices>;
+};
+const volarLanguagePluginInitializers = new Set<
+	VolarLanguagePluginInitializer<object>
+>();
+
+type ProxiedTSProgram = ts.Program & {
+	__flintVolarLanguage?: undefined | VolarLanguage<string>;
+};
+
+export type VolarBasedLanguagePrepareFile<ContextServices extends object> = (
+	filePathAbsolute: string,
+	tsFile: DisposableTypeScriptFile,
+	volarLanguage: VolarLanguage,
+	sourceScript: VolarSourceScript<string> & {
+		generated: NonNullable<VolarSourceScript<string>["generated"]>;
+	},
+	serviceScript: VolarTypeScriptServiceScript,
+) => {
+	directives?: ExtractedDirective[];
+	firstStatementPosition: number;
+	reports?: FileReport[];
+	cache?: LanguageFileCacheImpacts;
+	getDiagnostics?(): LanguageDiagnostics;
+	extraContext: (reportTranslated: RuleReporter<string>) => ContextServices;
+};
+
+type VolarLanguagePluginWithPrepareFile = VolarLanguagePlugin & {
+	__flintPrepareFile?: VolarBasedLanguagePrepareFile<object> | undefined;
+};
+
+setTSProgramCreationProxy(
+	(ts, createProgram) =>
+		new Proxy(function () {} as unknown as typeof createProgram, {
+			apply(target, thisArg, args) {
+				let volarLanguage = null as null | VolarLanguage<string>;
+				const proxied = proxyCreateProgram(ts, createProgram, (ts, options) => {
+					const languagePlugins = Array.from(volarLanguagePluginInitializers)
+						.map((initializer) => initializer(ts, options))
+						.map(({ languagePlugins, prepareFile }) =>
+							flatten(languagePlugins).map((plugin) => {
+								(
+									plugin as VolarLanguagePluginWithPrepareFile
+								).__flintPrepareFile = prepareFile;
+								if (plugin.typescript == null) {
+									return plugin;
+								}
+
+								const { getServiceScript } = plugin.typescript;
+								plugin.typescript.getServiceScript = (root) => {
+									const script = getServiceScript(root);
+									if (script == null) {
+										return script;
+									}
+									return {
+										...script,
+										// Leading offset is useful for LanguageService [1], but we don't use it.
+										// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
+										// have to provide it ourselves.
+										//
+										// [1] https://github.com/volarjs/volar.js/discussions/188
+										// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
+										preventLeadingOffset: true,
+									};
+								};
+
+								return plugin;
+							}),
+						);
+					return {
+						languagePlugins: flatten(languagePlugins),
+						setup: (lang) => (volarLanguage = lang),
+					};
+				});
+
+				const program: ProxiedTSProgram = Reflect.apply(proxied, thisArg, args);
+
+				if (volarLanguage == null) {
+					throw new Error("Flint bug: volarLanguage is not defined");
+				}
+
+				if (program.__flintVolarLanguage != null) {
+					return program;
+				}
+
+				program.__flintVolarLanguage = volarLanguage;
+				return program;
+			},
+		}),
+);
+
+setVolarPrepareFile(
+	(
+		filePathAbsolute,
+		{ program, sourceFile, [Symbol.dispose]: disposeFile },
+	) => {
+		const volarLanguage = (program as ProxiedTSProgram).__flintVolarLanguage;
+		assert.ok(
+			volarLanguage != null,
+			`Flint bug: TypeScript wasn't proxied with Volar.js`,
+		);
+
+		const sourceScript = volarLanguage.scripts.get(sourceFile.fileName);
+
+		assert.ok(
+			sourceScript != null,
+			`Flint bug: Volar.js source script for ${sourceFile.fileName} is undefined`,
+		);
+		assert.ok(
+			sourceScript.generated != null,
+			`Flint bug: Volar.js sourceScript.generated for ${sourceFile.fileName} is undefined`,
+		);
+		assert.ok(
+			sourceScript.generated.languagePlugin.typescript != null,
+			`Flint bug: Volar.js sourceScript.generated.languagePlugin.typescript for ${sourceFile.fileName} is undefined`,
+		);
+
+		const prepareFile = (
+			sourceScript.generated
+				.languagePlugin as VolarLanguagePluginWithPrepareFile
+		).__flintPrepareFile;
+		assert.ok(
+			prepareFile != null,
+			`Flint bug: Volar.js language plugin for script (${sourceFile.fileName}) with language id ${sourceScript.generated.root.languageId} doesn't have __flintPrepareFile function`,
+		);
+
+		const sourceText = sourceScript.snapshot.getText(
+			0,
+			sourceScript.snapshot.getLength(),
+		);
+		const sourceTextWithLineMap: SourceFileWithLineMap = {
+			text: sourceText,
+		};
+		function normalizeSourceRange(
+			range: CharacterReportRange,
+		): NormalizedReportRangeObject {
+			return {
+				begin: getColumnAndLineOfPosition(sourceTextWithLineMap, range.begin),
+				end: getColumnAndLineOfPosition(sourceTextWithLineMap, range.end),
+			};
+		}
+
+		const serviceScript =
+			sourceScript.generated.languagePlugin.typescript.getServiceScript(
+				sourceScript.generated.root,
+			);
+		assert.ok(
+			serviceScript != null,
+			`Flint bug: Volar.js service script for ${sourceFile.fileName} is undefined`,
+		);
+
+		const map = volarLanguage.maps.get(serviceScript.code, sourceScript);
+		const sortedMappings = map.mappings.toSorted(
+			(a, b) => a.generatedOffsets[0] - b.generatedOffsets[0],
+		);
+		const {
+			directives,
+			firstStatementPosition,
+			reports,
+			extraContext,
+			getDiagnostics,
+			cache,
+		} = prepareFile(
+			filePathAbsolute,
+			{
+				program,
+				sourceFile,
+				[Symbol.dispose]: disposeFile,
+			},
+			volarLanguage,
+			sourceScript as VolarSourceScript<string> & {
+				generated: NonNullable<VolarSourceScript<string>["generated"]>;
+			},
+			serviceScript,
+		);
+
+		const translatedDirectives = [...(directives ?? [])];
+
+		for (const d of extractDirectivesFromTypeScriptFile(sourceFile)) {
+			const range = translateRange(map, d.range.begin.raw, d.range.end.raw);
+			if (range != null) {
+				translatedDirectives.push({
+					...d,
+					range: normalizeSourceRange(range),
+				});
+			}
+		}
+
+		const directivesCollector = new DirectivesCollector(firstStatementPosition);
+		translatedDirectives.sort((a, b) => a.range.begin.raw - b.range.begin.raw);
+		for (const { range, selection, type } of translatedDirectives) {
+			directivesCollector.add(range, selection, type);
+		}
+
+		const collected = directivesCollector.collect();
+
+		return {
+			directives: collected.directives,
+			reports: [...collected.reports, ...(reports ?? [])],
+			file: {
+				cache,
+				getDiagnostics() {
+					return [
+						...ts.getPreEmitDiagnostics(program, sourceFile).map((diagnostic) =>
+							convertTypeScriptDiagnosticToLanguageFileDiagnostic({
+								...diagnostic,
+								// For some unknown reason, Volar doesn't set file.text to sourceText
+								// when preventLeadingOffset is true, so we have to do it ourselves
+								// https://github.com/volarjs/volar.js/blob/4a9d25d797d08d9c149bebf0f52ac5e172f4757d/packages/typescript/lib/node/transform.ts#L102
+								file: diagnostic.file
+									? {
+											fileName: diagnostic.file.fileName,
+											text: sourceText,
+										}
+									: diagnostic.file,
+							}),
+						),
+						...(getDiagnostics?.() ?? []),
+					];
+				},
+				async runRule(rule, options) {
+					const reports: NormalizedReport[] = [];
+					const context = {
+						program,
+						sourceFile,
+						typeChecker: program.getTypeChecker(),
+						report: (report) => {
+							const reportRange = translateRange(
+								map,
+								report.range.begin,
+								report.range.end,
+							);
+							if (reportRange == null) {
+								return;
+							}
+
+							const translatedReport: NormalizedReport = {
+								...report,
+								fix:
+									report.fix && !Array.isArray(report.fix)
+										? [report.fix]
+										: report.fix,
+								message: rule.messages[report.message],
+								range: normalizeSourceRange(reportRange),
+							};
+
+							for (const suggestion of translatedReport.suggestions ?? []) {
+								assert.ok(
+									!isSuggestionForFiles(suggestion),
+									`Flint bug: suggestions for multiple files in Volar.js based languages are not yet supported`,
+								);
+								const range = translateRange(
+									map,
+									suggestion.range.begin,
+									suggestion.range.end,
+								);
+								// TODO: maybe we should filter out these suggestions intead of erroring?
+								assert.ok(
+									range != null,
+									`Flint rule bug: suggestion ranges must not overlap with virtual code`,
+								);
+								suggestion.range = range;
+							}
+
+							reports.push(translatedReport);
+						},
+						...extraContext?.((report) => {
+							reports.push({
+								...report,
+								fix:
+									report.fix && !Array.isArray(report.fix)
+										? [report.fix]
+										: report.fix,
+								message: rule.messages[report.message],
+								range: normalizeSourceRange(report.range),
+							});
+						}),
+					} satisfies TypeScriptFileServices & RuleContext<string>;
+
+					const runtime = await rule.setup(context, options);
+
+					if (runtime?.visitors) {
+						const { visitors } = runtime;
+						let lastMappingIdx = 0;
+						const visit = (node: ts.Node) => {
+							visitors[NodeSyntaxKinds[node.kind]]?.(node, context);
+
+							node.forEachChild(visit);
+						};
+						// Visit only statements that have a mapping to the source code
+						// to avoid doing extra work
+						Statements: for (const statement of sourceFile.statements) {
+							while (true) {
+								const currentMapping = sortedMappings[lastMappingIdx];
+								if (currentMapping == null) {
+									break Statements;
+								}
+								const currentMappingLength =
+									currentMapping.generatedLengths?.[0] ??
+									currentMapping.lengths[0];
+								if (
+									currentMappingLength === 0 ||
+									statement.pos >=
+										currentMapping.generatedOffsets[0] + currentMappingLength
+								) {
+									lastMappingIdx++;
+									continue;
+								}
+								if (statement.end <= currentMapping.generatedOffsets[0]) {
+									continue Statements;
+								}
+								break;
+							}
+
+							visit(statement);
+						}
+						visit(sourceFile.endOfFileToken);
+					}
+
+					await runtime?.teardown?.();
+
+					return reports;
+				},
+				[Symbol.dispose]() {
+					disposeFile?.();
+				},
+			},
+		};
+	},
+);
+
+export function translateRange(
+	map: VolarMapper,
+	serviceBegin: number,
+	serviceEnd: number,
+): null | { begin: number; end: number } {
+	for (const [begin, end] of map.toSourceRange(
+		serviceBegin,
+		serviceEnd,
+		true,
+	)) {
+		if (begin === end) {
+			continue;
+		}
+		return { begin, end };
+	}
+	return null;
+}
+
+export function createVolarBasedLanguage<ContextServices extends object>(
+	initializer: VolarLanguagePluginInitializer<ContextServices>,
+) {
+	volarLanguagePluginInitializers.add(initializer);
+	const language: Language<
+		TSNodesByName,
+		ContextServices & TypeScriptFileServices
+	> = {
+		about: {
+			name: "Volar.js-based language",
+		},
+		createRule: (ruleDefinition: AnyRuleDefinition) => {
+			return {
+				...ruleDefinition,
+				// @ts-expect-error - ContextServices type is not satisfied, but we pass correct
+				// services in runRule
+				language: typescriptLanguage as Language<
+					TSNodesByName,
+					ContextServices & TypeScriptFileServices
+				>,
+			};
+		},
+		prepare() {
+			throw new Error(
+				"Flint bug: Volar.js based language should never be prepared directly",
+			);
+		},
+	};
+
+	return language;
+}
diff --git a/packages/volar-language/tsconfig.json b/packages/volar-language/tsconfig.json
new file mode 100644
index 000000000..e996a4e06
--- /dev/null
+++ b/packages/volar-language/tsconfig.json
@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"outDir": "lib",
+		"rootDir": "src"
+	},
+	"extends": "../../tsconfig.base.json",
+	"include": ["src"],
+	"references": [
+		{ "path": "../core" },
+		{ "path": "../ts" },
+		{ "path": "../ts-patch" }
+	]
+}
diff --git a/packages/vue-language/package.json b/packages/vue-language/package.json
index ee5e31fa5..192f34646 100644
--- a/packages/vue-language/package.json
+++ b/packages/vue-language/package.json
@@ -18,6 +18,7 @@
 		"@flint.fyi/core": "workspace:",
 		"@flint.fyi/ts": "workspace:",
 		"@flint.fyi/ts-patch": "workspace:",
+		"@flint.fyi/volar-language": "workspace:",
 		"@volar/language-core": "2.4.27",
 		"@volar/typescript": "2.4.27",
 		"@vue/compiler-dom": "^3.5.0",
diff --git a/packages/vue-language/src/language.ts b/packages/vue-language/src/language.ts
index 70010b932..587f57eef 100644
--- a/packages/vue-language/src/language.ts
+++ b/packages/vue-language/src/language.ts
@@ -1,22 +1,8 @@
-import {
-	CharacterReportRange,
-	createLanguage,
-	DirectivesCollector,
-	getColumnAndLineOfPosition,
-	isSuggestionForFiles,
-	LanguagePreparedDefinition,
-	NormalizedReport,
-	NormalizedReportRangeObject,
-	RuleContext,
-	RuleReport,
-	RuleReporter,
-	SourceFileWithLineMap,
-} from "@flint.fyi/core";
+import assert from "node:assert/strict";
+import { RuleReporter } from "@flint.fyi/core";
 import { setTSExtraSupportedExtensions } from "@flint.fyi/ts-patch";
-import {
-	Language as VolarLanguage,
-	Mapper as VolarMapper,
-} from "@volar/language-core";
+import { createVolarBasedLanguage } from "@flint.fyi/volar-language";
+import { Mapper as VolarMapper } from "@volar/language-core";
 import {
 	parse as vueParse,
 	NodeTypes,
@@ -28,28 +14,16 @@ import {
 	createParsedCommandLine as createVueParsedCommandLine,
 	createParsedCommandLineByJson as createVueParsedCommandLineByJson,
 	tsCodegen,
-	VueCompilerOptions,
 	VueVirtualCode,
 } from "@vue/language-core";
 import {
 	collectTypeScriptFileCacheImpacts,
-	convertTypeScriptDiagnosticToLanguageFileDiagnostic,
-	createTypeScriptBasedLanguage,
-	extractDirectivesFromTypeScriptFile,
-	NodeSyntaxKinds,
-	prepareTypeScriptBasedLanguage,
-	prepareTypeScriptFile,
-	TSNodesByName,
-	TypeScriptBasedLanguageFile,
-	TypeScriptFileServices,
+	ExtractedDirective,
 } from "@flint.fyi/ts";
-import ts from "typescript";
-
-// TODO: css
 
 setTSExtraSupportedExtensions([".vue"]);
 
-export interface VueServices extends TypeScriptFileServices {
+export interface VueServices {
 	vueServices?: {
 		codegen: VueCodegen;
 		map: VolarMapper;
@@ -62,173 +36,104 @@ export interface VueServices extends TypeScriptFileServices {
 
 type VueCodegen = typeof tsCodegen extends WeakMap<any, infer V> ? V : never;
 
-export const vueLanguage = createTypeScriptBasedLanguage<
-	TSNodesByName,
-	VueServices
->((ts, options) => {
-	const { configFilePath } = options.options;
-	const vueCompilerOptions = (
-		typeof configFilePath === "string"
-			? createVueParsedCommandLine(
-					ts,
-					ts.sys,
-					configFilePath.replaceAll("\\", "/"),
-				)
-			: createVueParsedCommandLineByJson(
-					ts,
-					ts.sys,
-					(options.host ?? ts.sys).getCurrentDirectory(),
-					{},
-				)
-	).vueOptions;
-	return {
-		languagePlugins: createVueLanguagePlugin(
-			ts,
-			options.options,
-			vueCompilerOptions,
-			(id) => id,
-		),
-		prepareFile(filePathAbsolute, { program, sourceFile }, sourceScript) {
-			// @ts-expect-error
-			const volarLanguage: VolarLanguage = program.__flintVolarLanguage;
-
-			if (volarLanguage == null) {
-				throw new Error(
-					"'typescript' package wasn't properly patched. Make sure you don't import 'typescript' before Flint.",
+export const vueLanguage = createVolarBasedLanguage<VueServices>(
+	(ts, options) => {
+		const { configFilePath } = options.options;
+		const vueCompilerOptions = (
+			typeof configFilePath === "string"
+				? createVueParsedCommandLine(
+						ts,
+						ts.sys,
+						configFilePath.replaceAll("\\", "/"),
+					)
+				: createVueParsedCommandLineByJson(
+						ts,
+						ts.sys,
+						(options.host ?? ts.sys).getCurrentDirectory(),
+						{},
+					)
+		).vueOptions;
+		return {
+			languagePlugins: createVueLanguagePlugin(
+				ts,
+				options.options,
+				vueCompilerOptions,
+				(id) => id,
+			),
+			prepareFile(
+				filePathAbsolute,
+				{ program, sourceFile },
+				volarLanguage,
+				sourceScript,
+				serviceScript,
+			) {
+				const sourceText = sourceScript.snapshot.getText(
+					0,
+					sourceScript.snapshot.getLength(),
 				);
-			}
-
-			if (sourceScript.snapshot == null) {
-				throw new Error("Expected sourceScript.snapshot to be set");
-			}
-			if (sourceScript.generated.languagePlugin.typescript == null) {
-				throw new Error(
-					"Expected sourceScript.generated.languagePlugin.typescript to be set",
+				const virtualCode = sourceScript.generated.root as VueVirtualCode;
+				const codegen = tsCodegen.get(virtualCode.sfc);
+				assert.ok(
+					codegen != null,
+					`Flint bug: tsCodegen for ${filePathAbsolute} is undefined`,
 				);
-			}
-
-			const sourceText = sourceScript.snapshot.getText(
-				0,
-				sourceScript.snapshot.getLength(),
-			);
-			const sourceTextWithLineMap: SourceFileWithLineMap = {
-				text: sourceText,
-			};
-			function normalizeSourceRange(
-				range: CharacterReportRange,
-			): NormalizedReportRangeObject {
-				return {
-					begin: getColumnAndLineOfPosition(sourceTextWithLineMap, range.begin),
-					end: getColumnAndLineOfPosition(sourceTextWithLineMap, range.end),
-				};
-			}
 
-			const serviceScript =
-				sourceScript.generated.languagePlugin.typescript.getServiceScript(
-					sourceScript.generated.root,
-				);
-			if (serviceScript == null) {
-				throw new Error("Expected serviceScript to exist");
-			}
-
-			const virtualCode = sourceScript.generated.root as VueVirtualCode;
-			const codegen = tsCodegen.get(virtualCode.sfc);
-			if (codegen == null) {
-				throw new Error("Expected codegen to exist");
-			}
-
-			const map = volarLanguage.maps.get(serviceScript.code, sourceScript);
-
-			const sfcAst = vueParse(sourceText, {
-				comments: true,
-				expressionPlugins: ["typescript"],
-				parseMode: "html",
-				// We ignore errors because virtual code already provides them,
-				// and it also provides them with sourceText-based locations,
-				// so we don't have to remap them. Oh, and it also contains errors from
-				// other blocks rather than only <template> as well.
-				// If we don't provide this callback, @vue/compiler-core will throw.
-				onError: () => {},
-			});
-
-			// TODO: extract directives from other blocks too
-
-			const directives: {
-				range: NormalizedReportRangeObject;
-				selection: string;
-				type: string;
-			}[] = [];
-			function visitTemplate(elem: TemplateChildNode) {
-				if (elem.type === NodeTypes.ELEMENT) {
-					elem.children.forEach(visitTemplate);
-					return;
-				}
-				if (elem.type !== NodeTypes.COMMENT) {
-					return;
-				}
-				const match = /\s*flint-(\S+)(?:\s+(.+))?/.exec(elem.content);
-				if (match == null) {
-					return;
-				}
-				const [, type, selection] = match;
-				directives.push({
-					range: {
-						begin: {
-							column: elem.loc.start.column - 1,
-							line: elem.loc.start.line - 1,
-							raw: elem.loc.start.offset,
-						},
-						end: {
-							column: elem.loc.end.column - 1,
-							line: elem.loc.end.line - 1,
-							raw: elem.loc.end.offset,
-						},
-					},
-					selection,
-					type,
+				const map = volarLanguage.maps.get(serviceScript.code, sourceScript);
+
+				const sfcAst = vueParse(sourceText, {
+					comments: true,
+					expressionPlugins: ["typescript"],
+					parseMode: "html",
+					// We ignore errors because virtual code already provides them,
+					// and it also provides them with sourceText-based locations,
+					// so we don't have to remap them. Oh, and it also contains errors from
+					// other blocks rather than only <template> as well.
+					// If we don't provide this callback, @vue/compiler-core will throw.
+					onError: () => {},
 				});
-			}
-			sfcAst.children.forEach(visitTemplate);
 
-			for (const d of extractDirectivesFromTypeScriptFile(sourceFile)) {
-				const range = translateRange(map, d.range.begin.raw, d.range.end.raw);
-				if (range != null) {
+				// TODO: extract directives from other blocks too
+				const directives: ExtractedDirective[] = [];
+				function visitTemplate(elem: TemplateChildNode) {
+					if (elem.type === NodeTypes.ELEMENT) {
+						elem.children.forEach(visitTemplate);
+						return;
+					}
+					if (elem.type !== NodeTypes.COMMENT) {
+						return;
+					}
+					const match = /\s*flint-(\S+)(?:\s+(.+))?/.exec(elem.content);
+					if (match == null) {
+						return;
+					}
+					const [, type, selection] = match;
 					directives.push({
-						...d,
-						range: normalizeSourceRange(range),
+						range: {
+							begin: {
+								column: elem.loc.start.column - 1,
+								line: elem.loc.start.line - 1,
+								raw: elem.loc.start.offset,
+							},
+							end: {
+								column: elem.loc.end.column - 1,
+								line: elem.loc.end.line - 1,
+								raw: elem.loc.end.offset,
+							},
+						},
+						selection,
+						type,
 					});
 				}
-			}
-
-			const directivesCollector = new DirectivesCollector(
-				sfcAst.children.find((c) => c.type !== NodeTypes.COMMENT)?.loc.start
-					.offset ?? sourceText.length,
-			);
-			directives.sort((a, b) => a.range.begin.raw - b.range.begin.raw);
-			for (const { range, selection, type } of directives) {
-				directivesCollector.add(range, selection, type);
-			}
+				sfcAst.children.forEach(visitTemplate);
 
-			return {
-				...directivesCollector.collect(),
-				cache: collectTypeScriptFileCacheImpacts(program, sourceFile),
-				getDiagnostics() {
-					return [
-						...ts.getPreEmitDiagnostics(program, sourceFile).map((diagnostic) =>
-							convertTypeScriptDiagnosticToLanguageFileDiagnostic({
-								...diagnostic,
-								// For some unknown reason, Volar doesn't set file.text to sourceText
-								// when preventLeadingOffset is true, so we have to do it ourselves
-								// https://github.com/volarjs/volar.js/blob/4a9d25d797d08d9c149bebf0f52ac5e172f4757d/packages/typescript/lib/node/transform.ts#L102
-								file: diagnostic.file
-									? {
-											fileName: diagnostic.file.fileName,
-											text: sourceText,
-										}
-									: diagnostic.file,
-							}),
-						),
-						...(virtualCode.vueSfc?.errors ?? []).map((e) => {
+				return {
+					directives,
+					firstStatementPosition:
+						sfcAst.children.find((c) => c.type !== NodeTypes.COMMENT)?.loc.start
+							.offset ?? sourceText.length,
+					cache: collectTypeScriptFileCacheImpacts(program, sourceFile),
+					getDiagnostics() {
+						return (virtualCode.vueSfc?.errors ?? []).map((e) => {
 							const fileName = sourceFile.fileName.startsWith("./")
 								? sourceFile.fileName.slice(2)
 								: sourceFile.fileName.slice(process.cwd().length + 1);
@@ -246,40 +151,22 @@ export const vueLanguage = createTypeScriptBasedLanguage<
 								code,
 								text: `${fileName}${loc} - ${code}: ${e.name} - ${e.message}`,
 							};
-						}),
-					];
-				},
-				extraContext: (reportTranslated) => ({
-					vueServices: {
-						codegen,
-						map,
-						reportSfc: reportTranslated,
-						sfc: sfcAst,
-						virtualCode,
+						});
 					},
-				}),
-			};
-		},
-	};
-});
-
-function translateRange(
-	map: VolarMapper,
-	serviceBegin: number,
-	serviceEnd: number,
-): null | { begin: number; end: number } {
-	for (const [begin, end] of map.toSourceRange(
-		serviceBegin,
-		serviceEnd,
-		true,
-	)) {
-		if (begin === end) {
-			continue;
-		}
-		return { begin, end };
-	}
-	return null;
-}
+					extraContext: (reportTranslated) => ({
+						vueServices: {
+							codegen,
+							map,
+							reportSfc: reportTranslated,
+							sfc: sfcAst,
+							virtualCode,
+						},
+					}),
+				};
+			},
+		};
+	},
+);
 
 // TODO:
 // export function vueWrapRules(
@@ -291,8 +178,3 @@ function translateRange(
 // 			.map((rule) => vueLanguage.createRule(rule)),
 // 	);
 // }
-
-function prepareVueFile(
-	filePathAbsolute: string,
-	tsFile: TypeScriptBasedLanguageFile,
-): LanguagePreparedDefinition;
diff --git a/packages/vue-language/tsconfig.json b/packages/vue-language/tsconfig.json
index a1fdca4f8..16522fb6a 100644
--- a/packages/vue-language/tsconfig.json
+++ b/packages/vue-language/tsconfig.json
@@ -9,6 +9,7 @@
 		{ "path": "../core" },
 		{ "path": "../ts" },
 		{ "path": "../rule-tester" },
-		{ "path": "../ts-patch" }
+		{ "path": "../ts-patch" },
+		{ "path": "../volar-language" }
 	]
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7066cf795..ad4f2318b 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -637,6 +637,27 @@ importers:
 
   packages/utils: {}
 
+  packages/volar-language:
+    dependencies:
+      '@flint.fyi/core':
+        specifier: 'workspace:'
+        version: link:../core
+      '@flint.fyi/ts':
+        specifier: 'workspace:'
+        version: link:../ts
+      '@flint.fyi/ts-patch':
+        specifier: 'workspace:'
+        version: link:../ts-patch
+      '@volar/language-core':
+        specifier: 2.4.27
+        version: 2.4.27
+      '@volar/typescript':
+        specifier: 2.4.27
+        version: 2.4.27
+      typescript:
+        specifier: '>=5.9.3'
+        version: 5.9.3
+
   packages/vue-language:
     dependencies:
       '@flint.fyi/core':
@@ -648,6 +669,9 @@ importers:
       '@flint.fyi/ts-patch':
         specifier: 'workspace:'
         version: link:../ts-patch
+      '@flint.fyi/volar-language':
+        specifier: 'workspace:'
+        version: link:../volar-language
       '@volar/language-core':
         specifier: 2.4.27
         version: 2.4.27
diff --git a/tsconfig.json b/tsconfig.json
index 8d90b27dd..8c2f95705 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -26,6 +26,7 @@
 		{ "path": "./packages/text" },
 		{ "path": "./packages/ts" },
 		{ "path": "./packages/ts-patch" },
+		{ "path": "./packages/volar-language" },
 		{ "path": "./packages/vue-language" },
 		{ "path": "./packages/yaml" }
 	]

From 27656e1e46026b9a0d49ef9300f573e4f9b1578b Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Wed, 31 Dec 2025 22:19:03 +0300
Subject: [PATCH 08/11] wip

---
 .vscode/launch.json                           |   2 +-
 packages/astro-language/package.json          |  13 +-
 packages/astro-language/src/index.ts          | 428 ------------------
 packages/astro-language/src/language.ts       |  45 ++
 .../src/rules/anyReturns.test.ts              |   3 +-
 .../astro-language/src/rules/ruleTester.ts    |   9 +-
 packages/astro-language/tsconfig.json         |   4 +-
 packages/rule-tester/src/host.ts              |   3 +
 packages/ts/package.json                      |   3 -
 packages/volar-language/src/index.ts          |   4 +-
 packages/vue-language/package.json            |   5 +-
 packages/vue-language/src/language.ts         |   2 +-
 patches/@volar__typescript@2.4.27.patch       |  12 +
 pnpm-lock.yaml                                | 274 ++---------
 pnpm-workspace.yaml                           |  11 +-
 15 files changed, 114 insertions(+), 704 deletions(-)
 delete mode 100644 packages/astro-language/src/index.ts
 create mode 100644 packages/astro-language/src/language.ts
 create mode 100644 patches/@volar__typescript@2.4.27.patch

diff --git a/.vscode/launch.json b/.vscode/launch.json
index 57134c35e..70d958ac1 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -6,7 +6,7 @@
 			"request": "launch",
 			"name": "Run Current File Tests",
 			"program": "${workspaceFolder}/node_modules/vitest/vitest.mjs",
-			"args": ["${fileBasenameNoExtension}"],
+			"args": ["${fileDirname}/${fileBasenameNoExtension}"],
 			"sourceMaps": true,
 			"console": "integratedTerminal",
 			"internalConsoleOptions": "neverOpen"
diff --git a/packages/astro-language/package.json b/packages/astro-language/package.json
index f782d025f..01113cd5b 100644
--- a/packages/astro-language/package.json
+++ b/packages/astro-language/package.json
@@ -13,16 +13,17 @@
 		"email": "npm@joshuakgoldberg.com"
 	},
 	"type": "module",
-	"main": "./lib/index.js",
+	"exports": {
+		".": "./lib/index.js"
+	},
 	"dependencies": {
-		"@astrojs/language-server": "^2.16.2",
+		"@astrojs/ts-plugin": "^1.10.6",
 		"@flint.fyi/core": "workspace:",
 		"@flint.fyi/ts": "workspace:",
-		"@volar/language-core": "2.4.27",
-		"@volar/typescript": "2.4.27",
+		"@flint.fyi/ts-patch": "workspace:",
+		"@flint.fyi/volar-language": "workspace:",
 		"ts-api-utils": "^2.1.0",
-		"typescript": ">=5.9.3",
-		"vscode-uri": "^3.1.0"
+		"typescript": ">=5.9.3"
 	},
 	"devDependencies": {
 		"@flint.fyi/rule-tester": "workspace:"
diff --git a/packages/astro-language/src/index.ts b/packages/astro-language/src/index.ts
deleted file mode 100644
index 355f67c42..000000000
--- a/packages/astro-language/src/index.ts
+++ /dev/null
@@ -1,428 +0,0 @@
-import {
-	LanguagePlugin as VolarLanguagePlugin,
-	Language as VolarLanguage,
-	Mapper as VolarMapper,
-	CodegenContext as VolarCodegenContext,
-} from "@volar/language-core";
-import {
-	AstroVirtualCode,
-	getAstroLanguagePlugin,
-} from "@astrojs/language-server/dist/core/index.js";
-import {
-	convertTypeScriptDiagnosticToLanguageFileDiagnostic,
-	extractDirectivesFromTypeScriptFile,
-	NodeSyntaxKinds,
-	prepareTypeScriptBasedLanguage,
-	prepareTypeScriptFile,
-	TSNodesByName,
-	TypeScriptBasedLanguageFile,
-	TypeScriptFileServices,
-} from "@flint.fyi/ts";
-// for LanguagePlugin interface augmentation
-import "@volar/typescript";
-import { URI } from "vscode-uri";
-
-import {
-	CharacterReportRange,
-	createLanguage,
-	DirectivesCollector,
-	getColumnAndLineOfPosition,
-	isSuggestionForFiles,
-	LanguagePreparedDefinition,
-	NormalizedReport,
-	NormalizedReportRangeObject,
-	RuleContext,
-	setTSExtraSupportedExtensions,
-	setTSProgramCreationProxy,
-	SourceFileWithLineMap,
-} from "@flint.fyi/core";
-import { proxyCreateProgram } from "@volar/typescript/lib/node/proxyCreateProgram.js";
-import ts from "typescript";
-
-type ProxiedTSProgram = ts.Program & {
-	__flintVolarLanguage?: undefined | VolarLanguage<string>;
-};
-
-setTSExtraSupportedExtensions([".astro"]);
-setTSProgramCreationProxy(
-	(ts, createProgram) =>
-		new Proxy(function () {} as unknown as typeof createProgram, {
-			apply(target, thisArg, args) {
-				let volarLanguage = null as null | VolarLanguage<string>;
-				const proxied = proxyCreateProgram(ts, createProgram, (ts, options) => {
-					const {
-						getLanguageId,
-						createVirtualCode,
-						updateVirtualCode,
-						disposeVirtualCode,
-						isAssociatedFileOnly,
-						typescript,
-					} = getAstroLanguagePlugin();
-					const languagePlugin: VolarLanguagePlugin<string, AstroVirtualCode> =
-						{
-							getLanguageId(scriptId) {
-								return getLanguageId(URI.file(scriptId));
-							},
-							createVirtualCode(scriptId, languageId, snapshot) {
-								// astro never touches ctx
-								const ctx = {} as VolarCodegenContext<URI>;
-								return createVirtualCode?.(
-									URI.file(scriptId),
-									languageId,
-									snapshot,
-									ctx,
-								);
-							},
-							updateVirtualCode(scriptId, virtualCode, newSnapshot) {
-								// astro never touches ctx
-								const ctx = {} as VolarCodegenContext<URI>;
-								return updateVirtualCode?.(
-									URI.file(scriptId),
-									virtualCode,
-									newSnapshot,
-									ctx,
-								);
-							},
-							disposeVirtualCode(scriptId, virtualCode) {
-								return disposeVirtualCode?.(URI.file(scriptId), virtualCode);
-							},
-							...(isAssociatedFileOnly != null && {
-								isAssociatedFileOnly(scriptId, languageId): boolean {
-									return isAssociatedFileOnly(URI.file(scriptId), languageId);
-								},
-							}),
-							typescript,
-						};
-					if (languagePlugin.typescript != null) {
-						const { getServiceScript } = languagePlugin.typescript;
-						// getExtraServiceScripts() is not available in this use case.
-						delete languagePlugin.typescript.getExtraServiceScripts;
-						languagePlugin.typescript.getServiceScript = (root) => {
-							const script = getServiceScript(root);
-							if (script == null) {
-								return script;
-							}
-							return {
-								...script,
-								// Leading offset is useful for LanguageService [1], but we don't use it.
-								// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
-								// have to provide it ourselves.
-								//
-								// [1] https://github.com/volarjs/volar.js/discussions/188
-								// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
-								preventLeadingOffset: true,
-							};
-						};
-					}
-					return {
-						languagePlugins: [languagePlugin],
-						setup: (lang) => (volarLanguage = lang),
-					};
-				});
-
-				const program: ProxiedTSProgram = Reflect.apply(proxied, thisArg, args);
-
-				if (volarLanguage == null) {
-					throw new Error("Flint bug: volarLanguage is not defined");
-				}
-
-				if (program.__flintVolarLanguage != null) {
-					return program;
-				}
-
-				program.__flintVolarLanguage = volarLanguage;
-				return program;
-			},
-		}),
-);
-
-export interface AstroServices extends TypeScriptFileServices {
-	astroServices?: {
-		// codegen: VueCodegen;
-		// map: VolarMapper;
-		// sfc: RootNode;
-		// virtualCode: VueVirtualCode;
-		// // TODO: can we type MessageId?
-		// reportSfc: RuleReporter<string>;
-	};
-}
-
-export const astroLanguage = createLanguage<TSNodesByName, AstroServices>({
-	about: {
-		name: "Astro",
-	},
-	prepare: () => {
-		const tsLang = prepareTypeScriptBasedLanguage();
-
-		return {
-			prepareFromDisk: (filePathAbsolute) => {
-				return prepareAstroFile(
-					filePathAbsolute,
-					tsLang.createFromDisk(filePathAbsolute),
-				);
-			},
-			prepareFromVirtual: (filePathAbsolute, sourceText) => {
-				return prepareAstroFile(
-					filePathAbsolute,
-					tsLang.createFromVirtual(filePathAbsolute, sourceText),
-				);
-			},
-		};
-	},
-});
-
-function prepareAstroFile(
-	filePathAbsolute: string,
-	tsFile: TypeScriptBasedLanguageFile,
-): LanguagePreparedDefinition {
-	const { program, sourceFile, [Symbol.dispose]: onDispose } = tsFile;
-
-	// @ts-expect-error
-	const volarLanguage: VolarLanguage = program.__flintVolarLanguage;
-
-	if (volarLanguage == null) {
-		throw new Error(
-			"'typescript' package wasn't properly patched. Make sure you don't import 'typescript' before Flint.",
-		);
-	}
-
-	const sourceScript = volarLanguage.scripts.get(filePathAbsolute);
-	if (sourceScript == null) {
-		throw new Error("Expected sourceScript to be set");
-	}
-	if (sourceScript.languageId !== "astro") {
-		return prepareTypeScriptFile({
-			program,
-			sourceFile,
-			[Symbol.dispose]: onDispose,
-		});
-	}
-	if (sourceScript.generated == null) {
-		throw new Error("Expected sourceScript.generated to be set");
-	}
-	if (sourceScript.snapshot == null) {
-		throw new Error("Expected sourceScript.snapshot to be set");
-	}
-	if (sourceScript.generated.languagePlugin.typescript == null) {
-		throw new Error(
-			"Expected sourceScript.generated.languagePlugin.typescript to be set",
-		);
-	}
-
-	const sourceText = sourceScript.snapshot.getText(
-		0,
-		sourceScript.snapshot.getLength(),
-	);
-	const sourceTextWithLineMap: SourceFileWithLineMap = {
-		text: sourceText,
-	};
-	function normalizeSourceRange(
-		range: CharacterReportRange,
-	): NormalizedReportRangeObject {
-		return {
-			begin: getColumnAndLineOfPosition(sourceTextWithLineMap, range.begin),
-			end: getColumnAndLineOfPosition(sourceTextWithLineMap, range.end),
-		};
-	}
-
-	const serviceScript =
-		sourceScript.generated.languagePlugin.typescript.getServiceScript(
-			sourceScript.generated.root,
-		);
-	if (serviceScript == null) {
-		throw new Error("Expected serviceScript to exist");
-	}
-
-	const virtualCode = sourceScript.generated.root as AstroVirtualCode;
-	// const codegen = tsCodegen.get(virtualCode.sfc);
-	// if (codegen == null) {
-	// 	throw new Error("Expected codegen to exist");
-	// }
-
-	const map = volarLanguage.maps.get(serviceScript.code, sourceScript);
-	const sortedMappings = map.mappings.toSorted(
-		(a, b) => a.generatedOffsets[0] - b.generatedOffsets[0],
-	);
-
-	// const sfcAst = vueParse(sourceText, {
-	// 	comments: true,
-	// 	expressionPlugins: ["typescript"],
-	// 	parseMode: "html",
-	// 	// We ignore errors because virtual code already provides them,
-	// 	// and it also provides them with sourceText-based locations,
-	// 	// so we don't have to remap them. Oh, and it also contains errors from
-	// 	// other blocks rather than only <template> as well.
-	// 	// If we don't provide this callback, @vue/compiler-core will throw.
-	// 	onError: () => {},
-	// });
-
-	return {
-		file: {
-			...(onDispose != null && { [Symbol.dispose]: onDispose }),
-			getDiagnostics() {
-				return [
-					...ts.getPreEmitDiagnostics(program, sourceFile).map((diagnostic) =>
-						convertTypeScriptDiagnosticToLanguageFileDiagnostic({
-							...diagnostic,
-							// For some unknown reason, Volar doesn't set file.text to sourceText
-							// when preventLeadingOffset is true, so we have to do it ourselves
-							// https://github.com/volarjs/volar.js/blob/4a9d25d797d08d9c149bebf0f52ac5e172f4757d/packages/typescript/lib/node/transform.ts#L102
-							file: diagnostic.file
-								? {
-										fileName: diagnostic.file.fileName,
-										text: sourceText,
-									}
-								: diagnostic.file,
-						}),
-					),
-					// ...(virtualCode.vueSfc?.errors ?? []).map((e) => {
-					// 	const fileName = sourceFile.fileName.startsWith("./")
-					// 		? sourceFile.fileName.slice(2)
-					// 		: sourceFile.fileName.slice(process.cwd().length + 1);
-					// 	let code = "VUE";
-					// 	let loc = "";
-					// 	if ("code" in e) {
-					// 		// TODO: think about codes
-					// 		code += "999999" + e.code.toString();
-					// 		loc =
-					// 			e.loc != null
-					// 				? `:${e.loc?.start.line}:${e.loc?.start.column}`
-					// 				: "";
-					// 	}
-					// 	return {
-					// 		code,
-					// 		text: `${fileName}${loc} - ${code}: ${e.name} - ${e.message}`,
-					// 	};
-					// }),
-				];
-			},
-			async runRule(rule, options) {
-				const reports: NormalizedReport[] = [];
-				const context: RuleContext<string> & AstroServices = {
-					program,
-					report: (report) => {
-						const reportRange = translateRange(
-							map,
-							report.range.begin,
-							report.range.end,
-						);
-						if (reportRange == null) {
-							return;
-						}
-
-						const translatedReport: NormalizedReport = {
-							...report,
-							fix:
-								report.fix && !Array.isArray(report.fix)
-									? [report.fix]
-									: report.fix,
-							message: rule.messages[report.message],
-							range: normalizeSourceRange(reportRange),
-						};
-
-						for (const suggestion of translatedReport.suggestions ?? []) {
-							if (isSuggestionForFiles(suggestion)) {
-								throw new Error(
-									"TODO: vue - suggestions for multiple files are not yet supported",
-								);
-							}
-							const range = translateRange(
-								map,
-								suggestion.range.begin,
-								suggestion.range.end,
-							);
-							if (range == null) {
-								// TODO: maybe we should filter out these suggestions intead of erroring?
-								throw new Error("Suggestion range overlaps with virtual code");
-							}
-							suggestion.range = range;
-						}
-
-						reports.push(translatedReport);
-					},
-					sourceFile,
-					typeChecker: program.getTypeChecker(),
-					// vueServices: {
-					// 	codegen,
-					// 	map,
-					// 	reportSfc: (report: RuleReport) => {
-					// 		reports.push({
-					// 			...report,
-					// 			fix:
-					// 				report.fix && !Array.isArray(report.fix)
-					// 					? [report.fix]
-					// 					: report.fix,
-					// 			message: rule.messages[report.message],
-					// 			range: normalizeSourceRange(report.range),
-					// 		});
-					// 	},
-					// 	sfc: sfcAst,
-					// 	virtualCode,
-					// },
-				};
-
-				const runtime = await rule.setup(context, options);
-
-				if (runtime?.visitors) {
-					const { visitors } = runtime;
-					let lastMappingIdx = 0;
-					const visit = (node: ts.Node) => {
-						visitors[NodeSyntaxKinds[node.kind]]?.(node, context);
-
-						node.forEachChild(visit);
-					};
-					// Visit only statements that have a mapping to the source code
-					// to avoid doing extra work
-					Statements: for (const statement of sourceFile.statements) {
-						while (true) {
-							const currentMapping = sortedMappings[lastMappingIdx];
-							if (currentMapping == null) {
-								break Statements;
-							}
-							const currentMappingLength =
-								currentMapping.generatedLengths?.[0] ??
-								currentMapping.lengths[0];
-							if (
-								currentMappingLength === 0 ||
-								statement.pos >=
-									currentMapping.generatedOffsets[0] + currentMappingLength
-							) {
-								lastMappingIdx++;
-								continue;
-							}
-							if (statement.end <= currentMapping.generatedOffsets[0]) {
-								continue Statements;
-							}
-							break;
-						}
-
-						visit(statement);
-					}
-					visit(sourceFile.endOfFileToken);
-				}
-
-				await runtime?.teardown?.();
-
-				return reports;
-			},
-		},
-	};
-}
-
-function translateRange(
-	map: VolarMapper,
-	serviceBegin: number,
-	serviceEnd: number,
-): null | { begin: number; end: number } {
-	for (const [begin, end] of map.toSourceRange(
-		serviceBegin,
-		serviceEnd,
-		true,
-	)) {
-		if (begin === end) {
-			continue;
-		}
-		return { begin, end };
-	}
-	return null;
-}
diff --git a/packages/astro-language/src/language.ts b/packages/astro-language/src/language.ts
new file mode 100644
index 000000000..804549b76
--- /dev/null
+++ b/packages/astro-language/src/language.ts
@@ -0,0 +1,45 @@
+import { getLanguagePlugin } from "@astrojs/ts-plugin/dist/language.js";
+
+import { RuleReporter } from "@flint.fyi/core";
+
+import { setTSExtraSupportedExtensions } from "@flint.fyi/ts-patch";
+import { createVolarBasedLanguage } from "@flint.fyi/volar-language";
+
+setTSExtraSupportedExtensions([".astro"]);
+
+export interface AstroServices {
+	astroServices?: {
+		reportComponent: RuleReporter<string>;
+	};
+}
+
+export const astroLanguage = createVolarBasedLanguage<AstroServices>(
+	(ts, options) => {
+		return {
+			languagePlugins: getLanguagePlugin(),
+			prepareFile(
+				filePathAbsolute,
+				{ program, sourceFile },
+				volarLanguage,
+				sourceScript,
+				serviceScript,
+			) {
+				const sourceText = sourceScript.snapshot.getText(
+					0,
+					sourceScript.snapshot.getLength(),
+				);
+				return {
+					// TODO: first statement
+					firstStatementPosition: sourceText.length,
+					extraContext(reportTranslated) {
+						return {
+							astroServices: {
+								reportComponent: reportTranslated,
+							},
+						};
+					},
+				};
+			},
+		};
+	},
+);
diff --git a/packages/astro-language/src/rules/anyReturns.test.ts b/packages/astro-language/src/rules/anyReturns.test.ts
index 2fcb5d49b..2d8a8cd41 100644
--- a/packages/astro-language/src/rules/anyReturns.test.ts
+++ b/packages/astro-language/src/rules/anyReturns.test.ts
@@ -1,5 +1,5 @@
 import rule from "../../../ts/lib/rules/anyReturns.js";
-import { astroLanguage } from "../index.js";
+import { astroLanguage } from "../language.js";
 import { ruleTester } from "./ruleTester.js";
 
 ruleTester.describe(astroLanguage.createRule(rule), {
@@ -29,7 +29,6 @@ function foo() {
 		{
 			code: `
 ---
-type bar = 1
 function foo() {
 	return 1
 }
diff --git a/packages/astro-language/src/rules/ruleTester.ts b/packages/astro-language/src/rules/ruleTester.ts
index 80b290b77..c5d374870 100644
--- a/packages/astro-language/src/rules/ruleTester.ts
+++ b/packages/astro-language/src/rules/ruleTester.ts
@@ -1,14 +1,11 @@
-import path from "node:path";
-
-import { RuleTester } from "@flint.fyi/rule-tester";
+import { createRuleTesterTSHost, RuleTester } from "@flint.fyi/rule-tester";
 import { describe, it } from "vitest";
 
-const fileName = path.join(import.meta.dirname, "file.astro");
-
 export const ruleTester = new RuleTester({
 	describe,
 	it,
 	defaults: {
-		fileName,
+		fileName: "file.astro",
 	},
+	host: createRuleTesterTSHost(import.meta.dirname),
 });
diff --git a/packages/astro-language/tsconfig.json b/packages/astro-language/tsconfig.json
index 55ddcc02e..16522fb6a 100644
--- a/packages/astro-language/tsconfig.json
+++ b/packages/astro-language/tsconfig.json
@@ -8,6 +8,8 @@
 	"references": [
 		{ "path": "../core" },
 		{ "path": "../ts" },
-		{ "path": "../rule-tester" }
+		{ "path": "../rule-tester" },
+		{ "path": "../ts-patch" },
+		{ "path": "../volar-language" }
 	]
 }
diff --git a/packages/rule-tester/src/host.ts b/packages/rule-tester/src/host.ts
index bdc9402c5..3ab4dd779 100644
--- a/packages/rule-tester/src/host.ts
+++ b/packages/rule-tester/src/host.ts
@@ -9,6 +9,9 @@ export function createRuleTesterTSHost(
 	dirname: string,
 	opts: RuleTesterTSHostOptions = {},
 ) {
+	// TODO: should we nest dirname by some non-existent dir?
+	// This will avoid loading all test files located in the ${dirname}/
+	// in the TS program
 	const fsHost = createFSBackedLinterHost(dirname);
 	const overlay = createVFSLinterHost(dirname, {
 		...fsHost,
diff --git a/packages/ts/package.json b/packages/ts/package.json
index 915a64f25..99a0782a6 100644
--- a/packages/ts/package.json
+++ b/packages/ts/package.json
@@ -25,9 +25,6 @@
 		"@flint.fyi/core": "workspace:",
 		"@flint.fyi/ts-patch": "workspace:",
 		"@typescript-eslint/project-service": "^8.46.2",
-		"@typescript/vfs": "^1.6.1",
-		"@volar/language-core": "2.4.27",
-		"@volar/typescript": "2.4.27",
 		"cached-factory": "^0.1.0",
 		"debug-for-file": "^0.2.0",
 		"ts-api-utils": "^2.1.0",
diff --git a/packages/volar-language/src/index.ts b/packages/volar-language/src/index.ts
index e92e29b29..61a2da1fb 100644
--- a/packages/volar-language/src/index.ts
+++ b/packages/volar-language/src/index.ts
@@ -404,7 +404,7 @@ export function createVolarBasedLanguage<ContextServices extends object>(
 	volarLanguagePluginInitializers.add(initializer);
 	const language: Language<
 		TSNodesByName,
-		ContextServices & TypeScriptFileServices
+		Partial<ContextServices> & TypeScriptFileServices
 	> = {
 		about: {
 			name: "Volar.js-based language",
@@ -416,7 +416,7 @@ export function createVolarBasedLanguage<ContextServices extends object>(
 				// services in runRule
 				language: typescriptLanguage as Language<
 					TSNodesByName,
-					ContextServices & TypeScriptFileServices
+					Partial<ContextServices> & TypeScriptFileServices
 				>,
 			};
 		},
diff --git a/packages/vue-language/package.json b/packages/vue-language/package.json
index 192f34646..1cde20a51 100644
--- a/packages/vue-language/package.json
+++ b/packages/vue-language/package.json
@@ -13,14 +13,15 @@
 		"email": "npm@joshuakgoldberg.com"
 	},
 	"type": "module",
-	"main": "./lib/index.js",
+	"exports": {
+		".": "./lib/index.js"
+	},
 	"dependencies": {
 		"@flint.fyi/core": "workspace:",
 		"@flint.fyi/ts": "workspace:",
 		"@flint.fyi/ts-patch": "workspace:",
 		"@flint.fyi/volar-language": "workspace:",
 		"@volar/language-core": "2.4.27",
-		"@volar/typescript": "2.4.27",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/language-core": "3.2.1",
 		"ts-api-utils": "^2.1.0",
diff --git a/packages/vue-language/src/language.ts b/packages/vue-language/src/language.ts
index 587f57eef..eb72be27b 100644
--- a/packages/vue-language/src/language.ts
+++ b/packages/vue-language/src/language.ts
@@ -24,7 +24,7 @@ import {
 setTSExtraSupportedExtensions([".vue"]);
 
 export interface VueServices {
-	vueServices?: {
+	vueServices: {
 		codegen: VueCodegen;
 		map: VolarMapper;
 		sfc: RootNode;
diff --git a/patches/@volar__typescript@2.4.27.patch b/patches/@volar__typescript@2.4.27.patch
new file mode 100644
index 000000000..deaecade6
--- /dev/null
+++ b/patches/@volar__typescript@2.4.27.patch
@@ -0,0 +1,12 @@
+diff --git a/lib/node/proxyCreateProgram.js b/lib/node/proxyCreateProgram.js
+index 18fda8087826637b592c63e61518b3e42f7187cb..ee2c78734474b153b6cb1b20b7b42e8a712736b8 100644
+--- a/lib/node/proxyCreateProgram.js
++++ b/lib/node/proxyCreateProgram.js
+@@ -138,6 +138,7 @@ function proxyCreateProgram(ts, original, create) {
+                             const parsedSourceFile = ts.createSourceFile(fileName, virtualContents, languageVersionOrOptions, undefined, serviceScript.scriptKind);
+                             // @ts-expect-error
+                             parsedSourceFile.version = originalSourceFile.version;
++                            originalSourceFile.scriptKind = serviceScript.scriptKind;
+                             parsedSourceFiles.set(originalSourceFile, parsedSourceFile);
+                         }
+                         if (getExtraServiceScripts) {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index ad4f2318b..b43bc1f5c 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -13,6 +13,9 @@ patchedDependencies:
   '@typescript-eslint/project-service@8.50.1':
     hash: cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c
     path: patches/@typescript-eslint__project-service@8.50.1.patch
+  '@volar/typescript@2.4.27':
+    hash: aafa6fa3aabd60fa3c1b015842a4397edd236864bd97db78fa3437464b03b0ed
+    path: patches/@volar__typescript@2.4.27.patch
 
 importers:
 
@@ -126,30 +129,27 @@ importers:
 
   packages/astro-language:
     dependencies:
-      '@astrojs/language-server':
-        specifier: ^2.16.2
-        version: 2.16.2(prettier-plugin-astro@0.14.1)(prettier@3.7.4)(typescript@5.9.3)
+      '@astrojs/ts-plugin':
+        specifier: ^1.10.6
+        version: 1.10.6
       '@flint.fyi/core':
         specifier: 'workspace:'
         version: link:../core
       '@flint.fyi/ts':
         specifier: 'workspace:'
         version: link:../ts
-      '@volar/language-core':
-        specifier: 2.4.27
-        version: 2.4.27
-      '@volar/typescript':
-        specifier: 2.4.27
-        version: 2.4.27
+      '@flint.fyi/ts-patch':
+        specifier: 'workspace:'
+        version: link:../ts-patch
+      '@flint.fyi/volar-language':
+        specifier: 'workspace:'
+        version: link:../volar-language
       ts-api-utils:
         specifier: ^2.1.0
         version: 2.1.0(typescript@5.9.3)
       typescript:
         specifier: '>=5.9.3'
         version: 5.9.3
-      vscode-uri:
-        specifier: ^3.1.0
-        version: 3.1.0
     devDependencies:
       '@flint.fyi/rule-tester':
         specifier: 'workspace:'
@@ -597,15 +597,6 @@ importers:
       '@typescript-eslint/project-service':
         specifier: ^8.46.2
         version: 8.50.1(patch_hash=cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c)(typescript@5.9.3)
-      '@typescript/vfs':
-        specifier: ^1.6.1
-        version: 1.6.1(typescript@5.9.3)
-      '@volar/language-core':
-        specifier: 2.4.27
-        version: 2.4.27
-      '@volar/typescript':
-        specifier: 2.4.27
-        version: 2.4.27
       cached-factory:
         specifier: ^0.1.0
         version: 0.1.0
@@ -653,7 +644,7 @@ importers:
         version: 2.4.27
       '@volar/typescript':
         specifier: 2.4.27
-        version: 2.4.27
+        version: 2.4.27(patch_hash=aafa6fa3aabd60fa3c1b015842a4397edd236864bd97db78fa3437464b03b0ed)
       typescript:
         specifier: '>=5.9.3'
         version: 5.9.3
@@ -675,9 +666,6 @@ importers:
       '@volar/language-core':
         specifier: 2.4.27
         version: 2.4.27
-      '@volar/typescript':
-        specifier: 2.4.27
-        version: 2.4.27
       '@vue/compiler-dom':
         specifier: ^3.5.0
         version: 3.5.26
@@ -749,18 +737,6 @@ packages:
       prettier-plugin-astro:
         optional: true
 
-  '@astrojs/language-server@2.16.2':
-    resolution: {integrity: sha512-J3hVx/mFi3FwEzKf8ExYXQNERogD6RXswtbU+TyrxoXRBiQoBO5ooo7/lRWJ+rlUKUd7+rziMPI9jYB7TRlh0w==}
-    hasBin: true
-    peerDependencies:
-      prettier: ^3.0.0
-      prettier-plugin-astro: '>=0.11.0'
-    peerDependenciesMeta:
-      prettier:
-        optional: true
-      prettier-plugin-astro:
-        optional: true
-
   '@astrojs/markdown-remark@6.3.6':
     resolution: {integrity: sha512-bwylYktCTsLMVoCOEHbn2GSUA3c5KT/qilekBKA3CBng0bo1TYjNZPr761vxumRk9kJGqTOtU+fgCAp5Vwokug==}
 
@@ -801,6 +777,9 @@ packages:
     resolution: {integrity: sha512-UFBgfeldP06qu6khs/yY+q1cDAaArM2/7AEIqQ9Cuvf7B1hNLq0xDrZkct+QoIGyjq56y8IaE2I3CTvG99mlhQ==}
     engines: {node: 18.20.8 || ^20.3.0 || >=22.0.0}
 
+  '@astrojs/ts-plugin@1.10.6':
+    resolution: {integrity: sha512-Ke5CNwxn/ozsh6THJKuayUlBToa3uiPDi2oSwcXmTdeiJ0PGr+UkdQJf9hdMgBjbIka9fhnSn3UhYamfNfJ73A==}
+
   '@astrojs/yaml2ts@0.2.2':
     resolution: {integrity: sha512-GOfvSr5Nqy2z5XiwqTouBBpy5FyI6DEe+/g/Mk5am9SjILN1S5fOEvYK0GuWHg98yS/dobP4m8qyqw/URW35fQ==}
 
@@ -1185,9 +1164,6 @@ packages:
   '@emmetio/css-parser@0.4.0':
     resolution: {integrity: sha512-z7wkxRSZgrQHXVzObGkXG+Vmj3uRlpM11oCZ9pbaz0nFejvCDmAiNDpY75+wgXOcffKpj4rzGtwGaZxfJKsJxw==}
 
-  '@emmetio/css-parser@0.4.1':
-    resolution: {integrity: sha512-2bC6m0MV/voF4CTZiAbG5MWKbq5EBmDPKu9Sb7s7nVcEzNQlrZP6mFFFlIaISM8X6514H9shWMme1fCm8cWAfQ==}
-
   '@emmetio/html-matcher@1.3.0':
     resolution: {integrity: sha512-NTbsvppE5eVyBMuyGfVu2CRrLvo7J4YHb6t9sBFLyY03WYhXET37qA4zOYUjBWFCRHO7pS1B9khERtY0f5JXPQ==}
 
@@ -2152,11 +2128,6 @@ packages:
     resolution: {integrity: sha512-IrDKrw7pCRUR94zeuCSUWQ+w8JEf5ZX5jl/e6AHGSLi1/zIr0lgutfn/7JpfCey+urpgQEdrZVYzCaVVKiTwhQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@typescript/vfs@1.6.1':
-    resolution: {integrity: sha512-JwoxboBh7Oz1v38tPbkrZ62ZXNHAk9bJ7c9x0eI5zBfBnBYGhURdbnh7Z4smN/MV48Y5OCcZb58n972UtbazsA==}
-    peerDependencies:
-      typescript: '*'
-
   '@ungap/structured-clone@1.3.0':
     resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==}
 
@@ -2285,14 +2256,6 @@ packages:
     engines: {node: '>=0.4.0'}
     hasBin: true
 
-  ajv-draft-04@1.0.0:
-    resolution: {integrity: sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw==}
-    peerDependencies:
-      ajv: ^8.5.0
-    peerDependenciesMeta:
-      ajv:
-        optional: true
-
   ajv@6.12.6:
     resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
 
@@ -4877,14 +4840,6 @@ packages:
       '@volar/language-service':
         optional: true
 
-  volar-service-css@0.0.67:
-    resolution: {integrity: sha512-zV7C6enn9T9tuvQ6iSUyYEs34iPXR69Pf9YYWpbFYPWzVs22w96BtE8p04XYXbmjU6unt5oFt+iLL77bMB5fhA==}
-    peerDependencies:
-      '@volar/language-service': ~2.4.0
-    peerDependenciesMeta:
-      '@volar/language-service':
-        optional: true
-
   volar-service-emmet@0.0.62:
     resolution: {integrity: sha512-U4dxWDBWz7Pi4plpbXf4J4Z/ss6kBO3TYrACxWNsE29abu75QzVS0paxDDhI6bhqpbDFXlpsDhZ9aXVFpnfGRQ==}
     peerDependencies:
@@ -4893,14 +4848,6 @@ packages:
       '@volar/language-service':
         optional: true
 
-  volar-service-emmet@0.0.67:
-    resolution: {integrity: sha512-UDBL5x7KptmuJZNCCXMlCndMhFult/tj+9jXq3FH1ZGS1E4M/1U5hC06pg1c6e4kn+vnR6bqmvX0vIhL4f98+A==}
-    peerDependencies:
-      '@volar/language-service': ~2.4.0
-    peerDependenciesMeta:
-      '@volar/language-service':
-        optional: true
-
   volar-service-html@0.0.62:
     resolution: {integrity: sha512-Zw01aJsZRh4GTGUjveyfEzEqpULQUdQH79KNEiKVYHZyuGtdBRYCHlrus1sueSNMxwwkuF5WnOHfvBzafs8yyQ==}
     peerDependencies:
@@ -4909,14 +4856,6 @@ packages:
       '@volar/language-service':
         optional: true
 
-  volar-service-html@0.0.67:
-    resolution: {integrity: sha512-ljREMF79JbcjNvObiv69HK2HCl5UT7WTD10zi6CRFUHMbPfiF2UZ42HGLsEGSzaHGZz6H4IFjSS/qfENRLUviQ==}
-    peerDependencies:
-      '@volar/language-service': ~2.4.0
-    peerDependenciesMeta:
-      '@volar/language-service':
-        optional: true
-
   volar-service-prettier@0.0.62:
     resolution: {integrity: sha512-h2yk1RqRTE+vkYZaI9KYuwpDfOQRrTEMvoHol0yW4GFKc75wWQRrb5n/5abDrzMPrkQbSip8JH2AXbvrRtYh4w==}
     peerDependencies:
@@ -4928,17 +4867,6 @@ packages:
       prettier:
         optional: true
 
-  volar-service-prettier@0.0.67:
-    resolution: {integrity: sha512-B4KnPJPNWFTkEDa6Fn08i5PpO6T1CecmLLTFZoXz2eI4Fxwba/3nDaaVSsEP7e/vEe+U5YqV9fBzayJT71G5xg==}
-    peerDependencies:
-      '@volar/language-service': ~2.4.0
-      prettier: ^2.2 || ^3.0
-    peerDependenciesMeta:
-      '@volar/language-service':
-        optional: true
-      prettier:
-        optional: true
-
   volar-service-typescript-twoslash-queries@0.0.62:
     resolution: {integrity: sha512-KxFt4zydyJYYI0kFAcWPTh4u0Ha36TASPZkAnNY784GtgajerUqM80nX/W1d0wVhmcOFfAxkVsf/Ed+tiYU7ng==}
     peerDependencies:
@@ -4947,14 +4875,6 @@ packages:
       '@volar/language-service':
         optional: true
 
-  volar-service-typescript-twoslash-queries@0.0.67:
-    resolution: {integrity: sha512-LD2R7WivDYp1SPgZrxx/0222xVTitDjm36oKo5+bfYG5kEgnw+BOPVHdwmvpJKg/RfssfxDI1ouwD4XkEDEfbA==}
-    peerDependencies:
-      '@volar/language-service': ~2.4.0
-    peerDependenciesMeta:
-      '@volar/language-service':
-        optional: true
-
   volar-service-typescript@0.0.62:
     resolution: {integrity: sha512-p7MPi71q7KOsH0eAbZwPBiKPp9B2+qrdHAd6VY5oTo9BUXatsOAdakTm9Yf0DUj6uWBAaOT01BSeVOPwucMV1g==}
     peerDependencies:
@@ -4963,14 +4883,6 @@ packages:
       '@volar/language-service':
         optional: true
 
-  volar-service-typescript@0.0.67:
-    resolution: {integrity: sha512-rfQBy36Rm1PU9vLWHk8BYJ4r2j/CI024vocJcH4Nb6K2RTc2Irmw6UOVY5DdGiPRV5r+e10wLMK5njj/EcL8sA==}
-    peerDependencies:
-      '@volar/language-service': ~2.4.0
-    peerDependenciesMeta:
-      '@volar/language-service':
-        optional: true
-
   volar-service-yaml@0.0.62:
     resolution: {integrity: sha512-k7gvv7sk3wa+nGll3MaSKyjwQsJjIGCHFjVkl3wjaSP2nouKyn9aokGmqjrl39mi88Oy49giog2GkZH526wjig==}
     peerDependencies:
@@ -4979,23 +4891,12 @@ packages:
       '@volar/language-service':
         optional: true
 
-  volar-service-yaml@0.0.67:
-    resolution: {integrity: sha512-jkdP/RF6wPIXEE3Ktnd81oJPn7aAvnVSiaqQHThC2Hrvo6xd9pEcqtbBUI+YfqVgvcMtXAkbtNO61K2GPhAiuA==}
-    peerDependencies:
-      '@volar/language-service': ~2.4.0
-    peerDependenciesMeta:
-      '@volar/language-service':
-        optional: true
-
   vscode-css-languageservice@6.3.7:
     resolution: {integrity: sha512-5TmXHKllPzfkPhW4UE9sODV3E0bIOJPOk+EERKllf2SmAczjfTmYeq5txco+N3jpF8KIZ6loj/JptpHBQuVQRA==}
 
   vscode-html-languageservice@5.5.1:
     resolution: {integrity: sha512-/ZdEtsZ3OiFSyL00kmmu7crFV9KwWR+MgpzjsxO60DQH7sIfHZM892C/E4iDd11EKocr+NYuvOA4Y7uc3QzLEA==}
 
-  vscode-html-languageservice@5.6.1:
-    resolution: {integrity: sha512-5Mrqy5CLfFZUgkyhNZLA1Ye5g12Cb/v6VM7SxUzZUaRKWMDz4md+y26PrfRTSU0/eQAl3XpO9m2og+GGtDMuaA==}
-
   vscode-json-languageservice@4.1.8:
     resolution: {integrity: sha512-0vSpg6Xd9hfV+eZAaYN63xVVMOTmJ4GgHxXnkLCh+9RsQBkWKIghzLhW2B9ebfG+LQQg8uLtsQ2aUKjTgE+QOg==}
     engines: {npm: '>=7.0.0'}
@@ -5104,10 +5005,6 @@ packages:
     resolution: {integrity: sha512-N47AqBDCMQmh6mBLmI6oqxryHRzi33aPFPsJhYy3VTUGCdLHYjGh4FZzpUjRlphaADBBkDmnkM/++KNIOHi5Rw==}
     hasBin: true
 
-  yaml-language-server@1.19.2:
-    resolution: {integrity: sha512-9F3myNmJzUN/679jycdMxqtydPSDRAarSj3wPiF7pchEPnO9Dg07Oc+gIYLqXR4L+g+FSEVXXv2+mr54StLFOg==}
-    hasBin: true
-
   yaml-unist-parser@3.1.0:
     resolution: {integrity: sha512-hkwsdPLFBV6Vs40Mw5A11gzN9f9AiN8g72D8fXxfqnrW/AYY8/d7Yphx780UMzREcH7aRuHYAyQj9AwrI4E4xg==}
     engines: {node: '>= 14'}
@@ -5116,11 +5013,6 @@ packages:
     resolution: {integrity: sha512-CBKFWExMn46Foo4cldiChEzn7S7SRV+wqiluAb6xmueD/fGyRHIhX8m14vVGgeFWjN540nKCNVj6P21eQjgTuA==}
     engines: {node: '>= 14'}
 
-  yaml@2.7.1:
-    resolution: {integrity: sha512-10ULxpnOCQXxJvBgxsn9ptjq6uviG/htZKk9veJGhlqn3w/DxQ631zFF+nlQXLwmImeS5amR2dl2U8sg6U9jsQ==}
-    engines: {node: '>= 14'}
-    hasBin: true
-
   yaml@2.8.2:
     resolution: {integrity: sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==}
     engines: {node: '>= 14.6'}
@@ -5225,32 +5117,6 @@ snapshots:
     transitivePeerDependencies:
       - typescript
 
-  '@astrojs/language-server@2.16.2(prettier-plugin-astro@0.14.1)(prettier@3.7.4)(typescript@5.9.3)':
-    dependencies:
-      '@astrojs/compiler': 2.13.0
-      '@astrojs/yaml2ts': 0.2.2
-      '@jridgewell/sourcemap-codec': 1.5.5
-      '@volar/kit': 2.4.23(typescript@5.9.3)
-      '@volar/language-core': 2.4.27
-      '@volar/language-server': 2.4.23
-      '@volar/language-service': 2.4.23
-      fast-glob: 3.3.3
-      muggle-string: 0.4.1
-      volar-service-css: 0.0.67(@volar/language-service@2.4.23)
-      volar-service-emmet: 0.0.67(@volar/language-service@2.4.23)
-      volar-service-html: 0.0.67(@volar/language-service@2.4.23)
-      volar-service-prettier: 0.0.67(@volar/language-service@2.4.23)(prettier@3.7.4)
-      volar-service-typescript: 0.0.67(@volar/language-service@2.4.23)
-      volar-service-typescript-twoslash-queries: 0.0.67(@volar/language-service@2.4.23)
-      volar-service-yaml: 0.0.67(@volar/language-service@2.4.23)
-      vscode-html-languageservice: 5.6.1
-      vscode-uri: 3.1.0
-    optionalDependencies:
-      prettier: 3.7.4
-      prettier-plugin-astro: 0.14.1
-    transitivePeerDependencies:
-      - typescript
-
   '@astrojs/markdown-remark@6.3.6':
     dependencies:
       '@astrojs/internal-helpers': 0.7.2
@@ -5406,6 +5272,16 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@astrojs/ts-plugin@1.10.6':
+    dependencies:
+      '@astrojs/compiler': 2.13.0
+      '@astrojs/yaml2ts': 0.2.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@volar/language-core': 2.4.27
+      '@volar/typescript': 2.4.27(patch_hash=aafa6fa3aabd60fa3c1b015842a4397edd236864bd97db78fa3437464b03b0ed)
+      semver: 7.7.3
+      vscode-languageserver-textdocument: 1.0.12
+
   '@astrojs/yaml2ts@0.2.2':
     dependencies:
       yaml: 2.8.2
@@ -5901,11 +5777,6 @@ snapshots:
       '@emmetio/stream-reader': 2.2.0
       '@emmetio/stream-reader-utils': 0.1.0
 
-  '@emmetio/css-parser@0.4.1':
-    dependencies:
-      '@emmetio/stream-reader': 2.2.0
-      '@emmetio/stream-reader-utils': 0.1.0
-
   '@emmetio/html-matcher@1.3.0':
     dependencies:
       '@emmetio/scanner': 1.0.4
@@ -6804,13 +6675,6 @@ snapshots:
       '@typescript-eslint/types': 8.50.1
       eslint-visitor-keys: 4.2.1
 
-  '@typescript/vfs@1.6.1(typescript@5.9.3)':
-    dependencies:
-      debug: 4.4.3
-      typescript: 5.9.3
-    transitivePeerDependencies:
-      - supports-color
-
   '@ungap/structured-clone@1.3.0': {}
 
   '@vitejs/plugin-react@4.7.0(vite@6.4.1(@types/node@24.10.1)(jiti@2.6.1)(yaml@2.8.2))':
@@ -6921,7 +6785,7 @@ snapshots:
       path-browserify: 1.0.1
       vscode-uri: 3.1.0
 
-  '@volar/typescript@2.4.27':
+  '@volar/typescript@2.4.27(patch_hash=aafa6fa3aabd60fa3c1b015842a4397edd236864bd97db78fa3437464b03b0ed)':
     dependencies:
       '@volar/language-core': 2.4.27
       path-browserify: 1.0.1
@@ -7007,10 +6871,6 @@ snapshots:
 
   acorn@8.15.0: {}
 
-  ajv-draft-04@1.0.0(ajv@8.17.1):
-    optionalDependencies:
-      ajv: 8.17.1
-
   ajv@6.12.6:
     dependencies:
       fast-deep-equal: 3.1.3
@@ -10204,14 +10064,6 @@ snapshots:
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
-  volar-service-css@0.0.67(@volar/language-service@2.4.23):
-    dependencies:
-      vscode-css-languageservice: 6.3.7
-      vscode-languageserver-textdocument: 1.0.12
-      vscode-uri: 3.1.0
-    optionalDependencies:
-      '@volar/language-service': 2.4.23
-
   volar-service-emmet@0.0.62(@volar/language-service@2.4.23):
     dependencies:
       '@emmetio/css-parser': 0.4.0
@@ -10221,15 +10073,6 @@ snapshots:
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
-  volar-service-emmet@0.0.67(@volar/language-service@2.4.23):
-    dependencies:
-      '@emmetio/css-parser': 0.4.1
-      '@emmetio/html-matcher': 1.3.0
-      '@vscode/emmet-helper': 2.11.0
-      vscode-uri: 3.1.0
-    optionalDependencies:
-      '@volar/language-service': 2.4.23
-
   volar-service-html@0.0.62(@volar/language-service@2.4.23):
     dependencies:
       vscode-html-languageservice: 5.5.1
@@ -10238,14 +10081,6 @@ snapshots:
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
-  volar-service-html@0.0.67(@volar/language-service@2.4.23):
-    dependencies:
-      vscode-html-languageservice: 5.6.1
-      vscode-languageserver-textdocument: 1.0.12
-      vscode-uri: 3.1.0
-    optionalDependencies:
-      '@volar/language-service': 2.4.23
-
   volar-service-prettier@0.0.62(@volar/language-service@2.4.23)(prettier@3.7.4):
     dependencies:
       vscode-uri: 3.1.0
@@ -10253,25 +10088,12 @@ snapshots:
       '@volar/language-service': 2.4.23
       prettier: 3.7.4
 
-  volar-service-prettier@0.0.67(@volar/language-service@2.4.23)(prettier@3.7.4):
-    dependencies:
-      vscode-uri: 3.1.0
-    optionalDependencies:
-      '@volar/language-service': 2.4.23
-      prettier: 3.7.4
-
   volar-service-typescript-twoslash-queries@0.0.62(@volar/language-service@2.4.23):
     dependencies:
       vscode-uri: 3.1.0
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
-  volar-service-typescript-twoslash-queries@0.0.67(@volar/language-service@2.4.23):
-    dependencies:
-      vscode-uri: 3.1.0
-    optionalDependencies:
-      '@volar/language-service': 2.4.23
-
   volar-service-typescript@0.0.62(@volar/language-service@2.4.23):
     dependencies:
       path-browserify: 1.0.1
@@ -10283,17 +10105,6 @@ snapshots:
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
-  volar-service-typescript@0.0.67(@volar/language-service@2.4.23):
-    dependencies:
-      path-browserify: 1.0.1
-      semver: 7.7.3
-      typescript-auto-import-cache: 0.3.6
-      vscode-languageserver-textdocument: 1.0.12
-      vscode-nls: 5.2.0
-      vscode-uri: 3.1.0
-    optionalDependencies:
-      '@volar/language-service': 2.4.23
-
   volar-service-yaml@0.0.62(@volar/language-service@2.4.23):
     dependencies:
       vscode-uri: 3.1.0
@@ -10301,13 +10112,6 @@ snapshots:
     optionalDependencies:
       '@volar/language-service': 2.4.23
 
-  volar-service-yaml@0.0.67(@volar/language-service@2.4.23):
-    dependencies:
-      vscode-uri: 3.1.0
-      yaml-language-server: 1.19.2
-    optionalDependencies:
-      '@volar/language-service': 2.4.23
-
   vscode-css-languageservice@6.3.7:
     dependencies:
       '@vscode/l10n': 0.0.18
@@ -10322,13 +10126,6 @@ snapshots:
       vscode-languageserver-types: 3.17.5
       vscode-uri: 3.1.0
 
-  vscode-html-languageservice@5.6.1:
-    dependencies:
-      '@vscode/l10n': 0.0.18
-      vscode-languageserver-textdocument: 1.0.12
-      vscode-languageserver-types: 3.17.5
-      vscode-uri: 3.1.0
-
   vscode-json-languageservice@4.1.8:
     dependencies:
       jsonc-parser: 3.3.1
@@ -10440,29 +10237,12 @@ snapshots:
     optionalDependencies:
       prettier: 2.8.7
 
-  yaml-language-server@1.19.2:
-    dependencies:
-      '@vscode/l10n': 0.0.18
-      ajv: 8.17.1
-      ajv-draft-04: 1.0.0(ajv@8.17.1)
-      lodash: 4.17.21
-      prettier: 3.7.4
-      request-light: 0.5.8
-      vscode-json-languageservice: 4.1.8
-      vscode-languageserver: 9.0.1
-      vscode-languageserver-textdocument: 1.0.12
-      vscode-languageserver-types: 3.17.5
-      vscode-uri: 3.1.0
-      yaml: 2.7.1
-
   yaml-unist-parser@3.1.0:
     dependencies:
       yaml: 2.8.2
 
   yaml@2.2.2: {}
 
-  yaml@2.7.1: {}
-
   yaml@2.8.2: {}
 
   yargs-parser@21.1.1: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 9d835180d..7a6992079 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,3 +1,6 @@
+packages:
+  - packages/*
+
 autoInstallPeers: false
 
 disallowWorkspaceCycles: true
@@ -11,12 +14,10 @@ overrides:
   read-pkg: 10.0.0
   unicorn-magic: 0.4.0
 
-packages:
-  - packages/*
+patchedDependencies:
+  "@typescript-eslint/project-service@8.50.1": patches/@typescript-eslint__project-service@8.50.1.patch
+  "@volar/typescript@2.4.27": patches/@volar__typescript@2.4.27.patch
 
 strictDepBuilds: true
 
 strictPeerDependencies: true
-
-patchedDependencies:
-  "@typescript-eslint/project-service@8.50.1": patches/@typescript-eslint__project-service@8.50.1.patch

From 085b836b873b585399d5e9d8d43365e6fad2b545 Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Thu, 1 Jan 2026 00:23:01 +0300
Subject: [PATCH 09/11] svelte!

---
 packages/astro-language/package.json          |   1 +
 .../src/rules/anyReturns.test.ts              |  24 ++-
 packages/svelte-language/package.json         |  41 ++++
 packages/svelte-language/src/language.ts      |  44 +++++
 .../src/rules/anyReturns.test.ts              |  55 ++++++
 .../svelte-language/src/rules/ruleTester.ts   |  11 ++
 .../src/volarLanguagePlugin.ts                | 175 ++++++++++++++++++
 packages/svelte-language/tsconfig.json        |  15 ++
 pnpm-lock.yaml                                | 123 ++++++++++++
 9 files changed, 487 insertions(+), 2 deletions(-)
 create mode 100644 packages/svelte-language/package.json
 create mode 100644 packages/svelte-language/src/language.ts
 create mode 100644 packages/svelte-language/src/rules/anyReturns.test.ts
 create mode 100644 packages/svelte-language/src/rules/ruleTester.ts
 create mode 100644 packages/svelte-language/src/volarLanguagePlugin.ts
 create mode 100644 packages/svelte-language/tsconfig.json

diff --git a/packages/astro-language/package.json b/packages/astro-language/package.json
index 01113cd5b..985c72fea 100644
--- a/packages/astro-language/package.json
+++ b/packages/astro-language/package.json
@@ -17,6 +17,7 @@
 		".": "./lib/index.js"
 	},
 	"dependencies": {
+		"@astrojs/compiler": "^2.13.0",
 		"@astrojs/ts-plugin": "^1.10.6",
 		"@flint.fyi/core": "workspace:",
 		"@flint.fyi/ts": "workspace:",
diff --git a/packages/astro-language/src/rules/anyReturns.test.ts b/packages/astro-language/src/rules/anyReturns.test.ts
index 2d8a8cd41..1c06cca46 100644
--- a/packages/astro-language/src/rules/anyReturns.test.ts
+++ b/packages/astro-language/src/rules/anyReturns.test.ts
@@ -7,7 +7,6 @@ ruleTester.describe(astroLanguage.createRule(rule), {
 		{
 			code: `
 ---
-type bar = 1
 function foo() {
 	return 1 as any
 }
@@ -15,7 +14,6 @@ function foo() {
 			`,
 			snapshot: `
 ---
-type bar = 1
 function foo() {
 	return 1 as any
 	~~~~~~~~~~~~~~~
@@ -24,6 +22,28 @@ function foo() {
 ---
 			`,
 		},
+		{
+			code: `
+---
+---
+{
+function foo() {
+	return 1 as any
+}
+}
+			`,
+			snapshot: `
+---
+---
+{
+function foo() {
+	return 1 as any
+	~~~~~~~~~~~~~~~
+	Unsafe return of a value of type \`any\`.
+}
+}
+			`,
+		},
 	],
 	valid: [
 		{
diff --git a/packages/svelte-language/package.json b/packages/svelte-language/package.json
new file mode 100644
index 000000000..2b09e6eb0
--- /dev/null
+++ b/packages/svelte-language/package.json
@@ -0,0 +1,41 @@
+{
+	"name": "@flint.fyi/svelte-language",
+	"version": "0.0.1",
+	"description": "[Experimental] TypeScript language plugin for Flint.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/JoshuaKGoldberg/flint",
+		"directory": "packages/ts"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "JoshuaKGoldberg",
+		"email": "npm@joshuakgoldberg.com"
+	},
+	"type": "module",
+	"exports": {
+		".": "./lib/index.js"
+	},
+	"dependencies": {
+		"@flint.fyi/core": "workspace:",
+		"@flint.fyi/ts": "workspace:",
+		"@flint.fyi/ts-patch": "workspace:",
+		"@flint.fyi/volar-language": "workspace:",
+		"@jridgewell/sourcemap-codec": "^1.5.5",
+		"@volar/language-core": "2.4.27",
+		"svelte2tsx": "^0.7.46",
+		"ts-api-utils": "^2.1.0",
+		"typescript": ">=5.9.3"
+	},
+	"devDependencies": {
+		"@flint.fyi/rule-tester": "workspace:",
+		"svelte": "^5.46.1"
+	},
+	"engines": {
+		"node": ">=24.0.0"
+	},
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	}
+}
diff --git a/packages/svelte-language/src/language.ts b/packages/svelte-language/src/language.ts
new file mode 100644
index 000000000..c11d23c75
--- /dev/null
+++ b/packages/svelte-language/src/language.ts
@@ -0,0 +1,44 @@
+import { RuleReporter } from "@flint.fyi/core";
+
+import { setTSExtraSupportedExtensions } from "@flint.fyi/ts-patch";
+import { createVolarBasedLanguage } from "@flint.fyi/volar-language";
+import { svelteVolarLanguagePlugin } from "./volarLanguagePlugin.js";
+
+setTSExtraSupportedExtensions([".svelte"]);
+
+export interface SvelteServices {
+	astroServices?: {
+		reportComponent: RuleReporter<string>;
+	};
+}
+
+export const svelteLanguage = createVolarBasedLanguage<SvelteServices>(
+	(ts, options) => {
+		return {
+			languagePlugins: svelteVolarLanguagePlugin,
+			prepareFile(
+				filePathAbsolute,
+				{ program, sourceFile },
+				volarLanguage,
+				sourceScript,
+				serviceScript,
+			) {
+				const sourceText = sourceScript.snapshot.getText(
+					0,
+					sourceScript.snapshot.getLength(),
+				);
+				return {
+					// TODO: first statement
+					firstStatementPosition: sourceText.length,
+					extraContext(reportTranslated) {
+						return {
+							astroServices: {
+								reportComponent: reportTranslated,
+							},
+						};
+					},
+				};
+			},
+		};
+	},
+);
diff --git a/packages/svelte-language/src/rules/anyReturns.test.ts b/packages/svelte-language/src/rules/anyReturns.test.ts
new file mode 100644
index 000000000..f3e9fbc43
--- /dev/null
+++ b/packages/svelte-language/src/rules/anyReturns.test.ts
@@ -0,0 +1,55 @@
+import rule from "../../../ts/lib/rules/anyReturns.js";
+import { svelteLanguage } from "../language.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(svelteLanguage.createRule(rule), {
+	invalid: [
+		{
+			code: `
+<script lang="ts">
+	function foo() {
+		return {} as any
+	}
+</script>
+			`,
+			snapshot: `
+<script lang="ts">
+	function foo() {
+		return {} as any
+		~~~~~~~~~~~~~~~~
+		Unsafe return of a value of type \`any\`.
+	}
+</script>
+			`,
+		},
+		{
+			code: `
+<script lang="ts">
+	let foo = {} as any
+</script>
+
+<button onclick={() => foo}></button>
+			`,
+			snapshot: `
+<script lang="ts">
+	let foo = {} as any
+</script>
+
+<button onclick={() => foo}></button>
+                       ~~~
+                       Unsafe return of a value of type \`any\`.
+			`,
+		},
+	],
+	valid: [
+		{
+			code: `
+<script lang="ts">
+	let foo = {}
+</script>
+
+<button onclick={() => foo}></button>
+		`,
+		},
+	],
+});
diff --git a/packages/svelte-language/src/rules/ruleTester.ts b/packages/svelte-language/src/rules/ruleTester.ts
new file mode 100644
index 000000000..171f59880
--- /dev/null
+++ b/packages/svelte-language/src/rules/ruleTester.ts
@@ -0,0 +1,11 @@
+import { createRuleTesterTSHost, RuleTester } from "@flint.fyi/rule-tester";
+import { describe, it } from "vitest";
+
+export const ruleTester = new RuleTester({
+	describe,
+	it,
+	defaults: {
+		fileName: "file.svelte",
+	},
+	host: createRuleTesterTSHost(import.meta.dirname),
+});
diff --git a/packages/svelte-language/src/volarLanguagePlugin.ts b/packages/svelte-language/src/volarLanguagePlugin.ts
new file mode 100644
index 000000000..17e2cc1fa
--- /dev/null
+++ b/packages/svelte-language/src/volarLanguagePlugin.ts
@@ -0,0 +1,175 @@
+import {
+	getPositionOfColumnAndLine,
+	SourceFileWithLineMap,
+} from "@flint.fyi/core";
+import { decode } from "@jridgewell/sourcemap-codec";
+import {
+	forEachEmbeddedCode,
+	type CodeMapping,
+	type LanguagePlugin,
+	type VirtualCode,
+} from "@volar/language-core";
+import { svelte2tsx } from "svelte2tsx";
+import type * as ts from "typescript";
+
+// adapted from https://github.com/withastro/astro/blob/a19140fd11efbc635a391d176da54b0dc5e4a99c/packages/language-tools/ts-plugin/src/astro2tsx.ts
+
+export const svelteVolarLanguagePlugin: LanguagePlugin<string> = {
+	getLanguageId(fileName) {
+		if (fileName.endsWith(".svelte")) {
+			return "svelte";
+		}
+	},
+	createVirtualCode(fileName, languageId, snapshot) {
+		if (languageId === "svelte") {
+			return {
+				id: "root",
+				languageId,
+				snapshot,
+				embeddedCodes: [
+					getEmbeddedTsCode(snapshot.getText(0, snapshot.getLength())),
+				].filter((v): v is VirtualCode => !!v),
+				mappings: [],
+				codegenStacks: [],
+			};
+		}
+	},
+	updateVirtualCode(_fileNameOrUri, virtualCode, snapshot) {
+		virtualCode.snapshot = snapshot;
+		virtualCode.embeddedCodes = [
+			getEmbeddedTsCode(snapshot.getText(0, snapshot.getLength())),
+		].filter((v): v is VirtualCode => !!v);
+		return virtualCode;
+	},
+	typescript: {
+		extraFileExtensions: [
+			{
+				extension: "svelte",
+				isMixedContent: true,
+				scriptKind: 7 satisfies ts.ScriptKind.Deferred,
+			},
+		],
+		getServiceScript(root) {
+			for (const code of forEachEmbeddedCode(root)) {
+				if (code.id === "tsx") {
+					return {
+						code,
+						scriptKind: 4,
+						extension: ".tsx",
+					};
+				}
+			}
+		},
+	},
+};
+
+function getEmbeddedTsCode(text: string): VirtualCode | undefined {
+	// TODO: handle parsing errors
+	const tsx = svelte2tsx(text, {
+		isTsFile: true,
+		mode: "ts",
+	});
+	const v3Mappings = decode(tsx.map.mappings);
+	const sourceTextWithLineMap: SourceFileWithLineMap = {
+		text,
+	};
+	const serviceTextWithLineMap: SourceFileWithLineMap = {
+		text: tsx.code,
+	};
+	const mappings: CodeMapping[] = [];
+
+	let current:
+		| {
+				genOffset: number;
+				sourceOffset: number;
+		  }
+		| undefined;
+
+	for (let genLine = 0; genLine < v3Mappings.length; genLine++) {
+		for (const segment of v3Mappings[genLine]) {
+			const genCharacter = segment[0];
+			const genOffset = getPositionOfColumnAndLine(serviceTextWithLineMap, {
+				line: genLine,
+				column: genCharacter,
+			});
+			if (current) {
+				let length = genOffset - current.genOffset;
+				const sourceText = text.substring(
+					current.sourceOffset,
+					current.sourceOffset + length,
+				);
+				const genText = tsx.code.substring(
+					current.genOffset,
+					current.genOffset + length,
+				);
+				if (sourceText !== genText) {
+					length = 0;
+					for (let i = 0; i < genOffset - current.genOffset; i++) {
+						if (sourceText[i] === genText[i]) {
+							length = i + 1;
+						} else {
+							break;
+						}
+					}
+				}
+				if (length > 0) {
+					const lastMapping = mappings.length
+						? mappings[mappings.length - 1]
+						: undefined;
+					if (
+						lastMapping &&
+						lastMapping.generatedOffsets[0] + lastMapping.lengths[0] ===
+							current.genOffset &&
+						lastMapping.sourceOffsets[0] + lastMapping.lengths[0] ===
+							current.sourceOffset
+					) {
+						lastMapping.lengths[0] += length;
+					} else {
+						mappings.push({
+							sourceOffsets: [current.sourceOffset],
+							generatedOffsets: [current.genOffset],
+							lengths: [length],
+							data: {
+								verification: true,
+								completion: true,
+								semantic: true,
+								navigation: true,
+								structure: false,
+								format: false,
+							},
+						});
+					}
+				}
+				current = undefined;
+			}
+			if (segment[2] !== undefined && segment[3] !== undefined) {
+				const sourceOffset = getPositionOfColumnAndLine(sourceTextWithLineMap, {
+					line: segment[2],
+					column: segment[3],
+				});
+				current = {
+					genOffset,
+					sourceOffset,
+				};
+			}
+		}
+	}
+
+	return {
+		id: "tsx",
+		languageId: "typescriptreact",
+		snapshot: {
+			getText(start, end) {
+				return tsx.code.substring(start, end);
+			},
+			getLength() {
+				return tsx.code.length;
+			},
+			getChangeRange() {
+				return undefined;
+			},
+		},
+		mappings: mappings,
+		embeddedCodes: [],
+	};
+}
diff --git a/packages/svelte-language/tsconfig.json b/packages/svelte-language/tsconfig.json
new file mode 100644
index 000000000..16522fb6a
--- /dev/null
+++ b/packages/svelte-language/tsconfig.json
@@ -0,0 +1,15 @@
+{
+	"compilerOptions": {
+		"outDir": "lib",
+		"rootDir": "src"
+	},
+	"extends": "../../tsconfig.base.json",
+	"include": ["src"],
+	"references": [
+		{ "path": "../core" },
+		{ "path": "../ts" },
+		{ "path": "../rule-tester" },
+		{ "path": "../ts-patch" },
+		{ "path": "../volar-language" }
+	]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b43bc1f5c..0d2e59bc5 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -129,6 +129,9 @@ importers:
 
   packages/astro-language:
     dependencies:
+      '@astrojs/compiler':
+        specifier: ^2.13.0
+        version: 2.13.0
       '@astrojs/ts-plugin':
         specifier: ^1.10.6
         version: 1.10.6
@@ -577,6 +580,43 @@ importers:
         specifier: 0.34.5
         version: 0.34.5
 
+  packages/svelte-language:
+    dependencies:
+      '@flint.fyi/core':
+        specifier: 'workspace:'
+        version: link:../core
+      '@flint.fyi/ts':
+        specifier: 'workspace:'
+        version: link:../ts
+      '@flint.fyi/ts-patch':
+        specifier: 'workspace:'
+        version: link:../ts-patch
+      '@flint.fyi/volar-language':
+        specifier: 'workspace:'
+        version: link:../volar-language
+      '@jridgewell/sourcemap-codec':
+        specifier: ^1.5.5
+        version: 1.5.5
+      '@volar/language-core':
+        specifier: 2.4.27
+        version: 2.4.27
+      svelte2tsx:
+        specifier: ^0.7.46
+        version: 0.7.46(svelte@5.46.1)(typescript@5.9.3)
+      ts-api-utils:
+        specifier: ^2.1.0
+        version: 2.1.0(typescript@5.9.3)
+      typescript:
+        specifier: '>=5.9.3'
+        version: 5.9.3
+    devDependencies:
+      '@flint.fyi/rule-tester':
+        specifier: 'workspace:'
+        version: link:../rule-tester
+      svelte:
+        specifier: ^5.46.1
+        version: 5.46.1
+
   packages/text:
     dependencies:
       '@flint.fyi/core':
@@ -1928,6 +1968,11 @@ packages:
   '@standard-schema/spec@1.0.0':
     resolution: {integrity: sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==}
 
+  '@sveltejs/acorn-typescript@1.0.8':
+    resolution: {integrity: sha512-esgN+54+q0NjB0Y/4BomT9samII7jGwNy/2a3wNZbT2A2RpmXsXwUt24LvLhx6jUq2gVk4cWEvcRO6MFQbOfNA==}
+    peerDependencies:
+      acorn: ^8.9.0
+
   '@swc/helpers@0.5.17':
     resolution: {integrity: sha512-5IKx/Y13RsYd+sauPb2x+U/xZikHjolzfuDgTAl/Tdf3Q8rslRvC19NKDLgAJQ6wsqADk10ntlv08nPFw/gO/A==}
 
@@ -2655,6 +2700,9 @@ packages:
   decode-named-character-reference@1.2.0:
     resolution: {integrity: sha512-c6fcElNV6ShtZXmsgNgFFV5tVX2PaV4g+MOAkb8eXHvn6sryJBrZa9r0zV6+dtTyoCKxtDy5tyQ5ZwQuidtd+Q==}
 
+  dedent-js@1.0.1:
+    resolution: {integrity: sha512-OUepMozQULMLUmhxS95Vudo0jb0UchLimi3+pQ2plj61Fcy8axbP9hbiD4Sz6DPqn6XG3kfmziVfQ1rSys5AJQ==}
+
   deep-is@0.1.4:
     resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
 
@@ -2907,6 +2955,9 @@ packages:
       jiti:
         optional: true
 
+  esm-env@1.2.2:
+    resolution: {integrity: sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==}
+
   espree@10.4.0:
     resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@@ -2924,6 +2975,9 @@ packages:
     resolution: {integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==}
     engines: {node: '>=0.10'}
 
+  esrap@2.2.1:
+    resolution: {integrity: sha512-GiYWG34AN/4CUyaWAgunGt0Rxvr1PTMlGC0vvEov/uOQYWne2bpN03Um+k8jT+q3op33mKouP2zeJ6OlM+qeUg==}
+
   esrecurse@4.3.0:
     resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
     engines: {node: '>=4.0'}
@@ -3324,6 +3378,9 @@ packages:
     resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==}
     engines: {node: '>=12'}
 
+  is-reference@3.0.3:
+    resolution: {integrity: sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==}
+
   is-subdir@1.2.0:
     resolution: {integrity: sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==}
     engines: {node: '>=4'}
@@ -3453,6 +3510,9 @@ packages:
     resolution: {integrity: sha512-ME4Fb83LgEgwNw96RKNvKV4VTLuXfoKudAmm2lP8Kk87KaMK0/Xrx/aAkMWmT8mDb+3MlFDspfbCs7adjRxA2g==}
     engines: {node: '>=20.0.0'}
 
+  locate-character@3.0.0:
+    resolution: {integrity: sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==}
+
   locate-path@5.0.0:
     resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
     engines: {node: '>=8'}
@@ -4234,6 +4294,9 @@ packages:
     resolution: {integrity: sha512-3A6sD0WYP7+QrjbfNA2FN3FsOaGGFoekCVgTyypy53gPxhbkCIjtO6YWgdrfM+n/8sI8JeXZOIxsHjMTNxQ4nQ==}
     engines: {node: ^14.0.0 || >=16.0.0}
 
+  scule@1.3.0:
+    resolution: {integrity: sha512-6FtHJEvt+pVMIB9IBY+IcCJ6Z5f1iQnytgyfKMhDKgmzYG+TeH/wx1y3l27rshSbLiSanrR9ffZDrEsmjlQF2g==}
+
   semver@6.3.1:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
@@ -4437,6 +4500,16 @@ packages:
     resolution: {integrity: sha512-i6sWEzuwadSlcr2mOnb0ktlIl+K5FVxsPXmoPfknDd2gyw4ZBIAZ5coc0NQzYqDdEYXMHy8NaY9rWwa1Q1myiQ==}
     engines: {node: '>=20'}
 
+  svelte2tsx@0.7.46:
+    resolution: {integrity: sha512-S++Vw3w47a8rBuhbz4JK0fcGea8tOoX1boT53Aib8+oUO2EKeOG+geXprJVTDfBlvR+IJdf3jIpR2RGwT6paQA==}
+    peerDependencies:
+      svelte: ^3.55 || ^4.0.0-next.0 || ^4.0 || ^5.0.0-next.0
+      typescript: ^4.9.4 || ^5.0.0
+
+  svelte@5.46.1:
+    resolution: {integrity: sha512-ynjfCHD3nP2el70kN5Pmg37sSi0EjOm9FgHYQdC4giWG/hzO3AatzXXJJgP305uIhGQxSufJLuYWtkY8uK/8RA==}
+    engines: {node: '>=18'}
+
   svgo@4.0.0:
     resolution: {integrity: sha512-VvrHQ+9uniE+Mvx3+C9IEe/lWasXCU0nXMY2kZeLrHNICuRiC8uMPyM14UEaMOFA5mhyQqEkB02VoQ16n3DLaw==}
     engines: {node: '>=16'}
@@ -5050,6 +5123,9 @@ packages:
     resolution: {integrity: sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==}
     engines: {node: '>=18'}
 
+  zimmerframe@1.1.4:
+    resolution: {integrity: sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==}
+
   zod-to-json-schema@3.25.0:
     resolution: {integrity: sha512-HvWtU2UG41LALjajJrML6uQejQhNJx+JBO9IflpSja4R03iNWfKXrj6W2h7ljuLyc1nKS+9yDyL/9tD1U/yBnQ==}
     peerDependencies:
@@ -6421,6 +6497,10 @@ snapshots:
 
   '@standard-schema/spec@1.0.0': {}
 
+  '@sveltejs/acorn-typescript@1.0.8(acorn@8.15.0)':
+    dependencies:
+      acorn: 8.15.0
+
   '@swc/helpers@0.5.17':
     dependencies:
       tslib: 2.8.1
@@ -7373,6 +7453,8 @@ snapshots:
     dependencies:
       character-entities: 2.0.2
 
+  dedent-js@1.0.1: {}
+
   deep-is@0.1.4: {}
 
   defu@6.1.4: {}
@@ -7695,6 +7777,8 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  esm-env@1.2.2: {}
+
   espree@10.4.0:
     dependencies:
       acorn: 8.15.0
@@ -7713,6 +7797,10 @@ snapshots:
     dependencies:
       estraverse: 5.3.0
 
+  esrap@2.2.1:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+
   esrecurse@4.3.0:
     dependencies:
       estraverse: 5.3.0
@@ -8210,6 +8298,10 @@ snapshots:
 
   is-plain-obj@4.1.0: {}
 
+  is-reference@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+
   is-subdir@1.2.0:
     dependencies:
       better-path-resolve: 1.0.0
@@ -8336,6 +8428,8 @@ snapshots:
       rfdc: 1.4.1
       wrap-ansi: 9.0.2
 
+  locate-character@3.0.0: {}
+
   locate-path@5.0.0:
     dependencies:
       p-locate: 4.1.0
@@ -9500,6 +9594,8 @@ snapshots:
       refa: 0.12.1
       regexp-ast-analysis: 0.7.1
 
+  scule@1.3.0: {}
+
   semver@6.3.1: {}
 
   semver@7.7.3: {}
@@ -9753,6 +9849,31 @@ snapshots:
       has-flag: 5.0.1
       supports-color: 10.2.2
 
+  svelte2tsx@0.7.46(svelte@5.46.1)(typescript@5.9.3):
+    dependencies:
+      dedent-js: 1.0.1
+      scule: 1.3.0
+      svelte: 5.46.1
+      typescript: 5.9.3
+
+  svelte@5.46.1:
+    dependencies:
+      '@jridgewell/remapping': 2.3.5
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@sveltejs/acorn-typescript': 1.0.8(acorn@8.15.0)
+      '@types/estree': 1.0.8
+      acorn: 8.15.0
+      aria-query: 5.3.2
+      axobject-query: 4.1.0
+      clsx: 2.1.1
+      devalue: 5.5.0
+      esm-env: 1.2.2
+      esrap: 2.2.1
+      is-reference: 3.0.3
+      locate-character: 3.0.0
+      magic-string: 0.30.21
+      zimmerframe: 1.1.4
+
   svgo@4.0.0:
     dependencies:
       commander: 11.1.0
@@ -10278,6 +10399,8 @@ snapshots:
 
   yoctocolors@2.1.2: {}
 
+  zimmerframe@1.1.4: {}
+
   zod-to-json-schema@3.25.0(zod@3.25.76):
     dependencies:
       zod: 3.25.76

From 75d19831b7476b89271989fbe25e9d1593d4e628 Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Thu, 1 Jan 2026 14:56:50 +0300
Subject: [PATCH 10/11] svelte & astro rules

---
 packages/astro-language/src/language.ts       |  7 ++-
 .../src/rules/anyReturns.test.ts              |  8 +--
 .../src/rules/setHtmlDirectives.test.ts       | 57 +++++++++++++++++
 .../src/rules/setHtmlDirectives.ts            | 42 +++++++++++++
 packages/svelte-language/src/language.ts      | 13 +++-
 .../src/rules/rawSpecialElements.test.ts      | 28 +++++++++
 .../src/rules/rawSpecialElements.ts           | 62 +++++++++++++++++++
 7 files changed, 207 insertions(+), 10 deletions(-)
 create mode 100644 packages/astro-language/src/rules/setHtmlDirectives.test.ts
 create mode 100644 packages/astro-language/src/rules/setHtmlDirectives.ts
 create mode 100644 packages/svelte-language/src/rules/rawSpecialElements.test.ts
 create mode 100644 packages/svelte-language/src/rules/rawSpecialElements.ts

diff --git a/packages/astro-language/src/language.ts b/packages/astro-language/src/language.ts
index 804549b76..c600ca06e 100644
--- a/packages/astro-language/src/language.ts
+++ b/packages/astro-language/src/language.ts
@@ -1,4 +1,6 @@
 import { getLanguagePlugin } from "@astrojs/ts-plugin/dist/language.js";
+import { parse } from "@astrojs/compiler/sync";
+import { RootNode } from "@astrojs/compiler/types";
 
 import { RuleReporter } from "@flint.fyi/core";
 
@@ -9,6 +11,7 @@ setTSExtraSupportedExtensions([".astro"]);
 
 export interface AstroServices {
 	astroServices?: {
+		ast: RootNode;
 		reportComponent: RuleReporter<string>;
 	};
 }
@@ -22,18 +25,20 @@ export const astroLanguage = createVolarBasedLanguage<AstroServices>(
 				{ program, sourceFile },
 				volarLanguage,
 				sourceScript,
-				serviceScript,
 			) {
 				const sourceText = sourceScript.snapshot.getText(
 					0,
 					sourceScript.snapshot.getLength(),
 				);
+				// TODO: report parsing errors?
+				const { ast } = parse(sourceText, { position: true });
 				return {
 					// TODO: first statement
 					firstStatementPosition: sourceText.length,
 					extraContext(reportTranslated) {
 						return {
 							astroServices: {
+								ast,
 								reportComponent: reportTranslated,
 							},
 						};
diff --git a/packages/astro-language/src/rules/anyReturns.test.ts b/packages/astro-language/src/rules/anyReturns.test.ts
index 1c06cca46..a3d9afa8b 100644
--- a/packages/astro-language/src/rules/anyReturns.test.ts
+++ b/packages/astro-language/src/rules/anyReturns.test.ts
@@ -24,8 +24,6 @@ function foo() {
 		},
 		{
 			code: `
----
----
 {
 function foo() {
 	return 1 as any
@@ -33,8 +31,6 @@ function foo() {
 }
 			`,
 			snapshot: `
----
----
 {
 function foo() {
 	return 1 as any
@@ -46,14 +42,12 @@ function foo() {
 		},
 	],
 	valid: [
-		{
-			code: `
+		`
 ---
 function foo() {
 	return 1
 }
 ---
 		`,
-		},
 	],
 });
diff --git a/packages/astro-language/src/rules/setHtmlDirectives.test.ts b/packages/astro-language/src/rules/setHtmlDirectives.test.ts
new file mode 100644
index 000000000..41adb5d00
--- /dev/null
+++ b/packages/astro-language/src/rules/setHtmlDirectives.test.ts
@@ -0,0 +1,57 @@
+import rule from "./setHtmlDirectives.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+---
+let string = 'this string contains some <strong>HTML!!!</strong>'
+---
+
+<p set:html={string}></p>
+			`,
+			snapshot: `
+---
+let string = 'this string contains some <strong>HTML!!!</strong>'
+---
+
+<p set:html={string}></p>
+   ~~~~~~~~
+   TODO: don't use set:html to reduce XSS risk
+			`,
+		},
+		{
+			code: `
+<div>
+	<p set:html=\`this string contains some <strong>HTML!!!</strong>\`></p>
+</div>
+			`,
+			snapshot: `
+<div>
+	<p set:html=\`this string contains some <strong>HTML!!!</strong>\`></p>
+	   ~~~~~~~~
+	   TODO: don't use set:html to reduce XSS risk
+</div>
+			`,
+		},
+	],
+	valid: [
+		`
+---
+let string = 'this string contains some <strong>HTML!!!</strong>'
+---
+
+<p set:text={string}></p>
+		`,
+		"<p set:text=`this string contains some <strong>HTML!!!</strong>`></p>",
+		`
+---
+let string = 'this string contains some <strong>HTML!!!</strong>'
+---
+
+<p>{string}</p>
+		`,
+		"<p>{`this string contains some <strong>HTML!!!</strong>`}</p>",
+	],
+});
diff --git a/packages/astro-language/src/rules/setHtmlDirectives.ts b/packages/astro-language/src/rules/setHtmlDirectives.ts
new file mode 100644
index 000000000..10dfe634e
--- /dev/null
+++ b/packages/astro-language/src/rules/setHtmlDirectives.ts
@@ -0,0 +1,42 @@
+import { astroLanguage } from "../language.js";
+
+export default astroLanguage.createRule({
+	about: {
+		description: "TODO",
+		id: "setHtmlDirectives",
+		preset: "logical",
+	},
+	messages: {
+		setHtml: {
+			primary: `TODO: don't use set:html to reduce XSS risk`,
+			secondary: ["TODO"],
+			suggestions: ["TODO"],
+		},
+	},
+	setup(context) {
+		const { astroServices } = context;
+		if (astroServices == null) {
+			return undefined;
+		}
+		astroServices.ast.children.forEach(function visit(node) {
+			if ("attributes" in node) {
+				for (const attr of node.attributes) {
+					if (attr.name === "set:html") {
+						const begin = attr.position!.start.offset;
+						astroServices.reportComponent({
+							message: "setHtml",
+							range: {
+								begin,
+								end: begin + attr.name.length,
+							},
+						});
+					}
+				}
+			}
+			if ("children" in node) {
+				node.children.forEach(visit);
+			}
+		});
+		return undefined;
+	},
+});
diff --git a/packages/svelte-language/src/language.ts b/packages/svelte-language/src/language.ts
index c11d23c75..40f293611 100644
--- a/packages/svelte-language/src/language.ts
+++ b/packages/svelte-language/src/language.ts
@@ -3,12 +3,15 @@ import { RuleReporter } from "@flint.fyi/core";
 import { setTSExtraSupportedExtensions } from "@flint.fyi/ts-patch";
 import { createVolarBasedLanguage } from "@flint.fyi/volar-language";
 import { svelteVolarLanguagePlugin } from "./volarLanguagePlugin.js";
+import { AST, parse } from "svelte/compiler";
 
 setTSExtraSupportedExtensions([".svelte"]);
 
 export interface SvelteServices {
-	astroServices?: {
+	svelteServices?: {
+		ast: AST.Root;
 		reportComponent: RuleReporter<string>;
+		sourceText: string;
 	};
 }
 
@@ -27,13 +30,19 @@ export const svelteLanguage = createVolarBasedLanguage<SvelteServices>(
 					0,
 					sourceScript.snapshot.getLength(),
 				);
+				// TODO: report parsing errors?
+				const ast = parse(sourceText, {
+					modern: true,
+				});
 				return {
 					// TODO: first statement
 					firstStatementPosition: sourceText.length,
 					extraContext(reportTranslated) {
 						return {
-							astroServices: {
+							svelteServices: {
+								ast,
 								reportComponent: reportTranslated,
+								sourceText,
 							},
 						};
 					},
diff --git a/packages/svelte-language/src/rules/rawSpecialElements.test.ts b/packages/svelte-language/src/rules/rawSpecialElements.test.ts
new file mode 100644
index 000000000..78dd9014a
--- /dev/null
+++ b/packages/svelte-language/src/rules/rawSpecialElements.test.ts
@@ -0,0 +1,28 @@
+import rule from "./rawSpecialElements.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+<head>
+  <title>Title</title>
+</head>
+			`,
+			snapshot: `
+<head>
+ ~~~~
+ TODO: don't use \`head\` tag, use \`svelte:head\` instead
+  <title>Title</title>
+</head>
+			`,
+		},
+	],
+	valid: [
+		`
+<svelte:head>
+  <title>Title</title>
+</svelte:head>
+		`,
+	],
+});
diff --git a/packages/svelte-language/src/rules/rawSpecialElements.ts b/packages/svelte-language/src/rules/rawSpecialElements.ts
new file mode 100644
index 000000000..48c8e0d54
--- /dev/null
+++ b/packages/svelte-language/src/rules/rawSpecialElements.ts
@@ -0,0 +1,62 @@
+import {
+	getPositionOfColumnAndLine,
+	SourceFileWithLineMap,
+} from "@flint.fyi/core";
+import { svelteLanguage } from "../language.js";
+
+export default svelteLanguage.createRule({
+	about: {
+		description: "TODO",
+		id: "rawSpecialElements",
+		preset: "logical",
+	},
+	messages: {
+		rawSpecialElement: {
+			primary:
+				"TODO: don't use `{{ element }}` tag, use `svelte:{{ element }}` instead",
+			secondary: ["TODO"],
+			suggestions: ["TODO"],
+		},
+	},
+	setup(context) {
+		const { svelteServices } = context;
+		if (svelteServices == null) {
+			return undefined;
+		}
+		const sourceText: SourceFileWithLineMap = {
+			text: svelteServices.sourceText,
+		};
+		svelteServices.ast.fragment.nodes.forEach(function visit(node) {
+			if (node.type === "RegularElement") {
+				switch (node.name) {
+					case "head":
+					case "body":
+					case "window":
+					case "document":
+					case "element":
+					case "options":
+						svelteServices.reportComponent({
+							message: "rawSpecialElement",
+							range: {
+								begin: getPositionOfColumnAndLine(sourceText, {
+									line: node.name_loc.start.line - 1,
+									column: node.name_loc.start.column,
+								}),
+								end: getPositionOfColumnAndLine(sourceText, {
+									line: node.name_loc.end.line - 1,
+									column: node.name_loc.end.column,
+								}),
+							},
+							data: {
+								element: node.name,
+							},
+						});
+				}
+			}
+			if ("fragment" in node) {
+				node.fragment.nodes.forEach(visit);
+			}
+		});
+		return undefined;
+	},
+});

From b22fa4604123e6e51a87b436697d777b0bc727cc Mon Sep 17 00:00:00 2001
From: auvred <aauvred@gmail.com>
Date: Thu, 1 Jan 2026 17:36:54 +0300
Subject: [PATCH 11/11] get rid of volar patch, speedup testing

---
 packages/core/src/host/createVFSLinterHost.ts |  15 +-
 packages/rule-tester/src/host.ts              |   9 +-
 packages/volar-language/src/index.ts          | 134 ++++++++++++------
 ...cript-eslint__project-service@8.50.1.patch |   4 +-
 patches/@volar__typescript@2.4.27.patch       |  12 --
 pnpm-lock.yaml                                |  17 +--
 pnpm-workspace.yaml                           |   1 -
 7 files changed, 120 insertions(+), 72 deletions(-)
 delete mode 100644 patches/@volar__typescript@2.4.27.patch

diff --git a/packages/core/src/host/createVFSLinterHost.ts b/packages/core/src/host/createVFSLinterHost.ts
index 426bea87b..1f980ef25 100644
--- a/packages/core/src/host/createVFSLinterHost.ts
+++ b/packages/core/src/host/createVFSLinterHost.ts
@@ -63,9 +63,14 @@ export function createVFSLinterHost(
 		},
 		readFile(filePathAbsolute) {
 			filePathAbsolute = normalizePath(filePathAbsolute);
-			return (
-				fileMap.get(filePathAbsolute) ?? baseHost?.readFile(filePathAbsolute)
-			);
+			const file = fileMap.get(filePathAbsolute);
+			if (file != null) {
+				return file;
+			}
+			if (baseHost?.stat(filePathAbsolute) === "file") {
+				return baseHost.readFile(filePathAbsolute);
+			}
+			return undefined;
 		},
 		readDirectory(directoryPathAbsolute) {
 			directoryPathAbsolute = normalizePath(directoryPathAbsolute) + "/";
@@ -94,7 +99,9 @@ export function createVFSLinterHost(
 
 			return [
 				...result.values(),
-				...(baseHost?.readDirectory(directoryPathAbsolute) ?? []),
+				...((baseHost?.stat(directoryPathAbsolute) === "directory" &&
+					baseHost.readDirectory(directoryPathAbsolute)) ||
+					[]),
 			];
 		},
 		watchFile(filePathAbsolute, callback) {
diff --git a/packages/rule-tester/src/host.ts b/packages/rule-tester/src/host.ts
index 3ab4dd779..99b2c1534 100644
--- a/packages/rule-tester/src/host.ts
+++ b/packages/rule-tester/src/host.ts
@@ -9,9 +9,12 @@ export function createRuleTesterTSHost(
 	dirname: string,
 	opts: RuleTesterTSHostOptions = {},
 ) {
-	// TODO: should we nest dirname by some non-existent dir?
-	// This will avoid loading all test files located in the ${dirname}/
-	// in the TS program
+	// At the time of writing this, packages/ts/src/rules contains ~120 .ts files.
+	// If we set the VFS cwd to dirname ('packages/ts/src/rules'), all 120 .ts files
+	// will be included into TS programs. However, if we create a virtual directory
+	// that contains only test case fixtures, we will avoid doing extra work.
+	// On my machine, this speeds up `pnpm vitest --run packages/ts` from ~22.6s to ~12.5s (1.8x).
+	dirname += "/_flint-rule-tester-virtual";
 	const fsHost = createFSBackedLinterHost(dirname);
 	const overlay = createVFSLinterHost(dirname, {
 		...fsHost,
diff --git a/packages/volar-language/src/index.ts b/packages/volar-language/src/index.ts
index 61a2da1fb..f44e0cf28 100644
--- a/packages/volar-language/src/index.ts
+++ b/packages/volar-language/src/index.ts
@@ -43,6 +43,7 @@ import {
 	SourceScript as VolarSourceScript,
 } from "@volar/language-core";
 import { TypeScriptServiceScript as VolarTypeScriptServiceScript } from "@volar/typescript";
+import { AsyncLocalStorage } from "node:async_hooks";
 
 type VolarLanguagePluginInitializer<ContextServices extends object> = (
 	ts: typeof import("typescript"),
@@ -80,61 +81,114 @@ type VolarLanguagePluginWithPrepareFile = VolarLanguagePlugin & {
 	__flintPrepareFile?: VolarBasedLanguagePrepareFile<object> | undefined;
 };
 
+type CompilerHostSourceFileGetterStorage = { sourceFile: ts.SourceFile | null };
+const compilerHostSourceFileGetterStorage =
+	new AsyncLocalStorage<CompilerHostSourceFileGetterStorage>();
+
 setTSProgramCreationProxy(
 	(ts, createProgram) =>
 		new Proxy(function () {} as unknown as typeof createProgram, {
 			apply(target, thisArg, args) {
 				let volarLanguage = null as null | VolarLanguage<string>;
-				const proxied = proxyCreateProgram(ts, createProgram, (ts, options) => {
-					const languagePlugins = Array.from(volarLanguagePluginInitializers)
-						.map((initializer) => initializer(ts, options))
-						.map(({ languagePlugins, prepareFile }) =>
-							flatten(languagePlugins).map((plugin) => {
-								(
-									plugin as VolarLanguagePluginWithPrepareFile
-								).__flintPrepareFile = prepareFile;
-								if (plugin.typescript == null) {
-									return plugin;
-								}
+				const createProgramProxy = new Proxy(createProgram, {
+					apply(target, thisArg, [options]: [ts.CreateProgramOptions]) {
+						assert.ok(options.host != null, `Flint bug: options.host is null`);
+						const patchedGetSourceFile = options.host.getSourceFile;
+						options.host.getSourceFile = (...args) => {
+							const store: CompilerHostSourceFileGetterStorage = {
+								sourceFile: null,
+							};
+							const result = compilerHostSourceFileGetterStorage.run(
+								store,
+								() => patchedGetSourceFile(...args),
+							);
+							if (result != null) {
+								assert.ok(
+									store.sourceFile,
+									`Flint bug: sourceFile in compilerHostSourceFileGetterStorage expected to be set`,
+								);
+								assert.ok(
+									"scriptKind" in store.sourceFile &&
+										typeof store.sourceFile.scriptKind === "number",
+									`Flint bug: ts.SourceFile doesn't have scriptKind property`,
+								);
+								assert.ok(
+									"scriptKind" in result &&
+										typeof result.scriptKind === "number",
+									`Flint bug: ts.SourceFile doesn't have scriptKind property`,
+								);
+								store.sourceFile.scriptKind = result.scriptKind;
+							}
+							return result;
+						};
+						return Reflect.apply(target, thisArg, args);
+					},
+				});
+				const proxied = proxyCreateProgram(
+					ts,
+					createProgramProxy,
+					(ts, options) => {
+						assert.ok(
+							options.host != null,
+							`Flint bug: createProgram was called without compiler host`,
+						);
+						const originalGetSourceFile = options.host.getSourceFile;
+						options.host.getSourceFile = (...args) => {
+							const file = originalGetSourceFile(...args);
+							const store = compilerHostSourceFileGetterStorage.getStore();
+							if (store != null && file != null) {
+								store.sourceFile = file;
+							}
+							return file;
+						};
 
-								const { getServiceScript } = plugin.typescript;
-								plugin.typescript.getServiceScript = (root) => {
-									const script = getServiceScript(root);
-									if (script == null) {
-										return script;
+						const languagePlugins = Array.from(volarLanguagePluginInitializers)
+							.map((initializer) => initializer(ts, options))
+							.map(({ languagePlugins, prepareFile }) =>
+								flatten(languagePlugins).map((plugin) => {
+									(
+										plugin as VolarLanguagePluginWithPrepareFile
+									).__flintPrepareFile = prepareFile;
+									if (plugin.typescript == null) {
+										return plugin;
 									}
-									return {
-										...script,
-										// Leading offset is useful for LanguageService [1], but we don't use it.
-										// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
-										// have to provide it ourselves.
-										//
-										// [1] https://github.com/volarjs/volar.js/discussions/188
-										// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
-										preventLeadingOffset: true,
+
+									const { getServiceScript } = plugin.typescript;
+									plugin.typescript.getServiceScript = (root) => {
+										const script = getServiceScript(root);
+										if (script == null) {
+											return script;
+										}
+										return {
+											...script,
+											// Leading offset is useful for LanguageService [1], but we don't use it.
+											// The Vue language plugin doesn't provide preventLeadingOffset [2], so we
+											// have to provide it ourselves.
+											//
+											// [1] https://github.com/volarjs/volar.js/discussions/188
+											// [2] https://github.com/vuejs/language-tools/blob/fd05a1c92c9af63e6af1eab926084efddf7c46c3/packages/language-core/lib/languagePlugin.ts#L113-L130
+											preventLeadingOffset: true,
+										};
 									};
-								};
 
-								return plugin;
-							}),
-						);
-					return {
-						languagePlugins: flatten(languagePlugins),
-						setup: (lang) => (volarLanguage = lang),
-					};
-				});
+									return plugin;
+								}),
+							);
+						return {
+							languagePlugins: flatten(languagePlugins),
+							setup: (lang) => (volarLanguage = lang),
+						};
+					},
+				);
 
 				const program: ProxiedTSProgram = Reflect.apply(proxied, thisArg, args);
 
-				if (volarLanguage == null) {
-					throw new Error("Flint bug: volarLanguage is not defined");
-				}
+				assert.ok(volarLanguage != null, `Flint bug: volarLanguage is null`);
 
-				if (program.__flintVolarLanguage != null) {
-					return program;
+				if (program.__flintVolarLanguage == null) {
+					program.__flintVolarLanguage = volarLanguage;
 				}
 
-				program.__flintVolarLanguage = volarLanguage;
 				return program;
 			},
 		}),
diff --git a/patches/@typescript-eslint__project-service@8.50.1.patch b/patches/@typescript-eslint__project-service@8.50.1.patch
index 4fb2f5df4..af43da3f0 100644
--- a/patches/@typescript-eslint__project-service@8.50.1.patch
+++ b/patches/@typescript-eslint__project-service@8.50.1.patch
@@ -1,12 +1,12 @@
 diff --git a/dist/createProjectService.d.ts b/dist/createProjectService.d.ts
-index 4a3aafa6dbab7af0af17fc038b516b40cb133576..0d1ee005c79fa1a04c9821fc101180721175d831 100644
+index 4a3aafa6dbab7af0af17fc038b516b40cb133576..042117fd48fce8440e5f816116a99affd3a9a5be 100644
 --- a/dist/createProjectService.d.ts
 +++ b/dist/createProjectService.d.ts
 @@ -41,6 +41,7 @@ export interface CreateProjectServiceSettings {
       * Root directory for the tsconfig.json file, if not the current directory.
       */
      tsconfigRootDir?: string;
-+		host?: ts.server.ServerHost
++		host?: ts.server.ServerHost | ts.System
  }
  /**
   * Creates a new Project Service instance, as well as metadata on its creation.
diff --git a/patches/@volar__typescript@2.4.27.patch b/patches/@volar__typescript@2.4.27.patch
deleted file mode 100644
index deaecade6..000000000
--- a/patches/@volar__typescript@2.4.27.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/lib/node/proxyCreateProgram.js b/lib/node/proxyCreateProgram.js
-index 18fda8087826637b592c63e61518b3e42f7187cb..ee2c78734474b153b6cb1b20b7b42e8a712736b8 100644
---- a/lib/node/proxyCreateProgram.js
-+++ b/lib/node/proxyCreateProgram.js
-@@ -138,6 +138,7 @@ function proxyCreateProgram(ts, original, create) {
-                             const parsedSourceFile = ts.createSourceFile(fileName, virtualContents, languageVersionOrOptions, undefined, serviceScript.scriptKind);
-                             // @ts-expect-error
-                             parsedSourceFile.version = originalSourceFile.version;
-+                            originalSourceFile.scriptKind = serviceScript.scriptKind;
-                             parsedSourceFiles.set(originalSourceFile, parsedSourceFile);
-                         }
-                         if (getExtraServiceScripts) {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 0d2e59bc5..fbc7ec45e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -11,11 +11,8 @@ overrides:
 
 patchedDependencies:
   '@typescript-eslint/project-service@8.50.1':
-    hash: cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c
+    hash: 72c8df0a24562534f43890bf6ae27982ba8076ad40902effd1f872cf614a355e
     path: patches/@typescript-eslint__project-service@8.50.1.patch
-  '@volar/typescript@2.4.27':
-    hash: aafa6fa3aabd60fa3c1b015842a4397edd236864bd97db78fa3437464b03b0ed
-    path: patches/@volar__typescript@2.4.27.patch
 
 importers:
 
@@ -636,7 +633,7 @@ importers:
         version: link:../ts-patch
       '@typescript-eslint/project-service':
         specifier: ^8.46.2
-        version: 8.50.1(patch_hash=cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c)(typescript@5.9.3)
+        version: 8.50.1(patch_hash=72c8df0a24562534f43890bf6ae27982ba8076ad40902effd1f872cf614a355e)(typescript@5.9.3)
       cached-factory:
         specifier: ^0.1.0
         version: 0.1.0
@@ -684,7 +681,7 @@ importers:
         version: 2.4.27
       '@volar/typescript':
         specifier: 2.4.27
-        version: 2.4.27(patch_hash=aafa6fa3aabd60fa3c1b015842a4397edd236864bd97db78fa3437464b03b0ed)
+        version: 2.4.27
       typescript:
         specifier: '>=5.9.3'
         version: 5.9.3
@@ -5354,7 +5351,7 @@ snapshots:
       '@astrojs/yaml2ts': 0.2.2
       '@jridgewell/sourcemap-codec': 1.5.5
       '@volar/language-core': 2.4.27
-      '@volar/typescript': 2.4.27(patch_hash=aafa6fa3aabd60fa3c1b015842a4397edd236864bd97db78fa3437464b03b0ed)
+      '@volar/typescript': 2.4.27
       semver: 7.7.3
       vscode-languageserver-textdocument: 1.0.12
 
@@ -6650,7 +6647,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/project-service@8.50.1(patch_hash=cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c)(typescript@5.9.3)':
+  '@typescript-eslint/project-service@8.50.1(patch_hash=72c8df0a24562534f43890bf6ae27982ba8076ad40902effd1f872cf614a355e)(typescript@5.9.3)':
     dependencies:
       '@typescript-eslint/tsconfig-utils': 8.50.1(typescript@5.9.3)
       '@typescript-eslint/types': 8.50.1
@@ -6710,7 +6707,7 @@ snapshots:
 
   '@typescript-eslint/typescript-estree@8.50.1(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/project-service': 8.50.1(patch_hash=cadeb65c3b6848828ad5574161fb60ac925894a54a076179f189d14e509be53c)(typescript@5.9.3)
+      '@typescript-eslint/project-service': 8.50.1(patch_hash=72c8df0a24562534f43890bf6ae27982ba8076ad40902effd1f872cf614a355e)(typescript@5.9.3)
       '@typescript-eslint/tsconfig-utils': 8.50.1(typescript@5.9.3)
       '@typescript-eslint/types': 8.50.1
       '@typescript-eslint/visitor-keys': 8.50.1
@@ -6865,7 +6862,7 @@ snapshots:
       path-browserify: 1.0.1
       vscode-uri: 3.1.0
 
-  '@volar/typescript@2.4.27(patch_hash=aafa6fa3aabd60fa3c1b015842a4397edd236864bd97db78fa3437464b03b0ed)':
+  '@volar/typescript@2.4.27':
     dependencies:
       '@volar/language-core': 2.4.27
       path-browserify: 1.0.1
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 7a6992079..aba663ef5 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -16,7 +16,6 @@ overrides:
 
 patchedDependencies:
   "@typescript-eslint/project-service@8.50.1": patches/@typescript-eslint__project-service@8.50.1.patch
-  "@volar/typescript@2.4.27": patches/@volar__typescript@2.4.27.patch
 
 strictDepBuilds: true