@monimesl/dot-cli 0.1.0-alpha.3 → 0.1.0-alpha.31

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

@@ -1,11 +1,14 @@
+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";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { parseLogicModule, parseStateModule } from "@monimesl/dot-script-parser";
-import { SourceError, builtinRegistry, eventName, eventProp, isEventProp } from "@monimesl/dot-core";
+import { parseDmlToIR } from "@monimesl/dot-dml-parser";
+import { ScriptParseError, parseExpression, parseLogicModule, parseStateModule } from "@monimesl/dot-script-parser";
+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
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
@@ -10141,12 +10144,57 @@ function getWellformedEdit(textEdit) {
 	return textEdit;
 }
 //#endregion
+//#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."
+};
+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 describeType(type) {
+	if (typeof type === "string") return type;
+	if (isWordsOr(type)) return `${describeType(type.words)} | ${otherThanWords(type)}`;
+	return type.map((value) => `"${value}"`).join(" | ");
+}
+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 typeSuffix(shape) {
+	return shape ? `: \`${shape.type}\`` : "";
+}
+function describeChildren(component) {
+	switch (component.children) {
+		case "none": return "no children";
+		case "text": return "text and inline components";
+		case "elements": return "any components";
+	}
+}
+//#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);
@@ -10154,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
 	};
@@ -10221,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: {
@@ -10241,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);
@@ -10253,7 +10301,8 @@ function readTag(text, start, offset, open) {
 					kind: "attributeValue",
 					start: valueStart,
 					element,
-					attribute: name
+					attribute: name,
+					loopVariables: loopVariables(openElements)
 				},
 				end: valueEnd
 			};
@@ -10262,32 +10311,34 @@ function readTag(text, start, offset, open) {
 		}
 	}
 }
-function valueContext(valueBeforeCursor, valueStart, element, attribute, 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",
 		start: valueStart + bindingStart + 2,
-		loopVariables: loopVariables(open)
+		loopVariables: variables
 	};
 	return {
 		kind: "attributeValue",
 		start: valueStart,
 		element,
-		attribute
+		attribute,
+		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",
@@ -10300,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;
@@ -10308,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--;
@@ -10318,92 +10371,163 @@ function wordAt(text, offset, pattern) {
 	};
 }
 //#endregion
