@monimesl/dot-cli 0.1.0-alpha.4 → 0.1.0-alpha.40

package/dist/{server-DFOUQnLA.js → server-DMnWDdJ6.js}

@@ -1,3 +1,4 @@
+import { t as findDotRoot } from "./cli.js";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { CONTROL_FLOW_TAGS, DATA_PREFIX, ROOT_TAG, canHaveChildren, compileView, dataKey, listStatics } from "@monimesl/dot-compiler";
@@ -5,7 +6,7 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { parseDmlToIR } from "@monimesl/dot-dml-parser";
 import { ScriptParseError, parseExpression, parseLogicModule, parseStateModule } from "@monimesl/dot-script-parser";
-import { SourceError, builtinRegistry, eventName, eventProp, isEventProp } from "@monimesl/dot-core";
+import { SourceError, builtinRegistry, eventName, eventProp, isEventProp, isWordsOr, otherThanWords } from "@monimesl/dot-core";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import ts from "typescript";
 //#region \0rolldown/runtime.js
@@ -10143,165 +10144,57 @@ function getWellformedEdit(textEdit) {
 	return textEdit;
 }
 //#endregion
-//#region src/lsp/shapes.ts
-const NUMBER = {
-	kind: "value",
-	type: "number"
+//#region src/lsp/descriptions.ts
+const CONTROL_FLOW_DOCS = {
+	If: "Shows its children when `condition` is true.",
+	ElseIf: "Goes after an `<If>` or `<ElseIf>`. Shows its children when every condition before it is false and `condition` is true.",
+	Else: "Goes after an `<If>` or `<ElseIf>`. Shows its children when every condition before it is false.",
+	For: "Repeats its children for each item in `each`. Inside, the item is named `item` and its position `index`. `key` tells items apart: a property of each item, `*this` for the item itself, or `*index` to match items by position."
 };
-function parseBinding(source) {
-	try {
-		return parseExpression(source);
-	} catch (error) {
-		if (error instanceof ScriptParseError) return;
-		throw error;
-	}
-}
-function shapeOf(expr, scope) {
-	switch (expr.type) {
-		case "Identifier":
-			if (scope.loops.has(expr.name)) return scope.loops.get(expr.name);
-			return scope.state[expr.name];
-		case "Member": {
-			const owner = shapeOf(expr.object, scope);
-			if (!owner) return;
-			const { property } = expr;
-			if (property.type === "Literal" && typeof property.value === "string") return membersOf(owner)[property.value];
-			return owner.kind === "list" ? owner.item : void 0;
-		}
-		default: return;
-	}
-}
-function membersOf(shape) {
-	switch (shape.kind) {
-		case "object": return shape.properties;
-		case "list": return { length: NUMBER };
-		case "value": return {};
+const CONTROL_FLOW_ATTRIBUTE_DOCS = {
+	condition: "A single `{{ }}` binding",
+	each: "The list to repeat, as a single `{{ }}` binding",
+	item: "The name for each item (default `item`)",
+	index: "The name for each position (default `index`)",
+	key: "A property of each item, `*this` or `*index`"
+};
+function describeComponent(component) {
+	const lines = [`**<${component.name}>** · ${describeChildren(component)}`];
+	const props = Object.entries(component.props);
+	if (props.length > 0) lines.push("", ...props.map(([name, type]) => `- \`${name}\`: ${describeType(type)}`));
+	if (component.events.length > 0) {
+		const eventProps = component.events.map((event) => `\`${eventProp(event)}\``);
+		lines.push("", `Events: ${eventProps.join(", ")}`);
 	}
+	return lines.join("\n");
 }
-function describeMembers(shape) {
-	return Object.keys(membersOf(shape)).join(", ") || "none";
-}
-function loopScope(variables, state) {
-	const loops = /* @__PURE__ */ new Map();
-	for (const variable of variables) if (variable.role === "index") loops.set(variable.name, NUMBER);
-	else loops.set(variable.name, itemShape(variable.list, {
-		state,
-		loops
-	}));
-	return {
-		state,
-		loops
-	};
-}
-function itemShape(each, scope) {
-	const list = parseBinding(each.replace(/^\s*{{|}}\s*$/g, ""));
-	const shape = list && shapeOf(list, scope);
-	return shape?.kind === "list" ? shape.item : void 0;
-}
-function withLoop(scope, item, itemShape, index) {
-	const loops = new Map(scope.loops).set(item, itemShape).set(index, NUMBER);
-	return {
-		state: scope.state,
-		loops
-	};
-}
-//#endregion
-//#region src/lsp/check-members.ts
-const BINDING = /{{([\s\S]*?)}}/g;
-/**
-* Finds the bindings that read a property their value doesn't have, going by the types in state.ts:
-* `{{ tap.nmae }}` where each tap is a `Tap`. A value whose type isn't known is not checked.
-*/
-function checkMembers(text, state) {
-	let nodes;
-	try {
-		nodes = parseDmlToIR(text, {
-			locations: true,
-			whitespace: "preserve"
-		});
-	} catch {
-		return [];
-	}
-	const problems = [];
-	checkNodes(text, nodes, {
-		state,
-		loops: /* @__PURE__ */ new Map()
-	}, problems);
-	return problems;
+function describeType(type) {
+	if (typeof type === "string") return type;
+	if (isWordsOr(type)) return `${describeType(type.words)} | ${otherThanWords(type)}`;
+	return type.map((value) => `"${value}"`).join(" | ");
 }
-function checkNodes(text, nodes, scope, problems) {
-	for (const node of nodes) {
-		const from = node.loc?.offset ?? 0;
-		if (node.type === "Text") {
-			checkBindings(text, node.content, from, scope, problems);
-			continue;
-		}
-		for (const value of Object.values(node.attributes)) checkBindings(text, value, from, scope, problems);
-		if (node.tag !== "For") {
-			checkNodes(text, node.children, scope, problems);
-			continue;
-		}
-		const { each = "", item = "item", index = "index", key } = node.attributes;
-		const itemOfList = itemShape(each, scope);
-		if (itemOfList?.kind === "object" && key !== void 0 && !key.startsWith("*") && !(key in itemOfList.properties)) problems.push({
-			message: `<For> \`key\` "${key}" is not a property of \`${itemOfList.type}\` (properties: ${describeMembers(itemOfList)})`,
-			offset: offsetOf(text, `key="${key}"`, from)
-		});
-		checkNodes(text, node.children, withLoop(scope, item, itemOfList, index), problems);
-	}
+function describeLoopVariable(variable, shape) {
+	const list = variable.list ? ` \`${variable.list}\`` : "";
+	if (variable.role === "item") return `each item of${list}${typeSuffix(shape)}`;
+	return `the position in${list}`;
 }
-function checkBindings(text, value, from, scope, problems) {
-	for (const [binding, source = ""] of value.matchAll(BINDING)) {
-		const expr = parseBinding(source);
-		if (!expr) continue;
-		const bindingOffset = offsetOf(text, binding, from);
-		for (const { name, owner } of unknownMembers(expr, scope)) problems.push({
-			message: `\`${name}\` is not a property of \`${owner.type}\` (properties: ${describeMembers(owner)})`,
-			offset: memberOffset(bindingOffset, binding, name)
-		});
-	}
+function typeSuffix(shape) {
+	return shape ? `: \`${shape.type}\`` : "";
 }
-function unknownMembers(expr, scope) {
-	const found = (node) => unknownMembers(node, scope);
-	switch (expr.type) {
-		case "Literal":
-		case "Identifier": return [];
-		case "Member": {
-			const inner = [...found(expr.object), ...found(expr.property)];
-			const { property } = expr;
-			if (property.type !== "Literal" || typeof property.value !== "string") return inner;
-			const owner = shapeOf(expr.object, scope);
-			if (owner && owner.kind !== "value" && !(property.value in membersOf(owner))) return [...inner, {
-				name: property.value,
-				owner
-			}];
-			return inner;
-		}
-		case "Unary": return found(expr.argument);
-		case "Binary": return [...found(expr.left), ...found(expr.right)];
-		case "Conditional": return [
-			...found(expr.test),
-			...found(expr.consequent),
-			...found(expr.alternate)
-		];
+function describeChildren(component) {
+	switch (component.children) {
+		case "none": return "no children";
+		case "text": return "text and inline components";
+		case "elements": return "any components";
 	}
 }
-function offsetOf(text, written, from) {
-	const at = text.indexOf(written, from);
-	return at < 0 ? from : at;
-}
-function memberOffset(bindingOffset, binding, name) {
-	const escapedName = name.replaceAll("$", "\\$");
-	const match = new RegExp(`(?<=\\.\\s*)${escapedName}(?![\\w$])`).exec(binding);
-	return match ? bindingOffset + match.index : bindingOffset;
-}
 //#endregion
 //#region src/lsp/markup.ts
-const NAME = /[A-Za-z0-9_.:-]/;
-const ATTRIBUTE_NAME_END = /[\s=/>"']/;
+const TAG_NAME = /[A-Za-z0-9_.:-]/;
+const ATTRIBUTE_NAME = /[^\s=/>"']/;
 const WHITESPACE = /\s/;
 function markupContextAt(text, offset) {
-	const open = [];
+	const openElements = [];
 	let index = 0;
 	while (index < offset) if (text.startsWith("<!--", index)) {
 		const end = text.indexOf("-->", index + 4);
@@ -10309,39 +10202,39 @@ function markupContextAt(text, offset) {
 		index = end + 3;
 	} else if (text.startsWith("</", index)) {
 		const nameStart = index + 2;
-		const nameEnd = readWhile(text, nameStart, NAME);
+		const nameEnd = readWhile(text, nameStart, TAG_NAME);
 		const close = text.indexOf(">", nameEnd);
 		if (offset <= nameEnd || close < 0 || close >= offset) return {
 			kind: "closeTag",
 			start: nameStart,
-			open: open.at(-1)
+			open: openElements.at(-1)
 		};
-		closeElement(open, text.slice(nameStart, nameEnd));
+		closeElement(openElements, text.slice(nameStart, nameEnd));
 		index = close + 1;
 	} else if (text[index] === "<") {
-		const tag = readTag(text, index, offset, open);
+		const tag = readTag(text, index, offset, openElements);
 		if (tag.context) return tag.context;
-		if (tag.element && !tag.selfClosing) open.push(tag.element);
+		if (tag.element && !tag.selfClosing) openElements.push(tag.element);
 		index = tag.end;
 	} else if (text.startsWith("{{", index)) {
 		const end = text.indexOf("}}", index + 2);
 		if (end < 0 || offset <= end) return {
 			kind: "binding",
 			start: index + 2,
-			loopVariables: loopVariables(open)
+			loopVariables: loopVariables(openElements)
 		};
 		index = end + 2;
 	} else index++;
 	return { kind: "text" };
 }
-function readTag(text, start, offset, open) {
+function readTag(text, start, offset, openElements) {
 	const nameStart = start + 1;
-	const nameEnd = readWhile(text, nameStart, NAME);
+	const nameEnd = readWhile(text, nameStart, TAG_NAME);
 	if (offset <= nameEnd) return {
 		context: {
 			kind: "tagName",
 			start: nameStart,
-			parents: [...open]
+			parents: [...openElements]
 		},
 		end: nameEnd
 	};
@@ -10376,7 +10269,7 @@ function readTag(text, start, offset, open) {
 			end: index + 1
 		};
 		const attributeStart = index;
-		index = readUntil(text, index + 1, ATTRIBUTE_NAME_END);
+		index = readWhile(text, index + 1, ATTRIBUTE_NAME);
 		const name = text.slice(attributeStart, index);
 		if (offset <= index) return {
 			context: {
@@ -10396,7 +10289,7 @@ function readTag(text, start, offset, open) {
 		if (quote === "\"" || quote === "'") {
 			const close = text.indexOf(quote, valueStart + 1);
 			if (close < 0 || offset <= close) return {
-				context: valueContext(text.slice(valueStart + 1, offset), valueStart + 1, element, name, open),
+				context: valueContext(text.slice(valueStart + 1, offset), valueStart + 1, element, name, openElements),
 				end: offset
 			};
 			attributes[name] = text.slice(valueStart + 1, close);
@@ -10409,7 +10302,7 @@ function readTag(text, start, offset, open) {
 					start: valueStart,
 					element,
 					attribute: name,
-					loopVariables: loopVariables(open)
+					loopVariables: loopVariables(openElements)
 				},
 				end: valueEnd
 			};
@@ -10418,8 +10311,8 @@ function readTag(text, start, offset, open) {
 		}
 	}
 }
-function valueContext(valueBeforeCursor, valueStart, element, attribute, open) {
-	const variables = loopVariables(open);
+function valueContext(valueBeforeCursor, valueStart, element, attribute, openElements) {
+	const variables = loopVariables(openElements);
 	const bindingStart = valueBeforeCursor.lastIndexOf("{{");
 	if (bindingStart >= 0 && !valueBeforeCursor.includes("}}", bindingStart)) return {
 		kind: "binding",
@@ -10434,18 +10327,18 @@ function valueContext(valueBeforeCursor, valueStart, element, attribute, open) {
 		loopVariables: variables
 	};
 }
-function closeElement(open, tag) {
-	for (let index = open.length - 1; index >= 0; index--) if (open[index].tag === tag) {
-		open.length = index;
+function closeElement(openElements, tag) {
+	for (let index = openElements.length - 1; index >= 0; index--) if (openElements[index].tag === tag) {
+		openElements.length = index;
 		return;
 	}
 }
-function loopVariables(open) {
+function loopVariables(openElements) {
 	const variables = [];
-	for (const element of open) {
+	for (const element of openElements) {
 		if (element.tag !== "For") continue;
 		const { item = "item", index = "index", each = "" } = element.attributes;
-		const list = each.replace(/^\s*{{\s*|\s*}}\s*$/g, "");
+		const list = bindingSource(each);
 		variables.push({
 			name: item,
 			role: "item",
@@ -10458,6 +10351,9 @@ function loopVariables(open) {
 	}
 	return variables;
 }
+function bindingSource(value) {
+	return value.replace(/^\s*{{\s*|\s*}}\s*$/g, "");
+}
 function readWhile(text, index, pattern) {
 	while (index < text.length && pattern.test(text[index])) index++;
 	return index;
@@ -10466,7 +10362,6 @@ function readUntil(text, index, pattern) {
 	while (index < text.length && !pattern.test(text[index])) index++;
 	return index;
 }
-/** The start and end of the run of `pattern` characters around `offset`. */
 function wordAt(text, offset, pattern) {
 	let start = offset;
 	while (start > 0 && pattern.test(text[start - 1])) start--;
@@ -10476,96 +10371,163 @@ function wordAt(text, offset, pattern) {
 	};
 }
 //#endregion
-//#region src/lsp/features.ts
-const TAG_NAME = /[A-Za-z0-9_.:-]/;
-const ATTRIBUTE_NAME = /[^\s=/>"']/;
-const IMAGE_ATTRIBUTES = ["src", "image"];
-const IDENTIFIER = /[\w$]/;
+//#region src/lsp/shapes.ts
+const NUMBER_SHAPE = {
+	kind: "value",
+	type: "number"
+};
 const MEMBER_CHAIN = /([A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*)\s*\.\s*$/;
-const VALUE = /[^\s"']/;
+function parseBinding(source) {
+	try {
+		return parseExpression(source);
+	} catch (error) {
+		if (error instanceof ScriptParseError) return;
+		throw error;
+	}
+}
+function shapeOf(expression, scope) {
+	switch (expression.type) {
+		case "Identifier":
+			if (scope.loops.has(expression.name)) return scope.loops.get(expression.name);
+			return scope.state[expression.name];
+		case "Member": {
+			const owner = shapeOf(expression.object, scope);
+			if (!owner) return;
+			const { property } = expression;
+			if (property.type === "Literal" && typeof property.value === "string") return membersOf(owner)[property.value];
+			if (owner.kind === "list") return owner.item;
+			return;
+		}
+		default: return;
+	}
+}
+function membersOf(shape) {
+	switch (shape.kind) {
+		case "object": return shape.properties;
+		case "list": return { length: NUMBER_SHAPE };
+		case "value": return {};
+	}
+}
+function describeMembers(shape) {
+	const names = Object.keys(membersOf(shape));
+	if (names.length === 0) return "none";
+	return names.join(", ");
+}
+function loopScope(variables, state) {
+	const loops = /* @__PURE__ */ new Map();
+	for (const variable of variables) if (variable.role === "index") loops.set(variable.name, NUMBER_SHAPE);
+	else loops.set(variable.name, itemShape(variable.list, {
+		state,
+		loops
+	}));
+	return {
+		state,
+		loops
+	};
+}
+function bindingScope(loopVariables, page) {
+	const shapes = page.state?.shapes;
+	if (!shapes) return;
+	return loopScope(loopVariables, shapes);
+}
+function itemShape(each, scope) {
+	const list = parseBinding(bindingSource(each));
+	if (!list) return;
+	const shape = shapeOf(list, scope);
+	if (shape?.kind === "list") return shape.item;
+}
+function withLoop(scope, item, itemOfList, index) {
+	const loops = new Map(scope.loops);
+	loops.set(item, itemOfList);
+	loops.set(index, NUMBER_SHAPE);
+	return {
+		state: scope.state,
+		loops
+	};
+}
+function isMember(text, bindingStart, wordStart) {
+	return text.slice(bindingStart, wordStart).trimEnd().endsWith(".");
+}
+function ownerOf(text, bindingStart, wordStart, scope) {
+	const chain = MEMBER_CHAIN.exec(text.slice(bindingStart, wordStart))?.[1];
+	if (chain === void 0) return;
+	const expression = parseBinding(chain);
+	if (!expression || !scope) return;
+	return shapeOf(expression, scope);
+}
+//#endregion
+//#region src/lsp/completion.ts
+const IMAGE_ATTRIBUTES = ["src", "image"];
+const IDENTIFIER_BEFORE_CURSOR = /[A-Za-z_$][\w$]*$/;
 const CONTROL_FLOW_SNIPPETS = {
 	If: "If condition=\"{{ $1 }}\">$0</If>",
 	ElseIf: "ElseIf condition=\"{{ $1 }}\">$0</ElseIf>",
 	Else: "Else>$0</Else>",
 	For: "For each=\"{{ $1 }}\" key=\"$2\">$0</For>"
 };
-const CONTROL_FLOW_DOCS = {
-	If: "Shows its children when `condition` is true.",
-	ElseIf: "Follows an `<If>` or `<ElseIf>`: shows its children when the ones before are false and `condition` is true.",
-	Else: "Follows an `<If>` or `<ElseIf>`: shows its children when the ones before are false.",
-	For: "Repeats its children for each item of `each`, as `item` and `index`. `key` is a property of each item, `*this` for the item itself, or `*index` to match items by position."
-};
-const CONTROL_FLOW_ATTRIBUTE_DOCS = {
-	condition: "A single `{{ }}` binding",
-	each: "The list to repeat, as a single `{{ }}` binding",
-	item: "The name of each item (default `item`)",
-	index: "The name of each position (default `index`)",
-	key: "A property of each item, `*this` or `*index`"
-};
-function complete(document, offset, page, { components }) {
+function complete(document, offset, page, components) {
 	const text = document.getText();
 	const context = markupContextAt(text, offset);
-	const range = (start) => ({
-		start: document.positionAt(start),
-		end: document.positionAt(offset)
-	});
 	switch (context.kind) {
-		case "tagName": return tagCompletions(context.parents, components).map((item) => ({
-			...item,
-			textEdit: {
-				range: range(context.start),
-				newText: item.insertText ?? item.label
-			}
-		}));
+		case "tagName": {
+			const items = tagCompletions(context.parents, components);
+			return replacingFrom(document, context.start, offset, items);
+		}
 		case "closeTag":
 			if (!context.open) return [];
 			return [{
 				label: `/${context.open.tag}`,
 				kind: import_main.CompletionItemKind.Property,
 				textEdit: {
-					range: range(context.start),
+					range: rangeFrom(document, context.start, offset),
 					newText: `${context.open.tag}>`
 				}
 			}];
-		case "attributeName": return attributeCompletions(context.element, components).map((item) => ({
-			...item,
-			textEdit: {
-				range: range(context.start),
-				newText: item.insertText ?? item.label
-			}
-		}));
+		case "attributeName": {
+			const items = attributeCompletions(context.element, components);
+			return replacingFrom(document, context.start, offset, items);
+		}
 		case "attributeValue": {
-			const scope = shapeScope(context.loopVariables, page);
-			return valueCompletions(context.element, context.attribute, page, scope, components).map((item) => ({
-				...item,
-				textEdit: {
-					range: range(context.start),
-					newText: item.label
-				}
-			}));
+			const scope = bindingScope(context.loopVariables, page);
+			const items = valueCompletions(context.element, context.attribute, page, scope, components);
+			return replacingFrom(document, context.start, offset, items);
 		}
 		case "binding": {
 			const typed = text.slice(context.start, offset);
-			const wordStart = offset - (/[A-Za-z_$][\w$]*$/.exec(typed)?.[0] ?? "").length;
-			const scope = shapeScope(context.loopVariables, page);
-			return (isMember(text, context.start, wordStart) ? memberCompletions(ownerOf(text, context.start, wordStart, scope)) : bindingCompletions(context.loopVariables, page, scope)).map((item) => ({
-				...item,
-				textEdit: {
-					range: range(wordStart),
-					newText: item.label
-				}
-			}));
+			const wordStart = offset - (IDENTIFIER_BEFORE_CURSOR.exec(typed)?.[0] ?? "").length;
+			const scope = bindingScope(context.loopVariables, page);
+			let items;
+			if (isMember(text, context.start, wordStart)) items = memberCompletions(ownerOf(text, context.start, wordStart, scope));
+			else items = bindingCompletions(context.loopVariables, page, scope);
+			return replacingFrom(document, wordStart, offset, items);
 		}
 		default: return [];
 	}
 }
+function rangeFrom(document, start, offset) {
+	return {
+		start: document.positionAt(start),
+		end: document.positionAt(offset)
+	};
+}
+function replacingFrom(document, start, offset, items) {
+	return items.map((item) => ({
+		...item,
+		textEdit: {
+			range: rangeFrom(document, start, offset),
+			newText: item.insertText ?? item.label
+		}
+	}));
+}
 function tagCompletions(parents, components) {
 	if (parents.length === 0) {
 		const root = components[ROOT_TAG];
-		return root ? [componentItem(root, "0")] : [];
+		if (!root) return [];
+		return [componentItem(root, "0")];
 	}
 	const parent = [...parents].reverse().find((element) => !(element.tag in CONTROL_FLOW_TAGS));
-	const parentManifest = parent && components[parent.tag];
+	let parentManifest;
+	if (parent) parentManifest = components[parent.tag];
 	const items = Object.values(components).filter((component) => !parentManifest || canHaveChildren(parentManifest, component)).map((component) => componentItem(component, "1"));
 	for (const [tag, snippet] of Object.entries(CONTROL_FLOW_SNIPPETS)) items.push({
 		label: tag,
@@ -10582,7 +10544,8 @@ function tagCompletions(parents, components) {
 	return items;
 }
 function componentItem(component, sortGroup) {
-	const snippet = component.children === "none" ? `${component.name}$1 />` : `${component.name}$1>$0</${component.name}>`;
+	let snippet = `${component.name}$1>$0</${component.name}>`;
+	if (component.children === "none") snippet = `${component.name}$1 />`;
 	return {
 		label: component.name,
 		kind: import_main.CompletionItemKind.Class,
@@ -10597,18 +10560,18 @@ function componentItem(component, sortGroup) {
 	};
 }
 function attributeCompletions(element, components) {
-	const written = (name) => name in element.attributes;
+	const isWritten = (name) => name in element.attributes;
 	const controlFlow = CONTROL_FLOW_TAGS[element.tag];
-	if (controlFlow) return controlFlow.attributes.filter((name) => !written(name)).map((name) => ({
+	if (controlFlow) return controlFlow.attributes.filter((name) => !isWritten(name)).map((name) => ({
 		label: name,
 		kind: import_main.CompletionItemKind.Property,
 		detail: CONTROL_FLOW_ATTRIBUTE_DOCS[name] ?? name,
-		insertText: name === "condition" || name === "each" ? `${name}="{{ $1 }}"` : `${name}="$1"`,
+		insertText: controlFlowAttributeSnippet(name),
 		insertTextFormat: import_main.InsertTextFormat.Snippet
 	}));
 	const component = components[element.tag];
 	if (!component) return [];
-	const props = Object.entries(component.props).filter(([name]) => !written(name)).map(([name, type]) => ({
+	const props = Object.entries(component.props).filter(([name]) => !isWritten(name)).map(([name, type]) => ({
 		label: name,
 		kind: import_main.CompletionItemKind.Property,
 		detail: describeType(type),
@@ -10616,7 +10579,7 @@ function attributeCompletions(element, components) {
 		insertTextFormat: import_main.InsertTextFormat.Snippet,
 		sortText: `0${name}`
 	}));
-	const events = component.events.map((event) => eventProp(event)).filter((name) => !written(name)).map((name) => ({
+	const events = component.events.map((event) => eventProp(event)).filter((name) => !isWritten(name)).map((name) => ({
 		label: name,
 		kind: import_main.CompletionItemKind.Event,
 		detail: "a mutation or action in controller.ts",
@@ -10626,27 +10589,20 @@ function attributeCompletions(element, components) {
 	}));
 	return [...props, ...events];
 }
+function controlFlowAttributeSnippet(name) {
+	if (name === "condition" || name === "each") return `${name}="{{ $1 }}"`;
+	return `${name}="$1"`;
+}
 function valueCompletions(element, attribute, page, scope, components) {
-	if (element.tag === "For" && attribute === "key") {
-		const item = scope && itemShape(element.attributes.each ?? "", scope);
-		return [
-			...item?.kind === "object" ? memberCompletions(item) : [],
-			{
-				label: "*this",
-				kind: import_main.CompletionItemKind.Value,
-				detail: "the item itself"
-			},
-			{
-				label: "*index",
-				kind: import_main.CompletionItemKind.Value,
-				detail: "match items by position"
-			}
-		];
-	}
+	if (element.tag === "For" && attribute === "key") return forKeyCompletions(element, scope);
 	const component = components[element.tag];
 	if (!component) return [];
-	if (isEventProp(attribute) && component.events.includes(eventName(attribute))) return handlerItems(page);
+	if (isEventProp(attribute) && component.events.includes(eventName(attribute))) return handlerCompletions(page);
 	const type = component.props[attribute];
+	if (type && isWordsOr(type)) return type.words.map((value) => ({
+		label: value,
+		kind: import_main.CompletionItemKind.EnumMember
+	}));
 	if (Array.isArray(type)) return type.map((value) => ({
 		label: value,
 		kind: import_main.CompletionItemKind.EnumMember
@@ -10661,27 +10617,52 @@ function valueCompletions(element, attribute, page, scope, components) {
 	}));
 	return [];
 }
-function handlerItems(page) {
+function forKeyCompletions(element, scope) {
+	let properties = [];
+	if (scope) {
+		const item = itemShape(element.attributes.each ?? "", scope);
+		if (item?.kind === "object") properties = memberCompletions(item);
+	}
+	return [
+		...properties,
+		{
+			label: "*this",
+			kind: import_main.CompletionItemKind.Value,
+			detail: "the item itself"
+		},
+		{
+			label: "*index",
+			kind: import_main.CompletionItemKind.Value,
+			detail: "match items by position"
+		}
+	];
+}
+function handlerCompletions(page) {
 	const { controller } = page;
 	if (!controller) return [];
-	return [...(controller.mutations ?? []).map((name) => ({
+	const mutations = (controller.mutations ?? []).map((name) => ({
 		label: name,
 		kind: import_main.CompletionItemKind.Method,
 		detail: "mutation"
-	})), ...(controller.actions ?? []).map((name) => ({
+	}));
+	const actions = (controller.actions ?? []).map((name) => ({
 		label: name,
 		kind: import_main.CompletionItemKind.Function,
 		detail: "action"
-	}))];
+	}));
+	return [...mutations, ...actions];
 }
 function bindingCompletions(loopVariables, page, scope) {
 	const items = /* @__PURE__ */ new Map();
-	for (const key of page.state?.keys ?? []) items.set(key, {
-		label: key,
-		kind: import_main.CompletionItemKind.Field,
-		detail: scope?.state[key] ? `state: ${scope.state[key].type}` : "state",
-		sortText: `1${key}`
-	});
+	for (const key of page.state?.keys ?? []) {
+		const shape = scope?.state[key];
+		items.set(key, {
+			label: key,
+			kind: import_main.CompletionItemKind.Field,
+			detail: shape ? `state: ${shape.type}` : "state",
+			sortText: `1${key}`
+		});
+	}
 	for (const variable of loopVariables) items.set(variable.name, {
 		label: variable.name,
 		kind: import_main.CompletionItemKind.Variable,
@@ -10698,232 +10679,109 @@ function memberCompletions(owner) {
 		detail: shape.type
 	}));
 }
-function shapeScope(loopVariables, page) {
-	const shapes = page.state?.shapes;
-	return shapes && loopScope(loopVariables, shapes);
-}
-function isMember(text, bindingStart, start) {
-	return text.slice(bindingStart, start).trimEnd().endsWith(".");
-}
-function ownerOf(text, bindingStart, start, scope) {
-	const chain = MEMBER_CHAIN.exec(text.slice(bindingStart, start))?.[1];
-	const expr = chain === void 0 ? void 0 : parseBinding(chain);
-	return expr && scope && shapeOf(expr, scope);
-}
-function hover(document, offset, page, { components }) {
-	const found = symbolAt(document.getText(), offset, page);
-	if (!found) return null;
-	const markdown = describeSymbol(found.symbol, page, components);
-	if (!markdown) return null;
-	return {
-		contents: {
-			kind: import_main.MarkupKind.Markdown,
-			value: markdown
-		},
-		range: {
-			start: document.positionAt(found.start),
-			end: document.positionAt(found.end)
-		}
-	};
-}
-function definition(document, offset, page) {
-	const found = symbolAt(document.getText(), offset, page);
-	if (!found) return null;
-	const { symbol } = found;
-	if (symbol.kind === "handler" && page.controller) return locationIn(page.controller.file, page.controller.text, page.controller.offsets[symbol.name]);
-	if (symbol.kind === "state" && page.state) return locationIn(page.state.file, page.state.text, page.state.offsets[symbol.name]);
-	if (symbol.kind === "property" && symbol.shape.declaration) {
-		const { file, line, character } = symbol.shape.declaration;
-		const position = {
-			line,
-			character
-		};
-		return {
-			uri: pathToFileURL(file).href,
-			range: {
-				start: position,
-				end: position
-			}
-		};
+//#endregion
+//#region src/lsp/check-members.ts
+const BINDING = /{{([\s\S]*?)}}/g;
+function checkMembers(text, state) {
+	let nodes;
+	try {
+		nodes = parseDmlToIR(text, {
+			locations: true,
+			whitespace: "preserve"
+		});
+	} catch {
+		return [];
 	}
-	if (symbol.kind === "static" && page.root) return locationIn(join(page.root, symbol.path), "", 0);
-	return null;
+	const problems = [];
+	checkNodes(text, nodes, {
+		state,
+		loops: /* @__PURE__ */ new Map()
+	}, problems);
+	return problems;
 }
-function symbolAt(text, offset, page) {
-	const context = markupContextAt(text, offset);
-	switch (context.kind) {
-		case "tagName":
-		case "closeTag": {
-			const { start, end } = wordAt(text, offset, TAG_NAME);
-			return {
-				symbol: {
-					kind: "component",
-					tag: text.slice(start, end)
-				},
-				start,
-				end
-			};
-		}
-		case "attributeName": {
-			const { start, end } = wordAt(text, offset, ATTRIBUTE_NAME);
-			const name = text.slice(start, end);
-			return name ? {
-				symbol: {
-					kind: "attribute",
-					tag: context.element.tag,
-					name
-				},
-				start,
-				end
-			} : null;
-		}
-		case "attributeValue": {
-			const { start, end } = wordAt(text, offset, VALUE);
-			const value = text.slice(start, end);
-			if (isEventProp(context.attribute)) return {
-				symbol: {
-					kind: "handler",
-					name: value
-				},
-				start,
-				end
-			};
-			if (page.statics?.includes(value)) return {
-				symbol: {
-					kind: "static",
-					path: value
-				},
-				start,
-				end
-			};
-			return null;
+function checkNodes(text, nodes, scope, problems) {
+	for (const node of nodes) {
+		const from = node.loc?.offset ?? 0;
+		if (node.type === "Text") {
+			checkBindings(text, node.content, from, scope, problems);
+			continue;
 		}
-		case "binding": {
-			const { start, end } = wordAt(text, offset, IDENTIFIER);
-			const name = text.slice(start, end);
-			if (!name) return null;
-			const scope = shapeScope(context.loopVariables, page);
-			if (isMember(text, context.start, start)) {
-				const owner = ownerOf(text, context.start, start, scope);
-				const shape = owner && membersOf(owner)[name];
-				return owner && shape ? {
-					symbol: {
-						kind: "property",
-						name,
-						owner,
-						shape
-					},
-					start,
-					end
-				} : null;
-			}
-			const variable = [...context.loopVariables].reverse().find((candidate) => candidate.name === name);
-			if (variable) {
-				const shape = scope?.loops.get(name);
-				return {
-					symbol: shape ? {
-						kind: "loopVariable",
-						variable,
-						shape
-					} : {
-						kind: "loopVariable",
-						variable
-					},
-					start,
-					end
-				};
-			}
-			return {
-				symbol: {
-					kind: "state",
-					name
-				},
-				start,
-				end
-			};
+		for (const value of Object.values(node.attributes)) checkBindings(text, value, from, scope, problems);
+		if (node.tag !== "For") {
+			checkNodes(text, node.children, scope, problems);
+			continue;
 		}
-		default: return null;
+		const { each = "", item = "item", index = "index", key } = node.attributes;
+		const itemOfList = itemShape(each, scope);
+		if (key !== void 0 && !key.startsWith("*") && itemOfList?.kind === "object" && !(key in itemOfList.properties)) problems.push({
+			message: `The <For> \`key\` "${key}" is not a property of \`${itemOfList.type}\`. It has: ${describeMembers(itemOfList)}`,
+			offset: offsetOf(text, `key="${key}"`, from)
+		});
+		checkNodes(text, node.children, withLoop(scope, item, itemOfList, index), problems);
 	}
 }
-function describeSymbol(symbol, page, components) {
-	switch (symbol.kind) {
-		case "component": {
-			const controlFlow = CONTROL_FLOW_DOCS[symbol.tag];
-			if (controlFlow) return `**<${symbol.tag}>** · control flow\n\n${controlFlow}`;
-			const component = components[symbol.tag];
-			return component ? describeComponent(component) : null;
-		}
-		case "attribute": {
-			if (CONTROL_FLOW_TAGS[symbol.tag]) {
-				const doc = CONTROL_FLOW_ATTRIBUTE_DOCS[symbol.name];
-				return doc ? `\`${symbol.name}\`: ${doc}` : null;
-			}
-			const component = components[symbol.tag];
-			if (!component) return null;
-			const type = component.props[symbol.name];
-			if (type) return `\`${symbol.name}\`: ${describeType(type)}`;
-			if (symbol.name.startsWith(DATA_PREFIX)) return `\`${symbol.name}\`: reaches this element's handlers as \`event.data.${dataKey(symbol.name)}\``;
-			if (isEventProp(symbol.name) && component.events.includes(eventName(symbol.name))) return `\`${symbol.name}\`: runs a mutation or action in controller.ts on \`${eventName(symbol.name)}\``;
-			return null;
-		}
-		case "handler": {
-			const { controller } = page;
-			if (controller?.mutations?.includes(symbol.name)) return `mutation \`${symbol.name}\` in controller.ts`;
-			if (controller?.actions?.includes(symbol.name)) return `action \`${symbol.name}\` in controller.ts`;
-			return null;
-		}
-		case "state": return page.state?.keys?.includes(symbol.name) ? `state \`${symbol.name}\` in state.ts${typeSuffix(page.state.shapes?.[symbol.name])}` : null;
-		case "loopVariable": return `\`${symbol.variable.name}\`: ${describeLoopVariable(symbol.variable, symbol.shape)}`;
-		case "property": return `\`${symbol.name}\`: \`${symbol.shape.type}\`, a property of \`${symbol.owner.type}\``;
-		case "static": return `image \`${symbol.path}\``;
+function checkBindings(text, value, from, scope, problems) {
+	for (const [binding, source = ""] of value.matchAll(BINDING)) {
+		const expression = parseBinding(source);
+		if (!expression) continue;
+		const bindingOffset = offsetOf(text, binding, from);
+		for (const { name, owner } of unknownMembers(expression, scope)) problems.push({
+			message: `\`${name}\` is not a property of \`${owner.type}\`. It has: ${describeMembers(owner)}`,
+			offset: memberOffset(bindingOffset, binding, name)
+		});
 	}
 }
-function describeComponent(component) {
-	const lines = [`**<${component.name}>** · ${describeChildren(component)}`];
-	const props = Object.entries(component.props);
-	if (props.length > 0) lines.push("", ...props.map(([name, type]) => `- \`${name}\`: ${describeType(type)}`));
-	if (component.events.length > 0) lines.push("", `Events: ${component.events.map((event) => `\`${eventProp(event)}\``).join(", ")}`);
-	return lines.join("\n");
-}
-function describeChildren(component) {
-	switch (component.children) {
-		case "none": return "no children";
-		case "text": return "text and inline components";
-		case "elements": return "any components";
+function unknownMembers(expression, scope) {
+	const unknownIn = (node) => unknownMembers(node, scope);
+	switch (expression.type) {
+		case "Literal":
+		case "Identifier": return [];
+		case "Member": {
+			const inner = [...unknownIn(expression.object), ...unknownIn(expression.property)];
+			const { property } = expression;
+			if (property.type !== "Literal" || typeof property.value !== "string") return inner;
+			const owner = shapeOf(expression.object, scope);
+			if (owner && owner.kind !== "value" && !(property.value in membersOf(owner))) return [...inner, {
+				name: property.value,
+				owner
+			}];
+			return inner;
+		}
+		case "Unary": return unknownIn(expression.argument);
+		case "Binary": return [...unknownIn(expression.left), ...unknownIn(expression.right)];
+		case "Conditional": return [
+			...unknownIn(expression.test),
+			...unknownIn(expression.consequent),
+			...unknownIn(expression.alternate)
+		];
 	}
 }
-function describeType(type) {
-	if (typeof type === "string") return type;
-	return type.map((value) => `"${value}"`).join(" | ");
-}
-function describeLoopVariable(variable, shape) {
-	const list = variable.list ? ` \`${variable.list}\`` : "";
-	return variable.role === "item" ? `each item of${list}${typeSuffix(shape)}` : `the position in${list}`;
-}
-function typeSuffix(shape) {
-	return shape ? `: \`${shape.type}\`` : "";
+function offsetOf(text, written, from) {
+	const foundAt = text.indexOf(written, from);
+	if (foundAt < 0) return from;
+	return foundAt;
 }
-function locationIn(file, text, offset) {
-	if (offset === void 0) return null;
-	const position = TextDocument.create("", "typescript", 0, text).positionAt(offset);
-	return {
-		uri: pathToFileURL(file).href,
-		range: {
-			start: position,
-			end: position
-		}
-	};
+function memberOffset(bindingOffset, binding, name) {
+	const escapedName = name.replaceAll("$", "\\$");
+	const match = new RegExp(`(?<=\\.\\s*)${escapedName}(?![\\w$])`).exec(binding);
+	if (!match) return bindingOffset;
+	return bindingOffset + match.index;
 }
-function diagnose(document, file, page, { components }) {
+//#endregion
+//#region src/lsp/diagnostics.ts
+function diagnose(document, file, page, components) {
 	const diagnostics = [];
 	const context = {
 		file,
 		components,
-		onWarning: (warning) => diagnostics.push(sourceDiagnostic(document, warning, import_main.DiagnosticSeverity.Warning))
+		onWarning: (warning) => {
+			diagnostics.push(sourceDiagnostic(document, warning, import_main.DiagnosticSeverity.Warning));
+		}
 	};
 	if (page.statics) context.statics = page.statics;
 	if (page.state?.keys) context.stateKeys = page.state.keys;
-	const { mutations, actions } = page.controller ?? {};
+	const mutations = page.controller?.mutations;
+	const actions = page.controller?.actions;
 	if (mutations && actions) context.handlers = [...mutations, ...actions];
 	try {
 		compileView(document.getText(), context);
@@ -10939,15 +10797,15 @@ function sourceDiagnostic(document, problem, severity) {
 }
 function diagnosticAt(document, start, message, severity) {
 	const text = document.getText();
-	let end = start;
-	while (end < text.length && !/[\s>]/.test(text[end])) end++;
+	const end = readUntil(text, start, /[\s>]/);
+	const atLeastOneCharacter = Math.min(start + 1, text.length);
 	return {
 		severity,
 		source: "dot",
 		message,
 		range: {
 			start: document.positionAt(start),
-			end: document.positionAt(Math.max(end, Math.min(start + 1, text.length)))
+			end: document.positionAt(Math.max(end, atLeastOneCharacter))
 		}
 	};
 }
@@ -10955,7 +10813,7 @@ function diagnosticAt(document, start, message, severity) {
 //#region src/lsp/page.ts
 async function readPage(viewFile, readText, stateTypes) {
 	const dir = dirname(viewFile);
-	const root = findRoot(dir);
+	const root = findDotRoot(dir);
 	const [state, controller, statics] = await Promise.all([
 		readState(join(dir, "state.ts"), root, readText, stateTypes),
 		readController(join(dir, "controller.ts"), readText),
@@ -10971,20 +10829,18 @@ async function readPage(viewFile, readText, stateTypes) {
 async function readState(file, root, readText, stateTypes) {
 	const text = await readText(file);
 	if (text === void 0) return;
-	let keys;
-	let offsets;
 	try {
-		({keys, keyOffsets: offsets} = parseStateModule(text, file));
+		const { keys, keyOffsets } = parseStateModule(text, file);
+		return {
+			file,
+			text,
+			keys,
+			offsets: keyOffsets,
+			shapes: readShapes(stateTypes, root, file, text)
+		};
 	} catch {
 		return;
 	}
-	return {
-		file,
-		text,
-		keys,
-		offsets,
-		shapes: readShapes(stateTypes, root, file, text)
-	};
 }
 function readShapes(stateTypes, root, file, text) {
 	try {
@@ -11009,14 +10865,6 @@ async function readController(file, readText) {
 		return;
 	}
 }
-function findRoot(dir) {
-	while (true) {
-		if (existsSync(join(dir, "dot.json"))) return dir;
-		const parent = dirname(dir);
-		if (parent === dir) return;
-		dir = parent;
-	}
-}
 //#endregion
 //#region src/lsp/state-types.ts
 const MAX_DEPTH = 8;
@@ -11028,23 +10876,19 @@ const FALLBACK_OPTIONS = {
 	noEmit: true,
 	skipLibCheck: true
 };
-/**
-* Reads the shapes of state.ts files. Each dot keeps one TypeScript language service, so reading
-* again after an edit rechecks only what changed.
-*/
 var StateTypes = class {
 	#projects = /* @__PURE__ */ new Map();
 	read(root, file, text) {
 		const key = root ?? file;
 		let project = this.#projects.get(key);
 		if (!project) {
-			project = new Project(root);
+			project = new TypeScriptProject(root);
 			this.#projects.set(key, project);
 		}
 		return project.read(file, text);
 	}
 };
-var Project = class {
+var TypeScriptProject = class {
 	#options;
 	#fileNames;
 	#open = /* @__PURE__ */ new Map();
@@ -11063,7 +10907,8 @@ var Project = class {
 			},
 			getScriptSnapshot: (file) => {
 				const text = this.#open.get(file)?.text ?? ts.sys.readFile(file);
-				return text === void 0 ? void 0 : ts.ScriptSnapshot.fromString(text);
+				if (text === void 0) return;
+				return ts.ScriptSnapshot.fromString(text);
 			},
 			getCurrentDirectory: () => root ?? process.cwd(),
 			getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
@@ -11087,7 +10932,8 @@ var Project = class {
 		if (!program || !source) return;
 		const checker = program.getTypeChecker();
 		const module = checker.getSymbolAtLocation(source);
-		let exported = module && checker.tryGetMemberInModuleExports("default", module);
+		if (!module) return;
+		let exported = checker.tryGetMemberInModuleExports("default", module);
 		if (!exported) return;
 		if (exported.flags & ts.SymbolFlags.Alias) exported = checker.getAliasedSymbol(exported);
 		const state = checker.getTypeOfSymbol(exported);
@@ -11099,9 +10945,9 @@ var Project = class {
 function readConfig(root) {
 	const file = join(root, "tsconfig.json");
 	if (!existsSync(file)) return;
-	const read = ts.readConfigFile(file, (path) => ts.sys.readFile(path));
-	if (read.error) return;
-	return ts.parseJsonConfigFileContent(read.config, ts.sys, root, void 0, file);
+	const configFile = ts.readConfigFile(file, (path) => ts.sys.readFile(path));
+	if (configFile.error) return;
+	return ts.parseJsonConfigFileContent(configFile.config, ts.sys, root, void 0, file);
 }
 function propertyShape(checker, property, depth, seen) {
 	const shape = typeShape(checker, checker.getTypeOfSymbol(property), depth, seen);
@@ -11128,13 +10974,15 @@ function typeShape(checker, type, depth, seen) {
 	const inner = new Set(seen).add(present);
 	if (checker.isArrayType(present) || checker.isTupleType(present)) {
 		const item = checker.getIndexTypeOfType(present, ts.IndexKind.Number);
+		let itemShape = {
+			kind: "value",
+			type: "unknown"
+		};
+		if (item) itemShape = typeShape(checker, item, depth + 1, inner);
 		return {
 			kind: "list",
 			type: name,
-			item: item ? typeShape(checker, item, depth + 1, inner) : {
-				kind: "value",
-				type: "unknown"
-			}
+			item: itemShape
 		};
 	}
 	if (!isRecord(checker, present)) return {
@@ -11153,45 +11001,231 @@ function isRecord(checker, type) {
 	return (type.isUnion() ? type.types : [type]).every((member) => (member.flags & ts.TypeFlags.Object) !== 0 && member.getCallSignatures().length === 0 && checker.getIndexInfosOfType(member).length === 0);
 }
 //#endregion
+//#region src/lsp/symbols.ts
+const IDENTIFIER = /[\w$]/;
+const VALUE = /[^\s"']/;
+function hover(document, offset, page, components) {
+	const found = symbolAt(document.getText(), offset, page);
+	if (!found) return null;
+	const markdown = describeSymbol(found.symbol, page, components);
+	if (!markdown) return null;
+	return {
+		contents: {
+			kind: import_main.MarkupKind.Markdown,
+			value: markdown
+		},
+		range: {
+			start: document.positionAt(found.start),
+			end: document.positionAt(found.end)
+		}
+	};
+}
+function definition(document, offset, page) {
+	const found = symbolAt(document.getText(), offset, page);
+	if (!found) return null;
+	const { symbol } = found;
+	if (symbol.kind === "handler" && page.controller) return definitionIn(page.controller, symbol.name);
+	if (symbol.kind === "state" && page.state) return definitionIn(page.state, symbol.name);
+	if (symbol.kind === "property" && symbol.shape.declaration) {
+		const { file, line, character } = symbol.shape.declaration;
+		const position = {
+			line,
+			character
+		};
+		return {
+			uri: pathToFileURL(file).href,
+			range: {
+				start: position,
+				end: position
+			}
+		};
+	}
+	if (symbol.kind === "static" && page.root) return locationIn(join(page.root, symbol.path), "", 0);
+	return null;
+}
+function symbolAt(text, offset, page) {
+	const context = markupContextAt(text, offset);
+	switch (context.kind) {
+		case "tagName":
+		case "closeTag": {
+			const { start, end } = wordAt(text, offset, TAG_NAME);
+			return {
+				symbol: {
+					kind: "component",
+					tag: text.slice(start, end)
+				},
+				start,
+				end
+			};
+		}
+		case "attributeName": {
+			const { start, end } = wordAt(text, offset, ATTRIBUTE_NAME);
+			const name = text.slice(start, end);
+			if (!name) return null;
+			return {
+				symbol: {
+					kind: "attribute",
+					tag: context.element.tag,
+					name
+				},
+				start,
+				end
+			};
+		}
+		case "attributeValue": {
+			const { start, end } = wordAt(text, offset, VALUE);
+			const value = text.slice(start, end);
+			if (isEventProp(context.attribute)) return {
+				symbol: {
+					kind: "handler",
+					name: value
+				},
+				start,
+				end
+			};
+			if (page.statics?.includes(value)) return {
+				symbol: {
+					kind: "static",
+					path: value
+				},
+				start,
+				end
+			};
+			return null;
+		}
+		case "binding": {
+			const { start, end } = wordAt(text, offset, IDENTIFIER);
+			const name = text.slice(start, end);
+			if (!name) return null;
+			const scope = bindingScope(context.loopVariables, page);
+			if (isMember(text, context.start, start)) {
+				const owner = ownerOf(text, context.start, start, scope);
+				if (!owner) return null;
+				const shape = membersOf(owner)[name];
+				if (!shape) return null;
+				return {
+					symbol: {
+						kind: "property",
+						name,
+						owner,
+						shape
+					},
+					start,
+					end
+				};
+			}
+			const variable = [...context.loopVariables].reverse().find((candidate) => candidate.name === name);
+			if (variable) return {
+				symbol: {
+					kind: "loopVariable",
+					variable,
+					shape: scope?.loops.get(name)
+				},
+				start,
+				end
+			};
+			return {
+				symbol: {
+					kind: "state",
+					name
+				},
+				start,
+				end
+			};
+		}
+		default: return null;
+	}
+}
+function describeSymbol(symbol, page, components) {
+	switch (symbol.kind) {
+		case "component": {
+			const controlFlowDoc = CONTROL_FLOW_DOCS[symbol.tag];
+			if (controlFlowDoc) return `**<${symbol.tag}>** · control flow\n\n${controlFlowDoc}`;
+			const component = components[symbol.tag];
+			if (!component) return null;
+			return describeComponent(component);
+		}
+		case "attribute": return describeAttribute(symbol.tag, symbol.name, components);
+		case "handler": {
+			const { controller } = page;
+			if (controller?.mutations?.includes(symbol.name)) return `mutation \`${symbol.name}\` in controller.ts`;
+			if (controller?.actions?.includes(symbol.name)) return `action \`${symbol.name}\` in controller.ts`;
+			return null;
+		}
+		case "state": {
+			if (!page.state?.keys?.includes(symbol.name)) return null;
+			const shape = page.state.shapes?.[symbol.name];
+			return `state \`${symbol.name}\` in state.ts${typeSuffix(shape)}`;
+		}
+		case "loopVariable": return `\`${symbol.variable.name}\`: ${describeLoopVariable(symbol.variable, symbol.shape)}`;
+		case "property": return `\`${symbol.name}\`: \`${symbol.shape.type}\`, a property of \`${symbol.owner.type}\``;
+		case "static": return `image \`${symbol.path}\``;
+	}
+}
+function describeAttribute(tag, name, components) {
+	if (CONTROL_FLOW_TAGS[tag]) {
+		const doc = CONTROL_FLOW_ATTRIBUTE_DOCS[name];
+		if (!doc) return null;
+		return `\`${name}\`: ${doc}`;
+	}
+	const component = components[tag];
+	if (!component) return null;
+	const type = component.props[name];
+	if (type) return `\`${name}\`: ${describeType(type)}`;
+	if (name.startsWith(DATA_PREFIX)) return `\`${name}\`: this element's handlers get it as \`event.data.${dataKey(name)}\``;
+	if (isEventProp(name) && component.events.includes(eventName(name))) return `\`${name}\`: on \`${eventName(name)}\`, runs a mutation or action from controller.ts`;
+	return null;
+}
+function definitionIn(source, name) {
+	return locationIn(source.file, source.text, source.offsets[name]);
+}
+function locationIn(file, text, offset) {
+	if (offset === void 0) return null;
+	const position = TextDocument.create("", "typescript", 0, text).positionAt(offset);
+	return {
+		uri: pathToFileURL(file).href,
+		range: {
+			start: position,
+			end: position
+		}
+	};
+}
+//#endregion
 //#region src/lsp/server.ts
-const WATCHED = [
+const WATCHED_FILES = [
 	"**/*.ts",
 	"**/dot.json",
 	"**/statics/**"
 ];
-/**
-* Serves .dml files over the Language Server Protocol: completion, hover, go to definition and
-* the compiler's own errors and warnings. It runs from the dot's own installed `dotctl`, so what
-* it knows always matches the Dot version the dot builds with.
-*/
 function startLanguageServer(connection) {
 	const documents = new import_main.TextDocuments(TextDocument);
-	const features = { components: builtinRegistry };
+	const components = builtinRegistry;
 	const stateTypes = new StateTypes();
 	let canWatchFiles = false;
 	const readText = async (file) => {
-		const open = documents.get(pathToFileURL(file).href);
-		if (open) return open.getText();
-		return existsSync(file) ? readFile(file, "utf8") : void 0;
+		const openDocument = documents.get(pathToFileURL(file).href);
+		if (openDocument) return openDocument.getText();
+		if (!existsSync(file)) return;
+		return readFile(file, "utf8");
 	};
-	const pageOf = async (uri) => {
+	const openView = async (uri) => {
 		const document = documents.get(uri);
 		if (!document || !uri.endsWith(".dml")) return;
 		const file = fileURLToPath(uri);
 		return {
 			document,
-			page: await readPage(file, readText, stateTypes),
-			file
+			file,
+			page: await readPage(file, readText, stateTypes)
 		};
 	};
 	const validate = async (uri) => {
 		try {
-			const found = await pageOf(uri);
-			if (!found) return;
-			const diagnostics = diagnose(found.document, found.file, found.page, features);
+			const view = await openView(uri);
+			if (!view) return;
+			const diagnostics = diagnose(view.document, view.file, view.page, components);
 			await connection.sendDiagnostics({
 				uri,
-				version: found.document.version,
+				version: view.document.version,
 				diagnostics
 			});
 		} catch (error) {
@@ -11220,10 +11254,14 @@ function startLanguageServer(connection) {
 		};
 	});
 	connection.onInitialized(() => {
-		if (canWatchFiles) connection.client.register(import_main.DidChangeWatchedFilesNotification.type, { watchers: WATCHED.map((globPattern) => ({ globPattern })) });
+		if (canWatchFiles) {
+			const watchers = WATCHED_FILES.map((globPattern) => ({ globPattern }));
+			connection.client.register(import_main.DidChangeWatchedFilesNotification.type, { watchers });
+		}
 	});
 	documents.onDidChangeContent(({ document }) => {
-		document.uri.endsWith(".dml") ? validate(document.uri) : validateAll();
+		if (document.uri.endsWith(".dml")) validate(document.uri);
+		else validateAll();
 	});
 	documents.onDidClose(({ document }) => {
 		connection.sendDiagnostics({
@@ -11234,30 +11272,37 @@ function startLanguageServer(connection) {
 	connection.onDidChangeWatchedFiles(() => {
 		validateAll();
 	});
-	connection.onCompletion(async ({ textDocument, position }) => {
-		const found = await pageOf(textDocument.uri);
-		if (!found) return [];
-		return complete(found.document, found.document.offsetAt(position), found.page, features);
+	const openViewAt = async ({ textDocument, position }) => {
+		const view = await openView(textDocument.uri);
+		if (!view) return;
+		return {
+			...view,
+			offset: view.document.offsetAt(position)
+		};
+	};
+	connection.onCompletion(async (request) => {
+		const view = await openViewAt(request);
+		if (!view) return [];
+		return complete(view.document, view.offset, view.page, components);
 	});
-	connection.onHover(async ({ textDocument, position }) => {
-		const found = await pageOf(textDocument.uri);
-		if (!found) return null;
-		return hover(found.document, found.document.offsetAt(position), found.page, features);
+	connection.onHover(async (request) => {
+		const view = await openViewAt(request);
+		if (!view) return null;
+		return hover(view.document, view.offset, view.page, components);
 	});
-	connection.onDefinition(async ({ textDocument, position }) => {
-		const found = await pageOf(textDocument.uri);
-		if (!found) return null;
-		return definition(found.document, found.document.offsetAt(position), found.page);
+	connection.onDefinition(async (request) => {
+		const view = await openViewAt(request);
+		if (!view) return null;
+		return definition(view.document, view.offset, view.page);
 	});
 	documents.listen(connection);
 	connection.listen();
 	return connection;
 }
-/** Serves an editor that started `dotctl lsp`, over stdin and stdout. */
 function serveStdio() {
 	return startLanguageServer((0, import_node.createConnection)(import_node.ProposedFeatures.all, process.stdin, process.stdout));
 }
 //#endregion
 export { serveStdio };
 
-//# sourceMappingURL=server-DFOUQnLA.js.map
+//# sourceMappingURL=server-DMnWDdJ6.js.map