@staticbolt/lsp 1.0.0-beta.30 → 1.0.0-beta.32

package/lib/index.mjs

@@ -1,258 +1,169 @@
+import { existsSync, globSync, watch } from "node:fs";
+import path from "node:path";
 import { format, stripVTControlCharacters } from "node:util";
-import * as vs from "vscode-languageserver/node";
-import * as vscode$1 from "vscode-languageserver";
-import vscode, { RequestType } from "vscode-languageserver";
-import { TextDocument } from "vscode-languageserver-textdocument";
-import * as vscodeUri from "vscode-uri";
-import { EventEmitter } from "node:events";
-import * as fs from "node:fs";
-import { globSync, watch } from "node:fs";
-import { access, constants } from "node:fs/promises";
-import * as path$1 from "node:path";
-import path, { join } from "node:path";
-import { pathToFileURL } from "node:url";
+import { createConnection, createServer, createTypeScriptProject, loadTsdkByPath } from "@volar/language-server/node.js";
+import { forEachEmbeddedCode } from "@volar/language-core";
+import { Resolver } from "@staticbolt/core";
 import vscodeHtml from "vscode-html-languageservice";
+import { TextDocument } from "vscode-languageserver-textdocument";
 import { markdownToMdast } from "satteri";
-import { Resolver } from "@staticbolt/core";
+import { pathToFileURL } from "node:url";
+import * as vscodeUri from "vscode-uri";
+import { URI } from "vscode-uri";
+import { CompletionItemKind, DiagnosticSeverity, SemanticTokenModifiers, SemanticTokenTypes, TextEdit } from "vscode-languageserver-protocol";
+import { decodeEmbeddedDocumentUri } from "@volar/language-service";
+import { create } from "volar-service-typescript";
 