-//#region src/lsp/features.ts
-const TAG_NAME = /[A-Za-z0-9_.:-]/;
-const ATTRIBUTE_NAME = /[^\s=/>"']/;
+//#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*$/;
+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 = /[\w$]/;
-const VALUE = /[^\s"']/;
+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 "attributeValue": return valueCompletions(context.element, context.attribute, page, components).map((item) => ({
-			...item,
-			textEdit: {
-				range: range(context.start),
-				newText: item.label
-			}
-		}));
+		case "attributeName": {
+			const items = attributeCompletions(context.element, components);
+			return replacingFrom(document, context.start, offset, items);
+		}
+		case "attributeValue": {
+			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 identifier = /[A-Za-z_$][\w$]*$/.exec(typed)?.[0] ?? "";
-			if (typed.slice(0, typed.length - identifier.length).trimEnd().endsWith(".")) return [];
-			return bindingCompletions(context.loopVariables, page).map((item) => ({
-				...item,
-				textEdit: {
-					range: range(offset - identifier.length),
-					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,
@@ -10420,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,
@@ -10435,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),
@@ -10454,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",
@@ -10464,20 +10589,20 @@ function attributeCompletions(element, components) {
 	}));
 	return [...props, ...events];
 }
-function valueCompletions(element, attribute, page, components) {
-	if (element.tag === "For" && attribute === "key") return [{
-		label: "*this",
-		kind: import_main.CompletionItemKind.Value,
-		detail: "the item itself"
-	}, {
-		label: "*index",
-		kind: import_main.CompletionItemKind.Value,
-		detail: "match items by position"
-	}];
+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") 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
@@ -10492,36 +10617,394 @@ function valueCompletions(element, attribute, page, 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) {
+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: "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,
-		detail: describeLoopVariable(variable),
+		detail: describeLoopVariable(variable, scope?.loops.get(variable.name)),
 		sortText: `0${variable.name}`
 	});
 	return [...items.values()];
 }
-function hover(document, offset, page, { components }) {
+function memberCompletions(owner) {
+	if (!owner) return [];
+	return Object.entries(membersOf(owner)).map(([name, shape]) => ({
+		label: name,
+		kind: import_main.CompletionItemKind.Field,
+		detail: shape.type
+	}));
+}
+//#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 [];
+	}
+	const problems = [];
+	checkNodes(text, nodes, {
+		state,
+		loops: /* @__PURE__ */ new Map()
+	}, problems);
+	return problems;
+}
+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 (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 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 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 offsetOf(text, written, from) {
+	const foundAt = text.indexOf(written, from);
+	if (foundAt < 0) return from;
+	return foundAt;
+}
+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;
+}
+//#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));
+		}
+	};
+	if (page.statics) context.statics = page.statics;
+	if (page.state?.keys) context.stateKeys = page.state.keys;
+	const mutations = page.controller?.mutations;
+	const actions = page.controller?.actions;
+	if (mutations && actions) context.handlers = [...mutations, ...actions];
+	try {
+		compileView(document.getText(), context);
+	} catch (error) {
+		if (!(error instanceof SourceError)) throw error;
+		diagnostics.push(sourceDiagnostic(document, error, import_main.DiagnosticSeverity.Error));
+	}
+	if (page.state?.shapes) for (const problem of checkMembers(document.getText(), page.state.shapes)) diagnostics.push(diagnosticAt(document, problem.offset, problem.message, import_main.DiagnosticSeverity.Error));
+	return diagnostics;
+}
+function sourceDiagnostic(document, problem, severity) {
+	return diagnosticAt(document, problem.loc?.offset ?? 0, problem.reason, severity);
+}
+function diagnosticAt(document, start, message, severity) {
+	const text = document.getText();
+	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, atLeastOneCharacter))
+		}
+	};
+}
+//#endregion
+//#region src/lsp/page.ts
+async function readPage(viewFile, readText, stateTypes) {
+	const dir = dirname(viewFile);
+	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),
+		root === void 0 ? void 0 : listStatics(root).catch(() => void 0)
+	]);
+	return {
+		root,
+		state,
+		controller,
+		statics
+	};
+}
+async function readState(file, root, readText, stateTypes) {
+	const text = await readText(file);
+	if (text === void 0) return;
+	try {
+		const { keys, keyOffsets } = parseStateModule(text, file);
+		return {
+			file,
+			text,
+			keys,
+			offsets: keyOffsets,
+			shapes: readShapes(stateTypes, root, file, text)
+		};
+	} catch {
+		return;
+	}
+}
+function readShapes(stateTypes, root, file, text) {
+	try {
+		return stateTypes.read(root, file, text);
+	} catch {
+		return;
+	}
+}
+async function readController(file, readText) {
+	const text = await readText(file);
+	if (text === void 0) return;
+	try {
+		const { mutations, actions, handlerOffsets } = parseLogicModule(text, file);
+		return {
+			file,
+			text,
+			mutations,
+			actions,
+			offsets: handlerOffsets
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/lsp/state-types.ts
+const MAX_DEPTH = 8;
+const FALLBACK_OPTIONS = {
+	target: ts.ScriptTarget.ES2022,
+	module: ts.ModuleKind.ESNext,
+	moduleResolution: ts.ModuleResolutionKind.Bundler,
+	strict: true,
+	noEmit: true,
+	skipLibCheck: true
+};
+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 TypeScriptProject(root);
+			this.#projects.set(key, project);
+		}
+		return project.read(file, text);
+	}
+};
+var TypeScriptProject = class {
+	#options;
+	#fileNames;
+	#open = /* @__PURE__ */ new Map();
+	#service;
+	constructor(root) {
+		const config = root === void 0 ? void 0 : readConfig(root);
+		this.#options = config?.options ?? FALLBACK_OPTIONS;
+		this.#fileNames = config?.fileNames ?? [];
+		const host = {
+			getCompilationSettings: () => this.#options,
+			getScriptFileNames: () => [.../* @__PURE__ */ new Set([...this.#fileNames, ...this.#open.keys()])],
+			getScriptVersion: (file) => {
+				const open = this.#open.get(file);
+				if (open) return String(open.version);
+				return String(ts.sys.getModifiedTime?.(file)?.getTime() ?? 0);
+			},
+			getScriptSnapshot: (file) => {
+				const text = this.#open.get(file)?.text ?? ts.sys.readFile(file);
+				if (text === void 0) return;
+				return ts.ScriptSnapshot.fromString(text);
+			},
+			getCurrentDirectory: () => root ?? process.cwd(),
+			getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+			fileExists: (file) => ts.sys.fileExists(file),
+			readFile: (file) => ts.sys.readFile(file),
+			readDirectory: (...args) => ts.sys.readDirectory(...args),
+			directoryExists: (dir) => ts.sys.directoryExists(dir),
+			getDirectories: (dir) => ts.sys.getDirectories(dir),
+			realpath: (path) => ts.sys.realpath?.(path) ?? path
+		};
+		this.#service = ts.createLanguageService(host);
+	}
+	read(file, text) {
+		const open = this.#open.get(file);
+		if (open?.text !== text) this.#open.set(file, {
+			text,
+			version: (open?.version ?? 0) + 1
+		});
+		const program = this.#service.getProgram();
+		const source = program?.getSourceFile(file);
+		if (!program || !source) return;
+		const checker = program.getTypeChecker();
+		const module = checker.getSymbolAtLocation(source);
+		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);
+		const shapes = {};
+		for (const property of checker.getPropertiesOfType(state)) shapes[property.name] = propertyShape(checker, property, 0, /* @__PURE__ */ new Set());
+		return shapes;
+	}
+};
+function readConfig(root) {
+	const file = join(root, "tsconfig.json");
+	if (!existsSync(file)) return;
+	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);
+	const declaration = property.valueDeclaration ?? property.declarations?.[0];
+	if (!declaration) return shape;
+	const source = declaration.getSourceFile();
+	const { line, character } = source.getLineAndCharacterOfPosition(declaration.getStart());
+	return {
+		...shape,
+		declaration: {
+			file: source.fileName,
+			line,
+			character
+		}
+	};
+}
+function typeShape(checker, type, depth, seen) {
+	const present = checker.getNonNullableType(type);
+	const name = checker.typeToString(present);
+	if (depth >= MAX_DEPTH || seen.has(present) || present.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return {
+		kind: "value",
+		type: name
+	};
+	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: itemShape
+		};
+	}
+	if (!isRecord(checker, present)) return {
+		kind: "value",
+		type: name
+	};
+	const properties = {};
+	for (const property of checker.getPropertiesOfType(present)) properties[property.name] = propertyShape(checker, property, depth + 1, inner);
+	return {
+		kind: "object",
+		type: name,
+		properties
+	};
+}
+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);
@@ -10541,8 +11024,22 @@ 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 === "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;
 }
