@lucidkiln/language-server 0.0.0-stage → 1.1.0

package/dist/main.js

@@ -0,0 +1,2561 @@
+#!/usr/bin/env node
+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";
+import { CompletionItemKind, InsertTextFormat, InsertTextMode, MarkupKind, SymbolKind } from "vscode-languageserver";
+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 = {
+	if: { snippet: block("if", " ${1:condition}") },
+	elseif: { snippet: "elseif ${1:condition} %}" },
+	else: { snippet: "else %}" },
+	for: { snippet: block("for", " ${1:item} in ${2:items}") },
+	set: { snippet: "set ${1:name} = ${2:value} %}" },
+	props: { snippet: "props ${1:name} %}" },
+	extends: { snippet: "extends \"${1:layouts/base}\" %}" },
+	block: { snippet: block("block", " ${1:name}") },
+	include: { snippet: "include \"${1}\" %}" },
+	component: { snippet: "component \"${1}\" with { $2 } %}\n	$0\n{% endcomponent %}" },
+	island: { snippet: "island \"${1}\" with { $2 } %}\n	$0\n{% endisland %}" },
+	fill: { snippet: block("fill", " \"${1:name}\"") },
+	slot: { snippet: "slot %}$0{% endslot %}" },
+	macro: { snippet: block("macro", " ${1:name}(${2})") },
+	import: { snippet: "import \"${1}\" as ${2:name} %}" },
+	from: { snippet: "from \"${1}\" import ${2:name} %}" },
+	with: { snippet: block("with", " { ${1} }") },
+	cache: { snippet: block("cache", " \"${1:key}\" for ${2:600}") },
+	outlet: { snippet: "outlet \"${1:head}\" %}" },
+	add: { snippet: block("add", " to \"${1:head}\"") },
+	flush: { snippet: "flush %}" },
+	apply: { snippet: block("apply", " ${1:filter}") },
+	autoescape: { snippet: block("autoescape", " \"${1:html}\"") },
+	verbatim: { snippet: "verbatim %}\n$0\n{% endverbatim %}" }
+};
+/** Tags that have a body and an end tag. */
+const BLOCK_TAGS = /* @__PURE__ */ new Set([
+	"if",
+	"for",
+	"set",
+	"block",
+	"component",
+	"island",
+	"fill",
+	"slot",
+	"macro",
+	"with",
+	"cache",
+	"add",
+	"apply",
+	"autoescape",
+	"verbatim"
+]);
+const FILTERS = {
+	upper: { signature: "upper" },
+	lower: { signature: "lower" },
+	capitalize: { signature: "capitalize" },
+	title: { signature: "title" },
+	trim: { signature: "trim(characters?, side?)" },
+	replace: { signature: "replace(search, replacement)" },
+	split: { signature: "split(separator, limit?)" },
+	truncate: { signature: "truncate(length, ellipsis?)" },
+	stripTags: { signature: "stripTags" },
+	nl2br: { signature: "nl2br" },
+	urlEncode: { signature: "urlEncode" },
+	json: { signature: "json(indent?)" },
+	escape: { signature: "escape(strategy?)" },
+	raw: { signature: "raw" },
+	default: { signature: "default(fallback)" },
+	length: { signature: "length" },
+	first: { signature: "first" },
+	last: { signature: "last" },
+	slice: { signature: "slice(start, end?)" },
+	join: { signature: "join(glue?, lastGlue?)" },
+	keys: { signature: "keys" },
+	merge: { signature: "merge(...values)" },
+	reverse: { signature: "reverse" },
+	sort: { signature: "sort(by?)" },
+	map: { signature: "map((value, key) => ...)" },
+	filter: { signature: "filter((value, key) => ...)" },
+	reduce: { signature: "reduce((total, value, key) => ..., initial)" },
+	find: { signature: "find((value, key) => ...)" },
+	column: { signature: "column(name)" },
+	batch: { signature: "batch(size, fill?)" },
+	abs: { signature: "abs" },
+	round: { signature: "round(precision?, method?)" },
+	formatNumber: { signature: "formatNumber(...options)" },
+	plural: { signature: "plural(one, other, ...forms)" },
+	formatDate: { signature: "formatDate(...options)" }
+};
+const FUNCTIONS = {
+	range: { signature: "range(start, end, step?)" },
+	max: { signature: "max(...values)" },
+	min: { signature: "min(...values)" },
+	cycle: { signature: "cycle(values, position)" },
+	date: { signature: "date(value?)" },
+	attrs: { signature: "attrs(attributes)" },
+	dump: { signature: "dump(...values)" },
+	parent: { signature: "parent()" },
+	block: { signature: "block(name)" }
+};
+const TESTS = {
+	defined: { signature: "defined" },
+	null: { signature: "null" },
+	empty: { signature: "empty" },
+	even: { signature: "even" },
+	odd: { signature: "odd" },
+	iterable: { signature: "iterable" },
+	"divisible by": { signature: "divisible by(divisor)" }
+};
+const LOOP_PROPERTIES = {
+	index: "Position, starting at 1.",
+	index0: "Position, starting at 0.",
+	revIndex: "Items left, ending at 1.",
+	revIndex0: "Items left, ending at 0.",
+	first: "`true` on the first item.",
+	last: "`true` on the last item.",
+	length: "Total number of items."
+};
+const KEYWORDS$1 = [
+	"true",
+	"false",
+	"null",
+	"and",
+	"or",
+	"not",
+	"in",
+	"is"
+];
+//#endregion
+//#region src/context.ts
+/** Where the output or tag around `offset` opens, and its kind. Null outside one, or inside a comment. */
+const enclosingDelimiter = (text, offset) => {
+	const before = text.slice(0, offset);
+	const output = before.lastIndexOf("{{");
+	const tag = before.lastIndexOf("{%");
+	const comment = before.lastIndexOf("{#");
+	if (comment !== -1 && before.indexOf("#}", comment) === -1) return null;
+	const start = Math.max(output, tag);
+	if (start === -1 || start < comment) return null;
+	const kind = start === tag ? "tag" : "output";
+	if (before.indexOf(kind === "tag" ? "%}" : "}}", start) !== -1) return null;
+	return {
+		start,
+		kind
+	};
+};
+/** The block tags open at `offset`, innermost last, from the tags before it. */
+const openBlocks = (text, offset) => {
+	const stack = [];
+	for (const match of text.slice(0, offset).matchAll(/\{%-?\s*(\w+)([^%]*)%\}/g)) {
+		const name = match[1];
+		const rest = match[2];
+		if (BLOCK_TAGS.has(name)) {
+			if (name === "set" && rest.includes("=")) continue;
+			if (name === "block" && rest.trim().includes(" ")) continue;
+			stack.push(name);
+		} else if (name.startsWith("end")) {
+			const index = stack.lastIndexOf(name.slice(3));
+			if (index !== -1) stack.length = index;
+		}
+	}
+	return stack;
+};
+const WORD_END = /[A-Za-z_][A-Za-z0-9_]*$/;
+const cursorContext = (text, offset) => {
+	const delimiter = enclosingDelimiter(text, offset);
+	if (!delimiter) return null;
+	const inner = text.slice(delimiter.start + 2, offset).replace(/^-/, "");
+	const word = WORD_END.exec(inner)?.[0] ?? "";
+	const start = offset - word.length;
+	const head = inner.slice(0, inner.length - word.length);
+	if (delimiter.kind === "tag" && /^\s*$/.test(head)) {
+		const after = /^\w*(\s*-?%\})/.exec(text.slice(offset).split("\n")[0] ?? "");
+		const blocks = openBlocks(text, delimiter.start);
+		return {
+			kind: "tag",
+			start,
+			end: after ? offset + after[0].length : null,
+			open: blocks.at(-1) ?? null
+		};
+	}
+	const template = /\b(?:extends|include|component|island|import|from)\s+(["'])([^"']*)$/.exec(inner);
+	if (template) {
+		const prefix = template[2];
+		return {
+			kind: "template",
+			start: offset - prefix.length,
+			prefix
+		};
+	}
+	if (/\bloop\.$/.test(head)) return {
+		kind: "loop",
+		start
+	};
+	if (/(?:^|[^|])\|\s*$/.test(head)) return {
+		kind: "filter",
+		start
+	};
+	if (/\bis\s+(?:not\s+)?$/.test(head)) return {
+		kind: "test",
+		start
+	};
+	const props = /\b(?:include|component|island)\s+(["'])([^"']+)\1\s+with\s+\{([^{}]*)$/.exec(head);
+	if (props && /(?:^|,)\s*$/.test(props[3])) return {
+		kind: "prop",
+		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",
+		start
+	};
+};
+/** Every template name written as a string after `extends`, `include`, `component`, `island`, `import` or `from`, with the name's offsets. */
+const templateStrings = (text) => {
+	const found = [];
+	for (const match of text.matchAll(/\{%-?\s*(?:extends|include|component|island|import|from)\s+(["'])([^"'\n]*)\1/g)) {
+		const name = match[2];
+		const end = match.index + match[0].length - 1;
+		found.push({
+			name,
+			start: end - name.length,
+			end
+		});
+	}
+	return found;
+};
+const symbolAt = (text, offset) => {
+	const string = templateStrings(text).find((found) => offset >= found.start && offset <= found.end);
+	if (string) return {
+		kind: "template",
+		...string
+	};
+	const delimiter = enclosingDelimiter(text, offset);
+	if (!delimiter) return null;
+	let start = offset;
+	let end = offset;
+	while (start > 0 && /\w/.test(text[start - 1])) start--;
+	while (end < text.length && /\w/.test(text[end])) end++;
+	if (start === end || !/^[A-Za-z_]/.test(text.slice(start))) return null;
+	let name = text.slice(start, end);
+	const head = text.slice(delimiter.start + 2, start);
+	const tail = text.slice(end, end + 40);
+	if (delimiter.kind === "tag" && /^-?\s*$/.test(head)) return {
+		kind: "tag",
+		name,
+		start,
+		end
+	};
+	if (/\|\s*$/.test(head)) return {
+		kind: "filter",
+		name,
+		start,
+		end
+	};
+	if (/\bis\s+(?:not\s+)?$/.test(head)) {
+		if (name === "divisible" && /^\s+by\b/.test(tail)) name = "divisible by";
+		return {
+			kind: "test",
+			name,
+			start,
+			end
+		};
+	}
+	if (name === "by" && /\bis\s+(?:not\s+)?divisible\s+$/.test(head)) return {
+		kind: "test",
+		name: "divisible by",
+		start,
+		end
+	};
+	if (/\bloop\.$/.test(head)) return {
+		kind: "loop",
+		name,
+		start,
+		end
+	};
+	if (/[.\w]$/.test(head)) return null;
+	if (/^\s*\(/.test(tail)) return {
+		kind: "function",
+		name,
+		start,
+		end
+	};
+	return {
+		kind: "variable",
+		name,
+		start,
+		end
+	};
+};
+//#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
+* `docs.json`; see `apps/documentation/src/editor-docs.ts`.
+*/
+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).",
+			"url": "https://kilnlang.com/docs/tags/outlet/#adding-content"
+		},
+		"apply": {
+			"markdown": "Run a section of output through filters.\n\n`apply` renders its content, then runs the result through one or more filters.\n\n---\n\n*page.kiln*\n\n```kiln\n{% apply upper|trim %}\n	Hello, {{ name }}\n{% endapply %}\n```\n\n*Output*\n\n```html\nHELLO, ADA\n```",
+			"url": "https://kilnlang.com/docs/tags/apply/"
+		},
+		"autoescape": {
+			"markdown": "Change how output is escaped for a section.\n\n`autoescape` changes how output is [escaped](https://kilnlang.com/docs/language/escaping/) inside a section.\n\n---\n\n*page.kiln*\n\n```kiln\n<script>\n{% autoescape \"js\" %}\n	const title = \"{{ page.title }}\";\n{% endautoescape %}\n<\/script>\n```\n\n*Output*\n\n```html\n<script>\nconst title = \"Tom\\u0027s\\u0020\\u0022best\\u0022\\u0020page\";\n<\/script>\n```",
+			"url": "https://kilnlang.com/docs/tags/autoescape/"
+		},
+		"block": {
+			"markdown": "- Block names must be unique within a template.\n- `{% endblock title %}` may repeat the name. If it does, it must match.\n- `{% block title page.title %}` is a short form for a block that holds one expression.\n- Layouts can extend other layouts, as deep as you need.",
+			"url": "https://kilnlang.com/docs/tags/extends/#blocks"
+		},
+		"cache": {
+			"markdown": "Save a section's output and reuse it in later renders.\n\n`cache` saves the output of a section, so later renders reuse it instead of rendering the section again. Use it for parts that are slow to build, such as long lists or sections that load data.\n\n---\n\n```kiln\n{% cache [\"post\", post.id, post.updatedAt] for 600 %}\n	<article>\n		<h2>{{ post.title }}</h2>\n		{{ post.body|raw }}\n	</article>\n{% endcache %}\n```",
+			"url": "https://kilnlang.com/docs/tags/cache/"
+		},
+		"component": {
+			"markdown": "Build reusable pieces of markup with props and slots.\n\nA component is a template that takes props and content from its caller. Use it for cards, buttons, dialogs and other reusable pieces with markup inside.\n\n---\n\n*page.kiln*\n\n```kiln\n{% component \"components/card\" with { title: post.title, href: post.url } %}\n	<p>{{ post.excerpt }}</p>\n	{% fill \"footer\" %}\n		<a href=\"{{ post.url }}\">Read more</a>\n	{% endfill %}\n{% endcomponent %}\n```\n\n*components/card.kiln*\n\n```kiln\n{% props title, href %}\n<article class=\"card\">\n	<h2><a href=\"{{ href }}\">{{ title }}</a></h2>\n	{% slot %}{% endslot %}\n	{% if slots.footer %}\n		<footer>\n			{% slot \"footer\" %}{% endslot %}\n		</footer>\n	{% endif %}\n</article>\n```\n\n*Output*\n\n```html\n<article class=\"card\">\n	<h2><a href=\"/blog/hello/\">Hello, world</a></h2>\n	<p>Our first post.</p>\n	<footer>\n		<a href=\"/blog/hello/\">Read more</a>\n	</footer>\n</article>\n```",
+			"url": "https://kilnlang.com/docs/tags/component/"
+		},
+		"else": {
+			"markdown": "Render content only when a condition holds.\n\n`if` renders its content only when a condition is true. Add `elseif` and `else` for other cases.\n\n---\n\n*page.kiln*\n\n```kiln\n{% if page.hero %}\n	<div class=\"hero\">{{ page.hero }}</div>\n{% elseif page.image %}\n	<img src=\"{{ page.image }}\" alt=\"\">\n{% else %}\n	<hr>\n{% endif %}\n```\n\n*Output*\n\n```html\n<img src=\"/img/cover.jpg\" alt=\"\">\n```",
+			"url": "https://kilnlang.com/docs/tags/if/"
+		},
+		"elseif": {
+			"markdown": "Render content only when a condition holds.\n\n`if` renders its content only when a condition is true. Add `elseif` and `else` for other cases.\n\n---\n\n*page.kiln*\n\n```kiln\n{% if page.hero %}\n	<div class=\"hero\">{{ page.hero }}</div>\n{% elseif page.image %}\n	<img src=\"{{ page.image }}\" alt=\"\">\n{% else %}\n	<hr>\n{% endif %}\n```\n\n*Output*\n\n```html\n<img src=\"/img/cover.jpg\" alt=\"\">\n```",
+			"url": "https://kilnlang.com/docs/tags/if/"
+		},
+		"extends": {
+			"markdown": "Share a layout between pages.\n\nLayouts hold the markup that pages share. A layout defines named `block` sections, and a page `extends` the layout and fills them in.\n\n---\n\n*page.kiln*\n\n```kiln\n{% extends \"layouts/base\" %}\n\n{% block title %}{{ page.title }} | {{ parent() }}{% endblock %}\n\n{% block content %}\n	<h1>{{ page.title }}</h1>\n{% endblock %}\n```\n\n*layouts/base.kiln*\n\n```kiln\n<title>{% block title %}{{ site.name }}{% endblock %}</title>\n<main>\n	{% block content %}{% endblock %}\n</main>\n```\n\n*Output*\n\n```html\n<title>About us | Example</title>\n<main>\n	<h1>About us</h1>\n</main>\n```",
+			"url": "https://kilnlang.com/docs/tags/extends/"
+		},
+		"fill": {
+			"markdown": "- `{% slot %}` outputs the caller's content. Content outside any `fill` goes into this default slot.\n- `{% fill \"name\" %}` in the caller provides content for a named slot, and `{% slot \"name\" %}` in the component outputs it.\n- Content inside `slot` is a fallback, shown when the caller didn't fill that slot. Variables first set in a fallback stay inside it.\n- `slots` is a hash that says which slots were filled, such as `slots.footer`. It includes slots declared by a layout the component extends.\n\n---\n\n```kiln\n<h2>{% slot \"title\" %}Untitled{% endslot %}</h2>\n```",
+			"url": "https://kilnlang.com/docs/tags/component/#slots"
+		},
+		"flush": {
+			"markdown": "Close outlets so a streamed page can be sent so far.\n\n`flush` closes the [outlets](https://kilnlang.com/docs/tags/outlet/) above it. When you [stream](https://kilnlang.com/docs/api/streaming/) a page, everything up to `flush` can then be sent, instead of waiting for the render to end.\n\n---\n\n*page.kiln*\n\n```kiln\n<html>\n	<head>\n		{% outlet \"head\" %}\n		{% add to \"head\" %}\n			<title>Home</title>\n		{% endadd %}\n	</head>\n	{% flush %}\n	<body>\n		<h1>Home</h1>\n	</body>\n</html>\n```\n\n*Output*\n\n```html\n<html>\n	<head>\n		<title>Home</title>\n	</head>\n	<body>\n		<h1>Home</h1>\n	</body>\n</html>\n```",
+			"url": "https://kilnlang.com/docs/tags/flush/"
+		},
+		"for": {
+			"markdown": "Loop over arrays, hashes and other collections.\n\n`for` renders its content once for each item in a collection. An `else` section renders when there are no items.\n\n---\n\n*page.kiln*\n\n```kiln\n{% for post in posts %}\n	<h2>{{ loop.index }}. {{ post.title }}</h2>\n{% else %}\n	<p>No posts yet.</p>\n{% endfor %}\n```\n\n*Output*\n\n```html\n<h2>1. Hello</h2>\n<h2>2. Second post</h2>\n```",
+			"url": "https://kilnlang.com/docs/tags/for/"
+		},
+		"from": {
+			"markdown": "`import` gives you all of a template's macros under one name. `from` imports chosen macros by name, optionally with an alias:\n\n---\n\n```kiln\n{% import \"macros/forms\" as forms %}\n{% from \"macros/forms\" import input, textarea as area %}\n```",
+			"url": "https://kilnlang.com/docs/tags/macro/#importing"
+		},
+		"if": {
+			"markdown": "Render content only when a condition holds.\n\n`if` renders its content only when a condition is true. Add `elseif` and `else` for other cases.\n\n---\n\n*page.kiln*\n\n```kiln\n{% if page.hero %}\n	<div class=\"hero\">{{ page.hero }}</div>\n{% elseif page.image %}\n	<img src=\"{{ page.image }}\" alt=\"\">\n{% else %}\n	<hr>\n{% endif %}\n```\n\n*Output*\n\n```html\n<img src=\"/img/cover.jpg\" alt=\"\">\n```",
+			"url": "https://kilnlang.com/docs/tags/if/"
+		},
+		"import": {
+			"markdown": "`import` gives you all of a template's macros under one name. `from` imports chosen macros by name, optionally with an alias:\n\n---\n\n```kiln\n{% import \"macros/forms\" as forms %}\n{% from \"macros/forms\" import input, textarea as area %}\n```",
+			"url": "https://kilnlang.com/docs/tags/macro/#importing"
+		},
+		"include": {
+			"markdown": "Render another template in place.\n\n`include` renders another template in place. Pass it variables with `with`.\n\n---\n\n*page.kiln*\n\n```kiln\n{% include \"partials/header\" with { title: page.title } %}\n```\n\n*partials/header.kiln*\n\n```kiln\n<header>\n	<a href=\"/\">{{ site.name }}</a>\n	<span>{{ title }}</span>\n</header>\n```\n\n*Output*\n\n```html\n<header>\n	<a href=\"/\">Example</a>\n	<span>Pricing</span>\n</header>\n```",
+			"url": "https://kilnlang.com/docs/tags/include/"
+		},
+		"island": {
+			"markdown": "Load part of a page after the rest, for live or slow data.\n\nAn island is a component that can load after the rest of the page. Use islands in a site you build to static files, for the few parts that need live data, such as stock levels, a basket or a visitor's name. On a server, use them to send the page before its slowest parts are ready.\n\n---\n\n```kiln\n{% island \"components/stock\" with { productId: product.id } %}\n	<p>Checking stock…</p>\n{% endisland %}\n```",
+			"url": "https://kilnlang.com/docs/tags/island/"
+		},
+		"macro": {
+			"markdown": "Define small reusable snippets you call like functions.\n\nA macro is a small piece of markup you call like a function. Define macros in a template, then import them where you need them.\n\n---\n\n*page.kiln*\n\n```kiln\n{% import \"macros/forms\" as forms %}\n\n{{ forms.input(\"email\", type: \"email\") }}\n{{ forms.input(\"name\", \"Ada\") }}\n```\n\n*macros/forms.kiln*\n\n```kiln\n{% macro input(name, value = \"\", type = \"text\") -%}\n	<input type=\"{{ type }}\" name=\"{{ name }}\" value=\"{{ value }}\">\n{%- endmacro %}\n```\n\n*Output*\n\n```html\n<input type=\"email\" name=\"email\" value=\"\">\n<input type=\"text\" name=\"name\" value=\"Ada\">\n```",
+			"url": "https://kilnlang.com/docs/tags/macro/"
+		},
+		"outlet": {
+			"markdown": "Let components add styles and scripts to the page's head.\n\n`outlet` marks a place in the page that any template can add to, and `add to` adds content there. Use them so a component can bring its own styles and scripts, and they end up in the page's `<head>`.\n\n---\n\n*page.kiln*\n\n```kiln\n{% extends \"layouts/base\" %}\n{% set title = \"Home\" %}\n{% block content %}\n	{% include \"components/card\" with { title: \"One\" } %}\n	{% include \"components/card\" with { title: \"Two\" } %}\n{% endblock %}\n```\n\n*layouts/base.kiln*\n\n```kiln\n<html>\n	<head>\n		<title>{{ title }}</title>\n		{% outlet \"head\" %}\n	</head>\n	<body>\n		{% block content %}{% endblock %}\n	</body>\n</html>\n```\n\n*components/card.kiln*\n\n```kiln\n{% props title %}\n{% add to \"head\" once %}\n	<link rel=\"stylesheet\" href=\"/card.css\">\n{% endadd %}\n<article class=\"card\">{{ title }}</article>\n```\n\n*Output*\n\n```html\n<html>\n	<head>\n		<title>Home</title>\n		<link rel=\"stylesheet\" href=\"/card.css\">\n	</head>\n	<body>\n		<article class=\"card\">One</article>\n		<article class=\"card\">Two</article>\n	</body>\n</html>\n```",
+			"url": "https://kilnlang.com/docs/tags/outlet/"
+		},
+		"props": {
+			"markdown": "Declare the variables a template expects.\n\n`props` declares the variables a template expects, with optional types and defaults. It is most useful in components and included templates, where it documents and checks their inputs.\n\n---\n\n*page.kiln*\n\n```kiln\n{% include \"components/button\" with { label: \"Sign up\", href: \"/join\" } %}\n{% include \"components/button\" with { label: \"Cancel\", variant: \"secondary\" } %}\n```\n\n*components/button.kiln*\n\n```kiln\n{% props label: string, href: string | null = null, variant: \"primary\" | \"secondary\" = \"primary\" %}\n{% if href %}\n	<a class=\"button button--{{ variant }}\" href=\"{{ href }}\">{{ label }}</a>\n{% else %}\n	<button class=\"button button--{{ variant }}\">{{ label }}</button>\n{% endif %}\n```\n\n*Output*\n\n```html\n<a class=\"button button--primary\" href=\"/join\">Sign up</a>\n<button class=\"button button--secondary\">Cancel</button>\n```",
+			"url": "https://kilnlang.com/docs/tags/props/"
+		},
+		"set": {
+			"markdown": "Assign a value or captured markup to a variable.\n\n`set` assigns a value to a variable.\n\n---\n\n*page.kiln*\n\n```kiln\n{% set title = page.title ?? \"Untitled\" %}\n<h1>{{ title }}</h1>\n```\n\n*Output*\n\n```html\n<h1>Untitled</h1>\n```",
+			"url": "https://kilnlang.com/docs/tags/set/"
+		},
+		"slot": {
+			"markdown": "- `{% slot %}` outputs the caller's content. Content outside any `fill` goes into this default slot.\n- `{% fill \"name\" %}` in the caller provides content for a named slot, and `{% slot \"name\" %}` in the component outputs it.\n- Content inside `slot` is a fallback, shown when the caller didn't fill that slot. Variables first set in a fallback stay inside it.\n- `slots` is a hash that says which slots were filled, such as `slots.footer`. It includes slots declared by a layout the component extends.\n\n---\n\n```kiln\n<h2>{% slot \"title\" %}Untitled{% endslot %}</h2>\n```",
+			"url": "https://kilnlang.com/docs/tags/component/#slots"
+		},
+		"verbatim": {
+			"markdown": "Output Kiln syntax without running it.\n\n`verbatim` outputs its content as plain text, without running any Kiln syntax inside it.\n\n---\n\n*page.kiln*\n\n```kiln\n{% verbatim %}\n<p>Write {{ name }} to output a variable.</p>\n{% endverbatim %}\n```\n\n*Output*\n\n```html\n<p>Write {{ name }} to output a variable.</p>\n```",
+			"url": "https://kilnlang.com/docs/tags/verbatim/"
+		},
+		"with": {
+			"markdown": "Add variables for a section of a template.\n\n`with` adds variables for a section of a template. They disappear at `endwith`.\n\n---\n\n*page.kiln*\n\n```kiln\n{% with { heading: \"Latest\", items: posts|slice(0, 3) } %}\n	<h2>{{ heading }}</h2>\n	{% for item in items %}\n		<p>{{ item.title }}</p>\n	{% endfor %}\n{% endwith %}\n```\n\n*Output*\n\n```html\n<h2>Latest</h2>\n<p>One</p>\n<p>Two</p>\n<p>Three</p>\n```",
+			"url": "https://kilnlang.com/docs/tags/with/"
+		}
+	},
+	filters: {
+		"abs": {
+			"markdown": "Returns the absolute value of a number.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ (-5)|abs }}\n```\n\n*Output*\n\n```html\n5\n```",
+			"url": "https://kilnlang.com/docs/filters/numbers-and-dates/#abs"
+		},
+		"batch": {
+			"markdown": "Splits an array into groups of a given size. Pass a second argument to fill up the last group.\n\n---\n\n*page.kiln*\n\n```kiln\n{% for row in [1, 2, 3, 4, 5]|batch(2, \"-\") %}\n	<div>{{ row|join(\" \") }}</div>\n{% endfor %}\n```\n\n*Output*\n\n```html\n<div>1 2</div>\n<div>3 4</div>\n<div>5 -</div>\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#batch"
+		},
+		"capitalize": {
+			"markdown": "Makes the first character upper case and the rest lower case.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"hELLO wORLD\"|capitalize }}\n```\n\n*Output*\n\n```html\nHello world\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#capitalize"
+		},
+		"column": {
+			"markdown": "Reads one property from each item.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ posts|column(\"author\")|join(\", \") }}\n```\n\n*Output*\n\n```html\nAda, Grace, Ada\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#column"
+		},
+		"default": {
+			"markdown": "Returns a fallback when the value is [empty](https://kilnlang.com/docs/language/values/#empty-values) or missing. In strict mode, it also stops a missing value from being an error.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ page.subtitle|default(\"No subtitle\") }}\n```\n\n*Output*\n\n```html\nNo subtitle\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#default"
+		},
+		"escape": {
+			"markdown": "Escapes a value with a strategy: `\"html\"` (the default), `\"attr\"`, `\"js\"`, `\"css\"` or `\"url\"`. See [Escaping](https://kilnlang.com/docs/language/escaping/).\n\n---\n\n*page.kiln*\n\n```kiln\n<a href=\"/tags/{{ \"a&b\"|escape(\"url\") }}\">Tag</a>\n```\n\n*Output*\n\n```html\n<a href=\"/tags/a%26b\">Tag</a>\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#escape"
+		},
+		"filter": {
+			"markdown": "Keeps the items for which the arrow function returns true.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ posts|filter(p => p.author == \"Ada\")|column(\"title\")|join(\", \") }}\n```\n\n*Output*\n\n```html\nHello, Workers\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#filter"
+		},
+		"find": {
+			"markdown": "Returns the first item for which the arrow function returns true, or null.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ (posts|find(p => p.views > 200)).title }}\n```\n\n*Output*\n\n```html\nLayouts\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#find"
+		},
+		"first": {
+			"markdown": "Return the first or last item, or null when there are none. On a string they return a character.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ (posts|first).title }} and {{ (posts|last).title }}\n```\n\n*Output*\n\n```html\nHello and Workers\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#first-and-last"
+		},
+		"formatDate": {
+			"markdown": "Formats a date with `Intl.DateTimeFormat`. It accepts a `Date`, an ISO 8601 string or milliseconds since 1970. A day past the end of its month, such as `2026-02-30`, is an error. Pass any of its options as named arguments, plus `locale` and `timeZone`. Option values must be strings, numbers or booleans. The default style is `dateStyle: \"medium\"`, unless you pass an option that chooses what to show, such as `timeStyle`, `month` or `hour`.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"2026-10-15\"|formatDate }}\n{{ \"2026-10-15\"|formatDate(dateStyle: \"long\", locale: \"en-GB\") }}\n{{ \"2026-10-15T14:30:00Z\"|formatDate(timeStyle: \"short\", timeZone: \"Europe/London\") }}\n{{ \"2026-10-15\"|formatDate(weekday: \"long\", day: \"numeric\", month: \"long\") }}\n```\n\n*Output*\n\n```html\nOct 15, 2026\n15 October 2026\n3:30 PM\nThursday, October 15\n```",
+			"url": "https://kilnlang.com/docs/filters/numbers-and-dates/#formatdate"
+		},
+		"formatNumber": {
+			"markdown": "Formats a number with `Intl.NumberFormat`. Pass any of its options as named arguments, plus `locale`. Option values must be strings, numbers or booleans, and an option name `Intl` doesn't know is an error.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ 1234567.891|formatNumber }}\n{{ 49.5|formatNumber(style: \"currency\", currency: \"GBP\") }}\n{{ 0.256|formatNumber(style: \"percent\") }}\n{{ 1234.5|formatNumber(locale: \"de-DE\", minimumFractionDigits: 2) }}\n```\n\n*Output*\n\n```html\n1,234,567.891\n£49.50\n26%\n1.234,50\n```",
+			"url": "https://kilnlang.com/docs/filters/numbers-and-dates/#formatnumber"
+		},
+		"join": {
+			"markdown": "Joins items into a string. A second separator goes between the last two items.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ [\"tea\", \"coffee\", \"water\"]|join(\", \", \" and \") }}\n```\n\n*Output*\n\n```html\ntea, coffee and water\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#join"
+		},
+		"json": {
+			"markdown": "Turns a value into JSON. Pass a number to indent it. Sets, generators and other iterables become arrays. The output escapes `<`, `>` and `&`, so it is safe inside a `<script>` tag with `raw`.\n\n---\n\n*page.kiln*\n\n```kiln\n<script>const page = {{ { title: \"Home\", tags: [\"a\", \"b\"] }|json|raw }};<\/script>\n```\n\n*Output*\n\n```html\n<script>const page = {\"title\":\"Home\",\"tags\":[\"a\",\"b\"]};<\/script>\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#json"
+		},
+		"keys": {
+			"markdown": "Returns the keys of a hash or map, or the indexes of an array.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ { a: 1, b: 2 }|keys|join(\", \") }}\n```\n\n*Output*\n\n```html\na, b\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#keys"
+		},
+		"last": {
+			"markdown": "Return the first or last item, or null when there are none. On a string they return a character.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ (posts|first).title }} and {{ (posts|last).title }}\n```\n\n*Output*\n\n```html\nHello and Workers\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#first-and-last"
+		},
+		"length": {
+			"markdown": "Counts the items in an array, the keys in a hash, or the characters in a string. A hash or map counts the entries a loop would see. Null has a length of 0.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ posts|length }} posts, {{ \"héllo\"|length }} letters\n```\n\n*Output*\n\n```html\n3 posts, 5 letters\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#length"
+		},
+		"lower": {
+			"markdown": "Change text to upper or lower case.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"Hello\"|upper }} {{ \"Hello\"|lower }}\n```\n\n*Output*\n\n```html\nHELLO hello\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#upper-and-lower"
+		},
+		"map": {
+			"markdown": "Calls an arrow function for each item and returns the results. The function gets the value and the key.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ posts|map(p => p.title|upper)|join(\", \") }}\n```\n\n*Output*\n\n```html\nHELLO, LAYOUTS, WORKERS\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#map"
+		},
+		"merge": {
+			"markdown": "Joins arrays together, or combines hashes. For hashes, later keys win. Mixing arrays and hashes is an error.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ [1, 2]|merge([3], [4])|join(\", \") }}\n{{ ({ size: \"md\", tone: \"plain\" }|merge({ size: \"lg\" })).size }}\n```\n\n*Output*\n\n```html\n1, 2, 3, 4\nlg\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#merge"
+		},
+		"nl2br": {
+			"markdown": "Escapes the text, then adds a `<br>` before each line break. Safe markup isn't escaped again. The result is safe HTML.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"Line one\nLine two\"|nl2br }}\n```\n\n*Output*\n\n```html\nLine one<br>\nLine two\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#nl2br"
+		},
+		"plural": {
+			"markdown": "Picks the word or phrase that fits a number, using the plural rules of the render's locale. Pass the forms as named arguments. Every `#` in the chosen form becomes the number, formatted for the locale.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ 1|plural(one: \"# item\", other: \"# items\") }}\n{{ 1200|plural(one: \"# item\", other: \"# items\") }}\n{{ 3|plural(\"item\", \"items\") }}\n```\n\n*Output*\n\n```html\n1 item\n1,200 items\nitems\n```",
+			"url": "https://kilnlang.com/docs/filters/numbers-and-dates/#plural"
+		},
+		"raw": {
+			"markdown": "Marks a value as safe, so it is output without escaping. Only use it for HTML you trust. Put it after filters that return plain values, such as `split` and `join`.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ html|raw }}\n```\n\n*Output*\n\n```html\n<em>Trusted</em>\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#raw"
+		},
+		"reduce": {
+			"markdown": "Combines the items into one value. The arrow function gets the running total, the value and the key. The second argument is the starting value. Without it, the total starts as null, which can't be added to, so pass 0 to add up numbers.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ posts|reduce((total, p) => total + p.views, 0) }} views\n```\n\n*Output*\n\n```html\n550 views\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#reduce"
+		},
+		"replace": {
+			"markdown": "Replaces every match of a piece of text. Pass a hash to replace several at once, and the longest match wins at each position. It matches plain text, not regular expressions.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"I like tea\"|replace(\"tea\", \"coffee\") }}\n{{ \"Hi NAME, welcome to PLACE\"|replace({ NAME: \"Ada\", PLACE: \"Kiln\" }) }}\n```\n\n*Output*\n\n```html\nI like coffee\nHi Ada, welcome to Kiln\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#replace"
+		},
+		"reverse": {
+			"markdown": "Reverses an array, string or hash. A hash keeps its keys.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ [1, 2, 3]|reverse|join(\", \") }} {{ \"kiln\"|reverse }}\n```\n\n*Output*\n\n```html\n3, 2, 1 nlik\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#reverse"
+		},
+		"round": {
+			"markdown": "Rounds to a number of decimal places, 0 by default. The second argument is the method: `\"common\"` (the default, which rounds halves away from zero), `\"ceil\"` or `\"floor\"`.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ 3.14159|round(2) }}\n{{ 2.5|round }}\n{{ 2.1|round(0, \"ceil\") }}\n```\n\n*Output*\n\n```html\n3.14\n3\n3\n```",
+			"url": "https://kilnlang.com/docs/filters/numbers-and-dates/#round"
+		},
+		"slice": {
+			"markdown": "Returns part of an array or string, from a start index up to, but not including, an end index. Negative numbers count from the end, as in JavaScript.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ [1, 2, 3, 4, 5]|slice(1, 3)|join(\", \") }}\n{{ [1, 2, 3, 4, 5]|slice(-2)|join(\", \") }}\n```\n\n*Output*\n\n```html\n2, 3\n4, 5\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#slice"
+		},
+		"sort": {
+			"markdown": "Returns a sorted copy. Without an argument, it sorts numbers, strings or dates in natural order. With a one-parameter arrow function, it sorts by the result. With a two-parameter one, it uses it to compare items, like JavaScript's `sort`. A hash keeps its keys, sorted by their values.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ [3, 1, 2]|sort|join(\", \") }}\n{{ posts|sort(p => p.date)|column(\"title\")|join(\", \") }}\n{{ posts|sort((a, b) => b.views - a.views)|column(\"title\")|join(\", \") }}\n```\n\n*Output*\n\n```html\n1, 2, 3\nLayouts, Workers, Hello\nLayouts, Hello, Workers\n```",
+			"url": "https://kilnlang.com/docs/filters/lists/#sort"
+		},
+		"split": {
+			"markdown": "Splits text into an array. An optional limit caps the number of items. An empty separator splits into characters.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"a,b,c\"|split(\",\")|join(\" / \") }}\n{{ \"a,b,c\"|split(\",\", 2)|join(\" / \") }}\n```\n\n*Output*\n\n```html\na / b / c\na / b\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#split"
+		},
+		"stripTags": {
+			"markdown": "Removes HTML tags and comments. It doesn't decode entities such as `&amp;amp;`, and removing a tag never leaves a new one behind. Its result is still escaped, so don't mark it with `raw` to make it safe.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"<p>Hello <b>world</b></p>\"|stripTags }}\n```\n\n*Output*\n\n```html\nHello world\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#striptags"
+		},
+		"title": {
+			"markdown": "Starts each word with an upper-case letter and makes the rest lower case. Accent marks and apostrophes belong to the word they are in, so \"o'neil\" becomes \"O'neil\".\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"the QUICK brown fox\"|title }}\n```\n\n*Output*\n\n```html\nThe Quick Brown Fox\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#title"
+		},
+		"trim": {
+			"markdown": "Removes whitespace from both ends. Pass characters to remove instead, and `\"start\"` or `\"end\"` to trim one side.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"  hello  \"|trim }}|{{ \"--hello--\"|trim(\"-\", \"end\") }}\n```\n\n*Output*\n\n```html\nhello|--hello\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#trim"
+		},
+		"truncate": {
+			"markdown": "Shortens text to a length, trims trailing spaces and adds an ellipsis if it cut anything. Pass a different ending as the second argument. Given safe markup, it counts only the text and closes any tags the cut leaves open.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"Kiln is a template language\"|truncate(13) }}\n{{ \"Short\"|truncate(13) }}\n```\n\n*Output*\n\n```html\nKiln is a tem…\nShort\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#truncate"
+		},
+		"upper": {
+			"markdown": "Change text to upper or lower case.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ \"Hello\"|upper }} {{ \"Hello\"|lower }}\n```\n\n*Output*\n\n```html\nHELLO hello\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#upper-and-lower"
+		},
+		"urlEncode": {
+			"markdown": "Encodes a string for use in a URL, or turns a hash into a query string.\n\n---\n\n*page.kiln*\n\n```kiln\n/search?q={{ \"tea & cake\"|urlEncode }}\n/search?{{ { q: \"tea\", page: 2 }|urlEncode }}\n```\n\n*Output*\n\n```html\n/search?q=tea%20%26%20cake\n/search?q=tea&amp;page=2\n```",
+			"url": "https://kilnlang.com/docs/filters/strings/#urlencode"
+		}
+	},
+	functions: {
+		"attrs": {
+			"markdown": "Builds HTML attributes from a hash. It handles the fiddly cases for you:\n\n- null and `false` leave the attribute out;\n- `true` writes the name on its own;\n- arrays are joined with spaces, skipping empty values;\n- everything else is escaped.\n\n---\n\n*page.kiln*\n\n```kiln\n<a{{ attrs({\n	href: post.url,\n	class: [\"card\", featured ? \"card--featured\"],\n	hidden: false,\n	\"aria-current\": current ? \"page\",\n}) }}>{{ post.title }}</a>\n```\n\n*Output*\n\n```html\n<a href=\"/blog/hello/\" class=\"card card--featured\">Hello</a>\n```",
+			"url": "https://kilnlang.com/docs/functions/#attrs"
+		},
+		"block": {
+			"markdown": "`parent()` outputs the layout's version of the current block. `block(\"name\")` outputs a block of the current template. See [extends and block](https://kilnlang.com/docs/tags/extends/#reusing-blocks).",
+			"url": "https://kilnlang.com/docs/functions/#parent-and-block"
+		},
+		"cycle": {
+			"markdown": "Returns the item at a position, starting again from the beginning when it runs out. Useful for alternating classes.\n\n---\n\n*page.kiln*\n\n```kiln\n{% for item in [\"a\", \"b\", \"c\"] %}\n	<li class=\"{{ cycle([\"odd\", \"even\"], loop.index0) }}\">{{ item }}</li>\n{% endfor %}\n```\n\n*Output*\n\n```html\n<li class=\"odd\">a</li>\n<li class=\"even\">b</li>\n<li class=\"odd\">c</li>\n```",
+			"url": "https://kilnlang.com/docs/functions/#cycle"
+		},
+		"date": {
+			"markdown": "Returns a `Date` from a date, an ISO 8601 string or milliseconds. With no argument, it returns the current time. With null, it returns null, so a missing date never becomes today.\n\n---\n\n*page.kiln*\n\n```kiln\n{% if date(post.publishedAt) < date(\"2026-06-01\") %}Older post{% endif %}\n```\n\n*Output*\n\n```html\nOlder post\n```",
+			"url": "https://kilnlang.com/docs/functions/#date"
+		},
+		"dump": {
+			"markdown": "Outputs a readable view of its arguments, for debugging. It only works when the environment has `debug: true`. Otherwise it outputs nothing, so a forgotten `dump` never leaks data.\n\n---\n\n```kiln\n{{ dump(page, route) }}\n```",
+			"url": "https://kilnlang.com/docs/functions/#dump"
+		},
+		"max": {
+			"markdown": "Return the largest or smallest argument, the largest or smallest item of one array, or the largest or smallest value of one hash. Null can't be compared, so it is an error.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ max(3, 8, 1) }} {{ min([4, 2, 9]) }}\n```\n\n*Output*\n\n```html\n8 2\n```",
+			"url": "https://kilnlang.com/docs/functions/#max-and-min"
+		},
+		"min": {
+			"markdown": "Return the largest or smallest argument, the largest or smallest item of one array, or the largest or smallest value of one hash. Null can't be compared, so it is an error.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ max(3, 8, 1) }} {{ min([4, 2, 9]) }}\n```\n\n*Output*\n\n```html\n8 2\n```",
+			"url": "https://kilnlang.com/docs/functions/#max-and-min"
+		},
+		"parent": {
+			"markdown": "`parent()` outputs the layout's version of the current block. `block(\"name\")` outputs a block of the current template. See [extends and block](https://kilnlang.com/docs/tags/extends/#reusing-blocks).",
+			"url": "https://kilnlang.com/docs/functions/#parent-and-block"
+		},
+		"range": {
+			"markdown": "Returns an array of numbers from a start to an end, including both. The optional third argument is the step. A fractional step, such as 0.1, still reaches the end.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ range(1, 5)|join(\", \") }}\n{{ range(0, 10, 5)|join(\", \") }}\n{{ range(3, 1)|join(\", \") }}\n{{ range(0, 0.3, 0.1)|join(\", \") }}\n```\n\n*Output*\n\n```html\n1, 2, 3, 4, 5\n0, 5, 10\n3, 2, 1\n0, 0.1, 0.2, 0.3\n```",
+			"url": "https://kilnlang.com/docs/functions/#range"
+		}
+	},
+	tests: {
+		"defined": {
+			"markdown": "True when a variable or property exists. It never raises a [strict mode](https://kilnlang.com/docs/language/strict-mode/) error, so it is the safe way to check for optional data.\n\n---\n\n*page.kiln*\n\n```kiln\n{% if page.subtitle is defined %}{{ page.subtitle }}{% else %}No subtitle{% endif %}\n```\n\n*Output*\n\n```html\nNo subtitle\n```",
+			"url": "https://kilnlang.com/docs/tests/#defined"
+		},
+		"divisible by": {
+			"markdown": "True when the value is a multiple of the argument.\n\n---\n\n*page.kiln*\n\n```kiln\n{% for n in 1..6 %}{{ n }}{% if n is divisible by(3) %} |{% endif %} {% endfor %}\n```\n\n*Output*\n\n```html\n1 2 3 | 4 5 6 |\n```",
+			"url": "https://kilnlang.com/docs/tests/#divisible-by"
+		},
+		"empty": {
+			"markdown": "True when the value is [empty](https://kilnlang.com/docs/language/values/#empty-values): null, `false`, an empty string, array, hash, set or map. `0` is not empty.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ [] is empty }} {{ 0 is empty }}\n```\n\n*Output*\n\n```html\ntrue false\n```",
+			"url": "https://kilnlang.com/docs/tests/#empty"
+		},
+		"even": {
+			"markdown": "True when the value is an even or odd whole number.\n\n---\n\n*page.kiln*\n\n```kiln\n{% for n in 1..4 %}{{ n }} is {{ n is even ? \"even\" : \"odd\" }}. {% endfor %}\n```\n\n*Output*\n\n```html\n1 is odd. 2 is even. 3 is odd. 4 is even.\n```",
+			"url": "https://kilnlang.com/docs/tests/#even-and-odd"
+		},
+		"iterable": {
+			"markdown": "True for arrays, hashes, sets, maps and other values `for` can loop over. Strings are not iterable.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ [1, 2] is iterable }} {{ \"abc\" is iterable }}\n```\n\n*Output*\n\n```html\ntrue false\n```",
+			"url": "https://kilnlang.com/docs/tests/#iterable"
+		},
+		"null": {
+			"markdown": "True when the value is null or undefined.\n\n---\n\n*page.kiln*\n\n```kiln\n{{ page.image is null ? \"No image\" : \"Has image\" }}\n```\n\n*Output*\n\n```html\nNo image\n```",
+			"url": "https://kilnlang.com/docs/tests/#null"
+		},
+		"odd": {
+			"markdown": "True when the value is an even or odd whole number.\n\n---\n\n*page.kiln*\n\n```kiln\n{% for n in 1..4 %}{{ n }} is {{ n is even ? \"even\" : \"odd\" }}. {% endfor %}\n```\n\n*Output*\n\n```html\n1 is odd. 2 is even. 3 is odd. 4 is even.\n```",
+			"url": "https://kilnlang.com/docs/tests/#even-and-odd"
+		}
+	}
+};
+/** A built-in's docs as Markdown, ending with a link to its section on the docs site. Null for names without docs. */
+const docsFor = (kind, name) => {
+	const doc = DOCS[kind][name];
+	return doc ? `${doc.markdown}\n\n---\n\n[Kiln docs](${doc.url})` : null;
+};
+//#endregion
+//#region src/html.ts
+const service = getLanguageService();
+/** The template as an HTML document, with Kiln syntax blanked out so the HTML service only sees the markup. */
+const htmlOf = (document) => {
+	const html = TextDocument.create(document.uri, "html", document.version, templateText(document.getText()));
+	return {
+		html,
+		parsed: service.parseHTMLDocument(html)
+	};
+};
+/** HTML elements, attributes and attribute values at `offset`, outside Kiln syntax. */
+const htmlCompletions = (document, offset) => {
+	const { html, parsed } = htmlOf(document);
+	return service.doComplete(html, document.positionAt(offset), parsed).items;
+};
+/** MDN's description of the HTML element or attribute at `offset`, outside Kiln syntax. */
+const htmlHover = (document, offset) => {
+	const { html, parsed } = htmlOf(document);
+	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([
+	"unknown-function",
+	"unknown-filter",
+	"unknown-test",
+	"unknown-type",
+	"missing-template"
+]);
+/**
+* Resolves a template name as Kiln does: relative to `from` when it starts with `./` or `../`, with `.kiln` added when the last part has no extension. Null when the name is invalid.
+*/
+const resolveName = (name, from) => {
+	const segments = (name.startsWith("./") || name.startsWith("../")) && from ? from.split("/").slice(0, -1) : [];
+	for (const segment of name.split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") {
+			if (segments.length === 0) return null;
+			segments.pop();
+		} else segments.push(segment);
+	}
+	const last = segments.at(-1);
+	if (last === void 0 || name.startsWith("/")) return null;
+	if (!last.includes(".")) segments[segments.length - 1] = `${last}.kiln`;
+	return segments.join("/");
+};
+/** The template name for a file, or null when it is outside the project's root. */
+const nameOf = (project, path) => {
+	const name = relative(project.root, path);
+	if (name.startsWith("..") || name.startsWith(sep) || name === "") return null;
+	return name.split(sep).join("/");
+};
+const pathOf = (project, name) => join(project.root, ...name.split("/"));
+/** Every template under the root, skipping dot folders and node_modules. */
+const listTemplates = async (project) => {
+	const names = [];
+	const visit = async (folder, from) => {
+		const entries = await readdir(folder, { withFileTypes: true }).catch(() => []);
+		for (const entry of entries) {
+			if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+			const name = from + entry.name;
+			if (entry.isDirectory()) await visit(join(folder, entry.name), name + "/");
+			else if (entry.isFile() && name.endsWith(".kiln")) names.push(name);
+		}
+	};
+	await visit(project.root, "");
+	return names.sort();
+};
+/** The nearest `kiln.json` in `folder` or above it, stopping at `stop` when given. */
+const findManifest = async (folder, stop) => {
+	for (let current = folder;; current = dirname(current)) {
+		const candidate = join(current, "kiln.json");
+		try {
+			await readFile(candidate, "utf8");
+			return candidate;
+		} catch {}
+		if (current === stop || dirname(current) === current) return null;
+	}
+};
+/** Reads `kiln.json`, filling in defaults. Throws when it isn't valid. */
+const readManifest = async (path) => {
+	const data = JSON.parse(await readFile(path, "utf8"));
+	if (typeof data !== "object" || data === null || Array.isArray(data)) throw new Error("kiln.json must hold an object");
+	const field = (key) => {
+		const value = data[key];
+		if (value === void 0) return [];
+		if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new Error(`"${key}" in kiln.json must be a list of names`);
+		return value;
+	};
+	const { root = ".", strict = true, htmlChecks = true } = data;
+	if (typeof root !== "string") throw new Error("\"root\" in kiln.json must be a string");
+	if (typeof strict !== "boolean") throw new Error("\"strict\" in kiln.json must be true or false");
+	if (typeof htmlChecks !== "boolean" && (typeof htmlChecks !== "object" || htmlChecks === null || Array.isArray(htmlChecks))) throw new Error("\"htmlChecks\" in kiln.json must be true, false or an object");
+	return {
+		root,
+		strict,
+		htmlChecks,
+		functions: field("functions"),
+		filters: field("filters"),
+		tests: field("tests"),
+		globals: field("globals"),
+		types: field("types")
+	};
+};
+/** Imports an entry point of the copy of Kiln installed in a project, or returns null. */
+const importInstalled = async (from, entry) => {
+	for (let current = from;; current = dirname(current)) {
+		const folder = join(current, "node_modules", "@lucidkiln", "core");
+		try {
+			const file = JSON.parse(await readFile(join(folder, "package.json"), "utf8")).exports?.[entry]?.import;
+			return file ? await import(pathToFileURL(join(folder, file)).href) : null;
+		} catch {}
+		if (dirname(current) === current) return null;
+	}
+};
+const stubs = (names, value) => Object.fromEntries(names.map((name) => [name, value]));
+/**
+* Opens the project for a template folder: the nearest `kiln.json`, or `fallbackRoot` without one. Prefers the project's own copy of Kiln, so errors match how it renders.
+*
+* A broken `kiln.json` is reported through `warn`, and the project is opened as if it had none.
+*/
+const openProject = async (manifestPath, fallbackRoot, warn) => {
+	let manifest = null;
+	if (manifestPath) try {
+		manifest = await readManifest(manifestPath);
+	} catch (error) {
+		warn(`Kiln: ignoring ${manifestPath}. ${error.message}`);
+	}
+	const root = manifestPath && manifest ? join(dirname(manifestPath), manifest.root) : fallbackRoot;
+	const base = manifestPath ? dirname(manifestPath) : fallbackRoot;
+	const { createKiln } = await importInstalled(base, ".") ?? bundledKiln;
+	const format = await importInstalled(base, "./format") ?? bundledFormat;
+	const overlay = /* @__PURE__ */ new Map();
+	const options = { loader: { load: async (name) => {
+		const open = overlay.get(name);
+		if (open !== void 0) return open;
+		if (!manifest) return null;
+		try {
+			return await readFile(join(root, ...name.split("/")), "utf8");
+		} catch {
+			return null;
+		}
+	} } };
+	let kiln;
+	try {
+		kiln = manifest ? createKiln({
+			...options,
+			functions: stubs(manifest.functions, () => null),
+			filters: stubs(manifest.filters, () => null),
+			tests: stubs(manifest.tests, () => true),
+			globals: stubs(manifest.globals, null),
+			types: stubs(manifest.types, () => true),
+			strict: manifest.strict,
+			htmlChecks: manifest.htmlChecks
+		}) : createKiln(options);
+	} catch (error) {
+		warn(`Kiln: ignoring ${manifestPath}. ${error.message}`);
+		manifest = null;
+		kiln = createKiln(options);
+	}
+	let typescript;
+	const folder = manifestPath && manifest ? dirname(manifestPath) : null;
+	return {
+		manifestPath,
+		manifest,
+		root,
+		kiln,
+		format,
+		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. */
+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.
+* - `Result`: what a call gives once Kiln waits for it. `Params` and `Returns` describe the function for hover.
+* - `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, RenderAware } 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 RenderAware<any, any, infer R> ? R : F extends (...args: any) => infer R ? R : unknown;
+type Result<F> = Awaited<Returns<F>>;
+type Params<F> = F extends RenderAware<any, infer A, any> ? A : F extends (...args: infer A) => any ? A : never;
+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;
+/** The TypeScript type of a variable, from where its value comes from. */
+const bindingType = (source, context, depth = 0) => {
+	const of = (expression) => expressionType(expression, context, 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 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 TypeScript type of a Kiln expression, using the helper types in `PRELUDE`. */
+const expressionType = (expression, context, depth = 0) => {
+	if (depth > MAX_DEPTH) return "unknown";
+	const of = (inner) => expressionType(inner, context, depth + 1);
+	const args = (list) => list.map((arg) => arg.type === "Spread" ? "unknown" : of(arg.value));
+	switch (expression.type) {
+		case "Literal": return expression.value === null ? "null" : typeof expression.value;
+		case "Interpolation": return "string";
+		case "Array": return `(${union(expression.elements.map((element) => element.type === "Spread" ? `Item<${of(element.value)}>` : of(element)))})[]`;
+		case "Hash": return `{ ${expression.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 expression.operator === "not" ? "boolean" : "number";
+		case "Binary": switch (expression.operator) {
+			case "??":
+			case "?:": return `NonNullable<${of(expression.left)}> | ${of(expression.right)}`;
+			case "~": return "string";
+			case "..": return "number[]";
+			case "+":
+			case "-":
+			case "*":
+			case "/":
+			case "//":
+			case "%":
+			case "**": return "number";
+			default: return "boolean";
+		}
+		case "Conditional": return union([of(expression.consequent), expression.alternate ? of(expression.alternate) : "null"]);
+		case "Member": {
+			const key = literalKey(expression.property) ?? "string";
+			return `Get<${of(expression.object)}, ${key}>`;
+		}
+		case "Call": {
+			const { callee } = expression;
+			if (callee.type === "Member") {
+				const key = literalKey(callee.property) ?? "string";
+				return `Result<Get<${of(callee.object)}, ${key}>>`;
+			}
+			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 `Result<Get<KilnFunctions, ${JSON.stringify(name)}>>`;
+		}
+		case "Filter": {
+			const input = of(expression.input);
+			const builtin = BUILTIN_FILTERS[expression.name];
+			if (!builtin || context.filters.includes(expression.name)) return `Result<Get<KilnFilters, ${JSON.stringify(expression.name)}>>`;
+			const arrow = expression.args[0]?.value;
+			if (expression.name === "map" && arrow?.type === "Arrow") return `(${of(arrow.body)})[]`;
+			return builtin(input, args(expression.args));
+		}
+		case "Test": return "boolean";
+		case "OptionalChain": return of(expression.expression);
+		case "Name": {
+			if (expression.name === "loop") return "unknown";
+			const binding = bindingAt(context.scopes, expression.name, expression.span.start);
+			if (binding) return bindingType(binding.source, context, depth + 1);
+			return `Get<KilnGlobals, ${JSON.stringify(expression.name)}>`;
+		}
+		default: return "unknown";
+	}
+};
+/** 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`. */
+const withTypes = (typescript, aliases, use) => {
+	const source = PRELUDE + 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. */
+const checkArguments = (typescript, checks) => {
+	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"
+		};
+	})) ?? checks.map(() => null);
+};
+//#endregion
+//#region src/features.ts
+const analyse = async (project, name, text) => {
+	try {
+		return await project.kiln.analyze(name, text);
+	} catch {
+		return null;
+	}
+};
+/** Writes a prop type as it appears in `props`, such as `"a" | "b"` or `{ url?: string }[]`. */
+const describeType = (type) => {
+	if (type === null) return "any";
+	return type.map((member) => {
+		if (typeof member === "string") return member;
+		if ("literal" in member) return JSON.stringify(member.literal);
+		if ("named" in member) return member.named;
+		if ("list" in member) {
+			const inner = describeType(member.list);
+			return member.list.length > 1 ? `(${inner})[]` : `${inner}[]`;
+		}
+		return `{ ${member.shape.map((key) => `${key.name}${key.optional ? "?" : ""}: ${describeType(key.type)}`).join(", ")} }`;
+	}).join(" | ");
+};
+const describeProp = (prop) => `${prop.name}${prop.required ? "" : "?"}: ${describeType(prop.type)}`;
+const markdown = (value) => ({
+	kind: MarkupKind.Markdown,
+	value
+});
+/** Markdown for an item's docs, or nothing when it has none. */
+const documentation = (kind, name) => {
+	const docs = docsFor(kind, name);
+	return docs ? markdown(docs) : void 0;
+};
+const builtinItems = (builtins, docKind, kind, extra) => [...Object.entries(builtins).map(([label, doc]) => ({
+	label,
+	kind,
+	detail: doc.signature,
+	documentation: documentation(docKind, label)
+})), ...extra.filter((name) => !(name in builtins)).map((label) => ({
+	label,
+	kind,
+	detail: "From your project"
+}))];
+/** Parses a template and finds its variables, with what `expressionType` 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 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 type = expressionType(object, context);
+	return withTypes(typescript, { Value: `Members<${type}>` }, (read) => read.members("Value")) ?? [];
+};
+/** 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;
+	const text = document.getText();
+	const context = cursorContext(text, offset);
+	if (!context) return enclosingDelimiter(text, offset) ? [] : htmlCompletions(document, offset);
+	const replace = (end = offset) => ({
+		start: document.positionAt(context.start),
+		end: document.positionAt(end)
+	});
+	const manifest = project.manifest;
+	switch (context.kind) {
+		case "tag": {
+			const items = Object.entries(TAGS).map(([label, tag]) => ({
+				label,
+				kind: CompletionItemKind.Keyword,
+				documentation: documentation("tags", label),
+				insertTextFormat: InsertTextFormat.Snippet,
+				insertTextMode: InsertTextMode.adjustIndentation,
+				textEdit: {
+					range: replace(context.end ?? offset),
+					newText: tag.snippet
+				}
+			}));
+			if (context.open) {
+				const label = `end${context.open}`;
+				items.unshift({
+					label,
+					kind: CompletionItemKind.Keyword,
+					detail: `Closes the open ${context.open}`,
+					sortText: "0",
+					textEdit: {
+						range: replace(context.end ?? offset),
+						newText: `${label} %}`
+					}
+				});
+			}
+			return items;
+		}
+		case "template": return (await listTemplates(project)).map((template) => {
+			const label = template.replace(/\.kiln$/, "");
+			return {
+				label,
+				kind: CompletionItemKind.File,
+				textEdit: {
+					range: replace(),
+					newText: label
+				}
+			};
+		});
+		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,
+			documentation: markdown(description)
+		}));
+		case "prop": {
+			const target = resolveName(context.template, name ?? void 0);
+			return ((target ? await analyse(project, target) : null)?.props ?? []).map((prop) => ({
+				label: prop.name,
+				kind: CompletionItemKind.Field,
+				detail: describeProp(prop),
+				insertText: `${prop.name}: `
+			}));
+		}
+		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] : [],
+				...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 {
+						label,
+						kind: CompletionItemKind.Variable,
+						detail: prop ? describeProp(prop) : void 0
+					};
+				}),
+				...builtinItems(FUNCTIONS, "functions", CompletionItemKind.Function, manifest?.functions ?? []),
+				...KEYWORDS$1.map((label) => ({
+					label,
+					kind: CompletionItemKind.Keyword
+				}))
+			];
+		}
+	}
+};
+/** The `{% macro name(params) %}` definitions in a template, by name. */
+const macrosIn = (text) => new Map([...text.matchAll(/\{%-?\s*macro\s+(\w+)\s*\(([^)]*)\)/g)].map((match) => [match[1], {
+	params: match[2].trim(),
+	start: match.index
+}]));
+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);
+	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));
+	switch (symbol.kind) {
+		case "tag": {
+			const tag = symbol.name in TAGS ? symbol.name : symbol.name.replace(/^end/, "");
+			const doc = TAGS[tag];
+			value = sections(doc && codeBlock(tagSyntax(doc.snippet)), docsFor("tags", tag));
+			break;
+		}
+		case "filter": {
+			const doc = FILTERS[symbol.name];
+			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 && !registers(project.manifest?.tests) ? builtin(`is ${doc.signature}`, "tests") : await describedCallable(open, "test", symbol.name) ?? fromProject(project.manifest?.tests, "test");
+			break;
+		}
+		case "loop": {
+			const description = LOOP_PROPERTIES[symbol.name];
+			value = description ? sections(codeBlock(`loop.${symbol.name}`), description) : null;
+			break;
+		}
+		case "function": {
+			const macro = macrosIn(text).get(symbol.name);
+			const doc = FUNCTIONS[symbol.name];
+			if (macro) value = codeBlock(`macro ${symbol.name}(${macro.params})`);
+			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 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 type = typescript ? withTypes(typescript, { Value: bindingType(binding.source, types.context) }, (read) => read.describe("Value")) : 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": {
+			const target = resolveName(symbol.name, name ?? void 0);
+			const analysis = target ? await analyse(project, target) : null;
+			if (!target || !analysis) {
+				value = project.manifest ? `Template \`${symbol.name}\` was not found.` : null;
+				break;
+			}
+			const lines = [`**${target}**`];
+			if (analysis.props.length > 0 || analysis.rest) {
+				const props = analysis.props.map(describeProp);
+				if (analysis.rest) props.push(`...${analysis.rest}`);
+				lines.push(codeBlock(`props ${props.join(", ")}`));
+			}
+			if (analysis.blocks.length > 0) lines.push(`Blocks: ${analysis.blocks.map((block) => `\`${block}\``).join(", ")}`);
+			value = lines.join("\n\n");
+		}
+	}
+	return value ? {
+		contents: markdown(value),
+		range: rangeOf(symbol)
+	} : null;
+};
+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");
+	return {
+		line: lines.length - 1,
+		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) {
+		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);
+	/** 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 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;
+			const target = resolveName(match[2], name ?? void 0);
+			const source = target ? await load(target) : null;
+			const macro = source ? macrosIn(source).get(original) : null;
+			if (target && source && macro) {
+				const position = positionIn(source, macro.start);
+				return inTemplate(target, position.line, position.character);
+			}
+		}
+		return inTypeScript("function");
+	}
+	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;
+			if (!parent) return null;
+			const source = await load(parent);
+			const block = source ? new RegExp(`\\{%-?\\s*block\\s+${symbol.name}\\b`).exec(source) : null;
+			if (source && block) {
+				const position = positionIn(source, block.index);
+				return inTemplate(parent, position.line, position.character);
+			}
+			current = parent;
+		}
+	}
+	return null;
+};
+const readTemplate = async (project, name) => {
+	try {
+		return await readFile(pathOf(project, name), "utf8");
+	} catch {
+		return null;
+	}
+};
+const links = (open) => {
+	const { document, project, name } = open;
+	if (!project.manifest) return [];
+	return templateStrings(document.getText()).flatMap((found) => {
+		const target = resolveName(found.name, name ?? void 0);
+		if (!target) return [];
+		return [{
+			range: {
+				start: document.positionAt(found.start),
+				end: document.positionAt(found.end)
+			},
+			target: pathToFileURL(pathOf(project, target)).href
+		}];
+	});
+};
+const SYMBOL_KINDS = {
+	block: SymbolKind.Module,
+	macro: SymbolKind.Function,
+	slot: SymbolKind.Field,
+	fill: SymbolKind.Field
+};
+const symbols = (document) => {
+	const text = document.getText();
+	const found = [];
+	for (const match of text.matchAll(/\{%-?\s*(block|macro|slot|fill)\b\s*(["']?)([\w-]*)\2[^%]*%\}/g)) {
+		const kind = match[1];
+		const range = {
+			start: document.positionAt(match.index),
+			end: document.positionAt(match.index + match[0].length)
+		};
+		found.push({
+			name: match[3] || (kind === "slot" ? "default" : kind),
+			detail: kind,
+			kind: SYMBOL_KINDS[kind] ?? SymbolKind.Field,
+			range,
+			selectionRange: range
+		});
+	}
+	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);
+	/**
+	* 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: expressionType(value, context),
+				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: expressionType(arg.value, context),
+				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).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. */
+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,
+				completionProvider: { triggerCharacters: [
+					"|",
+					".",
+					"%",
+					"\"",
+					"'",
+					"/",
+					" ",
+					"{",
+					",",
+					"<",
+					"="
+				] },
+				hoverProvider: true,
+				signatureHelpProvider: {
+					triggerCharacters: ["(", ","],
+					retriggerCharacters: [":", " "]
+				},
+				definitionProvider: true,
+				documentLinkProvider: { resolveProvider: false },
+				documentSymbolProvider: true,
+				documentFormattingProvider: true,
+				documentRangeFormattingProvider: true
+			},
+			serverInfo: { name: "kiln-language-server" }
+		};
+	});
+	connection.onInitialized(() => {
+		if (!canWatchFiles) return;
+		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) => {
+		const folder = workspaceFolders.filter((candidate) => {
+			const name = relative(candidate, path);
+			return name !== ".." && !name.startsWith(".." + sep) && !isAbsolute(name);
+		}).sort((a, b) => b.length - a.length)[0] ?? null;
+		const manifestPath = await findManifest(dirname(path), folder);
+		const fallbackRoot = folder ?? dirname(path);
+		const key = manifestPath ?? fallbackRoot;
+		let project = projects.get(key);
+		if (!project) {
+			project = openProject(manifestPath, fallbackRoot, (message) => connection.window.showWarningMessage(message));
+			projects.set(key, project);
+		}
+		return project;
+	};
+	const openTemplate = async (document) => {
+		if (!document.uri.startsWith("file:")) return null;
+		const path = fileURLToPath(document.uri);
+		const project = await projectFor(path);
+		return {
+			document,
+			project,
+			name: nameOf(project, path)
+		};
+	};
+	const pending = /* @__PURE__ */ new Map();
+	/** Checks a template shortly after its last change, and publishes its diagnostics. */
+	const scheduleCheck = (document) => {
+		clearTimeout(pending.get(document.uri));
+		pending.set(document.uri, setTimeout(() => {
+			pending.delete(document.uri);
+			check(document);
+		}, 150));
+	};
+	const check = async (document) => {
+		const open = await openTemplate(document);
+		if (!open?.name) return;
+		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,
+			version,
+			diagnostics: diagnostics.map((diagnostic) => ({
+				range: {
+					start: document.positionAt(diagnostic.start.offset),
+					end: document.positionAt(diagnostic.end.offset)
+				},
+				severity: diagnostic.severity === "error" ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning,
+				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. */
+	const checkProject = async (project) => {
+		for (const document of documents.all()) if ((await openTemplate(document))?.project === project) scheduleCheck(document);
+	};
+	documents.onDidChangeContent(async ({ document }) => {
+		const open = await openTemplate(document);
+		if (!open?.name) return;
+		open.project.overlay.set(open.name, document.getText());
+		open.project.kiln.invalidate(open.name);
+		await checkProject(open.project);
+	});
+	documents.onDidClose(async ({ document }) => {
+		clearTimeout(pending.get(document.uri));
+		connection.sendDiagnostics({
+			uri: document.uri,
+			diagnostics: []
+		});
+		const open = await openTemplate(document);
+		if (!open?.name) return;
+		open.project.overlay.delete(open.name);
+		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 }) => {
+		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) {
+					open.project.overlay.set(open.name, document.getText());
+					open.project.kiln.invalidate(open.name);
+				}
+			}
+		} else for (const change of changes) {
+			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);
+			if (name) project.kiln.invalidate(name);
+		}
+		for (const document of documents.all()) scheduleCheck(document);
+	});
+	/** Runs a handler with the open template for a request, or returns `fallback` when there is none. */
+	const withTemplate = (fallback, handler) => async (params) => {
+		const document = documents.get(params.textDocument.uri);
+		const open = document ? await openTemplate(document) : null;
+		return open ? handler(open, params) : fallback;
+	};
+	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.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. */
+	const formatTemplate = (open, options, range) => {
+		const { document, project } = open;
+		try {
+			return project.format.formatEdits(document.getText(), {
+				useTabs: !options.insertSpaces,
+				tabWidth: options.tabSize,
+				range
+			}).map((edit) => ({
+				range: {
+					start: document.positionAt(edit.start),
+					end: document.positionAt(edit.end)
+				},
+				newText: edit.text
+			}));
+		} catch (error) {
+			if (error instanceof project.format.KilnFormatError) connection.window.showErrorMessage(error.message);
+			return [];
+		}
+	};
+	connection.onDocumentFormatting(withTemplate([], (open, params) => formatTemplate(open, params.options)));
+	connection.onDocumentRangeFormatting(withTemplate([], (open, params) => formatTemplate(open, params.options, {
+		start: open.document.offsetAt(params.range.start),
+		end: open.document.offsetAt(params.range.end)
+	})));
+	documents.listen(connection);
+	connection.listen();
+};
+//#endregion
+//#region src/main.ts
+startServer(createConnection(ProposedFeatures.all));
+//#endregion
+export {};
+
+//# sourceMappingURL=main.js.map