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

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

@@ -3,9 +3,11 @@ 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 { 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 { 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,6 +10143,159 @@ function getWellformedEdit(textEdit) {
 	return textEdit;
 }
 //#endregion
+//#region src/lsp/shapes.ts
+const NUMBER = {
+	kind: "value",
+	type: "number"
+};
+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 {};
+	}
+}
+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 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 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 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 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=/>"']/;
@@ -10253,7 +10408,8 @@ function readTag(text, start, offset, open) {
 					kind: "attributeValue",
 					start: valueStart,
 					element,
-					attribute: name
+					attribute: name,
+					loopVariables: loopVariables(open)
 				},
 				end: valueEnd
 			};
@@ -10263,17 +10419,19 @@ function readTag(text, start, offset, open) {
 	}
 }
 function valueContext(valueBeforeCursor, valueStart, element, attribute, open) {
+	const variables = loopVariables(open);
 	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) {
@@ -10323,6 +10481,7 @@ const TAG_NAME = /[A-Za-z0-9_.:-]/;
 const ATTRIBUTE_NAME = /[^\s=/>"']/;
 const IMAGE_ATTRIBUTES = ["src", "image"];
 const IDENTIFIER = /[\w$]/;
+const MEMBER_CHAIN = /([A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*)\s*\.\s*$/;
 const VALUE = /[^\s"']/;
 const CONTROL_FLOW_SNIPPETS = {
 	If: "If condition=\"{{ $1 }}\">$0</If>",
@@ -10375,21 +10534,24 @@ function complete(document, offset, page, { components }) {
 				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 "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
+				}
+			}));
+		}
 		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) => ({
+			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(offset - identifier.length),
+					range: range(wordStart),
 					newText: item.label
 				}
 			}));
@@ -10464,16 +10626,23 @@ 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 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"
+			}
+		];
+	}
 	const component = components[element.tag];
 	if (!component) return [];
 	if (isEventProp(attribute) && component.events.includes(eventName(attribute))) return handlerItems(page);
@@ -10505,22 +10674,42 @@ function handlerItems(page) {
 		detail: "action"
 	}))];
 }
-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",
+		detail: scope?.state[key] ? `state: ${scope.state[key].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 memberCompletions(owner) {
+	if (!owner) return [];
+	return Object.entries(membersOf(owner)).map(([name, shape]) => ({
+		label: name,
+		kind: import_main.CompletionItemKind.Field,
+		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;
@@ -10543,6 +10732,20 @@ function definition(document, offset, page) {
 	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
+			}
+		};
+	}
 	if (symbol.kind === "static" && page.root) return locationIn(join(page.root, symbol.path), "", 0);
 	return null;
 }
@@ -10598,16 +10801,38 @@ 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 = 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) return {
-				symbol: {
-					kind: "loopVariable",
-					variable
-				},
-				start,
-				end
-			};
+			if (variable) {
+				const shape = scope?.loops.get(name);
+				return {
+					symbol: shape ? {
+						kind: "loopVariable",
+						variable,
+						shape
+					} : {
+						kind: "loopVariable",
+						variable
+					},
+					start,
+					end
+				};
+			}
 			return {
 				symbol: {
 					kind: "state",
@@ -10647,8 +10872,9 @@ function describeSymbol(symbol, page, components) {
 			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": 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}\``;
 	}
 }
@@ -10670,9 +10896,12 @@ function describeType(type) {
 	if (typeof type === "string") return type;
 	return type.map((value) => `"${value}"`).join(" | ");
 }