@@ -10564,7 +11061,8 @@ function symbolAt(text, offset, page) {
 		case "attributeName": {
 			const { start, end } = wordAt(text, offset, ATTRIBUTE_NAME);
 			const name = text.slice(start, end);
-			return name ? {
+			if (!name) return null;
+			return {
 				symbol: {
 					kind: "attribute",
 					tag: context.element.tag,
@@ -10572,7 +11070,7 @@ function symbolAt(text, offset, page) {
 				},
 				start,
 				end
-			} : null;
+			};
 		}
 		case "attributeValue": {
 			const { start, end } = wordAt(text, offset, VALUE);
@@ -10598,12 +11096,30 @@ function symbolAt(text, offset, page) {
 		case "binding": {
 			const { start, end } = wordAt(text, offset, IDENTIFIER);
 			const name = text.slice(start, end);
-			if (!name || text.slice(context.start, start).trimEnd().endsWith(".")) return null;
+			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
+					variable,
+					shape: scope?.loops.get(name)
 				},
 				start,
 				end
@@ -10623,56 +11139,45 @@ function symbolAt(text, offset, page) {
 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 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;
-			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;
+			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": return page.state?.keys?.includes(symbol.name) ? `state \`${symbol.name}\` in state.ts` : null;
-		case "loopVariable": return `\`${symbol.variable.name}\`: ${describeLoopVariable(symbol.variable)}`;
+		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 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 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 describeType(type) {
-	if (typeof type === "string") return type;
-	return type.map((value) => `"${value}"`).join(" | ");
-}
-function describeLoopVariable(variable) {
-	const list = variable.list ? ` \`${variable.list}\`` : "";
-	return variable.role === "item" ? `each item of${list}` : `the position in${list}`;
+function definitionIn(source, name) {
+	return locationIn(source.file, source.text, source.offsets[name]);
 }
 function locationIn(file, text, offset) {
 	if (offset === void 0) return null;
@@ -10685,136 +11190,42 @@ function locationIn(file, text, offset) {
 		}
 	};
 }
-function diagnose(document, file, page, { components }) {
-	const diagnostics = [];
-	const context = {
-		file,
-		components,
-		onWarning: (warning) => diagnostics.push(diagnosticAt(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 ?? {};
-	if (mutations && actions) context.handlers = [...mutations, ...actions];
-	try {
-		compileView(document.getText(), context);
-	} catch (error) {
-		if (!(error instanceof SourceError)) throw error;
-		diagnostics.push(diagnosticAt(document, error, import_main.DiagnosticSeverity.Error));
-	}
-	return diagnostics;
-}
-function diagnosticAt(document, problem, severity) {
-	const text = document.getText();
-	const start = problem.loc?.offset ?? 0;
-	let end = start;
-	while (end < text.length && !/[\s>]/.test(text[end])) end++;
-	return {
-		severity,
-		source: "dot",
-		message: problem.reason,
-		range: {
-			start: document.positionAt(start),
-			end: document.positionAt(Math.max(end, Math.min(start + 1, text.length)))
-		}
-	};
-}
-//#endregion
-//#region src/lsp/page.ts
-async function readPage(viewFile, readText) {
-	const dir = dirname(viewFile);
-	const root = findRoot(dir);
-	const [state, controller, statics] = await Promise.all([
-		readState(join(dir, "state.ts"), readText),
-		readController(join(dir, "controller.ts"), readText),
-		root === void 0 ? void 0 : listStatics(root).catch(() => void 0)
-	]);
-	return {
-		root,
-		state,
-		controller,
-		statics
-	};
-}
-async function readState(file, readText) {
-	const text = await readText(file);
-	if (text === void 0) return;
-	try {
-		const { keys, keyOffsets } = parseStateModule(text, file);
-		return {
-			file,
-			text,
-			keys,
-			offsets: keyOffsets
-		};
-	} catch {
-		return;
-	}
-}
-async function readController(file, readText) {
-	const text = await readText(file);
-	if (text === void 0) return;
-	try {
-		const { mutations, actions, handlerOffsets } = parseLogicModule(text, file);
-		return {
-			file,
-			text,
-			mutations,
-			actions,
-			offsets: handlerOffsets
-		};
-	} catch {
-		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/server.ts
-const WATCHED = [
-	"**/state.ts",
-	"**/controller.ts",
+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),
-			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) {
@@ -10843,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({
@@ -10857,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-z7M4FLjf.js.map
+//# sourceMappingURL=server-DMnWDdJ6.js.map