@lucidkiln/language-server 1.0.0 → 1.2.0

package/dist/main.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { DiagnosticSeverity, DidChangeWatchedFilesNotification, ProposedFeatures, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node";
-import { dirname, isAbsolute, join, relative, sep } from "node:path";
+import { createRequire } from "node:module";
+import { DiagnosticSeverity, DidChangeWatchedFilesNotification, FileChangeType, ProposedFeatures, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node";
+import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import { readFile, readdir } from "node:fs/promises";
@@ -9,6 +10,8 @@ import * as bundledKiln from "@lucidkiln/core";
 import { templateText } from "@lucidkiln/core";
 import { getLanguageService } from "vscode-html-languageservice";
 import * as bundledFormat from "@lucidkiln/core/format";
+import { readFileSync, readdirSync } from "node:fs";
+import { parse } from "@lucidkiln/core/syntax";
 //#region src/builtins.ts
 const block = (name, header) => `${name}${header} %}\n\t$0\n{% end${name} %}`;
 const TAGS = {
@@ -121,7 +124,7 @@ const LOOP_PROPERTIES = {
 	last: "`true` on the last item.",
 	length: "Total number of items."
 };
-const KEYWORDS = [
+const KEYWORDS$1 = [
 	"true",
 	"false",
 	"null",
@@ -211,6 +214,10 @@ const cursorContext = (text, offset) => {
 		start,
 		template: props[2]
 	};
+	if (/[\w\])]\??\.$/.test(head) && !/(?:^|[^\w$])\d+\.$/.test(head)) return {
+		kind: "member",
+		start
+	};
 	if (/[.\w]$/.test(head) || /["']$/.test(head)) return null;
 	return {
 		kind: "expression",
@@ -295,6 +302,107 @@ const symbolAt = (text, offset) => {
 	};
 };
 //#endregion
+//#region src/calls.ts
+const CLOSERS = {
+	"(": ")",
+	"[": "]",
+	"{": "}"
+};
+/** Words before `(` that aren't calls, as in `not (a or b)`. */
+const KEYWORDS = /* @__PURE__ */ new Set([
+	"and",
+	"or",
+	"not",
+	"in",
+	"is",
+	"if",
+	"else"
+]);
+const NAMED = /^\s*([A-Za-z_]\w*)\s*:(?!:)/;
+const callContext = (text, offset) => {
+	const delimiter = enclosingDelimiter(text, offset);
+	if (!delimiter) return null;
+	const stack = [];
+	let quote = null;
+	for (let index = delimiter.start + 2; index < offset; index++) {
+		const char = text[index];
+		if (quote) {
+			if (char === "\\") index++;
+			else if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'") quote = char;
+		else if (char in CLOSERS) {
+			let callee = null;
+			if (char === "(") {
+				const match = /(\|\s*|\.\s*)?([A-Za-z_]\w*)\s*$/.exec(text.slice(delimiter.start + 2, index));
+				const name = match?.[2];
+				if (name && !KEYWORDS.has(name) && !match[1]?.startsWith(".")) callee = {
+					kind: match[1] ? "filter" : "function",
+					name
+				};
+			}
+			stack.push({
+				char,
+				callee,
+				commas: 0,
+				segment: index + 1,
+				sawNamed: false
+			});
+		} else if (char === ")" || char === "]" || char === "}") stack.pop();
+		else if (char === ",") {
+			const frame = stack.at(-1);
+			if (frame) {
+				if (NAMED.test(text.slice(frame.segment, index))) frame.sawNamed = true;
+				frame.commas++;
+				frame.segment = index + 1;
+			}
+		}
+	}
+	const frame = stack.at(-1);
+	if (frame?.char !== "(" || !frame.callee) return null;
+	const segment = text.slice(frame.segment, offset);
+	const word = /[A-Za-z_]\w*$/.exec(segment)?.[0] ?? "";
+	return {
+		...frame.callee,
+		index: frame.commas,
+		named: NAMED.exec(segment)?.[1] ?? null,
+		sawNamed: frame.sawNamed,
+		namePosition: /^\s*[A-Za-z_]?\w*$/.test(segment),
+		start: offset - word.length
+	};
+};
+/**
+* Splits a parameter list, such as `a: string, b?: { c: number }`, at its top-level commas. Each part keeps its
+* offsets, so a signature can point at the parameter it's on.
+*/
+const splitParameters = (list) => {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	const push = (end) => {
+		const raw = list.slice(start, end);
+		const leading = raw.length - raw.trimStart().length;
+		const text = raw.trim();
+		if (text) parts.push({
+			text,
+			start: start + leading,
+			end: start + leading + text.length
+		});
+	};
+	for (let index = 0; index < list.length; index++) {
+		const char = list[index];
+		if ("([{<".includes(char)) depth++;
+		else if (")]}".includes(char) || char === ">" && list[index - 1] !== "=") depth--;
+		else if (char === "," && depth === 0) {
+			push(index);
+			start = index + 1;
+		}
+	}
+	push(list.length);
+	return parts;
+};
+//#endregion
 //#region src/docs.ts
 /**
 * What each built-in does, from its section of the docs site, up to the end of its first example. The docs build writes
@@ -303,7 +411,7 @@ const symbolAt = (text, offset) => {
 const DOCS = {
 	tags: {
 		"add": {
-			"markdown": "- Content goes to the outlet with the same name, in the order it was added. It doesn't matter whether `add to` runs before or after the outlet.\n- The content lines up with the outlet's indentation.\n- The content can read the variables around it. Variables you `set` inside it stay inside it.\n- Content for an outlet the page doesn't have is dropped. A component still works on a page without that outlet, and when you [render one block](https://kilnlang.com/docs/api/rendering/#rendering-one-block).",
+			"markdown": "- Content goes to the outlet with the same name, in the order it was added. It doesn't matter whether `add to` runs before or after the outlet.\n- The content can read the variables around it. Variables you `set` inside it stay inside it.\n- Content for an outlet the page doesn't have is dropped. A component still works on a page without that outlet, and when you [render one block](https://kilnlang.com/docs/api/rendering/#rendering-one-block).",
 			"url": "https://kilnlang.com/docs/tags/outlet/#adding-content"
 		},
 		"apply": {
@@ -637,6 +745,244 @@ const htmlHover = (document, offset) => {
 	return service.doHover(html, document.positionAt(offset), parsed);
 };
 //#endregion
+//#region src/typescript-6.ts
+/** A project checked by TypeScript 6's classic API, in this process. */
+const openTypeScript6 = (ts, configPath) => {
+	const parseConfig = () => {
+		const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, {
+			...ts.sys,
+			onUnRecoverableConfigFileDiagnostic: () => {}
+		});
+		if (!parsed) throw new Error(`can't read ${configPath}`);
+		return parsed;
+	};
+	let config = parseConfig();
+	const virtual = virtualPath(configPath, config.fileNames);
+	let text = "";
+	/** Bumped when a file changes, so the language service reads it again. */
+	const versions = /* @__PURE__ */ new Map();
+	const version = (path) => versions.get(path) ?? 0;
+	let fileNames = [...config.fileNames, virtual];
+	const read = (path) => samePath(path, virtual) ? text : ts.sys.readFile(path);
+	const service = ts.createLanguageService({
+		getCompilationSettings: () => config.options,
+		getScriptFileNames: () => fileNames,
+		getScriptVersion: (path) => String(version(path)),
+		getScriptSnapshot: (path) => {
+			const content = read(path);
+			return content === void 0 ? void 0 : ts.ScriptSnapshot.fromString(content);
+		},
+		getCurrentDirectory: () => dirname(configPath),
+		getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+		fileExists: (path) => samePath(path, virtual) || ts.sys.fileExists(path),
+		readFile: read,
+		readDirectory: (...args) => ts.sys.readDirectory(...args),
+		directoryExists: (path) => ts.sys.directoryExists(path),
+		getDirectories: (path) => ts.sys.getDirectories(path)
+	}, ts.createDocumentRegistry());
+	return {
+		query(source, use) {
+			if (source !== text) {
+				text = source;
+				versions.set(virtual, version(virtual) + 1);
+			}
+			const program = service.getProgram();
+			const file = program?.getSourceFile(virtual);
+			if (!program || !file) return null;
+			const checker = program.getTypeChecker();
+			const typeOf = (alias) => {
+				const declaration = file.statements.find((statement) => ts.isTypeAliasDeclaration(statement) && statement.name.text === alias);
+				return declaration ? checker.getTypeAtLocation(declaration.name) : void 0;
+			};
+			return use({
+				describe: (alias) => {
+					const type = typeOf(alias);
+					return type ? checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation) : null;
+				},
+				members: (alias) => {
+					const type = typeOf(alias);
+					if (!type) return [];
+					return checker.getPropertiesOfType(type).map((symbol) => {
+						const node = symbol.declarations?.[0];
+						const declaredIn = node?.getSourceFile();
+						return {
+							name: symbol.name,
+							optional: (symbol.flags & ts.SymbolFlags.Optional) !== 0,
+							type: checker.typeToString(checker.getTypeOfSymbolAtLocation(symbol, file), void 0, ts.TypeFormatFlags.NoTruncation),
+							docs: ts.displayPartsToString(symbol.getDocumentationComment(checker)),
+							tags: symbol.getJsDocTags(checker).map((tag) => ({
+								name: tag.name,
+								text: ts.displayPartsToString(tag.text)
+							})),
+							location: node && declaredIn ? {
+								path: declaredIn.fileName,
+								...declaredIn.getLineAndCharacterOfPosition(node.getStart(declaredIn))
+							} : null
+						};
+					});
+				}
+			});
+		},
+		changed(changes) {
+			for (const change of changes) versions.set(change.path, version(change.path) + 1);
+			if (changes.some((change) => change.kind !== "changed")) {
+				config = parseConfig();
+				fileNames = [...config.fileNames, virtual];
+			}
+		},
+		close() {
+			service.dispose();
+		}
+	};
+};
+//#endregion
+//#region src/typescript-7.ts
+/** `TypeFormatFlags.NoTruncation`, so long types are written in full. */
+const NO_TRUNCATION = 1;
+/** A project checked by TypeScript 7's API, which runs the native compiler in its own process. */
+const openTypeScript7 = (sync, configPath) => {
+	let virtual = "";
+	let text = "";
+	const api = new sync.API({
+		cwd: dirname(configPath),
+		fs: {
+			readFile: (path) => samePath(path, virtual) ? text : void 0,
+			fileExists: (path) => samePath(path, virtual) ? true : void 0,
+			getAccessibleEntries: (folder) => virtual && samePath(folder, dirname(virtual)) ? entriesWith(folder, basename(virtual)) : void 0
+		}
+	});
+	virtual = virtualPath(configPath, api.parseConfigFile(configPath).fileNames);
+	let snapshot = api.updateSnapshot({ openProjects: [configPath] });
+	const update = (changes) => {
+		snapshot.dispose();
+		snapshot = api.updateSnapshot(changes);
+	};
+	return {
+		query(source, use) {
+			if (source !== text) {
+				text = source;
+				update({ fileChanges: { changed: [virtual] } });
+			}
+			const project = snapshot.getProject(configPath);
+			if (!project?.program.getSourceFile(virtual)) return null;
+			const { checker } = project;
+			const typeOf = (alias) => {
+				const at = text.indexOf(`type ${alias} =`);
+				return at === -1 ? void 0 : checker.getTypeAtPosition(virtual, at + 5);
+			};
+			return use({
+				describe: (alias) => {
+					const type = typeOf(alias);
+					return type ? checker.typeToString(type, void 0, NO_TRUNCATION) : null;
+				},
+				members: (alias) => {
+					const type = typeOf(alias);
+					if (!type) return [];
+					return checker.getPropertiesOfType(type).map((symbol) => {
+						const node = symbol.declarations[0]?.resolve(project);
+						const file = node?.getSourceFile();
+						const memberType = checker.getTypeOfSymbol(symbol);
+						return {
+							name: symbol.name,
+							optional: (symbol.flags & sync.SymbolFlags.Optional) !== 0,
+							type: memberType ? checker.typeToString(memberType, void 0, NO_TRUNCATION) : "unknown",
+							docs: checker.getDocumentationCommentOfSymbol(symbol),
+							tags: checker.getJsDocTagsOfSymbol(symbol).map((tag) => ({
+								name: tag.name,
+								text: tag.text ?? ""
+							})),
+							location: node && file ? {
+								path: file.fileName,
+								...lineAndCharacter(file.text, node.getStart(file))
+							} : null
+						};
+					});
+				}
+			});
+		},
+		changed(changes) {
+			const paths = (kind) => changes.filter((change) => change.kind === kind).map((change) => change.path);
+			update({ fileChanges: {
+				created: paths("created"),
+				changed: paths("changed"),
+				deleted: paths("deleted")
+			} });
+		},
+		close() {
+			snapshot.dispose();
+			api.close();
+		}
+	};
+};
+//#endregion
+//#region src/typescript.ts
+/** The generated file's name. Nothing in the project should use it. */
+const VIRTUAL_NAME = "__kiln_types__.ts";
+/** Where the generated file goes: the folder of the project's first TypeScript source file, or the config's folder. */
+const virtualPath = (configPath, fileNames) => {
+	const root = dirname(configPath);
+	const source = fileNames.find((name) => {
+		const path = relative(root, name);
+		return /\.[cm]?tsx?$/.test(name) && !/\.d\.[cm]?ts$/.test(name) && !path.startsWith("..") && !path.split(sep).includes("node_modules");
+	});
+	return join(source ? dirname(source) : root, VIRTUAL_NAME);
+};
+/** Whether two paths are the same file. TypeScript may change a path's case on case-insensitive file systems. */
+const samePath = (a, b) => a === b || a.toLowerCase() === b.toLowerCase();
+/** A folder's entries with the generated file added, for TypeScript's include globs. */
+const entriesWith = (folder, name) => {
+	const entries = readdirSync(folder, { withFileTypes: true });
+	return {
+		files: [...entries.filter((entry) => entry.isFile()).map((entry) => entry.name), name],
+		directories: entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name)
+	};
+};
+/** The zero-based line and character of an offset in `text`. */
+const lineAndCharacter = (text, offset) => {
+	const lines = text.slice(0, offset).split("\n");
+	return {
+		line: lines.length - 1,
+		character: lines.at(-1).length
+	};
+};
+/** The nearest `tsconfig.json` in `folder` or a folder above it. */
+const findConfig = (folder) => {
+	for (let current = folder;; current = dirname(current)) {
+		const candidate = join(current, "tsconfig.json");
+		try {
+			readFileSync(candidate);
+			return candidate;
+		} catch {}
+		if (dirname(current) === current) return null;
+	}
+};
+/**
+* Loads the TypeScript installed for the project in `folder`, with the nearest `tsconfig.json`. Null when either is
+* missing or the version is older than 6. Version 7 and later use TypeScript's new API; version 6 uses the classic one.
+*/
+const openTypeScript = async (folder, warn) => {
+	const configPath = findConfig(folder);
+	if (!configPath) return null;
+	const require = createRequire(join(folder, "kiln.json"));
+	let major;
+	try {
+		const pkg = JSON.parse(readFileSync(require.resolve("typescript/package.json"), "utf8"));
+		major = Number(pkg.version.split(".")[0]);
+	} catch {
+		return null;
+	}
+	try {
+		if (major >= 7) {
+			const sync = await import(pathToFileURL(require.resolve("typescript/unstable/sync")).href);
+			return openTypeScript7(sync, configPath);
+		}
+		if (major === 6) return openTypeScript6(require("typescript"), configPath);
+	} catch (error) {
+		warn(`Kiln: couldn't load TypeScript. ${error.message}`);
+	}
+	return null;
+};
+//#endregion
 //#region src/project.ts
 /** Diagnostics that need to know the project's names and templates, so they are dropped without a `kiln.json`. */
 const NEEDS_MANIFEST = /* @__PURE__ */ new Set([
@@ -777,13 +1123,18 @@ const openProject = async (manifestPath, fallbackRoot, warn) => {
 		manifest = null;
 		kiln = createKiln(options);
 	}
+	let typescript;
+	const folder = manifestPath && manifest ? dirname(manifestPath) : null;
 	return {
 		manifestPath,
 		manifest,
 		root,
 		kiln,
 		format,
-		overlay
+		overlay,
+		typescript: () => typescript ??= folder ? openTypeScript(folder, warn) : Promise.resolve(null),
+		typescriptChanged: (changes) => void typescript?.then((opened) => opened?.changed(changes)),
+		close: () => void typescript?.then((opened) => opened?.close())
 	};
 };
 /** Checks a template's text and returns its own diagnostics. */
@@ -791,6 +1142,585 @@ const diagnose = async (project, name, text) => {
 	return (await project.kiln.check(name, text)).filter((diagnostic) => diagnostic.template === name && (project.manifest !== null || !NEEDS_MANIFEST.has(diagnostic.code)));
 };
 //#endregion
+//#region src/scopes.ts
+/** Whether a variable can be used at `offset`. A scope's end is exclusive, except at the end of the template. */
+const sees = (binding, offset, length) => offset >= binding.from && (offset < binding.scope.end || binding.scope.end === length);
+/** The offset of `name` as a whole word in `text`, searching `span` from `after`. Falls back to the span's start. */
+const nameIn = (text, span, name, after = span.start) => {
+	const pattern = new RegExp(`(?<![\\w$])${name}(?![\\w$])`, "g");
+	pattern.lastIndex = after;
+	const match = pattern.exec(text.slice(0, span.end));
+	const start = match ? match.index : span.start;
+	return {
+		start,
+		end: start + name.length
+	};
+};
+/** The expressions directly inside an expression. */
+const childExpressions = (expression) => {
+	const ofArgs = (args) => args.map((arg) => arg.value);
+	switch (expression.type) {
+		case "Interpolation": return expression.parts;
+		case "Array": return expression.elements.map((element) => element.type === "Spread" ? element.value : element);
+		case "Hash": return expression.entries.flatMap((entry) => entry.type === "Spread" ? [entry.value] : [entry.key, entry.value]);
+		case "Unary": return [expression.operand];
+		case "Binary": return [expression.left, expression.right];
+		case "Conditional": return [
+			expression.test,
+			expression.consequent,
+			...expression.alternate ? [expression.alternate] : []
+		];
+		case "Member": return [expression.object, expression.property];
+		case "Call": return [expression.callee, ...ofArgs(expression.args)];
+		case "Filter":
+		case "Test": return [expression.input, ...ofArgs(expression.args)];
+		case "Arrow": return [expression.body];
+		case "OptionalChain": return [expression.expression];
+		default: return [];
+	}
+};
+/** The expressions a statement holds itself, not those in nested statements. */
+const statementExpressions = (statement) => {
+	switch (statement.type) {
+		case "Output": return [statement.expression];
+		case "If": return statement.branches.map((branch) => branch.test);
+		case "For": return [statement.iterable];
+		case "Set": return [statement.value];
+		case "Props": return statement.props.flatMap((prop) => prop.default ? [prop.default] : []);
+		case "Extends": return [statement.template];
+		case "Include":
+		case "Component":
+		case "Island": return [statement.template, ...statement.with ? [statement.with] : []];
+		case "Macro": return statement.params.flatMap((param) => param.default ? [param.default] : []);
+		case "With": return [statement.value];
+		case "Cache": return [statement.key, ...statement.seconds ? [statement.seconds] : []];
+		case "Apply": return statement.filters.flatMap((filter) => filter.args.map((arg) => arg.value));
+		default: return [];
+	}
+};
+/** The statement lists inside a statement, and whether each starts a new scope. */
+const childBodies = (statement) => {
+	switch (statement.type) {
+		case "If": return [...statement.branches.map((branch) => ({
+			body: branch.body,
+			scoped: false
+		})), ...statement.alternate ? [{
+			body: statement.alternate,
+			scoped: false
+		}] : []];
+		case "For": return [{
+			body: statement.body,
+			scoped: true
+		}, ...statement.alternate ? [{
+			body: statement.alternate,
+			scoped: false
+		}] : []];
+		case "Component": return [{
+			body: statement.body,
+			scoped: true
+		}, ...statement.fills.map((fill) => ({
+			body: fill.body,
+			scoped: true
+		}))];
+		case "SetBlock":
+		case "Add":
+		case "Cache":
+		case "Apply":
+		case "Autoescape":
+		case "Island":
+		case "Slot": return [{
+			body: statement.body,
+			scoped: false
+		}];
+		case "Block":
+		case "Macro":
+		case "With": return [{
+			body: statement.body,
+			scoped: true
+		}];
+		default: return [];
+	}
+};
+/** Every expression in a list of statements, including nested ones, outermost first. */
+function* expressionsIn(statements) {
+	const visit = function* (expression) {
+		yield expression;
+		for (const child of childExpressions(expression)) yield* visit(child);
+	};
+	for (const statement of statements) {
+		for (const expression of statementExpressions(statement)) yield* visit(expression);
+		for (const { body } of childBodies(statement)) yield* expressionsIn(body);
+	}
+}
+/** The innermost expression whose span holds `offset`, and the expressions around it, outermost first. */
+const expressionPathAt = (ast, offset) => {
+	const path = [];
+	const visit = (expression) => {
+		if (offset < expression.span.start || offset > expression.span.end) return false;
+		path.push(expression);
+		for (const child of childExpressions(expression)) if (visit(child)) return true;
+		return true;
+	};
+	for (const expression of expressionsIn(ast.body)) if (visit(expression)) break;
+	return path;
+};
+/**
+* Parses a template and finds every variable it brings into scope, following Kiln's rules: `for`, `with`, `block`,
+* `macro`, `component` and `fill` start a scope, and `set` updates a variable that is already visible or creates one in
+* the current scope.
+*/
+const templateScopes = (text, isTest) => {
+	const { ast } = parse(text, { isTest });
+	const bindings = [];
+	const visible = (name, offset) => bindings.some((binding) => binding.name === name && sees(binding, offset, text.length));
+	const arrows = (expression) => {
+		for (const node of expressionsIn([{
+			type: "Output",
+			expression,
+			span: expression.span
+		}])) {
+			if (node.type !== "Filter") continue;
+			for (const arg of node.args) {
+				if (arg.value.type !== "Arrow") continue;
+				const arrow = arg.value;
+				const head = text.slice(arrow.span.start, arrow.body.span.start);
+				arrow.params.forEach((name, index) => {
+					const at = nameIn(head, {
+						start: 0,
+						end: head.length
+					}, name);
+					bindings.push({
+						name,
+						source: {
+							kind: "arrow",
+							filter: node.name,
+							input: node.input,
+							index
+						},
+						definition: {
+							start: arrow.span.start + at.start,
+							end: arrow.span.start + at.end
+						},
+						scope: arrow.span,
+						from: arrow.span.start
+					});
+				});
+			}
+		}
+	};
+	const walk = (statements, scope) => {
+		for (const statement of statements) {
+			for (const expression of statementExpressions(statement)) arrows(expression);
+			const add = (name, source, definition, inner = scope, from = statement.span.end) => bindings.push({
+				name,
+				source,
+				definition,
+				scope: inner,
+				from
+			});
+			switch (statement.type) {
+				case "Props":
+					for (const prop of statement.props) add(prop.name, {
+						kind: "prop",
+						type: prop.type,
+						optional: prop.default !== null
+					}, {
+						start: prop.span.start,
+						end: prop.span.start + prop.name.length
+					}, scope, scope.start);
+					if (statement.rest) {
+						const rest = statement.rest;
+						add(rest, { kind: "rest" }, nameIn(text, statement.span, rest), scope, scope.start);
+					}
+					break;
+				case "Set":
+				case "SetBlock":
+					if (!visible(statement.name, statement.span.start)) {
+						const after = text.indexOf("set", statement.span.start) + 3;
+						add(statement.name, statement.type === "Set" ? {
+							kind: "set",
+							value: statement.value
+						} : { kind: "capture" }, nameIn(text, statement.span, statement.name, after));
+					}
+					break;
+				case "For": {
+					const after = text.indexOf("for", statement.span.start) + 3;
+					const from = statement.iterable.span.end;
+					if (statement.keyName) add(statement.keyName, {
+						kind: "key",
+						iterable: statement.iterable
+					}, nameIn(text, statement.span, statement.keyName, after), statement.span, from);
+					add(statement.valueName, {
+						kind: "item",
+						iterable: statement.iterable
+					}, nameIn(text, statement.span, statement.valueName, statement.keyName ? nameIn(text, statement.span, statement.keyName, after).end : after), statement.span, from);
+					break;
+				}
+				case "Macro":
+					for (const param of statement.params) add(param.name, { kind: "param" }, {
+						start: param.span.start,
+						end: param.span.start + param.name.length
+					}, statement.span, param.span.end);
+					break;
+				case "With":
+					if (statement.value.type === "Hash") for (const entry of statement.value.entries) {
+						if (entry.type !== "Property" || entry.key.type !== "Literal" || typeof entry.key.value !== "string") continue;
+						add(entry.key.value, {
+							kind: "with",
+							value: statement.value,
+							key: entry.key.value
+						}, entry.key.span, statement.span, statement.value.span.end);
+					}
+					break;
+				case "Import": {
+					const after = text.lastIndexOf(" as ", statement.span.end);
+					add(statement.alias, { kind: "import" }, nameIn(text, statement.span, statement.alias, Math.max(after, 0)));
+					break;
+				}
+				case "FromImport": for (const item of statement.names) add(item.alias, { kind: "import" }, nameIn(text, item.span, item.alias, item.span.start));
+			}
+			for (const { body, scoped } of childBodies(statement)) walk(body, scoped ? statement.span : scope);
+		}
+	};
+	walk(ast.body, ast.span);
+	return {
+		ast,
+		bindings
+	};
+};
+/** The variable `name` refers to at `offset`: the one in the innermost scope that can see it there. */
+const bindingAt = (scopes, name, offset) => {
+	let found = null;
+	for (const binding of scopes.bindings) {
+		if (binding.name !== name || !sees(binding, offset, scopes.ast.span.end)) continue;
+		if (!found || binding.scope.end - binding.scope.start < found.scope.end - found.scope.start) found = binding;
+	}
+	return found;
+};
+/** Every variable visible at `offset`, innermost first, one per name. */
+const bindingsAt = (scopes, offset) => {
+	return [...new Set(scopes.bindings.map((binding) => binding.name))].flatMap((name) => {
+		const binding = bindingAt(scopes, name, offset);
+		return binding ? [binding] : [];
+	});
+};
+//#endregion
+//#region src/types.ts
+/**
+* Kiln's rules for values, written as TypeScript helper types. Each Kiln expression becomes a type built from these,
+* and the project's own TypeScript works out what it is.
+*
+* - `Get`: `a.b` and `a[0]`, reading a property, a map's value or a list's item.
+* - `Item`, `Key`: what `for` gives for each pass.
+* - `Params` and `Returns` describe a function for hover. A function made with `withRender` is an object whose `call`
+*   takes `RenderInfo` first, so `Params` leaves that out.
+* - `arg`, `plain`, `aware`, `dropRender`, `Called`: a call to a host function, written as a real call so TypeScript
+*   works out a generic function's type parameters from the arguments. See `typeWriter`.
+* - `Members`: the values whose properties a template can read, so lists, maps and primitives complete nothing.
+* - `Last`: a function's last parameter, which named arguments are gathered into.
+* - `Fits`, `NamedFit`: whether an argument fits its parameter. Unknown types always fit, so the editor never guesses.
+*/
+const PRELUDE = `import type { KilnFilters, KilnFunctions, KilnGlobals, KilnTests, KilnTypes, Markup } from "@lucidkiln/core";
+type Named<N extends string> = N extends keyof KilnTypes ? KilnTypes[N] : unknown;
+type Get<V, K> = NonNullable<V> extends infer O ? O extends ReadonlyMap<unknown, infer M> ? M : O extends readonly (infer I)[] ? (K extends number ? I : unknown) : K extends keyof O ? O[K] : unknown : never;
+type Item<V> = NonNullable<V> extends infer O ? O extends string ? unknown : O extends readonly (infer I)[] ? I : O extends ReadonlyMap<unknown, infer M> ? M : O extends ReadonlySet<infer S> ? S : O extends Iterable<infer I> ? I : O extends object ? O[keyof O] : unknown : never;
+type Key<V> = NonNullable<V> extends infer O ? O extends string ? unknown : O extends readonly unknown[] | ReadonlySet<unknown> ? number : O extends ReadonlyMap<infer K, unknown> ? K : O extends object ? keyof O & string : unknown : never;
+type Returns<F> = F extends (...args: never) => infer R ? R : F extends { readonly call: (...args: never) => infer R } ? R : unknown;
+type Params<F> = F extends (...args: infer A) => unknown ? A : F extends { readonly call: (render: never, ...args: infer A) => unknown } ? A : never;
+declare function arg<T>(): T;
+declare function plain<F>(fn: F): F extends (...args: never) => unknown ? F : never;
+declare function aware<F>(fn: F): F extends (...args: never) => unknown ? never : F extends { readonly call: infer C } ? C : never;
+declare function dropRender<A extends unknown[], R>(fn: (render: never, ...args: A) => R): (...args: A) => R;
+type Called<F, Plain, Aware> = unknown extends F ? unknown : F extends (...args: never) => unknown ? Awaited<Plain> : F extends { readonly call: unknown } ? Awaited<Aware> : unknown;
+type Tail<A> = A extends readonly [unknown?, ...infer R] ? R : A;
+type Last<A> = Required<A> extends readonly [...unknown[], infer L] ? L : A extends readonly (infer E)[] ? E : unknown;
+type Fits<A, P> = [P] extends [never] ? true : unknown extends P ? true : unknown extends A ? true : [Exclude<A, Markup>] extends [P] ? true : false;
+type NamedFit<L, K, A> = unknown extends L ? "ok" : [L] extends [never] ? "ok" : NonNullable<L> extends infer O ? string extends keyof O ? "ok" : K extends keyof O ? Fits<A, Exclude<O[K], undefined>> extends true ? "ok" : "mismatch" : "missing" : "ok";
+type Members<V> = NonNullable<V> extends infer O ? O extends string | number | boolean | bigint | symbol | Function | Date | Markup | readonly unknown[] | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> ? never : O : never;
+`;
+const BUILTIN_TYPES = {
+	null: "null",
+	boolean: "boolean",
+	number: "number",
+	string: "string | Markup",
+	array: "readonly unknown[]",
+	hash: "Readonly<Record<string, unknown>> | ReadonlyMap<string, unknown>",
+	set: "ReadonlySet<unknown>",
+	date: "Date",
+	markup: "Markup",
+	object: "object"
+};
+/** A prop's declared type as TypeScript, the same way `generateTypes` writes it. */
+const propType = (type) => {
+	if (type === null) return "unknown";
+	if (type.length === 0) return "never";
+	return type.map((member) => {
+		if (typeof member === "string") return BUILTIN_TYPES[member] ?? "unknown";
+		if ("literal" in member) return JSON.stringify(member.literal);
+		if ("named" in member) return `Named<${JSON.stringify(member.named)}>`;
+		if ("list" in member) return `readonly (${propType(member.list)})[]`;
+		if (member.shape.length === 0) return "object";
+		return `{ ${member.shape.map((key) => `${JSON.stringify(key.name)}${key.optional ? "?" : ""}: ${propType(key.type)}`).join("; ")} }`;
+	}).join(" | ");
+};
+const BUILTIN_FUNCTIONS = {
+	range: "number[]",
+	max: "number",
+	min: "number",
+	cycle: "unknown",
+	date: "Date",
+	attrs: "Markup",
+	dump: "Markup",
+	parent: "Markup",
+	block: "Markup"
+};
+/** What each built-in filter gives, from the type of the value before the `|` and the types of its arguments. */
+const BUILTIN_FILTERS = {
+	upper: () => "string",
+	lower: () => "string",
+	capitalize: () => "string",
+	title: () => "string",
+	trim: () => "string",
+	replace: () => "string",
+	split: () => "string[]",
+	truncate: () => "string",
+	stripTags: () => "string",
+	urlEncode: () => "string",
+	json: () => "Markup",
+	escape: () => "Markup",
+	raw: () => "Markup",
+	default: (input, [fallback = "string"]) => `NonNullable<${input}> | ${fallback}`,
+	length: () => "number",
+	first: (input) => `Item<${input}>`,
+	last: (input) => `Item<${input}>`,
+	slice: (input) => input,
+	join: () => "string",
+	keys: (input) => `Key<${input}>[]`,
+	merge: (input) => input,
+	reverse: (input) => input,
+	sort: (input) => input,
+	map: () => "unknown[]",
+	filter: (input) => input,
+	reduce: () => "unknown",
+	find: (input) => `Item<${input}> | null`,
+	column: () => "unknown[]",
+	batch: (input) => `Item<${input}>[][]`,
+	abs: () => "number",
+	round: () => "number",
+	formatNumber: () => "string",
+	plural: () => "string",
+	formatDate: () => "string"
+};
+/** The list item an arrow function's parameter gets, by filter: which parameter it is. */
+const ITEM_PARAMS = {
+	map: [0],
+	filter: [0],
+	find: [0],
+	sort: [0, 1],
+	reduce: [1]
+};
+const MAX_DEPTH = 32;
+const union = (types) => types.length === 0 ? "never" : [...new Set(types)].join(" | ");
+const literalKey = (expression) => expression.type === "Literal" && (typeof expression.value === "string" || typeof expression.value === "number") ? JSON.stringify(expression.value) : null;
+/**
+* Writes the types of a template's values. A literal's type is its value, so `"page"` is `"page"`. A call to a host
+* function or filter becomes a real call in `statements`, so TypeScript works out a generic function's type parameters
+* from the arguments:
+*
+* ```ts
+* declare const $fn0: Get<KilnFunctions, "document">;
+* const $plain0 = plain($fn0)(arg<"page">());
+* const $aware0 = dropRender(aware($fn0))(arg<"page">());
+* ```
+*
+* The call's type is `Called<typeof $fn0, typeof $plain0, typeof $aware0>`: the first call for a plain function, the
+* second for one made with `withRender`. Each expression is written once, however often a template reads it.
+*/
+const typeWriter = (context) => {
+	const statements = [];
+	const written = /* @__PURE__ */ new Map();
+	/** Writes a call to `callee`, a TypeScript type, with the types of its arguments, and returns the result's type. */
+	const call = (callee, args) => {
+		const id = statements.length;
+		const list = args.join(", ");
+		statements.push(`declare const $fn${id}: ${callee};\nconst $plain${id} = plain($fn${id})(${list});\nconst $aware${id} = dropRender(aware($fn${id}))(${list});\n`);
+		return `Called<typeof $fn${id}, typeof $plain${id}, typeof $aware${id}>`;
+	};
+	/** A call's arguments as TypeScript: named arguments are gathered into one hash at the end, as Kiln does. */
+	const callArgs = (list, depth, input) => {
+		const named = list.flatMap((item) => item.type === "Named" ? [`${JSON.stringify(item.name)}: ${expression(item.value, depth)}`] : []);
+		return [
+			...input ? [`arg<${input}>()`] : [],
+			...list.flatMap((item) => {
+				if (item.type === "Named") return [];
+				const type = expression(item.value, depth);
+				return [item.type === "Spread" ? `...arg<Item<${type}>[]>()` : `arg<${type}>()`];
+			}),
+			...named.length > 0 ? [`arg<{ ${named.join("; ")} }>()`] : []
+		];
+	};
+	const binding = (source, depth) => {
+		const of = (value) => expression(value, depth + 1);
+		switch (source.kind) {
+			case "prop": return propType(source.type);
+			case "rest": return "Readonly<Record<string, unknown>>";
+			case "set": return of(source.value);
+			case "capture": return "Markup";
+			case "item": return `Item<${of(source.iterable)}>`;
+			case "key": return `Key<${of(source.iterable)}>`;
+			case "arrow": return ITEM_PARAMS[source.filter]?.includes(source.index) ? `Item<${of(source.input)}>` : "unknown";
+			case "with": return `Get<${of(source.value)}, ${JSON.stringify(source.key)}>`;
+			default: return "unknown";
+		}
+	};
+	const expression = (node, depth) => {
+		if (depth > MAX_DEPTH) return "unknown";
+		const known = written.get(node);
+		if (known) return known;
+		const type = write(node, depth + 1);
+		written.set(node, type);
+		return type;
+	};
+	const write = (node, depth) => {
+		const of = (inner) => expression(inner, depth);
+		switch (node.type) {
+			case "Literal": return typeof node.value === "string" ? JSON.stringify(node.value) : String(node.value);
+			case "Interpolation": return "string";
+			case "Array": return `(${union(node.elements.map((element) => element.type === "Spread" ? `Item<${of(element.value)}>` : of(element)))})[]`;
+			case "Hash": return `{ ${node.entries.flatMap((entry) => {
+				if (entry.type === "Spread") return [];
+				const key = entry.key.type === "Name" ? JSON.stringify(entry.key.name) : literalKey(entry.key);
+				return key ? [`${key}: ${of(entry.value)}`] : [];
+			}).join("; ")} }`;
+			case "Unary": return node.operator === "not" ? "boolean" : "number";
+			case "Binary": switch (node.operator) {
+				case "??":
+				case "?:": return `NonNullable<${of(node.left)}> | ${of(node.right)}`;
+				case "~": return "string";
+				case "..": return "number[]";
+				case "+":
+				case "-":
+				case "*":
+				case "/":
+				case "//":
+				case "%":
+				case "**": return "number";
+				default: return "boolean";
+			}
+			case "Conditional": return union([of(node.consequent), node.alternate ? of(node.alternate) : "null"]);
+			case "Member": {
+				const key = literalKey(node.property) ?? "string";
+				return `Get<${of(node.object)}, ${key}>`;
+			}
+			case "Call": {
+				const { callee } = node;
+				if (callee.type === "Member") {
+					const key = literalKey(callee.property) ?? "string";
+					return call(`Get<${of(callee.object)}, ${key}>`, callArgs(node.args, depth));
+				}
+				if (callee.type !== "Name") return "unknown";
+				const name = callee.name;
+				if (context.macros.has(name)) return "Markup";
+				const builtin = BUILTIN_FUNCTIONS[name];
+				if (builtin && !context.functions.includes(name)) return builtin;
+				return call(`Get<KilnFunctions, ${JSON.stringify(name)}>`, callArgs(node.args, depth));
+			}
+			case "Filter": {
+				const input = of(node.input);
+				const builtin = BUILTIN_FILTERS[node.name];
+				if (!builtin || context.filters.includes(node.name)) return call(`Get<KilnFilters, ${JSON.stringify(node.name)}>`, callArgs(node.args, depth, input));
+				const arrow = node.args[0]?.value;
+				if (node.name === "map" && arrow?.type === "Arrow") return `(${of(arrow.body)})[]`;
+				return builtin(input, node.args.map((item) => item.type === "Spread" ? "unknown" : of(item.value)));
+			}
+			case "Test": return "boolean";
+			case "OptionalChain": return of(node.expression);
+			case "Name": {
+				if (node.name === "loop") return "unknown";
+				const found = bindingAt(context.scopes, node.name, node.span.start);
+				if (found) return binding(found.source, depth);
+				return `Get<KilnGlobals, ${JSON.stringify(node.name)}>`;
+			}
+			default: return "unknown";
+		}
+	};
+	return {
+		expression: (node) => expression(node, 0),
+		binding: (source) => binding(source, 0),
+		statements
+	};
+};
+/** The registries a project describes in TypeScript, by the kind of name the language server looks up. */
+const REGISTRIES = {
+	function: "KilnFunctions",
+	filter: "KilnFilters",
+	test: "KilnTests",
+	global: "KilnGlobals"
+};
+/**
+* Checks a file of `type name = type` aliases with the project's TypeScript, and reads it with `use`. `statements` are
+* what the aliases read, from a `TypeWriter`.
+*/
+const withTypes = (typescript, aliases, use, statements = []) => {
+	const source = PRELUDE + statements.join("") + Object.entries(aliases).map(([name, type]) => `type ${name} = ${type};\n`).join("");
+	return typescript.query(source, use);
+};
+/** The TypeScript type of a registered function, filter or test, by kind and name. */
+const callableType = (kind, name) => `Get<${REGISTRIES[kind]}, ${JSON.stringify(name)}>`;
+/** Its parameters as a tuple: a filter's first parameter is the value before the `|`, so `withInput` keeps it. */
+const parametersType = (kind, name, withInput = false) => {
+	const params = `Params<${callableType(kind, name)}>`;
+	return kind === "function" || withInput ? params : `Tail<${params}>`;
+};
+/** A host function, filter or test as hover shows it, such as `documents(collection: string): Promise<Page[]>`. */
+const describeCallable = (typescript, kind, name) => withTypes(typescript, {
+	Registry: REGISTRIES[kind],
+	Parameters: parametersType(kind, name),
+	Return: `Returns<${callableType(kind, name)}>`
+}, (read) => {
+	const member = read.members("Registry").find((item) => item.name === name);
+	const parameters = read.describe("Parameters");
+	const result = read.describe("Return");
+	if (!member || !parameters || !result) return null;
+	const list = parameters.replace(/^\[|\]$/g, "");
+	const prefix = `${kind === "filter" ? "|" : kind === "test" ? "is " : ""}${name}(`;
+	return {
+		label: `${prefix}${list}): ${result}`,
+		parameters: splitParameters(list).map((part) => ({
+			name: /^(?:\.\.\.)?([\w$]+)/.exec(part.text)?.[1] ?? part.text,
+			start: prefix.length + part.start,
+			end: prefix.length + part.end
+		})),
+		member
+	};
+});
+/** The names a function or filter takes as named arguments: the properties of its last parameter. */
+const namedOptions = (typescript, kind, name) => withTypes(typescript, { Options: `Members<Last<${parametersType(kind, name)}>>` }, (read) => read.members("Options")) ?? [];
+/**
+* Checks arguments against their parameters with one TypeScript query. Null for an argument that fits. `statements` are
+* what the argument types read, from a `TypeWriter`.
+*/
+const checkArguments = (typescript, checks, statements = []) => {
+	if (checks.length === 0) return [];
+	const aliases = {};
+	checks.forEach((check, index) => {
+		const expected = "index" in check ? `Required<${check.parameters}>[${check.index}]` : `Exclude<Get<Last<${check.parameters}>, ${JSON.stringify(check.name)}>, undefined>`;
+		aliases[`Fit${index}`] = "index" in check ? `Fits<${check.type}, ${expected}> extends true ? "ok" : "mismatch"` : `NamedFit<Last<${check.parameters}>, ${JSON.stringify(check.name)}, ${check.type}>`;
+		aliases[`Expected${index}`] = expected;
+		aliases[`Actual${index}`] = check.type;
+	});
+	return withTypes(typescript, aliases, (read) => checks.map((_, index) => {
+		const fit = read.describe(`Fit${index}`);
+		if (fit === "\"missing\"") return { kind: "missing" };
+		if (fit !== "\"mismatch\"") return null;
+		return {
+			kind: "mismatch",
+			expected: read.describe(`Expected${index}`) ?? "unknown",
+			actual: read.describe(`Actual${index}`) ?? "unknown"
+		};
+	}), statements) ?? checks.map(() => null);
+};
+//#endregion
 //#region src/features.ts
 const analyse = async (project, name, text) => {
 	try {
@@ -833,21 +1763,63 @@ const builtinItems = (builtins, docKind, kind, extra) => [...Object.entries(buil
 	kind,
 	detail: "From your project"
 }))];
-/** Names a template sets or brings into scope before `offset`: loop variables, sets, macros and imports. */
-const localNames = (text, offset) => {
-	const before = text.slice(0, offset);
-	const names = /* @__PURE__ */ new Set();
-	for (const match of before.matchAll(/\{%-?\s*for\s+(\w+)(?:\s*,\s*(\w+))?\s+in\b/g)) {
-		names.add(match[1]);
-		if (match[2]) names.add(match[2]);
-	}
-	for (const match of before.matchAll(/\{%-?\s*(?:set|macro)\s+(\w+)/g)) names.add(match[1]);
-	for (const match of before.matchAll(/\{%-?\s*import\s+["'][^"']*["']\s+as\s+(\w+)/g)) names.add(match[1]);
-	for (const match of before.matchAll(/\{%-?\s*from\s+["'][^"']*["']\s+import\s+([^%]*)%\}/g)) for (const part of match[1].split(",")) {
-		const alias = /(\w+)\s*$/.exec(part.trim())?.[1];
-		if (alias) names.add(alias);
+/** Parses a template and finds its variables, with what `typeWriter` needs to work out their types. */
+const templateTypes = (open, text) => {
+	const manifest = open.project.manifest;
+	const scopes = templateScopes(text, (name) => name in TESTS || (manifest?.tests.includes(name) ?? false));
+	const macros = /* @__PURE__ */ new Set([...macrosIn(text).keys(), ...scopes.bindings.filter((binding) => binding.source.kind === "import").map((binding) => binding.name)]);
+	return {
+		scopes,
+		context: {
+			scopes,
+			functions: manifest?.functions ?? [],
+			filters: manifest?.filters ?? [],
+			macros
+		}
+	};
+};
+/** The property under the cursor in `a.b`, with the expression it's read from. */
+const propertyAt = (scopes, text, offset) => {
+	const path = expressionPathAt(scopes.ast, offset);
+	for (let index = path.length - 1; index >= 0; index--) {
+		const node = path[index];
+		if (node.type !== "Member") continue;
+		const { property } = node;
+		if (property.type === "Literal" && typeof property.value === "string" && offset >= property.span.start && offset <= property.span.end && text[property.span.start - 1] === ".") return {
+			name: property.value,
+			object: node.object,
+			span: property.span
+		};
 	}
-	return [...names];
+	return null;
+};
+/** A member's doc comment and tags, as Markdown. */
+const memberDocs = (member) => [member.docs, ...member.tags.map((tag) => `*@${tag.name}* ${tag.text}`.trim())].filter(Boolean).join("\n\n");
+/** The properties TypeScript finds on the value of `object`. Empty without TypeScript. */
+const membersOf = async (open, object, context) => {
+	const typescript = await open.project.typescript();
+	if (!typescript) return [];
+	const types = typeWriter(context);
+	const type = types.expression(object);
+	return withTypes(typescript, { Value: `Members<${type}>` }, (read) => read.members("Value"), types.statements) ?? [];
+};
+/** A function, filter, test or global the project describes in TypeScript. */
+const registered = async (open, kind, name) => {
+	const typescript = await open.project.typescript();
+	if (!typescript) return null;
+	return withTypes(typescript, { Registry: REGISTRIES[kind] }, (read) => read.members("Registry").find((member) => member.name === name)) ?? null;
+};
+const BINDING_NOTES = {
+	prop: "A prop of this template.",
+	rest: "The variables passed to this template that it doesn't declare.",
+	set: "Set in this template.",
+	capture: "Set in this template, from a `set` block.",
+	item: "A loop variable.",
+	key: "A loop variable.",
+	arrow: "An arrow function's parameter.",
+	with: "From the `with` tag.",
+	param: "A macro argument.",
+	import: "Imported macros."
 };
 const complete = async (open, offset) => {
 	const { document, project, name } = open;
@@ -900,6 +1872,22 @@ const complete = async (open, offset) => {
 		});
 		case "filter": return builtinItems(FILTERS, "filters", CompletionItemKind.Function, manifest?.filters ?? []);
 		case "test": return builtinItems(TESTS, "tests", CompletionItemKind.Function, manifest?.tests ?? []);
+		case "member": {
+			const patched = context.start === offset ? `${text.slice(0, offset)}__kiln__${text.slice(offset)}` : text;
+			const types = templateTypes(open, patched);
+			const property = propertyAt(types.scopes, patched, context.start);
+			if (!property) return [];
+			return (await membersOf(open, property.object, types.context)).map((member) => ({
+				label: member.name,
+				kind: CompletionItemKind.Property,
+				detail: `${member.name}${member.optional ? "?" : ""}: ${member.type}`,
+				documentation: memberDocs(member) ? markdown(memberDocs(member)) : void 0,
+				textEdit: {
+					range: replace(),
+					newText: member.name
+				}
+			}));
+		}
 		case "loop": return Object.entries(LOOP_PROPERTIES).map(([label, description]) => ({
 			label,
 			kind: CompletionItemKind.Property,
@@ -916,14 +1904,17 @@ const complete = async (open, offset) => {
 		}
 		case "expression": {
 			const analysis = name ? await analyse(project, name, text) : null;
+			const { scopes } = templateTypes(open, text);
 			const variables = /* @__PURE__ */ new Set([
 				...analysis?.props.map((prop) => prop.name) ?? [],
 				...analysis?.rest ? [analysis.rest] : [],
-				...localNames(text, offset),
+				...bindingsAt(scopes, offset).map((binding) => binding.name),
+				...macrosIn(text).keys(),
 				...manifest?.globals ?? []
 			]);
 			const props = new Map(analysis?.props.map((prop) => [prop.name, prop]));
 			return [
+				...await namedArgumentItems(open, text, offset),
 				...[...variables].map((label) => {
 					const prop = props.get(label);
 					return {
@@ -933,7 +1924,7 @@ const complete = async (open, offset) => {
 					};
 				}),
 				...builtinItems(FUNCTIONS, "functions", CompletionItemKind.Function, manifest?.functions ?? []),
-				...KEYWORDS.map((label) => ({
+				...KEYWORDS$1.map((label) => ({
 					label,
 					kind: CompletionItemKind.Keyword
 				}))
@@ -946,21 +1937,51 @@ const macrosIn = (text) => new Map([...text.matchAll(/\{%-?\s*macro\s+(\w+)\s*\(
 	params: match[2].trim(),
 	start: match.index
 }]));
-const codeBlock = (code) => `\`\`\`kiln\n${code}\n\`\`\``;
+const codeBlock = (code, language = "kiln") => `\`\`\`${language}\n${code}\n\`\`\``;
 /** A hover's parts, such as a signature and its docs, with a rule between each. Missing parts are left out. */
 const sections = (...parts) => parts.filter(Boolean).join("\n\n---\n\n");
 /** A tag's syntax, from its completion snippet: named placeholders become their names, and the rest become `…`. */
 const tagSyntax = (snippet) => `{% ${snippet.replace(/\$\{\d+:([^}]*)\}/g, "$1").replace(/\$\{?\d+\}?/g, "…")}`;
+/** A registered function, filter or test as the project's TypeScript describes it: its signature, then its docs. */
+const describedCallable = async (open, kind, name) => {
+	const typescript = await open.project.typescript();
+	const described = typescript ? describeCallable(typescript, kind, name) : null;
+	return described ? sections(codeBlock(described.label, "ts"), memberDocs(described.member)) : null;
+};
+/** The variable a name refers to: the one it declares when the cursor is on a declaration, or the one in scope. */
+const bindingFor = (scopes, symbol) => scopes.bindings.find((binding) => binding.name === symbol.name && symbol.start >= binding.definition.start && symbol.start < binding.definition.end) ?? bindingAt(scopes, symbol.name, symbol.start);
+/** The property under the cursor in `a.b`, and what TypeScript knows about it. */
+const memberAt = async (open, text, offset) => {
+	const types = templateTypes(open, text);
+	const property = propertyAt(types.scopes, text, offset);
+	if (!property) return null;
+	const member = (await membersOf(open, property.object, types.context)).find((item) => item.name === property.name);
+	return member ? {
+		member,
+		span: property.span
+	} : null;
+};
 const hover = async (open, offset) => {
 	const { document, project, name } = open;
 	const text = document.getText();
 	const symbol = symbolAt(text, offset);
-	if (!symbol) return enclosingDelimiter(text, offset) ? null : htmlHover(document, offset);
-	const range = {
-		start: document.positionAt(symbol.start),
-		end: document.positionAt(symbol.end)
-	};
+	const rangeOf = (span) => ({
+		start: document.positionAt(span.start),
+		end: document.positionAt(span.end)
+	});
+	if (!symbol) {
+		if (!enclosingDelimiter(text, offset)) return htmlHover(document, offset);
+		const found = await memberAt(open, text, offset);
+		if (!found) return null;
+		const { member } = found;
+		return {
+			contents: markdown(sections(codeBlock(`${member.name}${member.optional ? "?" : ""}: ${member.type}`, "ts"), memberDocs(member))),
+			range: rangeOf(found.span)
+		};
+	}
 	const fromProject = (names, what) => names?.includes(symbol.name) ? `A ${what} your project registers.` : null;
+	/** Whether the project registers a name, which replaces a built-in with the same name. */
+	const registers = (names) => names?.includes(symbol.name) ?? false;
 	let value = null;
 	/** A built-in's signature, then its docs. */
 	const builtin = (signature, kind) => sections(codeBlock(signature), docsFor(kind, symbol.name));
@@ -973,12 +1994,12 @@ const hover = async (open, offset) => {
 		}
 		case "filter": {
 			const doc = FILTERS[symbol.name];
-			value = doc ? builtin(`|${doc.signature}`, "filters") : fromProject(project.manifest?.filters, "filter");
+			value = doc && !registers(project.manifest?.filters) ? builtin(`|${doc.signature}`, "filters") : await describedCallable(open, "filter", symbol.name) ?? fromProject(project.manifest?.filters, "filter");
 			break;
 		}
 		case "test": {
 			const doc = TESTS[symbol.name];
-			value = doc ? builtin(`is ${doc.signature}`, "tests") : fromProject(project.manifest?.tests, "test");
+			value = doc && !registers(project.manifest?.tests) ? builtin(`is ${doc.signature}`, "tests") : await describedCallable(open, "test", symbol.name) ?? fromProject(project.manifest?.tests, "test");
 			break;
 		}
 		case "loop": {
@@ -990,16 +2011,25 @@ const hover = async (open, offset) => {
 			const macro = macrosIn(text).get(symbol.name);
 			const doc = FUNCTIONS[symbol.name];
 			if (macro) value = codeBlock(`macro ${symbol.name}(${macro.params})`);
-			else if (doc) value = builtin(doc.signature, "functions");
-			else value = fromProject(project.manifest?.functions, "function");
+			else if (doc && !registers(project.manifest?.functions)) value = builtin(doc.signature, "functions");
+			else value = await describedCallable(open, "function", symbol.name) ?? fromProject(project.manifest?.functions, "function");
 			break;
 		}
 		case "variable": {
-			const analysis = name ? await analyse(project, name, text) : null;
-			const prop = analysis?.props.find((item) => item.name === symbol.name);
-			if (prop) value = sections(codeBlock(describeProp(prop)), "A prop of this template.");
-			else if (symbol.name === analysis?.rest) value = sections(codeBlock(`...${symbol.name}`), "The variables passed to this template that it doesn't declare.");
-			else if (project.manifest?.globals.includes(symbol.name)) value = "A global your project provides.";
+			const types = templateTypes(open, text);
+			const binding = bindingFor(types.scopes, symbol);
+			if (binding?.source.kind === "prop" || binding?.source.kind === "rest") {
+				const prop = (name ? await analyse(project, name, text) : null)?.props.find((item) => item.name === symbol.name);
+				value = sections(codeBlock(prop ? describeProp(prop) : `...${symbol.name}`), BINDING_NOTES[binding.source.kind]);
+			} else if (binding) {
+				const typescript = await project.typescript();
+				const writer = typeWriter(types.context);
+				const type = typescript ? withTypes(typescript, { Value: writer.binding(binding.source) }, (read) => read.describe("Value"), writer.statements) : null;
+				value = sections(codeBlock(type && type !== "unknown" ? `${symbol.name}: ${type}` : symbol.name, "ts"), BINDING_NOTES[binding.source.kind]);
+			} else {
+				const global = await registered(open, "global", symbol.name);
+				value = global ? sections(codeBlock(`${symbol.name}: ${global.type}`, "ts"), memberDocs(global)) : project.manifest?.globals.includes(symbol.name) ? "A global your project provides." : null;
+			}
 			break;
 		}
 		case "template": {
@@ -1021,22 +2051,19 @@ const hover = async (open, offset) => {
 	}
 	return value ? {
 		contents: markdown(value),
-		range
+		range: rangeOf(symbol)
 	} : null;
 };
-const fileLocation = (project, name, line = 0, character = 0) => ({
-	uri: pathToFileURL(pathOf(project, name)).href,
-	range: {
-		start: {
-			line,
-			character
-		},
-		end: {
-			line,
-			character
-		}
-	}
-});
+const point = (line, character) => {
+	const position = {
+		line,
+		character
+	};
+	return {
+		start: position,
+		end: position
+	};
+};
 /** The line and column of an offset in another template's text. */
 const positionIn = (text, offset) => {
 	const lines = text.slice(0, offset).split("\n");
@@ -1045,28 +2072,63 @@ const positionIn = (text, offset) => {
 		character: lines.at(-1).length
 	};
 };
+/**
+* Where the name under the cursor is defined. The link's origin is the whole name, so editors underline all of
+* `"layouts/base"` rather than one word of it.
+*
+* Variables go to where the template declares them. Without `kiln.json`, template names have no root, so nothing in
+* other templates is found. With the project's TypeScript, its functions, filters, tests, globals and the properties of
+* typed values go to their TypeScript source.
+*/
 const definition = async (open, offset) => {
 	const { document, project, name } = open;
 	const text = document.getText();
+	const link = (origin, uri, range) => ({
+		originSelectionRange: {
+			start: document.positionAt(origin.start),
+			end: document.positionAt(origin.end)
+		},
+		targetUri: uri,
+		targetRange: range,
+		targetSelectionRange: range
+	});
+	const inSource = (origin, location) => link(origin, pathToFileURL(location.path).href, point(location.line, location.character));
 	const symbol = symbolAt(text, offset);
-	if (!symbol) return null;
+	if (!symbol) {
+		if (!enclosingDelimiter(text, offset)) return null;
+		const found = await memberAt(open, text, offset);
+		return found?.member.location ? inSource(found.span, found.member.location) : null;
+	}
+	const inTemplate = (template, line = 0, character = 0) => link(symbol, pathToFileURL(pathOf(project, template)).href, point(line, character));
 	const load = (template) => project.overlay.get(template) ?? readTemplate(project, template);
-	if (symbol.kind === "template") {
-		const target = resolveName(symbol.name, name ?? void 0);
-		return target ? fileLocation(project, target) : null;
+	/** Goes to a function, filter, test or global in the project's TypeScript. */
+	const inTypeScript = async (kind) => {
+		const member = await registered(open, kind, symbol.name);
+		return member?.location ? inSource(symbol, member.location) : null;
+	};
+	const blockName = symbol.kind === "variable" && /\{%-?\s*block\s+$/.test(text.slice(Math.max(0, symbol.start - 40), symbol.start));
+	if (symbol.kind === "variable" && !blockName) {
+		const binding = bindingFor(templateTypes(open, text).scopes, symbol);
+		if (binding) return link(symbol, document.uri, {
+			start: document.positionAt(binding.definition.start),
+			end: document.positionAt(binding.definition.end)
+		});
+		return inTypeScript("global");
 	}
 	if (symbol.kind === "function") {
 		const local = macrosIn(text).get(symbol.name);
 		if (local) {
 			const position = document.positionAt(local.start);
-			return {
-				uri: document.uri,
-				range: {
-					start: position,
-					end: position
-				}
-			};
+			return link(symbol, document.uri, point(position.line, position.character));
 		}
+	}
+	if (!project.manifest) return null;
+	if (symbol.kind === "template") {
+		const target = resolveName(symbol.name, name ?? void 0);
+		return target ? inTemplate(target) : null;
+	}
+	if (symbol.kind === "filter" || symbol.kind === "test") return inTypeScript(symbol.kind);
+	if (symbol.kind === "function") {
 		for (const match of text.matchAll(/\{%-?\s*from\s+(["'])([^"']*)\1\s+import\s+([^%]*)%\}/g)) for (const part of match[3].split(",")) {
 			const [original, alias = original] = part.trim().split(/\s+as\s+/);
 			if (alias !== symbol.name || !original) continue;
@@ -1075,13 +2137,12 @@ const definition = async (open, offset) => {
 			const macro = source ? macrosIn(source).get(original) : null;
 			if (target && source && macro) {
 				const position = positionIn(source, macro.start);
-				return fileLocation(project, target, position.line, position.character);
+				return inTemplate(target, position.line, position.character);
 			}
 		}
-		return null;
+		return inTypeScript("function");
 	}
-	const tag = /\{%-?\s*block\s+$/.exec(text.slice(Math.max(0, symbol.start - 40), symbol.start));
-	if (symbol.kind === "variable" && tag && name) {
+	if (blockName && name) {
 		let current = name;
 		for (let depth = 0; depth < 20; depth++) {
 			const parent = (await analyse(project, current, current === name ? text : void 0))?.templates.find((ref) => ref.kind === "extends")?.name;
@@ -1090,7 +2151,7 @@ const definition = async (open, offset) => {
 			const block = source ? new RegExp(`\\{%-?\\s*block\\s+${symbol.name}\\b`).exec(source) : null;
 			if (source && block) {
 				const position = positionIn(source, block.index);
-				return fileLocation(project, parent, position.line, position.character);
+				return inTemplate(parent, position.line, position.character);
 			}
 			current = parent;
 		}
@@ -1144,6 +2205,193 @@ const symbols = (document) => {
 	}
 	return found;
 };
+/** Whether the project registers a function or filter, which replaces a built-in with the same name. */
+const isRegistered = (project, kind, name) => (kind === "function" ? project.manifest?.functions : project.manifest?.filters)?.includes(name) ?? false;
+/** A built-in's documented signature, such as `round(precision?, method?)`, when it takes arguments. */
+const builtinSignature = (kind, name) => {
+	const doc = (kind === "function" ? FUNCTIONS : FILTERS)[name];
+	if (!doc?.signature.includes("(")) return null;
+	const label = `${kind === "filter" ? "|" : ""}${doc.signature}`;
+	const open = label.indexOf("(") + 1;
+	const list = label.slice(open, label.lastIndexOf(")"));
+	return {
+		label,
+		parameters: splitParameters(list).map((part) => ({
+			name: /^(?:\.\.\.)?(\w+)/.exec(part.text)?.[1] ?? part.text,
+			start: open + part.start,
+			end: open + part.end
+		}))
+	};
+};
+/** Named arguments the function or filter at the cursor takes, such as `limit:`, when an argument could start there. */
+const namedArgumentItems = async (open, text, offset) => {
+	const call = callContext(text, offset);
+	if (!call?.namePosition) return [];
+	const range = {
+		start: open.document.positionAt(call.start),
+		end: open.document.positionAt(offset)
+	};
+	const item = (label, detail, docs) => ({
+		label: `${label}:`,
+		kind: CompletionItemKind.Field,
+		detail,
+		documentation: docs ? markdown(docs) : void 0,
+		sortText: `0${label}`,
+		textEdit: {
+			range,
+			newText: `${label}: `
+		}
+	});
+	const builtin = isRegistered(open.project, call.kind, call.name) ? null : builtinSignature(call.kind, call.name);
+	if (builtin) return builtin.parameters.map((param) => item(param.name));
+	if (call.kind === "function" && macrosIn(text).has(call.name)) return [];
+	const typescript = await open.project.typescript();
+	if (!typescript) return [];
+	return namedOptions(typescript, call.kind, call.name).map((member) => item(member.name, `${member.name}${member.optional ? "?" : ""}: ${member.type}`, memberDocs(member)));
+};
+/**
+* The parameters of the function or filter whose arguments the cursor is in, with the one it's on active. Named
+* arguments are gathered into the last parameter, so a named argument makes that one active and shows its own type.
+*/
+const signatureHelp = async (open, offset) => {
+	const text = open.document.getText();
+	const call = callContext(text, offset);
+	if (!call) return null;
+	let signature = null;
+	const macro = call.kind === "function" ? macrosIn(text).get(call.name) : null;
+	if (macro) signature = {
+		label: `${call.name}(${macro.params})`,
+		parameters: splitParameters(macro.params).map((part) => ({
+			name: /^\w+/.exec(part.text)?.[0] ?? part.text,
+			start: call.name.length + 1 + part.start,
+			end: call.name.length + 1 + part.end
+		}))
+	};
+	else if (!isRegistered(open.project, call.kind, call.name)) {
+		const builtin = builtinSignature(call.kind, call.name);
+		if (builtin) signature = {
+			...builtin,
+			docs: docsFor(call.kind === "function" ? "functions" : "filters", call.name)
+		};
+	}
+	const typescript = signature ? null : await open.project.typescript();
+	if (typescript) {
+		const described = describeCallable(typescript, call.kind, call.name);
+		if (described) {
+			const params = new Map(described.member.tags.flatMap((tag) => {
+				const match = /^(\w+)\s*(.*)$/s.exec(tag.text);
+				return tag.name === "param" && match ? [[match[1], match[2]]] : [];
+			}));
+			signature = {
+				label: described.label,
+				parameters: described.parameters,
+				docs: described.member.docs,
+				paramDocs: params
+			};
+		}
+	}
+	if (!signature || signature.parameters.length === 0) return null;
+	const last = signature.parameters.length - 1;
+	const active = call.named || call.sawNamed ? last : Math.min(call.index, last);
+	let namedDocs = null;
+	if (call.named && typescript) {
+		const option = namedOptions(typescript, call.kind, call.name).find((member) => member.name === call.named);
+		if (option) namedDocs = sections(codeBlock(`${option.name}${option.optional ? "?" : ""}: ${option.type}`, "ts"), memberDocs(option));
+	}
+	const found = signature;
+	return {
+		signatures: [{
+			label: found.label,
+			documentation: found.docs ? markdown(found.docs) : void 0,
+			parameters: found.parameters.map((param, index) => {
+				const docs = index === active && namedDocs ? namedDocs : found.paramDocs?.get(param.name);
+				return {
+					label: [param.start, param.end],
+					documentation: docs ? markdown(docs) : void 0
+				};
+			})
+		}],
+		activeSignature: 0,
+		activeParameter: active
+	};
+};
+/**
+* Checks the arguments of calls to the project's own functions and filters against their TypeScript types. A filter's
+* value before the `|` is its first argument. Calls with `...` spreads, and arguments whose type is unknown, aren't
+* checked.
+*/
+const argumentWarnings = async (open) => {
+	const typescript = await open.project.typescript();
+	if (!typescript) return [];
+	const text = open.document.getText();
+	const { scopes, context } = templateTypes(open, text);
+	const types = typeWriter(context);
+	/**
+	* Each check, with what it's for: a filter's input, a positional or a named argument. A wrong type is reported on
+	* the value, and a named argument the function doesn't take on its name.
+	*/
+	const checks = [];
+	for (const node of expressionsIn(scopes.ast.body)) {
+		let kind;
+		let name;
+		if (node.type === "Call" && node.callee.type === "Name") {
+			kind = "function";
+			name = node.callee.name;
+			if (context.macros.has(name)) continue;
+		} else if (node.type === "Filter") {
+			kind = "filter";
+			name = node.name;
+		} else continue;
+		if ((kind === "function" ? FUNCTIONS : FILTERS)[name] && !isRegistered(open.project, kind, name)) continue;
+		if (node.args.some((arg) => arg.type === "Spread")) continue;
+		const parameters = parametersType(kind, name, true);
+		[...node.type === "Filter" ? [node.input] : [], ...node.args.flatMap((arg) => arg.type === "Positional" ? [arg.value] : [])].forEach((value, index) => {
+			checks.push({
+				type: types.expression(value),
+				parameters,
+				index,
+				span: value.span,
+				callee: name,
+				role: node.type === "Filter" && index === 0 ? "input" : "positional"
+			});
+		});
+		for (const arg of node.args) {
+			if (arg.type !== "Named") continue;
+			checks.push({
+				type: types.expression(arg.value),
+				parameters,
+				name: arg.name,
+				span: arg.value.span,
+				nameSpan: {
+					start: arg.span.start,
+					end: arg.span.start + arg.name.length
+				},
+				callee: name,
+				role: "named"
+			});
+		}
+	}
+	return checkArguments(typescript, checks, types.statements).flatMap((problem, index) => {
+		const check = checks[index];
+		if (!problem || !check) return [];
+		if (problem.kind === "missing") {
+			const option = "name" in check ? check.name : "";
+			return [{
+				...check.nameSpan ?? check.span,
+				code: "unknown-argument",
+				message: `\`${check.callee}\` doesn't take \`${option}\`.`
+			}];
+		}
+		const expected = `\`${problem.expected}\``;
+		const actual = `not \`${problem.actual}\``;
+		const message = check.role === "input" ? `\`${check.callee}\` needs ${expected} before the \`|\`, ${actual}.` : check.role === "named" && "name" in check ? `\`${check.name}\` should be ${expected}, ${actual}.` : `This argument should be ${expected}, ${actual}.`;
+		return [{
+			...check.span,
+			code: "argument-type",
+			message
+		}];
+	});
+};
 //#endregion
 //#region src/server.ts
 /** Serves Kiln templates over a language server connection. */
@@ -1151,11 +2399,14 @@ const startServer = (connection) => {
 	const documents = new TextDocuments(TextDocument);
 	let workspaceFolders = [];
 	let canWatchFiles = false;
+	/** Whether the client takes `LocationLink`s from go to definition. Plain locations lose the clicked range. */
+	let definitionLinks = false;
 	/** Open projects, by the path of their `kiln.json`, or their folder when they have none. */
 	const projects = /* @__PURE__ */ new Map();
 	connection.onInitialize((params) => {
 		workspaceFolders = (params.workspaceFolders ?? []).map((folder) => folder.uri).concat(params.rootUri && !params.workspaceFolders ? [params.rootUri] : []).filter((uri) => uri.startsWith("file:")).map((uri) => fileURLToPath(uri));
 		canWatchFiles = params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true;
+		definitionLinks = params.capabilities.textDocument?.definition?.linkSupport === true;
 		return {
 			capabilities: {
 				textDocumentSync: TextDocumentSyncKind.Incremental,
@@ -1173,6 +2424,10 @@ const startServer = (connection) => {
 					"="
 				] },
 				hoverProvider: true,
+				signatureHelpProvider: {
+					triggerCharacters: ["(", ","],
+					retriggerCharacters: [":", " "]
+				},
 				definitionProvider: true,
 				documentLinkProvider: { resolveProvider: false },
 				documentSymbolProvider: true,
@@ -1184,7 +2439,12 @@ const startServer = (connection) => {
 	});
 	connection.onInitialized(() => {
 		if (!canWatchFiles) return;
-		connection.client.register(DidChangeWatchedFilesNotification.type, { watchers: [{ globPattern: "**/*.kiln" }, { globPattern: "**/kiln.json" }] });
+		connection.client.register(DidChangeWatchedFilesNotification.type, { watchers: [
+			{ globPattern: "**/*.kiln" },
+			{ globPattern: "**/kiln.json" },
+			{ globPattern: "**/*.{ts,tsx,mts,cts}" },
+			{ globPattern: "**/tsconfig*.json" }
+		] });
 	});
 	/** The project a file belongs to: the nearest `kiln.json` inside its workspace folder, or the folder itself. */
 	const projectFor = async (path) => {
@@ -1227,6 +2487,7 @@ const startServer = (connection) => {
 		const { project, name } = open;
 		const version = document.version;
 		const diagnostics = await diagnose(project, name, document.getText()).catch(() => []);
+		const warnings = await argumentWarnings(open).catch(() => []);
 		if (documents.get(document.uri)?.version !== version) return;
 		connection.sendDiagnostics({
 			uri: document.uri,
@@ -1240,7 +2501,16 @@ const startServer = (connection) => {
 				code: diagnostic.code,
 				source: "kiln",
 				message: diagnostic.message
-			}))
+			})).concat(warnings.map((warning) => ({
+				range: {
+					start: document.positionAt(warning.start),
+					end: document.positionAt(warning.end)
+				},
+				severity: DiagnosticSeverity.Warning,
+				code: warning.code,
+				source: "kiln",
+				message: warning.message
+			})))
 		});
 	};
 	/** Every open template in a project sees an edit to any of them, since one template's props can break another. */
@@ -1266,9 +2536,22 @@ const startServer = (connection) => {
 		open.project.kiln.invalidate(open.name);
 		await checkProject(open.project);
 	});
+	/** Closes every open project, so the next request opens them again from their settings. */
+	const closeProjects = async () => {
+		const open = [...projects.values()];
+		projects.clear();
+		for (const project of open) (await project).close();
+	};
+	connection.onShutdown(closeProjects);
 	connection.onDidChangeWatchedFiles(async ({ changes }) => {
-		if (changes.some((change) => change.uri.endsWith("/kiln.json"))) {
-			projects.clear();
+		const isSettings = (uri) => uri.endsWith("/kiln.json") || /\/tsconfig[^/]*\.json$/.test(uri);
+		const typescriptChanges = changes.flatMap((change) => change.uri.startsWith("file:") && /\.[cm]?tsx?$/.test(change.uri) ? [{
+			path: fileURLToPath(change.uri),
+			kind: change.type === FileChangeType.Created ? "created" : change.type === FileChangeType.Deleted ? "deleted" : "changed"
+		}] : []);
+		if (typescriptChanges.length > 0) for (const project of projects.values()) (await project).typescriptChanged(typescriptChanges);
+		if (changes.some((change) => isSettings(change.uri))) {
+			await closeProjects();
 			for (const document of documents.all()) {
 				const open = await openTemplate(document);
 				if (open?.name) {
@@ -1277,7 +2560,7 @@ const startServer = (connection) => {
 				}
 			}
 		} else for (const change of changes) {
-			if (!change.uri.startsWith("file:")) continue;
+			if (!change.uri.startsWith("file:") || !change.uri.endsWith(".kiln")) continue;
 			const path = fileURLToPath(change.uri);
 			const project = await projectFor(path);
 			const name = nameOf(project, path);
@@ -1293,7 +2576,15 @@ const startServer = (connection) => {
 	};
 	connection.onCompletion(withTemplate([], (open, params) => complete(open, open.document.offsetAt(params.position))));
 	connection.onHover(withTemplate(null, (open, params) => hover(open, open.document.offsetAt(params.position))));
-	connection.onDefinition(withTemplate(null, (open, params) => definition(open, open.document.offsetAt(params.position))));
+	connection.onSignatureHelp(withTemplate(null, (open, params) => signatureHelp(open, open.document.offsetAt(params.position))));
+	connection.onDefinition(withTemplate(null, async (open, params) => {
+		const link = await definition(open, open.document.offsetAt(params.position));
+		if (!link || definitionLinks) return link && [link];
+		return {
+			uri: link.targetUri,
+			range: link.targetSelectionRange
+		};
+	}));
 	connection.onDocumentLinks(withTemplate([], (open) => links(open)));
 	connection.onDocumentSymbol(withTemplate([], (open) => symbols(open.document)));
 	/** Formats a template, or part of one, as edits. Templates with syntax errors are left alone. */