-//#region src/helpers/config-loader.ts
-/** Iterated in order, so the first one that exists wins. */
-const CONFIG_CANDIDATES = /* @__PURE__ */ new Set([".staticbolt.ts", ".staticbolt.js"]);
-async function findConfigFile(workspaceRoot) {
-	for (const name of CONFIG_CANDIDATES) {
-		const full = join(workspaceRoot, name);
-		try {
-			await access(full, constants.R_OK);
-			return full;
-		} catch {}
-	}
-	return null;
-}
-async function importFresh(absolutePath) {
-	const module_ = await import(`${pathToFileURL(absolutePath).href}?t=${Date.now()}`);
-	if (!("default" in module_)) throw new Error(`Config file "${absolutePath}" has no default export. Use \`export default { … }\`.`);
-	return module_.default;
-}
-var ConfigLoader = class extends EventEmitter {
-	workspaceRoot;
-	configPath = null;
-	watcher = null;
-	current = null;
-	debounceTimer = null;
-	DEBOUNCE_MS = 150;
-	constructor(workspaceRoot) {
-		super();
-		this.workspaceRoot = workspaceRoot;
-	}
-	/** Start watching. Resolves with the initial config (or null if absent). */
-	async start() {
-		this.configPath = await findConfigFile(this.workspaceRoot);
-		if (!this.configPath) return null;
-		await this.load();
-		this.watch();
-		return this.current;
-	}
-	/** Stop watching and release all resources. */
-	dispose() {
-		if (this.debounceTimer !== null) clearTimeout(this.debounceTimer);
-		this.watcher?.close();
-		this.watcher = null;
-	}
-	/** The last successfully loaded config, or null if none loaded yet. */
-	get config() {
-		return this.current;
-	}
-	async load() {
-		if (!this.configPath) return;
-		try {
-			this.current = await importFresh(this.configPath);
-			this.emit("change", this.current);
-		} catch (error) {
-			this.emit("error", error instanceof Error ? error : new Error(String(error)));
-		}
-	}
-	/**
-	* The directory is watched rather than the file. A watch on the file itself is bound to the inode, so an editor saving through
-	* a temporary file and a rename leaves it watching a replaced file, and on macOS it never reports a plain write either.
-	*/
-	watch() {
-		this.watcher = watch(this.workspaceRoot, { persistent: false }, (_event, filename) => {
-			if (typeof filename === "string" && CONFIG_CANDIDATES.has(filename)) this.scheduleReload();
-		});
-		this.watcher.on("error", (error) => this.emit("error", error));
-	}
-	scheduleReload() {
-		if (this.debounceTimer !== null) clearTimeout(this.debounceTimer);
-		this.debounceTimer = setTimeout(async () => {
-			this.debounceTimer = null;
-			this.configPath = await findConfigFile(this.workspaceRoot);
-			if (!this.configPath) {
-				this.emit("error", /* @__PURE__ */ new Error(`Config file was removed from: ${this.workspaceRoot}`));
-				return;
-			}
-			await this.load();
-		}, this.DEBOUNCE_MS);
-	}
-};
-var ConfigManager = class {
-	console;
-	configs = /* @__PURE__ */ new Map();
-	lspHtmlData = [];
-	constructor(console) {
-		this.console = console;
-	}
-	async get(workspaceRoot) {
-		const configLoader = this.configs.get(workspaceRoot);
-		if (configLoader) {
-			if (!configLoader.config) {
-				this.configs.delete(workspaceRoot);
-				return null;
-			}
-			return configLoader.config;
-		}
-		const newConfigLoader = new ConfigLoader(workspaceRoot);
-		this.configs.set(workspaceRoot, newConfigLoader);
-		newConfigLoader.on("error", (error) => {
-			this.console.error(`Failed to load config file: ${error.message}`);
-		});
-		newConfigLoader.on("change", async (config) => {
-			await this.collectData(config);
-		});
-		await newConfigLoader.start();
-		if (!newConfigLoader.config) return null;
-		return newConfigLoader.config;
-	}
-	dispose() {
-		for (const configLoader of this.configs.values()) configLoader.dispose();
-	}
-	async collectData(config) {
-		const collected = [];
-		const plugins = config.plugins ?? [];
-		for (const pluginOrArray of plugins) {
-			const plugins = Array.isArray(pluginOrArray) ? pluginOrArray : [pluginOrArray];
-			for (const plugin of plugins) {
-				if (!plugin.lspHtmlData) continue;
-				const htmlData = await plugin.lspHtmlData();
-				if (htmlData) {
-					htmlDataInjectPluginName(htmlData, plugin.name);
-					collected.push(htmlData);
-				}
-			}
+//#region src/helpers/inferred-project.ts
+/**
+* The module kind of the project a document outside every config file is served by.
+*
+* TypeScript takes such a document into a project of its own and gives that project CommonJS modules, which a page's scripts are
+* not: `import.meta` alone is an error there. `preserve` leaves the imports as they are written, which is what a browser gets.
+*
+* The settings are only read once the project has its config, so they are taken as they are asked for, and the same object is
+* given back until they change.
+*/
+function useModuleScripts(typescript, projectHost) {
+	const compilationSettings = projectHost.getCompilationSettings.bind(projectHost);
+	let read;
+	let settings;
+	projectHost.getCompilationSettings = () => {
+		const current = compilationSettings();
+		if (current !== read) {
+			read = current;
+			settings = {
+				...current,
+				module: typescript.ModuleKind.Preserve ?? typescript.ModuleKind.ESNext
+			};
 		}
-		this.lspHtmlData = collected;
-	}
-};
-function htmlDataInjectPluginName(htmlData, pluginName) {
-	const tags = htmlData.tags ?? [];
-	for (const tag of tags) {
-		tag.description = replaceDescription(tag.description, pluginName);
-		const attributes = tag.attributes ?? [];
-		for (const attribute of attributes) attribute.description = replaceDescription(attribute.description, pluginName);
-	}
-	const globalAttributes = htmlData.globalAttributes ?? [];
-	for (const attribute of globalAttributes) attribute.description = replaceDescription(attribute.description, pluginName);
-}
-function replaceDescription(description, pluginName) {
-	const info = `_Provided by **staticbolt** \`${pluginName}\` plugin._`;
-	if (!description) return info;
-	if (typeof description === "string") {
-		if (description.includes(info)) return description;
-		return `${description}\n\n${info}`;
-	}
-	if (description.value.includes(info)) return description;
-	description.value = `${description.value}\n\n${info}`;
-	return description;
+		return settings;
+	};
 }
 
 //#endregion
-//#region src/helpers/find-projects.ts
-function findStaticboltProjects(searchRoots) {
-	const results = [];
-	for (const root of searchRoots) {
-		const rootPath = vscodeUri.URI.parse(root.uri).fsPath;
-		const configs = globSync("**/.staticbolt.{ts,js}", {
-			cwd: rootPath,
-			exclude: ["**/node_modules/**", "**/.git/**"]
-		});
-		for (const configPath of configs) {
-			const absDirectory = path$1.join(rootPath, path$1.dirname(configPath));
-			const projectUri = vscodeUri.URI.file(absDirectory).toString();
-			results.push({
-				name: path$1.basename(absDirectory),
-				uri: projectUri
-			});
+//#region src/helpers/document-elements.ts
+/** The token kinds the HTML scanner reports. */
+const TokenType = vscodeHtml.TokenType;
+/**
+* Every element of a parsed document in document order, with the attribute offsets the parser leaves out: each start tag is
+* scanned again for them.
+*/
+function parseElements(languageService, text, htmlDocument) {
+	const elements = [];
+	for (const root of htmlDocument.roots) collectElements(languageService, text, root, void 0, elements);
+	return elements;
+}
+/** The element for a node and, after it, the ones for its children; the tree only ever holds elements. */
+function collectElements(languageService, text, node, parent, elements) {
+	const element = createElement(languageService, text, node, parent);
+	elements.push(element);
+	parent?.children.push(element);
+	for (const child of node.children) collectElements(languageService, text, child, element, elements);
+}
+/** The element for a node, with its attributes scanned from its start tag. */
+function createElement(languageService, text, node, parent) {
+	const tag = node.tag ?? "";
+	const startTagEnd = node.startTagEnd ?? node.end;
+	const attributes = [];
+	const findAttribute = (name) => {
+		const wanted = name.toLowerCase();
+		return attributes.find((attribute) => attribute.name.toLowerCase() === wanted);
+	};
+	const element = {
+		name: tag.toLowerCase(),
+		attributes,
+		parent,
+		children: [],
+		range: {
+			start: node.start,
+			end: node.end
+		},
+		nameRange: {
+			start: node.start + 1,
+			end: node.start + 1 + tag.length
+		},
+		contentRange: contentRangeOf(node, startTagEnd),
+		attribute: findAttribute,
+		has: (name) => findAttribute(name) !== void 0
+	};
+	attributes.push(...scanAttributes(languageService, text, element, node.start, startTagEnd));
+	return element;
+}
+/**
+* From the end of the start tag to the end tag, or to wherever the parser closed an element missing its end tag; nothing for an
+* element that is over with its start tag, void or self-closing.
+*/
+function contentRangeOf(node, startTagEnd) {
+	const end = node.endTagStart ?? node.end;
+	if (end <= startTagEnd) return;
+	return {
+		start: startTagEnd,
+		end
+	};
+}
+/** The attributes in a start tag, with where their names and values sit. */
+function scanAttributes(languageService, text, element, start, end) {
+	const attributes = [];
+	const scanner = languageService.createScanner(text.slice(start, end));
+	let pending;
+	for (let token = scanner.scan(); token !== TokenType.EOS; token = scanner.scan()) {
+		const range = {
+			start: start + scanner.getTokenOffset(),
+			end: start + scanner.getTokenEnd()
+		};
+		if (token === TokenType.AttributeName) {
+			pending = {
+				name: scanner.getTokenText(),
+				value: void 0,
+				element,
+				nameRange: range,
+				valueRange: void 0
+			};
+			attributes.push(pending);
+			continue;
 		}
+		if (token !== TokenType.AttributeValue || !pending) continue;
+		const raw = scanner.getTokenText();
+		const quote = raw.startsWith("\"") || raw.startsWith("'") ? 1 : 0;
+		pending.value = raw.slice(quote, raw.length - quote);
+		pending.valueRange = {
+			start: range.start + quote,
+			end: range.end - quote
+		};
+		pending = void 0;
 	}
-	return results;
+	return attributes;
 }
 
 //#endregion
-//#region src/language-model-cache.ts
-function getLanguageModelCache(maxEntries, cleanupIntervalTimeInSec, parse) {
-	let languageModels = {};
-	let nModels = 0;
-	let cleanupInterval;
-	if (cleanupIntervalTimeInSec > 0) cleanupInterval = setInterval(() => {
-		const cutoffTime = Date.now() - cleanupIntervalTimeInSec * 1e3;
-		const uris = Object.keys(languageModels);
-		for (const uri of uris) if (languageModels[uri].cTime < cutoffTime) {
-			delete languageModels[uri];
-			nModels--;
-		}
-	}, cleanupIntervalTimeInSec * 1e3);
+//#region src/helpers/document-info.ts
+/** The document as a plugin sees it: its text and elements, with lookups over them and the project's resolver. */
+function describeDocument(text, file, elements, resolver) {
 	return {
-		get(document) {
-			const version = document.version;
-			const languageId = document.languageId;
-			const languageModelInfo = languageModels[document.uri];
-			if (languageModelInfo && languageModelInfo.version === version && languageModelInfo.languageId === languageId) {
-				languageModelInfo.cTime = Date.now();
-				return languageModelInfo.languageModel;
-			}
-			const languageModel = parse(document);
-			languageModels[document.uri] = {
-				languageModel,
-				version,
-				languageId,
-				cTime: Date.now()
-			};
-			if (!languageModelInfo) nModels++;
-			if (nModels === maxEntries) {
-				let oldestTime = Number.MAX_VALUE;
-				let oldestUri = null;
-				for (const uri in languageModels) {
-					const languageModelInfo = languageModels[uri];
-					if (languageModelInfo.cTime < oldestTime) {
-						oldestUri = uri;
-						oldestTime = languageModelInfo.cTime;
-					}
-				}
-				if (oldestUri) {
-					delete languageModels[oldestUri];
-					nModels--;
-				}
-			}
-			return languageModel;
+		file,
+		text,
+		elements,
+		select(...names) {
+			const wanted = new Set(names.map((name) => name.toLowerCase()));
+			return elements.filter((element) => wanted.has(element.name));
 		},
-		onDocumentRemoved(document) {
-			const uri = document.uri;
-			if (Object.hasOwn(languageModels, uri)) {
-				delete languageModels[uri];
-				nModels--;
-			}
+		textOf(range) {
+			return text.slice(range.start, range.end);
 		},
-		dispose() {
-			if (cleanupInterval === void 0) return;
-			clearInterval(cleanupInterval);
-			cleanupInterval = void 0;
-			languageModels = {};
-			nModels = 0;
+		resolve(source) {
+			const resolved = resolver.resolve(source, file);
+			if (!resolved) return;
+			return {
+				path: resolved.path,
+				exists: resolved.exists
+			};
 		}
 	};
 }
 
 //#endregion
-//#region src/modes/markdown-regions.ts
+//#region src/helpers/markdown-regions.ts
 /**
 * Markdown allows raw HTML anywhere, so a ".md" file is served as HTML with the parts that can never be HTML — front matter, code
 * blocks and code spans — blanked out first. Blanking keeps every offset, so positions still point at the same place in the
@@ -278,16 +189,18 @@ function findMarkdownNonHtmlRegions(text) {
 	const pending = [tree];
 	while (pending.length > 0) {
 		const node = pending.pop();
-		if (NON_HTML_NODES.has(node.type)) {
-			const start = node.position?.start.offset;
-			const end = node.position?.end.offset;
-			if (start !== void 0 && end !== void 0) regions.push({
-				start,
-				end
-			});
+		if ("children" in node) {
+			pending.push(...node.children);
 			continue;
 		}
-		if ("children" in node) pending.push(...node.children);
+		if (!NON_HTML_NODES.has(node.type)) continue;
+		const start = node.position?.start.offset;
+		const end = node.position?.end.offset;
+		if (start === void 0 || end === void 0) continue;
+		regions.push({
+			start,
+			end
+		});
 	}
 	return toUtf16Offsets(text, regions.toSorted((a, b) => a.start - b.start));
 }
@@ -303,160 +216,631 @@ function toUtf16Offsets(text, regions) {
 		if (character.length === 2) astral.push(codePoint);
 		codePoint++;
 	}
-	const toUtf16 = (offset) => offset + astral.filter((position) => position < offset).length;
+	/** Shifts a code point offset by the number of astral characters before it. */
+	function toUtf16(offset) {
+		return offset + astral.filter((position) => position < offset).length;
+	}
 	return regions.map((region) => ({
 		start: toUtf16(region.start),
 		end: toUtf16(region.end)
 	}));
 }
-/** Replaces every region with spaces, keeping the length of the text and its line breaks. Regions must be sorted and disjoint. */
+
+//#endregion
+//#region src/helpers/regions.ts
+/** Regions in text order. */
+const byStart = (a, b) => a.start - b.start;
+/**
+* The regions of every plugin language that claims the document, in text order. A region inside one a language earlier in the
+* config claimed already is left to that language: a plugin that runs a script elsewhere claims it before the core plugin, last
+* in the config, sees the browser in it. A region of another language inside this one is a hole, not a claim.
+*/
+function findPluginRegions(document, languages) {
+	const regions = [];
+	for (const language of languages) {
+		if (!language.filter(document.file)) continue;
+		for (const region of language.findRegions(document)) {
+			if (regions.some((claimed) => isInside(region, claimed))) continue;
+			regions.push({
+				...region,
+				language
+			});
+		}
+	}
+	return regions.toSorted(byStart);
+}
+/** Whether a range lies within another. */
+function isInside(range, outer) {
+	return outer.start <= range.start && range.end <= outer.end;
+}
+/**
+* The plugin regions by the file they share: the classic regions of a language together, each module on its own. Every group is
+* in text order, with the regions of other languages inside its own as its holes: a placeholder inside a build-time script is
+* the placeholder language's.
+*/
+function groupByFile(regions) {
+	const groups = /* @__PURE__ */ new Map();
+	let modules = 0;
+	for (const region of regions) {
+		const id = region.isModule ? `${region.language.name}.module${modules++}` : region.language.name;
+		const group = groups.get(id) ?? {
+			id,
+			language: region.language,
+			isModule: region.isModule === true,
+			regions: [],
+			holes: []
+		};
+		group.regions.push({
+			start: region.start,
+			end: region.end
+		});
+		group.holes.push(...holesOf(region, regions));
+		groups.set(id, group);
+	}
+	return groups.values().toArray();
+}
+/** The whole construct a region sits in, delimiters included, or the region itself when it has no more. */
+function extentOf(region) {
+	return region.extent ?? {
+		start: region.start,
+		end: region.end
+	};
+}
+/** Whether an offset falls in any of the regions, their ends included. */
+function isInRegions(regions, offset) {
+	return regions.some((region) => region.start <= offset && offset <= region.end);
+}
+/** The regions of other languages lying inside a region, as their whole constructs. */
+function holesOf(region, regions) {
+	const holes = [];
+	for (const other of regions) {
+		if (other.language === region.language) continue;
+		const hole = extentOf(other);
+		if (hole.start < region.start || hole.end > region.end) continue;
+		holes.push(hole);
+	}
+	return holes;
+}
+
+//#endregion
+//#region src/helpers/virtual-document.ts
+/**
+* The text with everything outside the regions blanked, keeping line breaks, so every offset means the same thing as in the text.
+* The character right after a region becomes a `;`, so neighbouring regions on one line stay separate statements.
+*/
+function blankAround(text, regions) {
+	let result = "";
+	let cursor = 0;
+	for (const region of regions) {
+		result += blank(text.slice(cursor, region.start)) + text.slice(region.start, region.end);
+		cursor = region.end;
+		const next = text[cursor];
+		if (next === void 0 || next === "\n" || next === "\r") continue;
+		result += ";";
+		cursor++;
+	}
+	return result + blank(text.slice(cursor));
+}
+/** The text with the regions blanked, keeping line breaks, so every offset means the same thing as in the text. */
 function blankRegions(text, regions) {
-	if (regions.length === 0) return text;
 	let result = "";
 	let cursor = 0;
 	for (const region of regions) {
-		result += text.slice(cursor, region.start) + text.slice(region.start, region.end).replaceAll(/[^\n\r]/g, " ");
+		result += text.slice(cursor, region.start) + blank(text.slice(region.start, region.end));
 		cursor = region.end;
 	}
 	return result + text.slice(cursor);
 }
+/**
+* The holes masked, keeping line breaks, so the code around them still parses and types as it will once they are filled: a hole
+* in a string literal makes the whole literal `("" + "")`, a `string` rather than a literal type; a hole in a template becomes a
+* `${<any>0}` substitution, for the same reason; any other hole reads as `(<any>0)`, a value of a type nobody knows yet.
+*
+* A mask stands where an expression stands, so it is parenthesised: whatever surrounds it, `+"{{ n }}"` say, binds to the mask as
+* a whole and not to a part of it. A hole too short for its mask gets the longest shorter one that fits, down to nothing.
+*/
+function mask(typescript, text, holes) {
+	if (holes.length === 0) return text;
+	const sourceFile = typescript.createSourceFile("mask.ts", text, typescript.ScriptTarget.Latest, true);
+	let result = text;
+	for (const hole of holes) {
+		const token = tokenAt(sourceFile, hole.start);
+		if (token?.kind === typescript.SyntaxKind.StringLiteral) {
+			const range = {
+				start: token.getStart(sourceFile),
+				end: token.getEnd()
+			};
+			result = replace(result, range, fill(text.slice(range.start, range.end), "(\"\" + \"\")", "(\"\"+\"\")", "(\"\")", "\"\""));
+			continue;
+		}
+		if (token && typescript.isTemplateLiteralToken(token)) {
+			result = replace(result, hole, fill(text.slice(hole.start, hole.end), "${<any>0}", "${0}"));
+			continue;
+		}
+		result = replace(result, hole, fill(text.slice(hole.start, hole.end), "(<any>0)", "<any>0", "(0)", "0"));
+	}
+	return result;
+}
+/**
+* The first replacement the original has room for, followed by the rest of the original blanked, so the length and the line
+* breaks are kept; nothing but the blanks when even the shortest is too long.
+*/
+function fill(original, ...replacements) {
+	const fitting = replacements.find((replacement) => replacement.length <= original.length) ?? "";
+	return fitting + blank(original.slice(fitting.length));
+}
+/** The token of a parsed text an offset falls in: the deepest node there that has no children. */
+function tokenAt(sourceFile, offset) {
+	let node = sourceFile;
+	while (true) {
+		const child = node.getChildren(sourceFile).find((candidate) => candidate.getStart(sourceFile) <= offset && offset < candidate.getEnd());
+		if (!child) return node === sourceFile ? void 0 : node;
+		node = child;
+	}
+}
+/** The text with a range replaced by a replacement of the same length. */
+function replace(text, range, replacement) {
+	return text.slice(0, range.start) + replacement + text.slice(range.end);
+}
+/** Every character but the line breaks replaced by a space. */
+function blank(text) {
+	return text.replaceAll(/[^\n\r]/g, " ");
+}
 
 //#endregion
-//#region src/modes/embedded-support.ts
-const TokenType = vscodeHtml.TokenType;
-function getDocumentRegions(languageService, document) {
-	const source = document.getText();
-	const isMarkdown = document.languageId === "markdown";
-	const markdownRegions = isMarkdown ? findMarkdownNonHtmlRegions(source).map((region) => ({
-		...region,
-		languageId: void 0
-	})) : [];
-	const htmlText = isMarkdown ? blankRegions(source, markdownRegions) : source;
-	const regions = [];
-	const scanner = languageService.createScanner(htmlText);
-	let lastTagName = "";
-	let lastAttributeName = null;
-	let languageIdFromType;
-	let token = scanner.scan();
-	while (token !== TokenType.EOS) {
-		switch (token) {
-			case TokenType.StartTag:
-				lastTagName = scanner.getTokenText();
-				lastAttributeName = null;
-				languageIdFromType = "javascript";
-				break;
-			case TokenType.Styles:
-				regions.push({
-					languageId: "css",
-					start: scanner.getTokenOffset(),
-					end: scanner.getTokenEnd()
-				});
-				break;
-			case TokenType.Script:
-				regions.push({
-					languageId: languageIdFromType,
-					start: scanner.getTokenOffset(),
-					end: scanner.getTokenEnd()
-				});
-				break;
-			case TokenType.AttributeName:
-				lastAttributeName = scanner.getTokenText();
-				break;
-			case TokenType.AttributeValue:
-				if (lastAttributeName === "type" && lastTagName.toLowerCase() === "script") {
-					const token = scanner.getTokenText();
-					if (/["'](module|(text|application)\/(java|ecma)script|text\/babel)["']/.test(token) || token === "module") languageIdFromType = "javascript";
-					else if (/["']text\/typescript["']/.test(token)) languageIdFromType = "typescript";
-					else languageIdFromType = void 0;
-				} else {
-					const attributeLanguageId = getAttributeLanguage(lastAttributeName);
-					if (attributeLanguageId) {
-						let start = scanner.getTokenOffset();
-						let end = scanner.getTokenEnd();
-						const firstChar = htmlText[start];
-						if (firstChar === "'" || firstChar === "\"") {
-							start++;
-							end--;
-						}
-						regions.push({
-							languageId: attributeLanguageId,
-							start,
-							end
-						});
-					}
-				}
-				lastAttributeName = null;
-		}
-		token = scanner.scan();
+//#region src/virtual-code.ts
+/** The id of the root code, and of the HTML copy a markdown document is served through. */
+const ROOT_ID = "root";
+/** The id of the embedded code holding the HTML of a document that is not HTML itself. */
+const HTML_ID = "html";
+/** The TypeScript file name an embedded code of a document is served under. */
+function embeddedFileName(documentFileName, codeId) {
+	return `${documentFileName}.${codeId}.ts`;
+}
+/** What every feature is allowed to do on a mapped stretch of code. */
+const ALL_FEATURES = {
+	verification: true,
+	completion: true,
+	semantic: true,
+	navigation: true,
+	structure: true,
+	format: false
+};
+/** The HTML language service the codes parse with; no data provider, only the tree is wanted here. */
+const htmlLanguageService = vscodeHtml.getLanguageService({ useDefaultDataProvider: false });
+/**
+* A document as the server sees it: the HTML (a markdown document's with everything that cannot be HTML blanked out), the regions
+* plugins embed in it, and an embedded TypeScript code per plugin language, served through the project's TypeScript.
+*/
+var StaticboltCode = class {
+	/** The root is the document. */
+	id = ROOT_ID;
+	/** `html` or `markdown`. */
+	languageId;
+	/** The document's text. */
+	snapshot;
+	/** The whole document maps onto itself. */
+	mappings;
+	/** The HTML copy of a markdown document, then the TypeScript code of every plugin language with regions. */
+	embeddedCodes;
+	/** The document's uri. */
+	uri;
+	/** The project the document belongs to, or nothing when it is outside every loaded one. */
+	project;
+	/** The document's path relative to its project, or its whole path outside one. */
+	file;
+	/** The document as HTML: the text itself, or for markdown the blanked copy. */
+	html;
+	/** The regions the plugins embed, in text order. */
+	regions;
+	/** The regions by plugin language. */
+	languages;
+	/** The parsed HTML, on first use. */
+	#htmlDocument;
+	/** The document as the plugins see it, on first use. */
+	#info;
+	constructor(typescript, uri, languageId, snapshot, project) {
+		const text = snapshot.getText(0, snapshot.getLength());
+		this.uri = uri;
+		this.languageId = languageId;
+		this.snapshot = snapshot;
+		this.project = project;
+		this.file = project ? path.relative(project.root, uri.fsPath) : uri.fsPath;
+		this.mappings = [identityMapping(text.length)];
+		this.html = languageId === "markdown" ? blankRegions(text, findMarkdownNonHtmlRegions(text)) : text;
+		this.regions = project ? findPluginRegions(this.info, project.embeddedLanguages) : [];
+		this.languages = groupByFile(this.regions);
+		this.embeddedCodes = this.languages.map((group) => createTypeScriptCode(typescript, this.info, group));
+		if (languageId === "markdown") this.embeddedCodes.unshift(createHtmlCode(typescript, this.html));
 	}
-	const allRegions = mergeRegions(regions, markdownRegions);
-	const htmlDocument = isMarkdown ? TextDocument.create(document.uri, "html", document.version, htmlText) : document;
+	/** The parsed HTML. */
+	get htmlDocument() {
+		this.#htmlDocument ??= htmlLanguageService.parseHTMLDocument(TextDocument.create(this.uri.toString(), "html", 0, this.html));
+		return this.#htmlDocument;
+	}
+	/**
+	* The document as the plugins see it: its elements with their attributes and where everything sits, and the project's resolver.
+	* Outside a project, a resolver of the document's own directory.
+	*/
+	get info() {
+		this.#info ??= describeDocument(this.html, this.file, parseElements(htmlLanguageService, this.html, this.htmlDocument), this.project?.resolver ?? new Resolver(path.dirname(this.uri.fsPath), false, {}, false));
+		return this.#info;
+	}
+};
+/** A mapping of a whole text onto itself. */
+function identityMapping(length) {
 	return {
-		getLanguageAtPosition: (position) => getLanguageAtPosition(document, allRegions, position),
-		getLanguagesInDocument: () => getLanguagesInDocument(allRegions),
-		getHtmlDocument: () => htmlDocument
+		sourceOffsets: [0],
+		generatedOffsets: [0],
+		lengths: [length],
+		data: ALL_FEATURES
 	};
 }
-/** The lookups below read the regions in order, so an overlap is dropped: a scanned region always wins over a markdown one. */
-function mergeRegions(scanned, markdown) {
-	if (markdown.length === 0) return scanned;
-	const merged = [...scanned, ...markdown].toSorted((a, b) => a.start - b.start || b.end - a.end);
-	const result = [];
-	for (const region of merged) {
-		const previous = result.at(-1);
-		if (previous && region.start < previous.end) continue;
-		result.push(region);
+/** A markdown document's HTML copy, at the same offsets. */
+function createHtmlCode(typescript, html) {
+	return {
+		id: HTML_ID,
+		languageId: "html",
+		snapshot: typescript.ScriptSnapshot.fromString(html),
+		mappings: [identityMapping(html.length)]
+	};
+}
+/**
+* The TypeScript code of one file of a plugin language: the document with everything outside the file's regions blanked, so every
+* offset means the same thing in both, the regions of other languages masked, and the language's prelude appended at the end. A
+* module is made one with an `export {}`, so its top level is its own; a script's top level is the global scope, as it is in the
+* browser. The regions map back to the document; what lies before the first and after the last maps onto their edges, so what
+* TypeScript puts at the top or the bottom of the file, an import or a declaration it adds say, lands in the code.
+*/
+function createTypeScriptCode(typescript, info, group) {
+	const { id, language, isModule, regions, holes } = group;
+	const prelude = typeof language.prelude === "function" ? language.prelude(info) : language.prelude;
+	const suffix = [isModule ? "export {};" : "", prelude ?? ""].filter(Boolean).join("\n");
+	const text = `${mask(typescript, blankAround(info.text, regions), holes)}\n${suffix}\n`;
+	const first = regions[0];
+	const last = regions.at(-1) ?? first;
+	return {
+		id,
+		languageId: "typescript",
+		snapshot: typescript.ScriptSnapshot.fromString(text),
+		mappings: [
+			{
+				sourceOffsets: regions.map((region) => region.start),
+				generatedOffsets: regions.map((region) => region.start),
+				lengths: regions.map((region) => region.end - region.start),
+				data: ALL_FEATURES
+			},
+			edgeMapping(topOf(info.text, first), 0, first.start),
+			edgeMapping(last.end, last.end, text.length - last.end)
+		]
+	};
+}
+/**
+* A stretch of the generated text outside the regions mapped onto one spot of the document, for the edits of completions and code
+* actions only: nothing there is verified, coloured or folded.
+*/
+function edgeMapping(sourceOffset, generatedOffset, generatedLength) {
+	return {
+		sourceOffsets: [sourceOffset],
+		generatedOffsets: [generatedOffset],
+		lengths: [0],
+		generatedLengths: [generatedLength],
+		data: {
+			completion: true,
+			navigation: true,
+			verification: false,
+			semantic: false,
+			structure: false,
+			format: false
+		}
+	};
+}
+/** Where the top of a file's code is in the document: the first region's start, past the line break a script body opens with. */
+function topOf(text, first) {
+	const lineBreak = /^\r?\n/.exec(text.slice(first.start, first.end));
+	return first.start + (lineBreak?.[0].length ?? 0);
+}
+
+//#endregion
+//#region src/language-plugin.ts
+/** The language ids by file extension. */
+const LANGUAGE_IDS = {
+	".html": "html",
+	".md": "markdown"
+};
+/**
+* Tells Volar what an HTML or markdown document is: the document itself, and a TypeScript file per plugin language, named after
+* the document and the language and served by the project's TypeScript next to it.
+*/
+function createLanguagePlugin(typescript, projects) {
+	return {
+		getLanguageId(uri) {
+			return LANGUAGE_IDS[path.extname(uri.path).toLowerCase()];
+		},
+		createVirtualCode(uri, languageId, snapshot) {
+			if (uri.scheme !== "file") return;
+			if (languageId !== "html" && languageId !== "markdown") return;
+			return new StaticboltCode(typescript, uri, languageId, snapshot, projects.of(uri.toString()));
+		},
+		typescript: {
+			extraFileExtensions: [{
+				extension: "html",
+				isMixedContent: true,
+				scriptKind: typescript.ScriptKind.Deferred
+			}, {
+				extension: "md",
+				isMixedContent: true,
+				scriptKind: typescript.ScriptKind.Deferred
+			}],
+			getServiceScript() {},
+			getExtraServiceScripts(fileName, root) {
+				const scripts = [];
+				for (const code of forEachEmbeddedCode(root)) {
+					if (code.languageId !== "typescript") continue;
+					scripts.push({
+						fileName: embeddedFileName(fileName, code.id),
+						code,
+						extension: ".ts",
+						scriptKind: typescript.ScriptKind.TS
+					});
+				}
+				return scripts;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/projects.ts
+/** In order, so the first one that exists wins. */
+const CONFIG_NAMES = [".staticbolt.ts", ".staticbolt.js"];
+/** A save may come as several writes; the config is loaded once they have stopped. */
+const RELOAD_DELAY_MS = 150;
+/** The directory of the nearest config file above a directory, which is the project it belongs to. */
+function findProjectRoot(directory) {
+	while (true) {
+		if (CONFIG_NAMES.some((name) => existsSync(path.join(directory, name)))) return directory;
+		const parent = path.dirname(directory);
+		if (parent === directory) return;
+		directory = parent;
 	}
-	return result;
 }
-function getLanguagesInDocument(regions) {
-	const languages = /* @__PURE__ */ new Set(["html"]);
-	for (const region of regions) if (region.languageId) languages.add(region.languageId);
-	return [...languages];
+/** A resolver for a root that does not log missing files, with the config's aliases on top of the tsconfig's. */
+function createResolver(root, aliases) {
+	return new Resolver(root, false, aliases, false);
 }
-function getLanguageAtPosition(document, regions, position) {
-	const offset = document.offsetAt(position);
-	for (const region of regions) if (region.start <= offset) {
-		if (offset <= region.end) return region.languageId;
-	} else break;
-	return "html";
+/** Every project under the workspace folders, for the startup log. */
+function findProjectRoots(folders) {
+	return folders.flatMap((folder) => {
+		const cwd = vscodeUri.URI.parse(folder.uri).fsPath;
+		return globSync(`**/{${CONFIG_NAMES.join(",")}}`, {
+			cwd,
+			exclude: ["**/node_modules/**", "**/.git/**"]
+		}).map((config) => path.join(cwd, path.dirname(config)));
+	});
 }
-function getAttributeLanguage(attributeName) {
-	const match = attributeName.match(/^(style)$|^(on\w+)$/i);
-	if (!match) return null;
-	return match[1] ? "css" : "javascript";
+/**
+* A staticbolt project as the server sees it: its config, kept current while the config file changes, and what its plugins
+* contribute to the editor.
+*/
+var Project = class {
+	/** The directory holding the config file. */
+	root;
+	/** The last config that loaded, or nothing when none did yet. */
+	config;
+	/** The tags and attributes the plugins contribute to HTML. A new array on every load, so consumers may cache on its identity. */
+	htmlData = [];
+	/** The languages the plugins embed in HTML. */
+	embeddedLanguages = [];
+	/** The plugins that check documents, by name. */
+	validators = [];
+	/** Resolves paths the way the project's build does: its tsconfig paths and config aliases. New on every load. */
+	resolver;
+	/** Where to log. */
+	#console;
+	/** Follows the root directory for saves of the config file. */
+	#watcher;
+	/** The reload waiting for the save to finish. */
+	#reload;
+	/** Told whenever the config loaded. */
+	#onLoad;
+	/** Nothing is loaded until `start` is called. */
+	constructor(root, console, onLoad) {
+		this.root = root;
+		this.resolver = createResolver(root);
+		this.#console = console;
+		this.#onLoad = onLoad;
+	}
+	/** Loads the config and starts following the config file. */
+	async start() {
+		this.#watcher = watch(this.root, { persistent: false }, (_event, filename) => {
+			if (typeof filename !== "string") return;
+			if (!CONFIG_NAMES.includes(filename)) return;
+			this.#scheduleReload();
+		});
+		this.#watcher.on("error", (error) => this.#console.error(`[staticbolt] watching ${this.root}: ${error.message}`));
+		await this.#load();
+	}
+	/** Stops following the config file. */
+	dispose() {
+		clearTimeout(this.#reload);
+		this.#watcher?.close();
+	}
+	/** Loads the config again once the save has stopped writing. */
+	#scheduleReload() {
+		clearTimeout(this.#reload);
+		this.#reload = setTimeout(() => void this.#load(), RELOAD_DELAY_MS);
+	}
+	/** Loads the config file and takes what its plugins contribute; a failure is logged and leaves the last config in place. */
+	async #load() {
+		const configPath = CONFIG_NAMES.map((name) => path.join(this.root, name)).find((candidate) => existsSync(candidate));
+		if (!configPath) {
+			this.#console.error(`[staticbolt] the config file of ${this.root} is gone`);
+			return;
+		}
+		try {
+			const module = await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`);
+			if (!module.default) throw new Error("it has no default export, use `export default { … }`");
+			await this.#collectPluginData(module.default);
+			this.config = module.default;
+			this.resolver = createResolver(this.root, module.default.aliases);
+			this.#onLoad();
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			this.#console.error(`[staticbolt] failed to load ${configPath}: ${reason}`);
+		}
+	}
+	/** Asks every plugin of the config what it contributes to the editor. */
+	async #collectPluginData(config) {
+		const plugins = (config.plugins ?? []).flat();
+		const embeddedLanguages = [];
+		const validators = [];
+		const htmlData = [];
+		for (const plugin of plugins) {
+			embeddedLanguages.push(...plugin.lspEmbeddedLanguages?.() ?? []);
+			if (plugin.lspValidate) validators.push({
+				name: plugin.name,
+				validate: plugin.lspValidate,
+				hasFailed: false
+			});
+			const data = await plugin.lspHtmlData?.();
+			if (data) htmlData.push(creditPlugin(data, plugin.name));
+		}
+		this.embeddedLanguages = embeddedLanguages;
+		this.validators = validators;
+		this.htmlData = htmlData;
+	}
+};
+/** The projects the server has been asked about, each started on first request. */
+var Projects = class {
+	/** Where to log. */
+	#console;
+	/** By root, from the moment a project was asked for. */
+	#starting = /* @__PURE__ */ new Map();
+	/** By root, once the project's config loaded. */
+	#loaded = /* @__PURE__ */ new Map();
+	/** The project root of every directory a document was served from. */
+	#roots = /* @__PURE__ */ new Map();
+	/** Told whenever any project's config loaded. */
+	#onLoad;
+	/** Starts with no projects; each is started the first time `get` asks for it. */
+	constructor(console, onLoad) {
+		this.#console = console;
+		this.#onLoad = onLoad;
+	}
+	/**
+	* The project at a root, or nothing while its config cannot be loaded. The project keeps following its config file either way,
+	* so a fixed config loads on its own.
+	*/
+	async get(root) {
+		let project = this.#starting.get(root);
+		if (!project) {
+			project = this.#start(root);
+			this.#starting.set(root, project);
+		}
+		const started = await project;
+		return started.config ? started : void 0;
+	}
+	/**
+	* The project a document belongs to, if it has loaded already. One that has not is started, and the document is served again
+	* once it loads; a document outside any project gets nothing.
+	*/
+	of(documentUri) {
+		const directory = path.dirname(vscodeUri.URI.parse(documentUri).fsPath);
+		const root = this.#roots.get(directory) ?? findProjectRoot(directory);
+		if (root === void 0) return;
+		this.#roots.set(directory, root);
+		const loaded = this.#loaded.get(root);
+		if (!loaded) this.get(root);
+		return loaded;
+	}
+	/** Stops following every project. */
+	async dispose() {
+		const projects = await Promise.all(this.#starting.values());
+		for (const project of projects) project.dispose();
+		this.#starting.clear();
+		this.#loaded.clear();
+		this.#roots.clear();
+	}
+	/** A project at a root, counted as loaded from the first time its config loads. */
+	async #start(root) {
+		const project = new Project(root, this.#console, () => {
+			this.#loaded.set(root, project);
+			this.#onLoad();
+		});
+		await project.start();
+		return project;
+	}
+};
+/** The data with every description saying which plugin it comes from. */
+function creditPlugin(htmlData, pluginName) {
+	const credit = `_Provided by **staticbolt** \`${pluginName}\` plugin._`;
+	const withCredit = (description) => {
+		if (!description) return credit;
+		const text = typeof description === "string" ? description : description.value;
+		if (text.includes(credit)) return description;
+		const credited = `${text}\n\n${credit}`;
+		if (typeof description === "string") return credited;
+		return {
+			...description,
+			value: credited
+		};
+	};
+	const creditAttributes = (attributes) => {
+		return attributes.map((attribute) => ({
+			...attribute,
+			description: withCredit(attribute.description)
+		}));
+	};
+	const tags = htmlData.tags?.map((tag) => {
+		return {
+			...tag,
+			description: withCredit(tag.description),
+			attributes: creditAttributes(tag.attributes)
+		};
+	});
+	const globalAttributes = htmlData.globalAttributes ? creditAttributes(htmlData.globalAttributes) : void 0;
+	return {
+		...htmlData,
+		tags,
+		globalAttributes
+	};
 }
 
 //#endregion
 //#region src/helpers/merge-html-data.ts
-/** Separates the documentation of two contributors. Rendered as a horizontal rule, unless the description is plain text. */
+/** The `valueSet` the HTML language service reads as "a boolean attribute". */
+const BOOLEAN_VALUE_SET = "v";
+/** Separates the documentation of two contributors, rendered as a horizontal rule. */
 const MARKDOWN_SEPARATOR = "\n\n---\n\n";
+/** The same, for descriptions that are plain text. */
 const PLAINTEXT_SEPARATOR = "\n\n";
 /** Groups entries by key, preserving the order of first appearance. */
 function groupBy(items, toKey) {
 	const groups = /* @__PURE__ */ new Map();
-	const ordered = [];
 	for (const item of items) {
 		const key = toKey(item);
-		let group = groups.get(key);
-		if (!group) {
-			group = [];
-			groups.set(key, group);
-			ordered.push(group);
-		}
+		const group = groups.get(key) ?? [];
 		group.push(item);
+		groups.set(key, group);
 	}
-	return ordered;
+	return groups.values().toArray();
 }
 /** Markdown wins over plain text, so a contributor asking for rich text still gets it. Plain strings imply no preference. */
 function mergeDescriptionKind(descriptions) {
 	let kind;
 	for (const description of descriptions) {
-		if (typeof description === "string" || kind === "markdown") continue;
+		if (typeof description === "string") continue;
+		if (kind === "markdown") break;
 		kind = description.kind;
 	}
 	return kind;
 }
+/** The text of a description, whichever shape it has. */
+function textOf(description) {
+	if (typeof description === "string") return description;
+	return description.value;
+}
 /** Concatenates every distinct description, so no contributor's documentation gets lost. */
 function mergeDescriptions(descriptions) {
 	const defined = descriptions.filter((description) => description !== void 0);
@@ -464,19 +848,22 @@ function mergeDescriptions(descriptions) {
 	const parts = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const description of defined) {
-		const text = (typeof description === "string" ? description : description.value).trim();
+		const text = textOf(description).trim();
 		if (!text || seen.has(text)) continue;
 		seen.add(text);
 		parts.push(text);
 	}
-	if (parts.length === 0) return void 0;
+	if (parts.length === 0) return;
 	const kind = mergeDescriptionKind(defined);
-	const value = parts.join(kind === "plaintext" ? PLAINTEXT_SEPARATOR : MARKDOWN_SEPARATOR);
-	return kind ? {
+	const separator = kind === "plaintext" ? PLAINTEXT_SEPARATOR : MARKDOWN_SEPARATOR;
+	const value = parts.join(separator);
+	if (!kind) return value;
+	return {
 		kind,
 		value
-	} : value;
+	};
 }
+/** Every distinct reference, a reference being the same as another when both name and url match. */
 function mergeReferences(references) {
 	const merged = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -489,15 +876,18 @@ function mergeReferences(references) {
 			merged.push(reference);
 		}
 	}
-	return merged.length > 0 ? merged : void 0;
+	if (merged.length === 0) return;
+	return merged;
 }
+/** Every distinct browser. */
 function mergeBrowsers(browsers) {
 	const merged = /* @__PURE__ */ new Set();
 	for (const list of browsers) {
 		const entries = list ?? [];
 		for (const browser of entries) merged.add(browser);
 	}
-	return merged.size > 0 ? [...merged] : void 0;
+	if (merged.size === 0) return;
+	return [...merged];
 }
 /** The values an attribute contributes, with its `valueSet` reference expanded. */
 function resolveValues(attribute, valueSets) {
@@ -528,9 +918,11 @@ function mergeAttributes(attributes, valueSets) {
 	return groupBy(attributes, (attribute) => attribute.name.toLowerCase()).map((group) => {
 		if (group.length === 1 && !group[0].valueSet) return group[0];
 		const values = mergeValues(group.flatMap((attribute) => resolveValues(attribute, valueSets)));
+		const isBoolean = group.some((attribute) => attribute.valueSet === BOOLEAN_VALUE_SET);
 		return {
 			name: group[0].name,
 			description: mergeDescriptions(group.map((attribute) => attribute.description)),
+			valueSet: isBoolean ? BOOLEAN_VALUE_SET : void 0,
 			values: values.length > 0 ? values : void 0,
 			references: mergeReferences(group.map((attribute) => attribute.references)),
 			browsers: mergeBrowsers(group.map((attribute) => attribute.browsers)),
@@ -562,8 +954,8 @@ function collectValueSets(htmlData) {
 	const valueSets = /* @__PURE__ */ new Map();
 	const collected = htmlData.flatMap((data) => data.valueSets ?? []);
 	for (const valueSet of collected) {
-		const existing = valueSets.get(valueSet.name);
-		valueSets.set(valueSet.name, existing ? mergeValues([...existing, ...valueSet.values]) : valueSet.values);
+		const existing = valueSets.get(valueSet.name) ?? [];
+		valueSets.set(valueSet.name, mergeValues([...existing, ...valueSet.values]));
 	}
 	return valueSets;
 }
@@ -600,453 +992,753 @@ function createMergedHtmlDataProvider(id, htmlData) {
 		provideAttributes,
 		provideValues(tag, attribute) {
 			const name = attribute.toLowerCase();
-			return provideAttributes(tag).find((a) => a.name.toLowerCase() === name)?.values ?? [];
+			return provideAttributes(tag).find((candidate) => candidate.name.toLowerCase() === name)?.values ?? [];
 		}
 	};
 }
 
 //#endregion
-//#region src/modes/html-mode.ts
-function getHTMLMode(htmlLanguageService) {
-	const htmlDocuments = getLanguageModelCache(10, 60, (document) => htmlLanguageService.parseHTMLDocument(document));
-	let lastHtmlData;
-	let lastProvider;
-	function setHtmlDataProviders(htmlData) {
-		if (!lastProvider || lastHtmlData !== htmlData) {
-			lastHtmlData = htmlData;
-			lastProvider = createMergedHtmlDataProvider(FILE_PROTOCOL, htmlData);
+//#region src/helpers/validation.ts
+/** What diagnostics from plugins are labelled with, followed by the plugin's name. */
+const SOURCE = "staticbolt";
+/**
+* Runs every validating plugin of the project over a document and gathers what they report as diagnostics. A plugin that throws
+* is skipped, so the others still report, and logged the first time.
+*/
+async function validateDocument({ document, info, project, console }) {
+	const diagnostics = [];
+	for (const validator of project.validators) {
+		const report = createReporter(document, validator.name, diagnostics);
+		try {
+			await validator.validate(info, report);
+		} catch (error) {
+			if (validator.hasFailed) continue;
+			validator.hasFailed = true;
+			console.error(`[staticbolt] the ${validator.name} plugin failed to validate ${info.file}:`, error);
 		}
-		htmlLanguageService.setDataProviders(false, [lastProvider]);
+	}
+	return diagnostics;
+}
+/** A reporter adding to `diagnostics`, each one labelled with the plugin it comes from. */
+function createReporter(document, pluginName, diagnostics) {
+	function reportAs(severity) {
+		return (target, message) => {
+			const { start, end } = rangeOf(target);
+			diagnostics.push({
+				range: {
+					start: document.positionAt(start),
+					end: document.positionAt(end)
+				},
+				message,
+				severity,
+				source: SOURCE,
+				code: pluginName
+			});
+		};
 	}
 	return {
-		getId() {
-			return "html";
-		},
-		async doComplete(document, position, documentContext, htmlData) {
-			setHtmlDataProviders(htmlData);
-			const htmlDocument = htmlDocuments.get(document);
-			const completionList = await htmlLanguageService.doComplete2(document, position, htmlDocument, documentContext);
-			for (const item of completionList.items) item.sortText = "0_" + item.label;
-			return completionList;
-		},
-		async doHover(document, position, htmlData) {
-			setHtmlDataProviders(htmlData);
-			return htmlLanguageService.doHover(document, position, htmlDocuments.get(document));
-		},
-		async onDocumentRemoved(document) {
-			htmlDocuments.onDocumentRemoved(document);
-		},
-		async findDocumentLinks(document, documentContext, projectRoot) {
-			const resolver = new Resolver(projectRoot);
-			const documentFs = vscodeUri.URI.parse(document.uri).fsPath;
-			const projectRootRelative = path.relative(projectRoot, documentFs);
-			const links = htmlLanguageService.findDocumentLinks(document, documentContext);
-			for (const link of links) {
-				if (!link.target) continue;
-				const linkFs = vscodeUri.URI.parse(link.target ?? "").fsPath;
-				const source = path.relative(path.dirname(documentFs), linkFs);
-				const resolved = resolver.resolve(source, projectRootRelative);
-				if (resolved) link.target = vscodeUri.URI.file(resolved.path).toString();
-			}
-			return links;
-		},
-		dispose() {
-			htmlDocuments.dispose();
-		}
+		error: reportAs(DiagnosticSeverity.Error),
+		warn: reportAs(DiagnosticSeverity.Warning),
+		info: reportAs(DiagnosticSeverity.Information),
+		hint: reportAs(DiagnosticSeverity.Hint)
 	};
 }
+/** An element underlines its tag name, an attribute its value or else its name, a range itself. */
+function rangeOf(target) {
+	if (isElement(target)) return target.nameRange;
+	if (isAttribute(target)) return target.valueRange ?? target.nameRange;
+	return target;
+}
+/** Only an element has children. */
+function isElement(target) {
+	return "children" in target;
+}
+/** Only an attribute is on an element. */
+function isAttribute(target) {
+	return "element" in target;
+}
 
 //#endregion
-//#region src/modes/language-modes.ts
-function isCompletionItemData(value) {
-	return value && typeof value.languageId === "string" && typeof value.uri === "string" && typeof value.offset === "number";
-}
-const FILE_PROTOCOL = "staticbolt-server";
-function getLanguageModes(clientCapabilities, requestService) {
-	const htmlLanguageService = vscodeHtml.getLanguageService({
-		clientCapabilities,
-		fileSystemProvider: requestService,
-		customDataProviders: [{
-			getId() {
-				return FILE_PROTOCOL;
-			},
-			isApplicable(languageId) {
-				return languageId === "html";
-			},
-			provideValues(tag, attribute) {
-				return [{ name: `tag:${tag} attribute:${attribute}` }];
-			},
-			provideTags() {
-				return [{
-					name: "staticbolt",
-					description: "# staticbolt-description",
-					attributes: []
-				}];
-			},
-			provideAttributes(tag) {
-				if (tag === "staticbolt") return [{
-					name: "staticbolt-attribute",
-					description: "# staticbolt-attribute-description",
-					values: [{ name: "staticbolt-attribute-value" }]
-				}];
-				return [{ name: "global-attribute" }];
-			}
-		}],
-		useDefaultDataProvider: false
-	});
-	const documentRegions = getLanguageModelCache(10, 60, (document) => getDocumentRegions(htmlLanguageService, document));
-	let modelCaches = [documentRegions];
-	let modes = Object.create(null);
-	modes["html"] = getHTMLMode(htmlLanguageService);
+//#region src/helpers/document-context.ts
+/** A reference that carries its own scheme, `https:` or `mailto:` say. */
+const WITH_SCHEME = /^[a-z][\w+.-]*:/i;
+/**
+* How references in a document map to files: path aliases through the project's resolver, absolute paths against the project
+* root, everything else relative to the document.
+*
+* The language service bases a reference on the uri of the document it was given, which is the embedded copy the server serves
+* the document through; that copy carries no path, so it falls back to the document itself, and any other base, a `<base href>`
+* say, stands as given.
+*/
+function getDocumentContext(documentUri, resolver) {
+	return { resolveReference(reference, base = documentUri) {
+		if (WITH_SCHEME.test(reference)) return reference;
+		if (decodeEmbeddedDocumentUri(vscodeUri.URI.parse(base)) !== void 0) base = documentUri;
+		const aliased = resolver.resolveAlias(reference);
+		if (aliased !== void 0) return vscodeUri.URI.file(path.join(resolver.root, aliased)).toString(true);
+		if (reference.startsWith("/")) return vscodeUri.URI.file(path.join(resolver.root, reference)).toString(true);
+		const baseUri = vscodeUri.URI.parse(base);
+		const baseDirectory = baseUri.path.endsWith("/") ? baseUri : vscodeUri.Utils.dirname(baseUri);
+		return vscodeUri.Utils.resolvePath(baseDirectory, reference).toString(true);
+	} };
+}
+
+//#endregion
+//#region src/services/staticbolt-service.ts
+/** The id the merged data provider registers under with the language service. */
+const DATA_PROVIDER_ID = "staticbolt";
+/** The cursor inside a `src` or `href` value before any slash, capturing what is typed of its first segment. */
+const PATH_VALUE_START = /(?:src|href)\s*=\s*["']([^"'/\s]*)$/;
+/** Has the editor open the completions again, right after an item is taken. */
+const SUGGEST = {
+	title: "Suggest",
+	command: "editor.action.triggerSuggest"
+};
+/**
+* What the plugins add to HTML: their tags and attributes for completion and hover, path completion that knows the project's
+* aliases, links resolved the way the build resolves them, and the problems the plugins find. The editor's own HTML support
+* covers the standard elements, and stays out of the regions the plugins embed.
+*/
+function createStaticboltService() {
 	return {
-		async updateDataProviders(dataProviders) {
-			htmlLanguageService.setDataProviders(true, dataProviders);
-		},
-		getHtmlDocument(document) {
-			return documentRegions.get(document).getHtmlDocument();
-		},
-		getModeAtPosition(document, position) {
-			const languageId = documentRegions.get(document).getLanguageAtPosition(position);
-			if (languageId) return modes[languageId];
+		name: "staticbolt",
+		capabilities: {
+			completionProvider: { triggerCharacters: [
+				".",
+				":",
+				"<",
+				"\"",
+				"=",
+				"/"
+			] },
+			hoverProvider: true,
+			documentLinkProvider: {},
+			diagnosticProvider: {
+				interFileDependencies: false,
+				workspaceDiagnostics: false
+			},
+			semanticTokensProvider: { legend: {
+				tokenTypes: [SemanticTokenTypes.operator],
+				tokenModifiers: []
+			} }
 		},
-		getAllModesInDocument(document) {
-			const result = [];
-			for (const languageId of documentRegions.get(document).getLanguagesInDocument()) {
-				const mode = modes[languageId];
-				if (mode) result.push(mode);
+		create(context) {
+			const languageServices = /* @__PURE__ */ new WeakMap();
+			/** The HTML language service that knows a project's tags and attributes. */
+			function languageServiceOf(project) {
+				let languageService = languageServices.get(project.htmlData);
+				if (!languageService) {
+					languageService = vscodeHtml.getLanguageService({
+						clientCapabilities: context.env.clientCapabilities,
+						fileSystemProvider: fileSystemOf(context),
+						useDefaultDataProvider: false,
+						customDataProviders: [createMergedHtmlDataProvider(DATA_PROVIDER_ID, project.htmlData)]
+					});
+					languageServices.set(project.htmlData, languageService);
+				}
+				return languageService;
 			}
-			return result;
-		},
-		getMode(languageId) {
-			return modes[languageId];
-		},
-		onDocumentRemoved(document) {
-			for (const mc of modelCaches) mc.onDocumentRemoved(document);
-			for (const mode in modes) modes[mode].onDocumentRemoved(document);
-		},
-		dispose() {
-			for (const mc of modelCaches) mc.dispose();
-			modelCaches = [];
-			for (const mode in modes) modes[mode].dispose();
-			modes = {};
+			/** The document's code and project, or nothing when the document is no HTML of a loaded project. */
+			function find(document) {
+				if (document.languageId !== "html") return;
+				const code = codeOf(context, document);
+				if (!code?.project) return;
+				return {
+					code,
+					project: code.project,
+					languageService: languageServiceOf(code.project)
+				};
+			}
+			return {
+				async provideCompletionItems(document, position) {
+					const found = find(document);
+					if (!found) return;
+					if (isInRegions(found.code.regions, document.offsetAt(position))) return;
+					const { code, project, languageService } = found;
+					const documentContext = getDocumentContext(code.uri.toString(), project.resolver);
+					const list = await languageService.doComplete2(document, position, code.htmlDocument, documentContext);
+					list.items.push(...aliasCompletions(document, position, project.resolver.aliases));
+					for (const item of list.items) item.sortText = "0_" + item.label;
+					return list;
+				},
+				provideHover(document, position) {
+					const found = find(document);
+					if (!found) return;
+					if (isInRegions(found.code.regions, document.offsetAt(position))) return;
+					return found.languageService.doHover(document, position, found.code.htmlDocument);
+				},
+				provideDocumentLinks(document) {
+					const found = find(document);
+					if (!found) return;
+					const { code, project, languageService } = found;
+					const documentPath = code.uri.fsPath;
+					const documentContext = getDocumentContext(code.uri.toString(), project.resolver);
+					const links = languageService.findDocumentLinks(document, documentContext);
+					for (const link of links) {
+						if (!link.target) continue;
+						const source = path.relative(path.dirname(documentPath), vscodeUri.URI.parse(link.target).fsPath);
+						const resolved = project.resolver.resolve(source, code.file);
+						if (!resolved) continue;
+						link.target = vscodeUri.URI.file(resolved.path).toString();
+					}
+					return links;
+				},
+				/**
+				* Colours the delimiters of the plugins' regions, the `{{` and `}}` of a placeholder: they are outside the code, so
+				* nothing else colours them, and they would take the colour of whatever they sit in, an attribute's string say.
+				*/
+				provideDocumentSemanticTokens(document, _range, legend) {
+					const found = find(document);
+					if (!found) return;
+					const type = legend.tokenTypes.indexOf(SemanticTokenTypes.operator);
+					const tokens = [];
+					for (const region of found.code.regions) {
+						if (!region.extent) continue;
+						for (const [start, end] of [[region.extent.start, region.start], [region.end, region.extent.end]]) {
+							if (end <= start) continue;
+							const { line, character } = document.positionAt(start);
+							tokens.push([
+								line,
+								character,
+								end - start,
+								type,
+								0
+							]);
+						}
+					}
+					return tokens;
+				},
+				provideDiagnostics(document) {
+					const found = find(document);
+					if (!found) return;
+					return validateDocument({
+						document,
+						info: found.code.info,
+						project: found.project,
+						console: context.env.console ?? console
+					});
+				}
+			};
 		}
 	};
 }
-
-//#endregion
-//#region src/requests.ts
-const FsStatRequest = { type: new RequestType("fs/stat") };
-const FsReadDirectoryRequest = { type: new RequestType("fs/readDir") };
-const FileType$1 = Object.freeze({
-	/** The file type is unknown. */
-	Unknown: 0,
-	/** A regular file. */
-	File: 1,
-	/** A directory. */
-	Directory: 2,
-	/** A symbolic link to a file. */
-	SymbolicLink: 64
-});
-function getFileSystemProvider(handledSchemas, connection, runtime) {
-	const fileFs = runtime.fileFs && handledSchemas.includes("file") ? runtime.fileFs : void 0;
+/** The editor's file system, as the HTML language service reads it for path completions; nothing is there without one. */
+function fileSystemOf(context) {
+	const missing = {
+		type: vscodeHtml.FileType.Unknown,
+		ctime: -1,
+		mtime: -1,
+		size: -1
+	};
 	return {
 		async stat(uri) {
-			if (fileFs && uri.startsWith("file:")) return fileFs.stat(uri);
-			return await connection.sendRequest(FsStatRequest.type, uri);
+			return await context.env.fs?.stat(vscodeUri.URI.parse(uri)) ?? missing;
 		},
-		readDirectory(uri) {
-			if (fileFs && uri.startsWith("file:")) return fileFs.readDirectory(uri);
-			return connection.sendRequest(FsReadDirectoryRequest.type, uri);
+		async readDirectory(uri) {
+			return await context.env.fs?.readDirectory(vscodeUri.URI.parse(uri)) ?? [];
 		}
 	};
 }
-
-//#endregion
-//#region src/utils/arrays.ts
-function pushAll(to, from) {
-	if (from) for (const item of from) to.push(item);
+/** The root code of the document a service is asked about, whether it is the document itself or its embedded HTML copy. */
+function codeOf(context, document) {
+	const uri = vscodeUri.URI.parse(document.uri);
+	const [sourceUri] = context.decodeEmbeddedDocumentUri(uri) ?? [uri];
+	const root = context.language.scripts.get(sourceUri)?.generated?.root;
+	if (!(root instanceof StaticboltCode)) return;
+	return root;
 }
-
-//#endregion
-//#region src/utils/strings.ts
-function isStartingWith(haystack, needle) {
-	if (haystack.length < needle.length) return false;
-	for (let index = 0; index < needle.length; index++) if (haystack[index] !== needle[index]) return false;
-	return true;
-}
-function isEndingWith(haystack, needle) {
-	const diff = haystack.length - needle.length;
-	if (diff > 0) return haystack.indexOf(needle, diff) === diff;
-	if (diff === 0) return haystack === needle;
-	return false;
-}
-const CR = "\r".codePointAt(0);
-const NL = "\n".codePointAt(0);
-
-//#endregion
-//#region src/utils/document-context.ts
-function getDocumentContext(documentUri, workspaceFolders) {
-	function getRootFolder() {
-		for (const folder of workspaceFolders) {
-			let folderURI = folder.uri;
-			if (!isEndingWith(folderURI, "/")) folderURI += "/";
-			if (isStartingWith(documentUri, folderURI)) return folderURI;
-		}
-	}
-	return { resolveReference: (reference, base = documentUri) => {
-		if (/^\w[\w\d+.-]*:/.test(reference)) return reference;
-		if (reference[0] === "/") {
-			const folderUri = getRootFolder();
-			if (folderUri) return folderUri + reference.slice(1);
-		}
-		const baseUri = vscodeUri.URI.parse(base);
-		const baseUriDirectory = baseUri.path.endsWith("/") ? baseUri : vscodeUri.Utils.dirname(baseUri);
-		return vscodeUri.Utils.resolvePath(baseUriDirectory, reference).toString(true);
-	} };
+/**
+* The path aliases, offered at the start of a `src` or `href` value: a partly typed one completes, and a directory alias opens
+* its listing right away.
+*/
+function aliasCompletions(document, position, aliases) {
+	const lineBeforeCursor = document.getText({
+		start: {
+			line: position.line,
+			character: 0
+		},
+		end: position
+	});
+	const typed = PATH_VALUE_START.exec(lineBeforeCursor)?.[1];
+	if (typed === void 0) return [];
+	const range = {
+		start: {
+			line: position.line,
+			character: position.character - typed.length
+		},
+		end: position
+	};
+	return Object.keys(aliases).map((alias) => {
+		const textEdit = TextEdit.replace(range, alias);
+		if (alias.endsWith("/")) return {
+			label: alias,
+			kind: CompletionItemKind.Folder,
+			textEdit,
+			command: SUGGEST
+		};
+		return {
+			label: alias,
+			kind: CompletionItemKind.File,
+			textEdit
+		};
+	});
 }
 
 //#endregion
-//#region src/utils/find-project-root.ts
-function findProjectRoot(fileUri) {
-	let directory = path$1.dirname(vscodeUri.URI.parse(fileUri).fsPath);
-	while (true) {
-		for (const config of [".staticbolt.ts", ".staticbolt.js"]) if (fs.existsSync(path$1.join(directory, config))) return directory;
-		const parent = path$1.dirname(directory);
-		if (parent === directory) return null;
-		directory = parent;
+//#region src/helpers/syntax-tokens.ts
+/** A member name, as TypeScript names the ones it knows. */
+const PROPERTY = {
+	type: SemanticTokenTypes.property,
+	modifiers: []
+};
+/** The literals of the language as the standard types see them: read-only variables of the library. */
+const LITERAL = {
+	type: SemanticTokenTypes.variable,
+	modifiers: [SemanticTokenModifiers.readonly, SemanticTokenModifiers.defaultLibrary]
+};
+/**
+* The token types of what TypeScript's own tokens leave out, after the grammar scopes a TypeScript file gets them coloured by, so
+* an editor that maps them to those scopes colours the code as it colours TypeScript. Split where themes tell the scopes apart: a
+* `const` sits in `meta.var.expr`, a `class` in `meta.class`, an `import` in `meta.import`. The values are the standard types an
+* editor that knows only those is sent instead.
+*/
+const SCOPED_TYPES = {
+	/** `if`, `return`, `await`: `keyword.control`. */
+	keywordControl: {
+		type: SemanticTokenTypes.keyword,
+		modifiers: []
+	},
+	/** `import`, `export`, `from`, `as`: `meta.import keyword.control.import`. */
+	keywordControlImport: {
+		type: SemanticTokenTypes.keyword,
+		modifiers: []
+	},
+	/** `const`, `let`, `var`: `meta.var.expr storage.type`. */
+	storageTypeVariable: {
+		type: SemanticTokenTypes.modifier,
+		modifiers: []
+	},
+	/** `function`: `meta.function storage.type.function`. */
+	storageTypeFunction: {
+		type: SemanticTokenTypes.modifier,
+		modifiers: []
+	},
+	/** `class`: `meta.class storage.type.class`. */
+	storageTypeClass: {
+		type: SemanticTokenTypes.modifier,
+		modifiers: []
+	},
+	/** `interface`, `type`, `enum`, `namespace`: `storage.type`. */
+	storageType: {
+		type: SemanticTokenTypes.modifier,
+		modifiers: []
+	},
+	/** `async`, `static`, `readonly`, `extends`: `storage.modifier`. */
+	storageModifier: {
+		type: SemanticTokenTypes.modifier,
+		modifiers: []
+	},
+	/** `typeof`, `instanceof`, `in`: `keyword.operator.expression`. */
+	keywordOperatorExpression: {
+		type: SemanticTokenTypes.keyword,
+		modifiers: []
+	},
+	/** `new`: `new.expr keyword.operator.new`. */
+	keywordOperatorNew: {
+		type: SemanticTokenTypes.keyword,
+		modifiers: []
+	},
+	/** `true`, `null`, `undefined`: `constant.language`. */
+	constantLanguage: LITERAL,
+	/** `this`, `super`: `variable.language`. */
+	variableLanguage: LITERAL,
+	/** `string`, `number`, `boolean`: `meta.type.annotation support.type.primitive`. */
+	supportTypePrimitive: {
+		type: SemanticTokenTypes.type,
+		modifiers: [SemanticTokenModifiers.defaultLibrary]
 	}
+};
+/** The punctuation that is an operator; the brackets, separators and accessors are left to the default colour. */
+const OPERATORS = new Set("= == === != !== + - * / % ** ++ -- < > <= >= && || ?? ! ~ & | ^ << >> >>> ? : => ... += -= *= /= %= **= <<= >>= >>>= &= |= ^= &&= ||= ??=".split(" "));
+/** The keyword table, with the `SyntaxKind` values of the TypeScript in use. */
+function keywordsOf(typescript) {
+	const { SyntaxKind } = typescript;
+	const keywords = {};
+	const table = [
+		[[
+			SyntaxKind.ImportKeyword,
+			SyntaxKind.ExportKeyword,
+			SyntaxKind.FromKeyword,
+			SyntaxKind.AsKeyword
+		], "keywordControlImport"],
+		[[
+			SyntaxKind.ConstKeyword,
+			SyntaxKind.LetKeyword,
+			SyntaxKind.VarKeyword
+		], "storageTypeVariable"],
+		[[SyntaxKind.FunctionKeyword], "storageTypeFunction"],
+		[[SyntaxKind.ClassKeyword], "storageTypeClass"],
+		[[
+			SyntaxKind.InterfaceKeyword,
+			SyntaxKind.TypeKeyword,
+			SyntaxKind.EnumKeyword,
+			SyntaxKind.NamespaceKeyword,
+			SyntaxKind.ModuleKeyword
+		], "storageType"],
+		[[
+			SyntaxKind.AbstractKeyword,
+			SyntaxKind.AccessorKeyword,
+			SyntaxKind.AsyncKeyword,
+			SyntaxKind.DeclareKeyword,
+			SyntaxKind.ExtendsKeyword,
+			SyntaxKind.ImplementsKeyword,
+			SyntaxKind.OverrideKeyword,
+			SyntaxKind.PrivateKeyword,
+			SyntaxKind.ProtectedKeyword,
+			SyntaxKind.PublicKeyword,
+			SyntaxKind.ReadonlyKeyword,
+			SyntaxKind.StaticKeyword
+		], "storageModifier"],
+		[[
+			SyntaxKind.DeleteKeyword,
+			SyntaxKind.InKeyword,
+			SyntaxKind.InferKeyword,
+			SyntaxKind.InstanceOfKeyword,
+			SyntaxKind.IsKeyword,
+			SyntaxKind.KeyOfKeyword,
+			SyntaxKind.OfKeyword,
+			SyntaxKind.SatisfiesKeyword,
+			SyntaxKind.TypeOfKeyword
+		], "keywordOperatorExpression"],
+		[[SyntaxKind.NewKeyword], "keywordOperatorNew"],
+		[[
+			SyntaxKind.TrueKeyword,
+			SyntaxKind.FalseKeyword,
+			SyntaxKind.NullKeyword
+		], "constantLanguage"],
+		[[SyntaxKind.ThisKeyword, SyntaxKind.SuperKeyword], "variableLanguage"],
+		[[
+			SyntaxKind.AnyKeyword,
+			SyntaxKind.BigIntKeyword,
+			SyntaxKind.BooleanKeyword,
+			SyntaxKind.NeverKeyword,
+			SyntaxKind.NumberKeyword,
+			SyntaxKind.ObjectKeyword,
+			SyntaxKind.StringKeyword,
+			SyntaxKind.SymbolKeyword,
+			SyntaxKind.UndefinedKeyword,
+			SyntaxKind.UnknownKeyword
+		], "supportTypePrimitive"]
+	];
+	for (const [kinds, type] of table) for (const kind of kinds) keywords[kind] = type;
+	return keywords;
 }
-
-//#endregion
-//#region src/utils/runner.ts
-function formatError(message, error) {
-	if (error instanceof Error) return `${message}: ${error.message}\n${error.stack}`;
-	if (typeof error === "string") return `${message}: ${error}`;
-	if (error) return `${message}: ${error}`;
-	return message;
-}
-function runSafe(runtime, function_, errorValue, errorMessage, token) {
-	return new Promise((resolve) => {
-		runtime.timer.setImmediate(() => {
-			if (token.isCancellationRequested) {
-				resolve(cancelValue());
+/**
+* A tokenizer for what TypeScript's own tokens leave out of a parsed text: keywords by what they are where they stand, literals,
+* comments and operators. The identifiers are left to TypeScript, which knows what each is, except the member names it knows
+* nothing about, a key of a `Record` say, which it leaves out: those are properties all the same. Unless `isScoped`, the keywords
+* are named as the nearest standard types.
+*/
+function createSyntaxTokenizer(typescript, isScoped) {
+	const keywords = keywordsOf(typescript);
+	return (sourceFile, document, checker) => {
+		const text = sourceFile.text;
+		const tokens = [];
+		const commentEnds = /* @__PURE__ */ new Set();
+		/** Whether an identifier names a member TypeScript has no symbol for, so it will not colour it. */
+		function isUnknownMember(node) {
+			if (!checker || !typescript.isPropertyAccessExpression(node.parent) || node.parent.name !== node) return false;
+			return checker.getSymbolAtLocation(node) === void 0;
+		}
+		/** The comments before a token, each once. */
+		function collectComments(position) {
+			const comments = typescript.getLeadingCommentRanges(text, position) ?? [];
+			for (const comment of comments) {
+				if (commentEnds.has(comment.end)) continue;
+				commentEnds.add(comment.end);
+				tokens.push(...splitLines(document, comment.pos, comment.end, {
+					type: SemanticTokenTypes.comment,
+					modifiers: []
+				}));
+			}
+		}
+		/** The tokens of a node and what is inside it. */
+		function visit(node) {
+			const children = node.getChildren(sourceFile);
+			if (children.length === 0) {
+				collectComments(node.getFullStart());
+				const named = isUnknownMember(node) ? PROPERTY : nameOf(typescript, keywords, node, isScoped);
+				if (named) tokens.push(...splitLines(document, node.getStart(sourceFile), node.getEnd(), named));
 				return;
 			}
-			return function_().then((result) => {
-				if (token.isCancellationRequested) {
-					resolve(cancelValue());
-					return;
-				}
-				resolve(result);
-			}, (error) => {
-				console.error(formatError(errorMessage, error));
-				resolve(errorValue);
-			});
-		});
-	});
+			for (const child of children) visit(child);
+		}
+		visit(sourceFile);
+		collectComments(sourceFile.endOfFileToken.getFullStart());
+		return tokens;
+	};
 }
-function cancelValue() {
-	return new vscode.ResponseError(vscode.LSPErrorCodes.RequestCancelled, "Request cancelled");
+/** The type and modifiers of a token, or nothing for the identifiers, plain punctuation and anything that is not a token. */
+function nameOf(typescript, keywords, node, isScoped) {
+	const { SyntaxKind } = typescript;
+	const kind = node.kind;
+	if (kind === SyntaxKind.Identifier) return node.getText() === "undefined" ? standardOrScoped("constantLanguage", isScoped) : void 0;
+	if (kind === SyntaxKind.StringLiteral || isTemplatePart(typescript, kind)) return {
+		type: SemanticTokenTypes.string,
+		modifiers: []
+	};
+	if (kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral) return {
+		type: SemanticTokenTypes.number,
+		modifiers: []
+	};
+	if (kind === SyntaxKind.RegularExpressionLiteral) return {
+		type: SemanticTokenTypes.regexp,
+		modifiers: []
+	};
+	if (kind >= SyntaxKind.FirstPunctuation && kind <= SyntaxKind.LastPunctuation) return OPERATORS.has(typescript.tokenToString(kind) ?? "") ? {
+		type: SemanticTokenTypes.operator,
+		modifiers: []
+	} : void 0;
+	if (kind < SyntaxKind.FirstKeyword || kind > SyntaxKind.LastKeyword) return;
+	if (kind === SyntaxKind.VoidKeyword) return standardOrScoped(node.parent.kind === SyntaxKind.VoidExpression ? "keywordOperatorExpression" : "supportTypePrimitive", isScoped);
+	return standardOrScoped(keywords[kind] ?? "keywordControl", isScoped);
 }
-
-//#endregion
-//#region src/html-server.ts
-function startServer(connection, runtime) {
-	const documents = new vscode$1.TextDocuments(TextDocument);
-	documents.listen(connection);
-	let lspSearchRoots = [];
-	let workspaceFolders = [];
-	let configManager;
-	let languageModes;
-	connection.onInitialize((parameters) => {
-		if (Array.isArray(parameters.workspaceFolders)) lspSearchRoots = parameters.workspaceFolders;
-		else {
-			lspSearchRoots = [];
-			if (parameters.rootPath) lspSearchRoots.push({
-				name: "",
-				uri: vscodeUri.URI.file(parameters.rootPath).toString()
-			});
-		}
-		workspaceFolders = findStaticboltProjects(lspSearchRoots);
-		connection.console.log(`[staticbolt] discovered projects:\n` + workspaceFolders.map((f) => `  - [${f.name}]:  ${f.uri}`).join("\n"));
-		const fileSystemProvider = getFileSystemProvider(["file"], connection, runtime);
-		languageModes = getLanguageModes(parameters.capabilities, fileSystemProvider);
-		configManager = new ConfigManager(connection.console);
-		documents.onDidClose((document) => {
-			languageModes.onDocumentRemoved(document.document);
-		});
-		connection.onShutdown(() => {
-			languageModes.dispose();
-			configManager.dispose();
+/** Whether a kind is one of the pieces a template literal is tokenized into. */
+function isTemplatePart(typescript, kind) {
+	const { SyntaxKind } = typescript;
+	return kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail;
+}
+/** A scoped type itself, or the standard type it stands for. */
+function standardOrScoped(type, isScoped) {
+	if (isScoped) return {
+		type,
+		modifiers: []
+	};
+	return SCOPED_TYPES[type];
+}
+/** A token per line of a stretch of the document, since a token may not span lines. */
+function splitLines(document, start, end, named) {
+	const tokens = [];
+	const first = document.positionAt(start);
+	const last = document.positionAt(end);
+	for (let line = first.line; line <= last.line; line++) {
+		const character = line === first.line ? first.character : 0;
+		const length = (line === last.line ? last.character : document.offsetAt({
+			line: line + 1,
+			character: 0
+		}) - document.offsetAt({
+			line,
+			character: 0
+		})) - character;
+		if (length > 0) tokens.push({
+			line,
+			character,
+			length,
+			...named
 		});
-		return { capabilities: {
-			textDocumentSync: vscode$1.TextDocumentSyncKind.Incremental,
-			completionProvider: {
-				resolveProvider: true,
-				triggerCharacters: [
-					".",
-					":",
-					"<",
-					"\"",
-					"=",
-					"/"
-				]
-			},
-			hoverProvider: true,
-			documentLinkProvider: { resolveProvider: false }
-		} };
-	});
-	connection.onInitialized(() => {});
-	connection.onCompletion(async (textDocumentPosition, token) => {
-		return runSafe(runtime, async () => {
-			const projectRoot = findProjectRoot(textDocumentPosition.textDocument.uri);
-			if (!projectRoot) return null;
-			const document = documents.get(textDocumentPosition.textDocument.uri);
-			if (!document) return null;
-			const mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
-			if (!mode?.doComplete) return {
-				isIncomplete: true,
-				items: []
-			};
-			if (!await configManager.get(projectRoot)) return {
-				isIncomplete: true,
-				items: []
-			};
-			const htmlDocument = languageModes.getHtmlDocument(document);
-			const documentContext = getDocumentContext(document.uri, workspaceFolders);
-			return mode.doComplete(htmlDocument, textDocumentPosition.position, documentContext, configManager.lspHtmlData);
-		}, null, `Error while computing completions for ${textDocumentPosition.textDocument.uri}`, token);
-	});
-	connection.onCompletionResolve((item, token) => {
-		return runSafe(runtime, async () => {
-			const data = item.data;
-			if (!isCompletionItemData(data)) return item;
-			const document = documents.get(data.uri);
-			if (!document) return item;
-			const mode = languageModes.getMode(data.languageId);
-			if (!mode?.doResolve) return item;
-			return mode.doResolve(languageModes.getHtmlDocument(document), item);
-		}, item, `Error while resolving completion proposal`, token);
-	});
-	connection.onHover((textDocumentPosition, token) => {
-		return runSafe(runtime, async () => {
-			const projectRoot = findProjectRoot(textDocumentPosition.textDocument.uri);
-			if (!projectRoot) return null;
-			const document = documents.get(textDocumentPosition.textDocument.uri);
-			if (!document) return null;
-			const mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
-			if (!mode?.doHover) return null;
-			if (!await configManager.get(projectRoot)) return null;
-			return mode.doHover(languageModes.getHtmlDocument(document), textDocumentPosition.position, configManager.lspHtmlData);
-		}, null, `Error while computing hover for ${textDocumentPosition.textDocument.uri}`, token);
-	});
-	connection.onDocumentLinks((documentLinkParameter, token) => {
-		return runSafe(runtime, async () => {
-			const projectRoot = findProjectRoot(documentLinkParameter.textDocument.uri);
-			if (!projectRoot) return null;
-			const document = documents.get(documentLinkParameter.textDocument.uri);
-			if (!document) return [];
-			const links = [];
-			const htmlDocument = languageModes.getHtmlDocument(document);
-			const documentContext = getDocumentContext(document.uri, workspaceFolders);
-			for (const mode of languageModes.getAllModesInDocument(document)) if (mode.findDocumentLinks) pushAll(links, await mode.findDocumentLinks(htmlDocument, documentContext, projectRoot));
-			return links;
-		}, [], `Error while document links for ${documentLinkParameter.textDocument.uri}`, token);
-	});
-	connection.listen();
+	}
+	return tokens;
 }
 
 //#endregion
-//#region src/utils/node-fs.ts
-const FileType = Object.freeze({
-	/** The file type is unknown. */
-	Unknown: 0,
-	/** A regular file. */
-	File: 1,
-	/** A directory. */
-	Directory: 2,
-	/** A symbolic link to a file. */
-	SymbolicLink: 64
-});
-function getNodeFileFS() {
-	function ensureFileUri(location) {
-		if (!location.startsWith("file:")) throw new Error("fileSystemProvider can only handle file URLs");
-	}
+//#region src/services/syntax-tokens-service.ts
+/**
+* Colours what TypeScript's own tokens leave out of the embedded code the editor's grammar cannot see, a placeholder say:
+* keywords, literals, operators and comments, named from TypeScript's parse of it. TypeScript names the identifiers; together
+* they colour the code the way a TypeScript file is coloured. The languages the editor colours itself get only the identifiers.
+* With `isScoped`, the keywords are sent as the scoped types an editor maps to grammar scopes, see `SCOPED_TYPES`; otherwise as
+* the nearest standard types.
+*/
+function createSyntaxTokensService(typescript, isScoped) {
+	const tokenize = createSyntaxTokenizer(typescript, isScoped);
 	return {
-		stat(location) {
-			ensureFileUri(location);
-			return new Promise((c, error_) => {
-				const uri = vscodeUri.URI.parse(location);
-				fs.stat(uri.fsPath, (error, stats) => {
-					if (error) return error.code === "ENOENT" ? c({
-						type: FileType.Unknown,
-						ctime: -1,
-						mtime: -1,
-						size: -1
-					}) : error_(error);
-					let type = FileType.Unknown;
-					if (stats.isFile()) type = FileType.File;
-					else if (stats.isDirectory()) type = FileType.Directory;
-					else if (stats.isSymbolicLink()) type = FileType.SymbolicLink;
-					c({
-						type,
-						ctime: stats.ctime.getTime(),
-						mtime: stats.mtime.getTime(),
-						size: stats.size
+		name: "staticbolt-syntax-tokens",
+		capabilities: { semanticTokensProvider: { legend: {
+			tokenTypes: [...Object.values(SemanticTokenTypes), ...Object.keys(SCOPED_TYPES)],
+			tokenModifiers: Object.values(SemanticTokenModifiers)
+		} } },
+		create(context) {
+			/**
+			* The parsed file of an embedded document as the project's TypeScript holds it, with the checker that knows its symbols, or
+			* a fresh parse alone when the project has none.
+			*/
+			function parse(document, fileName) {
+				const program = context.inject("typescript/languageService")?.getProgram();
+				const parsed = program?.getSourceFile(fileName);
+				if (program && parsed && parsed.text === document.getText()) return [parsed, program.getTypeChecker()];
+				return [typescript.createSourceFile(fileName, document.getText(), typescript.ScriptTarget.Latest, true), void 0];
+			}
+			return { provideDocumentSemanticTokens(document, _range, legend) {
+				if (document.languageId !== "typescript") return;
+				const embedded = embeddedOf(context, document);
+				if (!embedded || embedded.group.language.isColouredByEditor) return;
+				const [sourceFile, checker] = parse(document, embedded.fileName);
+				const tokens = [];
+				for (const token of tokenize(sourceFile, document, checker)) {
+					const type = legend.tokenTypes.indexOf(token.type);
+					if (type === -1) continue;
+					const offset = document.offsetAt({
+						line: token.line,
+						character: token.character
 					});
-				});
-			});
-		},
-		readDirectory(location) {
-			ensureFileUri(location);
-			return new Promise((c, error_) => {
-				const path = vscodeUri.URI.parse(location).fsPath;
-				fs.readdir(path, { withFileTypes: true }, (error, children) => {
-					if (error) return error_(error);
-					c(children.map((stat) => {
-						if (stat.isSymbolicLink()) return [stat.name, FileType.SymbolicLink];
-						if (stat.isDirectory()) return [stat.name, FileType.Directory];
-						return stat.isFile() ? [stat.name, FileType.File] : [stat.name, FileType.Unknown];
-					}));
-				});
-			});
+					if (isInRegions(embedded.group.holes, offset)) continue;
+					let modifiers = 0;
+					for (const modifier of token.modifiers) {
+						const bit = legend.tokenModifiers.indexOf(modifier);
+						if (bit === -1) continue;
+						modifiers |= 1 << bit;
+					}
+					tokens.push([
+						token.line,
+						token.character,
+						token.length,
+						type,
+						modifiers
+					]);
+				}
+				return tokens;
+			} };
 		}
 	};
 }
+/** The plugin language an embedded document belongs to and its TypeScript file name, as `getExtraServiceScripts` names it. */
+function embeddedOf(context, document) {
+	const decoded = context.decodeEmbeddedDocumentUri(URI.parse(document.uri));
+	if (!decoded) return;
+	const [sourceUri, codeId] = decoded;
+	const root = context.language.scripts.get(sourceUri)?.generated?.root;
+	if (!(root instanceof StaticboltCode)) return;
+	const group = root.languages.find((candidate) => candidate.id === codeId);
+	if (!group) return;
+	const documentFileName = context.project.typescript?.uriConverter.asFileName(sourceUri) ?? sourceUri.fsPath;
+	return {
+		group,
+		fileName: embeddedFileName(documentFileName, codeId)
+	};
+}
+
+//#endregion
+//#region src/services/typescript-service.ts
+/**
+* TypeScript's features for the embedded codes, through Volar's TypeScript service: completion, hover, diagnostics, semantic
+* tokens, definitions, references, rename, folding and the rest. Formatting is left out: a document is HTML to the editor, and
+* its own formatter takes care of the whole of it.
+*/
+function createTypeScriptServices(typescript) {
+	return create(typescript).map((plugin) => ({
+		...plugin,
+		capabilities: {
+			...plugin.capabilities,
+			documentFormattingProvider: void 0,
+			documentOnTypeFormattingProvider: void 0
+		}
+	}));
+}
 
 //#endregion
 //#region src/index.ts
-const connection = vs.createConnection();
+/** The initialization options, with anything that is not an object read as none. */
+function initializationOptionsOf(parameters) {
+	const options = parameters.initializationOptions;
+	if (typeof options !== "object" || options === null) return {};
+	return options;
+}
+/** The LSP connection to the editor, over stdio. */
+const connection = createConnection();
+/** Volar's server on top of the connection: documents, projects and the language features. */
+const server = createServer(connection);
 /**
 * `RemoteConsole` takes a single string, but the shared logger calls `console` with several arguments and colours them with
 * chalk. Passing the methods straight through drops everything after the first argument, and the output panel renders no ANSI —
 * so format the arguments the way `console` would, then strip the escapes.
 */
 function forward(write) {
-	return (...messages) => write(stripVTControlCharacters(format(...messages)));
+	return (...messages) => {
+		write(stripVTControlCharacters(format(...messages)));
+	};
 }
 console.log = forward(connection.console.log.bind(connection.console));
 console.info = forward(connection.console.info.bind(connection.console));
 console.warn = forward(connection.console.warn.bind(connection.console));
 console.error = forward(connection.console.error.bind(connection.console));
 process.on("unhandledRejection", (error) => {
-	connection.console.error(formatError(`Unhandled exception`, error));
+	console.error("[staticbolt] unhandled rejection:", error);
+});
+/** Whether a directory holds TypeScript with its API, which the native builds do not ship. */
+function hasTypeScriptApi(tsdk) {
+	return existsSync(path.join(tsdk, "typescript.js"));
+}
+/**
+* The directory of the TypeScript to run: the editor's choice from the initialization options, the `--tsdk` argument, or the
+* nearest `typescript` package with an API installed above the working directory.
+*/
+function findTsdk(parameters) {
+	const options = initializationOptionsOf(parameters);
+	if (options.typescript?.tsdk) return options.typescript.tsdk;
+	const argument = process.argv.find((value) => value.startsWith("--tsdk="));
+	if (argument) return argument.slice(7);
+	let directory = process.cwd();
+	while (true) {
+		const tsdk = path.join(directory, "node_modules", "typescript", "lib");
+		if (hasTypeScriptApi(tsdk)) return tsdk;
+		const parent = path.dirname(directory);
+		if (parent === directory) return;
+		directory = parent;
+	}
+}
+/** The workspace folders, or the root uri of an editor that has no folders. */
+function foldersOf(parameters) {
+	if (parameters.workspaceFolders) return parameters.workspaceFolders;
+	if (parameters.rootUri) return [{
+		name: "",
+		uri: parameters.rootUri
+	}];
+	return [];
+}
+/** The staticbolt projects of the workspace, from initialization on. */
+let projects;
+connection.listen();
+connection.onInitialize(async (parameters) => {
+	const tsdk = findTsdk(parameters);
+	if (tsdk === void 0 || !hasTypeScriptApi(tsdk)) throw new Error(`[staticbolt] no TypeScript with an API ${tsdk ? `at ${tsdk}` : "found"}; point typescript.tsdk or --tsdk at one, 6.x say`);
+	const { typescript, diagnosticMessages } = loadTsdkByPath(tsdk, parameters.locale);
+	console.log(`[staticbolt] TypeScript ${typescript.version} from ${tsdk}`);
+	let isInitialized = false;
+	const workspace = new Projects(connection.console, () => {
+		if (!isInitialized) return;
+		server.project.reload();
+	});
+	projects = workspace;
+	const roots = findProjectRoots(foldersOf(parameters));
+	console.log(`[staticbolt] discovered projects:\n${roots.map((root) => `  - ${root}`).join("\n")}`);
+	await Promise.all(roots.map((root) => workspace.get(root)));
+	isInitialized = true;
+	const languagePlugin = createLanguagePlugin(typescript, workspace);
+	const project = createTypeScriptProject(typescript, diagnosticMessages, ({ configFileName, projectHost }) => {
+		if (configFileName === void 0) useModuleScripts(typescript, projectHost);
+		return { languagePlugins: [languagePlugin] };
+	});
+	const services = [
+		createStaticboltService(),
+		createSyntaxTokensService(typescript, initializationOptionsOf(parameters).scopedTokens === true),
+		...createTypeScriptServices(typescript)
+	];
+	return server.initialize(parameters, project, services);
+});
+/** A TypeScript config, or one of those a config extends. */
+const TS_CONFIG = /\/(?:tsconfig|jsconfig)[^/]*\.json$/;
+connection.onInitialized(() => {
+	server.initialized();
+	server.fileWatcher.watchFiles(["**/*.{ts,mts,cts,js,mjs,cjs}", "**/{tsconfig,jsconfig}*.json"]);
+	server.fileWatcher.onDidChangeWatchedFiles(({ changes }) => {
+		if (changes.every((change) => !TS_CONFIG.test(change.uri))) return;
+		server.project.reload();
+	});
+});
+connection.onShutdown(async () => {
+	await projects?.dispose();
+	server.shutdown();
 });
-const runtime = {
-	timer: {
-		setImmediate(callback, ...arguments_) {
-			const handle = setImmediate(callback, ...arguments_);
-			return { dispose: () => clearImmediate(handle) };
-		},
-		setTimeout(callback, ms, ...arguments_) {
-			const handle = setTimeout(callback, ms, ...arguments_);
-			return { dispose: () => clearTimeout(handle) };
-		}
-	},
-	fileFs: getNodeFileFS()
-};
-connection.console.log("[staticbolt] starting server");
-startServer(connection, runtime);
 
 //#endregion
 export {  };