-function describeLoopVariable(variable) {
+function describeLoopVariable(variable, shape) {
 	const list = variable.list ? ` \`${variable.list}\`` : "";
-	return variable.role === "item" ? `each item of${list}` : `the position in${list}`;
+	return variable.role === "item" ? `each item of${list}${typeSuffix(shape)}` : `the position in${list}`;
+}
+function typeSuffix(shape) {
+	return shape ? `: \`${shape.type}\`` : "";
 }
 function locationIn(file, text, offset) {
 	if (offset === void 0) return null;
@@ -10690,7 +10919,7 @@ function diagnose(document, file, page, { components }) {
 	const context = {
 		file,
 		components,
-		onWarning: (warning) => diagnostics.push(diagnosticAt(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;
@@ -10700,19 +10929,22 @@ function diagnose(document, file, page, { components }) {
 		compileView(document.getText(), context);
 	} catch (error) {
 		if (!(error instanceof SourceError)) throw error;
-		diagnostics.push(diagnosticAt(document, error, import_main.DiagnosticSeverity.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 diagnosticAt(document, problem, severity) {
+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 start = problem.loc?.offset ?? 0;
 	let end = start;
 	while (end < text.length && !/[\s>]/.test(text[end])) end++;
 	return {
 		severity,
 		source: "dot",
-		message: problem.reason,
+		message,
 		range: {
 			start: document.positionAt(start),
 			end: document.positionAt(Math.max(end, Math.min(start + 1, text.length)))
@@ -10721,11 +10953,11 @@ function diagnosticAt(document, problem, severity) {
 }
 //#endregion
 //#region src/lsp/page.ts
-async function readPage(viewFile, readText) {
+async function readPage(viewFile, readText, stateTypes) {
 	const dir = dirname(viewFile);
 	const root = findRoot(dir);
 	const [state, controller, statics] = await Promise.all([
-		readState(join(dir, "state.ts"), readText),
+		readState(join(dir, "state.ts"), root, readText, stateTypes),
 		readController(join(dir, "controller.ts"), readText),
 		root === void 0 ? void 0 : listStatics(root).catch(() => void 0)
 	]);
@@ -10736,17 +10968,27 @@ async function readPage(viewFile, readText) {
 		statics
 	};
 }
-async function readState(file, readText) {
+async function readState(file, root, readText, stateTypes) {
 	const text = await readText(file);
 	if (text === void 0) return;
+	let keys;
+	let offsets;
 	try {
-		const { keys, keyOffsets } = parseStateModule(text, file);
-		return {
-			file,
-			text,
-			keys,
-			offsets: keyOffsets
-		};
+		({keys, keyOffsets: offsets} = parseStateModule(text, file));
+	} catch {
+		return;
+	}
+	return {
+		file,
+		text,
+		keys,
+		offsets,
+		shapes: readShapes(stateTypes, root, file, text)
+	};
+}
+function readShapes(stateTypes, root, file, text) {
+	try {
+		return stateTypes.read(root, file, text);
 	} catch {
 		return;
 	}
@@ -10776,10 +11018,144 @@ function findRoot(dir) {
 	}
 }
 //#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
+};
+/**
+* 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);
+			this.#projects.set(key, project);
+		}
+		return project.read(file, text);
+	}
+};
+var Project = 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);
+				return text === void 0 ? void 0 : 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);
+		let exported = module && 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 read = ts.readConfigFile(file, (path) => ts.sys.readFile(path));
+	if (read.error) return;
+	return ts.parseJsonConfigFileContent(read.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);
+		return {
+			kind: "list",
+			type: name,
+			item: item ? typeShape(checker, item, depth + 1, inner) : {
+				kind: "value",
+				type: "unknown"
+			}
+		};
+	}
+	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/server.ts
 const WATCHED = [
-	"**/state.ts",
-	"**/controller.ts",
+	"**/*.ts",
 	"**/dot.json",
 	"**/statics/**"
 ];
@@ -10791,6 +11167,7 @@ const WATCHED = [
 function startLanguageServer(connection) {
 	const documents = new import_main.TextDocuments(TextDocument);
 	const features = { components: builtinRegistry };
+	const stateTypes = new StateTypes();
 	let canWatchFiles = false;
 	const readText = async (file) => {
 		const open = documents.get(pathToFileURL(file).href);
@@ -10803,7 +11180,7 @@ function startLanguageServer(connection) {
 		const file = fileURLToPath(uri);
 		return {
 			document,
-			page: await readPage(file, readText),
+			page: await readPage(file, readText, stateTypes),
 			file
 		};
 	};
@@ -10883,4 +11260,4 @@ function serveStdio() {
 //#endregion
 export { serveStdio };
 
-//# sourceMappingURL=server-z7M4FLjf.js.map
+//# sourceMappingURL=server-DFOUQnLA.js.map