@arviahq/language-server 0.2.0

package/dist/server.cjs

@@ -0,0 +1,1746 @@
+#!/usr/bin/env node
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_url = require("node:url");
+let vscode_languageserver_node_js = require("vscode-languageserver/node.js");
+let vscode_languageserver_textdocument = require("vscode-languageserver-textdocument");
+let vscode_languageserver = require("vscode-languageserver");
+let vscode_css_languageservice = require("vscode-css-languageservice");
+let _arviahq_compiler = require("@arviahq/compiler");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+//#region src/ast-query.ts
+const inSpan = (offset, span) => offset >= span.start && offset < span.end;
+/** Name spans are hit-tested inclusively so a cursor at the end still matches. */
+const onSpan = (offset, span) => offset >= span.start && offset <= span.end;
+function nodeAtOffset(ast, offset) {
+	for (const item of ast.items) {
+		if (!inSpan(offset, item.span) && !onSpan(offset, item.span)) continue;
+		switch (item.kind) {
+			case "theme":
+				for (const group of item.groups) {
+					const hit = tokenGroupTarget(group, offset, "theme", null);
+					if (hit) return hit;
+				}
+				break;
+			case "recipe": {
+				if (onSpan(offset, item.nameSpan)) return {
+					kind: "recipe-name",
+					recipe: item
+				};
+				const hit = styleItemsTarget(item.items, offset, null);
+				if (hit) return hit;
+				break;
+			}
+			case "keyframes":
+				if (onSpan(offset, item.nameSpan)) return {
+					kind: "keyframes-name",
+					keyframes: item
+				};
+				for (const step of item.steps) for (const decl of step.decls) {
+					const hit = declTarget(decl, offset, null);
+					if (hit) return hit;
+				}
+				break;
+			case "styledecl": {
+				if (onSpan(offset, item.nameSpan)) return {
+					kind: "style-name",
+					style: item
+				};
+				const hit = styleItemsTarget(item.items, offset, null);
+				if (hit) return hit;
+				break;
+			}
+			case "component": {
+				const hit = componentTarget(item, offset);
+				if (hit) return hit;
+				break;
+			}
+			case "global":
+				for (const rule of item.rules) for (const decl of rule.decls) {
+					const hit = declTarget(decl, offset, null);
+					if (hit) return hit;
+				}
+				break;
+		}
+	}
+	return null;
+}
+function componentTarget(component, offset) {
+	if (onSpan(offset, component.nameSpan)) return {
+		kind: "component-name",
+		component
+	};
+	for (const item of component.items) switch (item.kind) {
+		case "decl": {
+			const hit = declTarget(item, offset, component);
+			if (hit) return hit;
+			break;
+		}
+		case "use":
+			if (onSpan(offset, item.recipeSpan)) return {
+				kind: "use-recipe",
+				name: item.recipe,
+				span: item.recipeSpan
+			};
+			break;
+		case "base": {
+			const hit = styleBodyTarget(item.body, offset, component);
+			if (hit) return hit;
+			break;
+		}
+		case "slots":
+			for (const slot of item.slots) {
+				if (onSpan(offset, slot.nameSpan)) return {
+					kind: "slot-name",
+					component,
+					name: slot.name,
+					span: slot.nameSpan
+				};
+				const hit = styleItemsTarget(slot.items, offset, component);
+				if (hit) return hit;
+			}
+			break;
+		case "variants":
+			for (const variant of item.variants) {
+				if (onSpan(offset, variant.nameSpan)) return {
+					kind: "variant-name",
+					component,
+					variant
+				};
+				for (const value of variant.values) {
+					if (onSpan(offset, value.nameSpan)) return {
+						kind: "variant-value-name",
+						component,
+						variant,
+						value
+					};
+					const hit = styleBodyTarget(value.body, offset, component);
+					if (hit) return hit;
+				}
+			}
+			break;
+		case "defaults": {
+			const hit = settingsTarget(item.entries, offset, component, "defaults");
+			if (hit) return hit;
+			break;
+		}
+		case "responsive":
+			for (const entry of item.entries) {
+				if (onSpan(offset, entry.breakpointSpan)) return {
+					kind: "conditional-key",
+					component,
+					key: entry.breakpoint,
+					span: entry.breakpointSpan,
+					context: "responsive"
+				};
+				const hit = settingsTarget(entry.variants, offset, component, "responsive");
+				if (hit) return hit;
+			}
+			break;
+		case "container":
+			for (const entry of item.entries) {
+				if (onSpan(offset, entry.containerSpan)) return {
+					kind: "conditional-key",
+					component,
+					key: entry.container,
+					span: entry.containerSpan,
+					context: "container"
+				};
+				const hit = settingsTarget(entry.variants, offset, component, "container");
+				if (hit) return hit;
+			}
+			break;
+		case "compound": {
+			const hit = settingsTarget(item.matchers, offset, component, "compound");
+			if (hit) return hit;
+			for (const slot of item.slots) {
+				if (onSpan(offset, slot.nameSpan)) return {
+					kind: "slot-name",
+					component,
+					name: slot.name,
+					span: slot.nameSpan
+				};
+				const inner = styleItemsTarget(slot.items, offset, component);
+				if (inner) return inner;
+			}
+			break;
+		}
+		case "tokens":
+			for (const group of item.groups) {
+				const hit = tokenGroupTarget(group, offset, "component", component);
+				if (hit) return hit;
+			}
+			break;
+	}
+	return null;
+}
+function tokenGroupTarget(group, offset, owner, component) {
+	const entries = [...group.entries, ...group.overrides.flatMap((o) => o.entries)];
+	for (const entry of entries) {
+		const valueHit = valueTarget(entry.value, offset, component);
+		if (valueHit) return valueHit;
+		if (onSpan(offset, entry.nameSpan)) return {
+			kind: "token-entry",
+			group,
+			name: entry.name,
+			span: entry.nameSpan,
+			value: entry.value.text,
+			doc: entry.doc,
+			owner,
+			component
+		};
+	}
+	return null;
+}
+function styleBodyTarget(body, offset, component) {
+	for (const item of body.items) if (item.kind === "slotblock") {
+		if (component && onSpan(offset, item.nameSpan)) return {
+			kind: "slot-name",
+			component,
+			name: item.name,
+			span: item.nameSpan
+		};
+		const hit = styleItemsTarget(item.items, offset, component);
+		if (hit) return hit;
+	} else {
+		const hit = styleItemsTarget([item], offset, component);
+		if (hit) return hit;
+	}
+	return null;
+}
+function styleItemsTarget(items, offset, component) {
+	for (const item of items) if (item.kind === "decl") {
+		const hit = declTarget(item, offset, component);
+		if (hit) return hit;
+	} else if (item.kind === "use") {
+		if (onSpan(offset, item.recipeSpan)) return {
+			kind: "use-recipe",
+			name: item.recipe,
+			span: item.recipeSpan
+		};
+	} else {
+		for (const decl of item.items) {
+			const hit = declTarget(decl, offset, component);
+			if (hit) return hit;
+		}
+		for (const slot of item.slots) {
+			if (component && onSpan(offset, slot.nameSpan)) return {
+				kind: "slot-name",
+				component,
+				name: slot.name,
+				span: slot.nameSpan
+			};
+			for (const decl of slot.items) {
+				if (decl.kind !== "decl") continue;
+				const hit = declTarget(decl, offset, component);
+				if (hit) return hit;
+			}
+		}
+	}
+	return null;
+}
+function declTarget(decl, offset, component) {
+	const propSpan = {
+		start: decl.span.start,
+		end: decl.span.start + decl.property.length,
+		line: decl.span.line,
+		col: decl.span.col
+	};
+	if (onSpan(offset, propSpan)) return {
+		kind: "css-property",
+		name: decl.property,
+		span: propSpan
+	};
+	return valueTarget(decl.value, offset, component);
+}
+function valueTarget(value, offset, component) {
+	if (!onSpan(offset, value.span)) return null;
+	for (const word of value.words) if (word.kind === "ref" && onSpan(offset, word.span)) return {
+		kind: "token-ref",
+		word,
+		component
+	};
+	return null;
+}
+function settingsTarget(entries, offset, component, context) {
+	for (const entry of entries) {
+		if (onSpan(offset, entry.variantSpan)) return {
+			kind: "variant-setting",
+			component,
+			entry,
+			part: "variant",
+			context
+		};
+		if (onSpan(offset, entry.valueSpan)) return {
+			kind: "variant-setting",
+			component,
+			entry,
+			part: "value",
+			context
+		};
+	}
+	return null;
+}
+//#endregion
+//#region src/cssdata.ts
+let propertyIndex = null;
+/** MDN-sourced CSS property data (the dataset behind VS Code's CSS hover). */
+function cssProperty(name) {
+	if (!propertyIndex) {
+		propertyIndex = /* @__PURE__ */ new Map();
+		for (const property of (0, vscode_css_languageservice.getDefaultCSSDataProvider)().provideProperties()) propertyIndex.set(property.name, property);
+	}
+	return propertyIndex.get(name);
+}
+function allCssProperties() {
+	cssProperty("color");
+	return [...propertyIndex.values()];
+}
+function propertyDescription(property) {
+	const desc = property.description;
+	if (!desc) return "";
+	return typeof desc === "string" ? desc : desc.value;
+}
+/** Markdown hover card for a CSS property (or custom property). */
+function cssPropertyHover(name) {
+	if (name.startsWith("--")) return `**${name}** — CSS custom property`;
+	const property = cssProperty(name);
+	if (!property) return null;
+	const parts = [`**${name}**`];
+	const description = propertyDescription(property);
+	if (description) parts.push(description);
+	if (property.syntax) parts.push(`\`\`\`\n${property.syntax}\n\`\`\``);
+	const mdn = property.references?.find((r) => r.name.includes("MDN"));
+	if (mdn) parts.push(`[MDN Reference](${mdn.url})`);
+	return parts.join("\n\n");
+}
+//#endregion
+//#region src/hover.ts
+function getHover(analysis, offset, workspace) {
+	const target = nodeAtOffset(analysis.ast, offset);
+	if (!target) return null;
+	const markdown = renderHover(target, analysis, workspace);
+	if (!markdown) return null;
+	return {
+		contents: {
+			kind: vscode_languageserver.MarkupKind.Markdown,
+			value: markdown
+		},
+		range: rangeOf(analysis, targetSpan(target))
+	};
+}
+function targetSpan(target) {
+	switch (target.kind) {
+		case "token-ref": return target.word.span;
+		case "use-recipe":
+		case "slot-name":
+		case "conditional-key":
+		case "token-entry": return target.span;
+		case "component-name": return target.component.nameSpan;
+		case "style-name": return target.style.nameSpan;
+		case "recipe-name": return target.recipe.nameSpan;
+		case "keyframes-name": return target.keyframes.nameSpan;
+		case "variant-name": return target.variant.nameSpan;
+		case "variant-value-name": return target.value.nameSpan;
+		case "variant-setting": return target.part === "variant" ? target.entry.variantSpan : target.entry.valueSpan;
+		case "css-property": return target.span;
+	}
+}
+function rangeOf(analysis, span) {
+	const range = analysis.index.spanToRange(span);
+	return {
+		start: {
+			line: range.start.line - 1,
+			character: range.start.col - 1
+		},
+		end: {
+			line: range.end.line - 1,
+			character: range.end.col - 1
+		}
+	};
+}
+function renderHover(target, analysis, workspace) {
+	const env = analysis.env;
+	switch (target.kind) {
+		case "token-ref": return target.word.group === "keyframes" ? keyframesRefHover(target.word, analysis, workspace) : tokenRefHover(target.word, target.component, env);
+		case "use-recipe": return recipeHover(target.name, env);
+		case "recipe-name": return recipeHover(target.recipe.name, env);
+		case "token-entry": {
+			const heading = target.owner === "component" ? `**${target.group.name}.${target.name}** — local to \`${target.component?.name}\`` : `**${target.group.name}.${target.name}**`;
+			const doc = target.doc ? `\n\n${target.doc}` : "";
+			return `${heading}\n\n\`\`\`css\n${target.value}\n\`\`\`${doc}`;
+		}
+		case "component-name": return componentHover(target.component);
+		case "style-name": return `**style ${target.style.name}** — exported class\n\n\`\`\`ts\nexport const ${target.style.name}: string;\n\`\`\``;
+		case "keyframes-name": return keyframesDeclHover(target.keyframes.name, analysis.ast);
+		case "variant-name": {
+			const values = target.variant.values.map((v) => v.name).join(" | ");
+			return `**variant ${target.variant.name}** of \`${target.component.name}\`\n\n\`\`\`ts\n${target.variant.name}?: ${values || "never"}\n\`\`\``;
+		}
+		case "variant-value-name": return `**${target.variant.name}: ${target.value.name}** — variant value of \`${target.component.name}\``;
+		case "slot-name": return `**slot ${target.name}** of \`${target.component.name}\``;
+		case "variant-setting": {
+			const variant = findVariant(target.component, target.entry.variant);
+			if (!variant) return null;
+			if (target.part === "variant") {
+				const values = variant.values.map((v) => v.name).join(" | ");
+				return `**variant ${variant.name}** of \`${target.component.name}\`\n\n\`\`\`ts\n${variant.name}?: ${values || "never"}\n\`\`\``;
+			}
+			return `**${target.entry.variant}: ${target.entry.value}** (${target.context})`;
+		}
+		case "conditional-key": {
+			const size = target.context === "responsive" ? env.breakpoints[target.key] : env.containers[target.key];
+			const label = target.context === "responsive" ? "breakpoint" : "container size";
+			return size ? `**${label} ${target.key}**\n\n\`\`\`css\nmin-width: ${size}\n\`\`\`` : null;
+		}
+		case "css-property": return cssPropertyHover(target.name);
+	}
+}
+function tokenRefHover(word, component, env) {
+	const local = component ? findLocalToken(component, word.group, word.name) : null;
+	if (local) {
+		const doc = local.doc ? `\n\n${local.doc}` : "";
+		return `**${word.group}.${word.name}** — local to \`${component.name}\`\n\n\`\`\`css\n${local.value}\n\`\`\`${doc}`;
+	}
+	const entry = env.tokens[word.group]?.[word.name];
+	if (entry === void 0) return null;
+	let body;
+	if (typeof entry === "string") body = `\`\`\`css\n${entry}\n\`\`\``;
+	else body = `| mode | value |\n| --- | --- |\n${Object.entries(entry).map(([mode, value]) => `| ${mode} | \`${value}\` |`).join("\n")}`;
+	const doc = env.tokenDocs[word.group]?.[word.name];
+	const docLine = doc ? `\n\n${doc}` : "";
+	const cssVar = env.modes ? `\n\n\`var(--arvia-${word.group}-${word.name})\`` : "";
+	return `**${word.group}.${word.name}**\n\n${body}${docLine}${cssVar}`;
+}
+function recipeHover(name, env) {
+	const recipe = env.recipes[name];
+	if (!recipe) return null;
+	const shown = recipe.decls.slice(0, 8);
+	const lines = shown.map((d) => `${d.property}: ${d.value};`);
+	if (recipe.decls.length > shown.length) lines.push(`/* +${recipe.decls.length - shown.length} more */`);
+	const selectorList = recipe.states.flatMap((s) => s.selectors).map((sel) => `\`&${sel.trim()}\``).join(", ");
+	const states = recipe.states.length > 0 ? `\n\n${recipe.states.length} state${recipe.states.length === 1 ? "" : "s"}: ${selectorList}` : "";
+	return `**recipe ${name}**\n\n\`\`\`css\n${lines.join("\n")}\n\`\`\`${states}`;
+}
+function componentHover(component) {
+	const slots = new Set(["root"]);
+	const variants = [];
+	for (const item of component.items) {
+		if (item.kind === "slots") for (const slot of item.slots) slots.add(slot.name);
+		if (item.kind === "variants") for (const variant of item.variants) variants.push(`${variant.name}: ${variant.values.map((v) => v.name).join(" | ")}`);
+	}
+	const lines = [`slots: ${[...slots].join(", ")}`, ...variants.length > 0 ? variants : ["(no variants)"]];
+	return `**component ${component.name}**\n\n\`\`\`\n${lines.join("\n")}\n\`\`\``;
+}
+function keyframesRefHover(word, analysis, workspace) {
+	const local = keyframesDeclHover(word.name, analysis.ast);
+	if (local) return local;
+	const theme = workspace.themeFor(analysis.file);
+	return theme ? keyframesDeclHover(word.name, theme.ast) : null;
+}
+function keyframesDeclHover(name, ast) {
+	for (const item of ast.items) {
+		if (item.kind !== "keyframes" || item.name !== name) continue;
+		return `**keyframes ${name}**\n\n\`\`\`\n${item.steps.map((s) => s.selector).join(" → ") || "(no steps)"}\n\`\`\``;
+	}
+	return null;
+}
+function findVariant(component, name) {
+	for (const item of component.items) {
+		if (item.kind !== "variants") continue;
+		const variant = item.variants.find((v) => v.name === name);
+		if (variant) return variant;
+	}
+}
+function findLocalToken(component, group, name) {
+	for (const item of component.items) {
+		if (item.kind !== "tokens") continue;
+		for (const g of item.groups) {
+			if (g.name !== group) continue;
+			for (const entry of g.entries) if (entry.name === name) return {
+				value: entry.value.text,
+				doc: entry.doc,
+				span: entry.nameSpan
+			};
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/walk.ts
+/** Every CSS declaration in the file, with its owning component (if any). */
+function walkDeclarations(ast) {
+	const out = [];
+	const visitItems = (items, component) => {
+		for (const item of items) if (item.kind === "decl") out.push({
+			decl: item,
+			component
+		});
+		else if (item.kind === "state") {
+			for (const decl of item.items) out.push({
+				decl,
+				component
+			});
+			for (const slot of item.slots) for (const decl of slot.items) if (decl.kind === "decl") out.push({
+				decl,
+				component
+			});
+		}
+	};
+	for (const top of ast.items) switch (top.kind) {
+		case "global":
+			for (const rule of top.rules) for (const decl of rule.decls) out.push({
+				decl,
+				component: null
+			});
+			break;
+		case "keyframes":
+			for (const step of top.steps) for (const decl of step.decls) out.push({
+				decl,
+				component: null
+			});
+			break;
+		case "recipe":
+		case "styledecl":
+			visitItems(top.items, null);
+			break;
+		case "component":
+			for (const item of top.items) switch (item.kind) {
+				case "decl":
+					out.push({
+						decl: item,
+						component: top
+					});
+					break;
+				case "base":
+					for (const part of item.body.items) if (part.kind === "slotblock") visitItems(part.items, top);
+					else visitItems([part], top);
+					break;
+				case "slots":
+					for (const slot of item.slots) visitItems(slot.items, top);
+					break;
+				case "variants":
+					for (const variant of item.variants) for (const value of variant.values) for (const part of value.body.items) if (part.kind === "slotblock") visitItems(part.items, top);
+					else visitItems([part], top);
+					break;
+				case "compound":
+					for (const slot of item.slots) visitItems(slot.items, top);
+					break;
+			}
+			break;
+	}
+	return out;
+}
+/** Every token entry (theme + component tokens, incl. mode overrides). */
+function walkTokenEntries(ast) {
+	const out = [];
+	const visitGroup = (group, owner, component) => {
+		for (const entry of group.entries) out.push({
+			entry,
+			group,
+			owner,
+			component
+		});
+		for (const override of group.overrides) for (const entry of override.entries) out.push({
+			entry,
+			group,
+			owner,
+			component
+		});
+	};
+	for (const top of ast.items) {
+		if (top.kind === "theme") for (const group of top.groups) visitGroup(group, "theme", null);
+		if (top.kind === "component") for (const item of top.items) {
+			if (item.kind !== "tokens") continue;
+			for (const group of item.groups) visitGroup(group, "component", top);
+		}
+	}
+	return out;
+}
+/** Every RawValue in the file (declaration values + token entry values). */
+function walkValues(ast) {
+	return [...walkDeclarations(ast).map(({ decl, component }) => ({
+		value: decl.value,
+		component
+	})), ...walkTokenEntries(ast).map(({ entry, component }) => ({
+		value: entry.value,
+		component
+	}))];
+}
+/** Every `use Recipe;` statement in the file. */
+function walkUses(ast) {
+	const out = [];
+	const visitItems = (items) => {
+		for (const item of items) if (item.kind === "use") out.push({
+			recipe: item.recipe,
+			recipeSpan: item.recipeSpan
+		});
+	};
+	for (const top of ast.items) switch (top.kind) {
+		case "recipe":
+		case "styledecl":
+			visitItems(top.items);
+			break;
+		case "component":
+			for (const item of top.items) {
+				if (item.kind === "use") out.push({
+					recipe: item.recipe,
+					recipeSpan: item.recipeSpan
+				});
+				if (item.kind === "base") for (const part of item.body.items) if (part.kind === "slotblock") visitItems(part.items);
+				else visitItems([part]);
+				if (item.kind === "slots") for (const slot of item.slots) visitItems(slot.items);
+				if (item.kind === "variants") for (const variant of item.variants) for (const value of variant.values) for (const part of value.body.items) if (part.kind === "slotblock") visitItems(part.items);
+				else visitItems([part]);
+				if (item.kind === "compound") for (const slot of item.slots) visitItems(slot.items);
+			}
+			break;
+	}
+	return out;
+}
+//#endregion
+//#region src/colors.ts
+const HEX_RE = /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+const FN_RE = /^(rgba?|hsla?)\(([^)]*)\)$/;
+const to255 = (v) => Math.round(v * 255);
+const rgbChannel = (raw) => raw.endsWith("%") ? parseFloat(raw) / 100 : parseFloat(raw) / 255;
+/** Inline color swatches for literal color values (hex / rgb / hsl). */
+function getDocumentColors(analysis) {
+	const out = [];
+	for (const { value } of walkValues(analysis.ast)) for (const word of value.words) {
+		if (word.kind !== "literal") continue;
+		const color = parseColor(word.text);
+		if (color) out.push({
+			range: rangeOf(analysis, word.span),
+			color
+		});
+	}
+	return out;
+}
+function getColorPresentations(color, span) {
+	const hex2 = (v) => to255(v).toString(16).padStart(2, "0");
+	const hex = color.alpha < 1 ? `#${hex2(color.red)}${hex2(color.green)}${hex2(color.blue)}${hex2(color.alpha)}` : `#${hex2(color.red)}${hex2(color.green)}${hex2(color.blue)}`;
+	const rgb = color.alpha < 1 ? `rgba(${to255(color.red)}, ${to255(color.green)}, ${to255(color.blue)}, ${Math.round(color.alpha * 100) / 100})` : `rgb(${to255(color.red)}, ${to255(color.green)}, ${to255(color.blue)})`;
+	return [{ label: hex }, { label: rgb }];
+}
+function parseColor(text) {
+	if (HEX_RE.test(text)) return parseHex(text);
+	const fn = FN_RE.exec(text);
+	if (fn) {
+		const args = fn[2].split(/[,\s/]+/).map((a) => a.trim()).filter(Boolean);
+		if (args.length < 3) return null;
+		if (fn[1].startsWith("rgb")) return parseRgbArgs(args);
+		return parseHslArgs(args);
+	}
+	return null;
+}
+function parseHex(text) {
+	const hex = text.slice(1);
+	const wide = hex.length >= 6;
+	const step = wide ? 2 : 1;
+	const channel = (i) => {
+		const part = hex.slice(i * step, i * step + step);
+		return parseInt(wide ? part : part + part, 16) / 255;
+	};
+	const hasAlpha = hex.length === 4 || hex.length === 8;
+	return {
+		red: channel(0),
+		green: channel(1),
+		blue: channel(2),
+		alpha: hasAlpha ? channel(3) : 1
+	};
+}
+function parseRgbArgs(args) {
+	const [r, g, b] = [
+		rgbChannel(args[0]),
+		rgbChannel(args[1]),
+		rgbChannel(args[2])
+	];
+	if ([
+		r,
+		g,
+		b
+	].some((v) => Number.isNaN(v))) return null;
+	const alpha = args[3] !== void 0 ? parseAlpha(args[3]) : 1;
+	return {
+		red: clamp01(r),
+		green: clamp01(g),
+		blue: clamp01(b),
+		alpha
+	};
+}
+function parseHslArgs(args) {
+	const h = parseFloat(args[0]);
+	const s = parseFloat(args[1]) / 100;
+	const l = parseFloat(args[2]) / 100;
+	if ([
+		h,
+		s,
+		l
+	].some((v) => Number.isNaN(v))) return null;
+	const alpha = args[3] !== void 0 ? parseAlpha(args[3]) : 1;
+	const c = (1 - Math.abs(2 * l - 1)) * s;
+	const hp = (h % 360 + 360) % 360 / 60;
+	const x = c * (1 - Math.abs(hp % 2 - 1));
+	const [r1, g1, b1] = hp < 1 ? [
+		c,
+		x,
+		0
+	] : hp < 2 ? [
+		x,
+		c,
+		0
+	] : hp < 3 ? [
+		0,
+		c,
+		x
+	] : hp < 4 ? [
+		0,
+		x,
+		c
+	] : hp < 5 ? [
+		x,
+		0,
+		c
+	] : [
+		c,
+		0,
+		x
+	];
+	const m = l - c / 2;
+	return {
+		red: clamp01(r1 + m),
+		green: clamp01(g1 + m),
+		blue: clamp01(b1 + m),
+		alpha
+	};
+}
+function parseAlpha(raw) {
+	return clamp01(raw.endsWith("%") ? parseFloat(raw) / 100 : parseFloat(raw));
+}
+function clamp01(v) {
+	return Math.max(0, Math.min(1, v));
+}
+//#endregion
+//#region src/completion.ts
+const SECTION_KEYWORDS = [
+	"base",
+	"slots",
+	"variants",
+	"defaults",
+	"responsive",
+	"container",
+	"compound",
+	"tokens"
+];
+const TOP_KEYWORDS = [
+	"theme",
+	"global",
+	"recipe",
+	"keyframes",
+	"style",
+	"component"
+];
+const DEFAULT_GROUPS = [
+	"color",
+	"space",
+	"radius",
+	"font",
+	"breakpoint",
+	"container",
+	"duration",
+	"easing"
+];
+function item(label, kind, detail) {
+	return {
+		label,
+		kind,
+		detail
+	};
+}
+function tokenKind(group, value) {
+	return group === "color" || /^#|rgb|hsl|oklch/.test(value) ? vscode_languageserver.CompletionItemKind.Color : vscode_languageserver.CompletionItemKind.Constant;
+}
+/** Returns the component whose span contains the offset, if any. */
+function enclosingComponent(analysis, offset) {
+	for (const top of analysis.ast.items) if (top.kind === "component" && offset >= top.span.start && offset <= top.span.end) return top;
+	return null;
+}
+function localTokenGroups(component) {
+	const groups = /* @__PURE__ */ new Map();
+	if (!component) return groups;
+	for (const part of component.items) {
+		if (part.kind !== "tokens") continue;
+		for (const group of part.groups) {
+			const bucket = groups.get(group.name) ?? /* @__PURE__ */ new Map();
+			for (const entry of group.entries) bucket.set(entry.name, entry.value.text);
+			groups.set(group.name, bucket);
+		}
+	}
+	return groups;
+}
+function tokenValueOf(env, group, name) {
+	const entry = env.tokens[group]?.[name];
+	if (entry === void 0) return "";
+	if (typeof entry === "string") return entry;
+	return Object.entries(entry).map(([mode, value]) => `${mode}: ${value}`).join(", ");
+}
+function getCompletions(analysis, offset) {
+	const source = analysis.source;
+	const env = analysis.env;
+	const before = source.slice(0, offset);
+	const lineStart = before.lastIndexOf("\n") + 1;
+	const linePrefix = before.slice(lineStart);
+	const component = enclosingComponent(analysis, offset);
+	const locals = localTokenGroups(component);
+	const items = [];
+	const groupDot = linePrefix.match(/([A-Za-z_][A-Za-z0-9_-]*)\.$/);
+	if (groupDot) {
+		const group = groupDot[1];
+		const localBucket = locals.get(group);
+		if (localBucket) for (const [name, value] of localBucket) items.push({
+			label: name,
+			kind: tokenKind(group, value),
+			detail: `${value} — local to ${component.name}`
+		});
+		const bucket = env.tokens[group];
+		if (bucket) for (const name of Object.keys(bucket)) {
+			if (localBucket?.has(name)) continue;
+			const value = tokenValueOf(env, group, name);
+			const doc = env.tokenDocs[group]?.[name];
+			items.push({
+				label: name,
+				kind: tokenKind(group, value),
+				detail: value,
+				documentation: doc
+			});
+		}
+		if (group === "keyframes") for (const name of Object.keys(env.keyframes)) items.push(item(name, vscode_languageserver.CompletionItemKind.Event, "keyframes"));
+		if (items.length > 0) return items;
+	}
+	if (/\buse\s+$/.test(linePrefix)) {
+		for (const [name, recipe] of Object.entries(env.recipes)) items.push(item(name, vscode_languageserver.CompletionItemKind.Reference, `recipe — ${recipe.decls.length} decls`));
+		return items;
+	}
+	if (linePrefix.endsWith("@")) {
+		for (const mode of env.modes ?? []) items.push(item(mode, vscode_languageserver.CompletionItemKind.EnumMember, "theme mode"));
+		return items;
+	}
+	if (/^\s*$/.test(linePrefix) && before.trimEnd().endsWith("{")) {
+		if (/\b(theme|tokens)\s*\{\s*$/.test(before.slice(-40))) {
+			if (/\btheme\s*\{\s*$/.test(before.slice(-40))) items.push(item("modes:", vscode_languageserver.CompletionItemKind.Keyword, "light | dark;"));
+			const groups = new Set([...DEFAULT_GROUPS, ...Object.keys(env.tokens)]);
+			for (const group of groups) items.push(item(group, vscode_languageserver.CompletionItemKind.Module, "token group"));
+		}
+		if (/\bcomponent\s+[\w$]+\s*\{\s*$/.test(before)) for (const kw of SECTION_KEYWORDS) items.push(item(kw, vscode_languageserver.CompletionItemKind.Keyword));
+		if (/\b(defaults|compound)\s*\{\s*$/.test(before.slice(-24)) && component) for (const variant of variantsOf(component)) items.push(item(variant.name, vscode_languageserver.CompletionItemKind.Enum, variant.values.join(" | ")));
+		if (/\bresponsive\s*\{\s*$/.test(before.slice(-20))) for (const [bp, size] of Object.entries(env.breakpoints)) items.push(item(bp, vscode_languageserver.CompletionItemKind.Variable, `min-width: ${size}`));
+		if (/\bcontainer\s*\{\s*$/.test(before.slice(-20))) for (const [cq, size] of Object.entries(env.containers)) items.push(item(cq, vscode_languageserver.CompletionItemKind.Variable, `min-width: ${size}`));
+		if (items.length > 0) return items;
+	}
+	const settingMatch = linePrefix.match(/^\s*([A-Za-z_][\w$-]*)\s*:\s*$/);
+	if (settingMatch && component) {
+		const variant = variantsOf(component).find((v) => v.name === settingMatch[1]);
+		if (variant) {
+			for (const value of variant.values) items.push(item(value, vscode_languageserver.CompletionItemKind.EnumMember, `value of ${variant.name}`));
+			return items;
+		}
+	}
+	if (/:\s*[^;]*$/.test(linePrefix)) {
+		const groups = new Set([...Object.keys(env.tokens), ...locals.keys()]);
+		for (const group of groups) items.push(item(group, vscode_languageserver.CompletionItemKind.Module, "token group"));
+		if (Object.keys(env.keyframes).length > 0) items.push(item("keyframes", vscode_languageserver.CompletionItemKind.Module, "animations"));
+		return items;
+	}
+	for (const prop of allCssProperties()) items.push({
+		label: prop.name,
+		kind: vscode_languageserver.CompletionItemKind.Property,
+		detail: prop.syntax,
+		documentation: propertyDescription(prop) || void 0
+	});
+	if (items.length > 0 && component) return items;
+	for (const kw of [
+		...TOP_KEYWORDS,
+		...SECTION_KEYWORDS,
+		"use"
+	]) items.push(item(kw, vscode_languageserver.CompletionItemKind.Keyword));
+	return items;
+}
+function variantsOf(component) {
+	const out = [];
+	for (const part of component.items) {
+		if (part.kind !== "variants") continue;
+		for (const variant of part.variants) out.push({
+			name: variant.name,
+			values: variant.values.map((v) => v.name)
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/definition.ts
+function getDefinition(analysis, offset, workspace) {
+	const target = nodeAtOffset(analysis.ast, offset);
+	if (!target) return null;
+	const theme = workspace.themeFor(analysis.file);
+	const isThemeDoc = theme !== null && theme.path === analysis.file;
+	const local = (span) => locationFor(analysis.file, analysis.index, span);
+	const inTheme = (span) => theme && !isThemeDoc ? locationFor(theme.path, theme.index, span) : null;
+	switch (target.kind) {
+		case "token-ref": {
+			if (target.word.group === "keyframes") {
+				const own = findKeyframes(analysis.ast, target.word.name);
+				if (own) return local(own);
+				const themed = theme && findKeyframes(theme.ast, target.word.name);
+				return themed ? inTheme(themed) : null;
+			}
+			if (target.component) {
+				const localToken = findLocalToken(target.component, target.word.group, target.word.name);
+				if (localToken) return local(localToken.span);
+			}
+			const own = findThemeEntry(analysis.ast, target.word.group, target.word.name);
+			if (own) return local(own);
+			const themed = theme && findThemeEntry(theme.ast, target.word.group, target.word.name);
+			return themed ? inTheme(themed) : null;
+		}
+		case "use-recipe": {
+			const own = findRecipe(analysis.ast, target.name);
+			if (own) return local(own);
+			const themed = theme && findRecipe(theme.ast, target.name);
+			return themed ? inTheme(themed) : null;
+		}
+		case "variant-setting": {
+			const variant = findVariantSpans(target.component, target.entry.variant);
+			if (!variant) return null;
+			if (target.part === "variant") return local(variant.nameSpan);
+			const value = variant.values.find((v) => v.name === target.entry.value);
+			return value ? local(value.nameSpan) : local(variant.nameSpan);
+		}
+		case "conditional-key": {
+			const group = target.context === "responsive" ? "breakpoint" : "container";
+			const own = findThemeEntry(analysis.ast, group, target.key);
+			if (own) return local(own);
+			const themed = theme && findThemeEntry(theme.ast, group, target.key);
+			return themed ? inTheme(themed) : null;
+		}
+		default: return null;
+	}
+}
+function locationFor(file, index, span) {
+	const range = index.spanToRange(span);
+	return {
+		uri: (0, node_url.pathToFileURL)(file).toString(),
+		range: {
+			start: {
+				line: range.start.line - 1,
+				character: range.start.col - 1
+			},
+			end: {
+				line: range.end.line - 1,
+				character: range.end.col - 1
+			}
+		}
+	};
+}
+function findThemeEntry(ast, group, name) {
+	for (const item of ast.items) {
+		if (item.kind !== "theme") continue;
+		for (const g of item.groups) {
+			if (g.name !== group) continue;
+			for (const entry of g.entries) if (entry.name === name) return entry.nameSpan;
+		}
+	}
+	return null;
+}
+function findRecipe(ast, name) {
+	for (const item of ast.items) if (item.kind === "recipe" && item.name === name) return item.nameSpan;
+	return null;
+}
+function findKeyframes(ast, name) {
+	for (const item of ast.items) if (item.kind === "keyframes" && item.name === name) return item.nameSpan;
+	return null;
+}
+function findVariantSpans(component, name) {
+	for (const item of component.items) {
+		if (item.kind !== "variants") continue;
+		const variant = item.variants.find((v) => v.name === name);
+		if (variant) return {
+			nameSpan: variant.nameSpan,
+			values: variant.values.map((v) => ({
+				name: v.name,
+				nameSpan: v.nameSpan
+			}))
+		};
+	}
+	return null;
+}
+//#endregion
+//#region src/diagnostics.ts
+/** Maps compiler diagnostics to LSP diagnostics with full (start+end) ranges. */
+function toLspDiagnostics(analysis) {
+	return analysis.diagnostics.map((d) => {
+		const range = analysis.index.spanToRange(d.span);
+		return {
+			severity: d.severity === "error" ? 1 : 2,
+			range: {
+				start: {
+					line: range.start.line - 1,
+					character: range.start.col - 1
+				},
+				end: {
+					line: range.end.line - 1,
+					character: range.end.col - 1
+				}
+			},
+			message: d.hint ? `${d.message} (${d.hint})` : d.message,
+			source: "arvia",
+			code: d.code
+		};
+	});
+}
+//#endregion
+//#region src/documents.ts
+function fileForUri(uri) {
+	return uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri;
+}
+/** Per-document analysis cache keyed by document version. */
+var DocumentStore = class {
+	workspaceFor;
+	cache = /* @__PURE__ */ new Map();
+	constructor(workspaceFor) {
+		this.workspaceFor = workspaceFor;
+	}
+	analysisFor(doc) {
+		const cached = this.cache.get(doc.uri);
+		if (cached && cached.version === doc.version) return cached.analysis;
+		const file = fileForUri(doc.uri);
+		const source = doc.getText();
+		const analysis = {
+			...(0, _arviahq_compiler.analyze)(source, {
+				filename: file,
+				env: this.workspaceFor(doc.uri).envFor(file)
+			}),
+			index: new _arviahq_compiler.LineIndex(source),
+			file,
+			source
+		};
+		this.cache.set(doc.uri, {
+			version: doc.version,
+			analysis
+		});
+		return analysis;
+	}
+	invalidate(uri) {
+		this.cache.delete(uri);
+	}
+	invalidateAll() {
+		this.cache.clear();
+	}
+};
+//#endregion
+//#region src/inlay-hints.ts
+const MAX_HINT_LENGTH = 28;
+/** `padding: space.4` → ghost text ` = 16px` after the ref. */
+function getInlayHints(analysis, range) {
+	const startOffset = analysis.index.offsetAt({
+		line: range.start.line + 1,
+		col: range.start.character + 1
+	});
+	const endOffset = analysis.index.offsetAt({
+		line: range.end.line + 1,
+		col: range.end.character + 1
+	});
+	const hints = [];
+	for (const { decl, component } of walkDeclarations(analysis.ast)) for (const word of decl.value.words) {
+		if (word.kind !== "ref" || word.group === "keyframes") continue;
+		if (word.span.end < startOffset || word.span.start > endOffset) continue;
+		const resolved = resolveForHint(analysis, word.group, word.name, component);
+		if (!resolved || resolved === word.text) continue;
+		const position = analysis.index.positionAt(word.span.end);
+		hints.push({
+			position: {
+				line: position.line - 1,
+				character: position.col - 1
+			},
+			label: ` = ${truncate(resolved)}`,
+			kind: vscode_languageserver.InlayHintKind.Type,
+			paddingLeft: false
+		});
+	}
+	return hints;
+}
+function resolveForHint(analysis, group, name, component) {
+	if (component) {
+		const local = findLocalToken(component, group, name);
+		if (local) return local.value;
+	}
+	const entry = analysis.env.tokens[group]?.[name];
+	if (entry === void 0) return null;
+	if (typeof entry === "string") return entry;
+	const first = analysis.env.modes?.[0];
+	return (first && entry[first]) ?? Object.values(entry)[0] ?? null;
+}
+function truncate(value) {
+	return value.length > MAX_HINT_LENGTH ? `${value.slice(0, MAX_HINT_LENGTH - 1)}…` : value;
+}
+//#endregion
+//#region src/rename.ts
+const NAME_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+const TOKEN_NAME_RE = /^[A-Za-z0-9_][A-Za-z0-9_-]*$/;
+function prepareRename(analysis, offset) {
+	const resolved = identityAt(analysis, offset);
+	if (!resolved) return null;
+	return {
+		range: rangeOf(analysis, resolved.span),
+		placeholder: resolved.placeholder
+	};
+}
+function getRenameEdits(analysis, offset, newName, workspace, contentFor) {
+	const resolved = identityAt(analysis, offset);
+	if (!resolved) return null;
+	const { identity } = resolved;
+	if (!(identity.kind === "token" ? TOKEN_NAME_RE : NAME_RE).test(newName)) return null;
+	const changes = {};
+	const addEdits = (file, source, ast) => {
+		const index = new _arviahq_compiler.LineIndex(source);
+		const edits = editsInFile(ast, identity, newName);
+		if (edits.length === 0) return;
+		const uri = (0, node_url.pathToFileURL)(file).toString();
+		changes[uri] = edits.map(({ span, text }) => ({
+			range: lspRange(index, span),
+			newText: text
+		}));
+	};
+	addEdits(analysis.file, analysis.source, analysis.ast);
+	if (crossFileKinds.has(identity.kind) && isSharedThemeMember(analysis, workspace)) {
+		const themePath = node_path.default.resolve(analysis.file);
+		for (const file of listArvFiles(workspace.root)) {
+			const resolvedFile = node_path.default.resolve(file);
+			if (resolvedFile === node_path.default.resolve(analysis.file)) continue;
+			if (workspace.themePathFor(resolvedFile) !== themePath) continue;
+			const source = contentFor(resolvedFile);
+			if (source === null) continue;
+			addEdits(resolvedFile, source, (0, _arviahq_compiler.parse)(source, resolvedFile).ast);
+		}
+	}
+	return Object.keys(changes).length > 0 ? { changes } : null;
+}
+const crossFileKinds = new Set([
+	"token",
+	"recipe",
+	"keyframes"
+]);
+/** True when the current document is a theme other files can resolve to. */
+function isSharedThemeMember(analysis, workspace) {
+	return workspace.themePathFor(analysis.file) === node_path.default.resolve(analysis.file);
+}
+function identityAt(analysis, offset) {
+	const target = nodeAtOffset(analysis.ast, offset);
+	if (!target) return null;
+	switch (target.kind) {
+		case "token-ref": {
+			if (target.word.group === "keyframes") return {
+				identity: {
+					kind: "keyframes",
+					name: target.word.name
+				},
+				span: target.word.span,
+				placeholder: target.word.name
+			};
+			const local = target.component ? findLocalToken(target.component, target.word.group, target.word.name) : null;
+			return {
+				identity: {
+					kind: "token",
+					group: target.word.group,
+					name: target.word.name,
+					component: local ? target.component : null
+				},
+				span: target.word.span,
+				placeholder: target.word.name
+			};
+		}
+		case "token-entry": return {
+			identity: {
+				kind: "token",
+				group: target.group.name,
+				name: target.name,
+				component: target.owner === "component" ? target.component : null
+			},
+			span: target.span,
+			placeholder: target.name
+		};
+		case "use-recipe": return {
+			identity: {
+				kind: "recipe",
+				name: target.name
+			},
+			span: target.span,
+			placeholder: target.name
+		};
+		case "recipe-name": return {
+			identity: {
+				kind: "recipe",
+				name: target.recipe.name
+			},
+			span: target.recipe.nameSpan,
+			placeholder: target.recipe.name
+		};
+		case "keyframes-name": return {
+			identity: {
+				kind: "keyframes",
+				name: target.keyframes.name
+			},
+			span: target.keyframes.nameSpan,
+			placeholder: target.keyframes.name
+		};
+		case "variant-name": return {
+			identity: {
+				kind: "variant",
+				component: target.component,
+				name: target.variant.name
+			},
+			span: target.variant.nameSpan,
+			placeholder: target.variant.name
+		};
+		case "variant-value-name": return {
+			identity: {
+				kind: "variant-value",
+				component: target.component,
+				variant: target.variant.name,
+				name: target.value.name
+			},
+			span: target.value.nameSpan,
+			placeholder: target.value.name
+		};
+		case "variant-setting":
+			if (target.part === "variant") return {
+				identity: {
+					kind: "variant",
+					component: target.component,
+					name: target.entry.variant
+				},
+				span: target.entry.variantSpan,
+				placeholder: target.entry.variant
+			};
+			return {
+				identity: {
+					kind: "variant-value",
+					component: target.component,
+					variant: target.entry.variant,
+					name: target.entry.value
+				},
+				span: target.entry.valueSpan,
+				placeholder: target.entry.value
+			};
+		case "slot-name": return {
+			identity: {
+				kind: "slot",
+				component: target.component,
+				name: target.name
+			},
+			span: target.span,
+			placeholder: target.name
+		};
+		default: return null;
+	}
+}
+function editsInFile(ast, identity, newName) {
+	const edits = [];
+	switch (identity.kind) {
+		case "token": {
+			const scoped = identity.component;
+			for (const visit of walkTokenEntries(ast)) {
+				if (visit.group.name !== identity.group || visit.entry.name !== identity.name) continue;
+				if (scoped ? visit.component !== scoped : visit.owner !== "theme") continue;
+				edits.push({
+					span: visit.entry.nameSpan,
+					text: newName
+				});
+			}
+			for (const { decl, component } of walkDeclarations(ast)) for (const word of decl.value.words) {
+				if (word.kind !== "ref" || word.group !== identity.group || word.name !== identity.name) continue;
+				const shadowed = component ? findLocalToken(component, identity.group, identity.name) !== null : false;
+				if (scoped ? component !== scoped : shadowed) continue;
+				edits.push({
+					span: word.span,
+					text: `${identity.group}.${newName}`
+				});
+			}
+			if (!scoped) {
+				for (const visit of walkTokenEntries(ast)) for (const word of visit.entry.value.words) if (word.kind === "ref" && word.group === identity.group && word.name === identity.name) edits.push({
+					span: word.span,
+					text: `${identity.group}.${newName}`
+				});
+			}
+			break;
+		}
+		case "recipe":
+			for (const item of ast.items) if (item.kind === "recipe" && item.name === identity.name) edits.push({
+				span: item.nameSpan,
+				text: newName
+			});
+			for (const use of walkUses(ast)) if (use.recipe === identity.name) edits.push({
+				span: use.recipeSpan,
+				text: newName
+			});
+			break;
+		case "keyframes":
+			for (const item of ast.items) if (item.kind === "keyframes" && item.name === identity.name) edits.push({
+				span: item.nameSpan,
+				text: newName
+			});
+			for (const { value } of walkValues(ast)) for (const word of value.words) if (word.kind === "ref" && word.group === "keyframes" && word.name === identity.name) edits.push({
+				span: word.span,
+				text: `keyframes.${newName}`
+			});
+			break;
+		case "variant":
+		case "variant-value":
+		case "slot": {
+			const component = findComponent(ast, identity.component.name);
+			if (component) edits.push(...componentEdits(component, identity, newName));
+			break;
+		}
+	}
+	return edits;
+}
+function componentEdits(component, identity, newName) {
+	const edits = [];
+	const settingEntries = (entries) => {
+		for (const entry of entries) {
+			if (identity.kind === "variant" && entry.variant === identity.name) edits.push({
+				span: entry.variantSpan,
+				text: newName
+			});
+			if (identity.kind === "variant-value" && entry.variant === identity.variant && entry.value === identity.name) edits.push({
+				span: entry.valueSpan,
+				text: newName
+			});
+		}
+	};
+	const slotName = (name, span) => {
+		if (identity.kind === "slot" && name === identity.name) edits.push({
+			span,
+			text: newName
+		});
+	};
+	for (const item of component.items) switch (item.kind) {
+		case "slots":
+			for (const slot of item.slots) slotName(slot.name, slot.nameSpan);
+			break;
+		case "base":
+			for (const part of item.body.items) {
+				if (part.kind === "slotblock") slotName(part.name, part.nameSpan);
+				if (part.kind === "state") for (const slot of part.slots) slotName(slot.name, slot.nameSpan);
+			}
+			break;
+		case "variants":
+			for (const variant of item.variants) {
+				if (identity.kind === "variant" && variant.name === identity.name) edits.push({
+					span: variant.nameSpan,
+					text: newName
+				});
+				for (const value of variant.values) {
+					if (identity.kind === "variant-value" && variant.name === identity.variant && value.name === identity.name) edits.push({
+						span: value.nameSpan,
+						text: newName
+					});
+					for (const part of value.body.items) {
+						if (part.kind === "slotblock") slotName(part.name, part.nameSpan);
+						if (part.kind === "state") for (const slot of part.slots) slotName(slot.name, slot.nameSpan);
+					}
+				}
+			}
+			break;
+		case "defaults":
+			settingEntries(item.entries);
+			break;
+		case "responsive":
+		case "container":
+			for (const entry of item.entries) settingEntries(entry.variants);
+			break;
+		case "compound":
+			settingEntries(item.matchers);
+			for (const slot of item.slots) slotName(slot.name, slot.nameSpan);
+			break;
+	}
+	return edits;
+}
+function findComponent(ast, name) {
+	for (const item of ast.items) if (item.kind === "component" && item.name === name) return item;
+	return null;
+}
+function lspRange(index, span) {
+	const range = index.spanToRange(span);
+	return {
+		start: {
+			line: range.start.line - 1,
+			character: range.start.col - 1
+		},
+		end: {
+			line: range.end.line - 1,
+			character: range.end.col - 1
+		}
+	};
+}
+const SKIP_DIRS = new Set([
+	"node_modules",
+	"dist",
+	".git",
+	"build",
+	"coverage"
+]);
+function listArvFiles(root) {
+	const out = [];
+	const walk = (dir) => {
+		let entries;
+		try {
+			entries = node_fs.default.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) if (entry.isDirectory()) {
+			if (!SKIP_DIRS.has(entry.name)) walk(node_path.default.join(dir, entry.name));
+		} else if (entry.name.endsWith(".arv")) out.push(node_path.default.join(dir, entry.name));
+	};
+	walk(root);
+	return out;
+}
+function readFileOr(file) {
+	try {
+		return node_fs.default.readFileSync(file, "utf8");
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/symbols.ts
+function getDocumentSymbols(analysis) {
+	const symbol = (name, kind, span, nameSpan, children, detail) => {
+		const full = analysis.index.spanToRange(span);
+		const sel = analysis.index.spanToRange(nameSpan);
+		return {
+			name,
+			kind,
+			detail,
+			range: {
+				start: {
+					line: full.start.line - 1,
+					character: full.start.col - 1
+				},
+				end: {
+					line: full.end.line - 1,
+					character: full.end.col - 1
+				}
+			},
+			selectionRange: {
+				start: {
+					line: sel.start.line - 1,
+					character: sel.start.col - 1
+				},
+				end: {
+					line: sel.end.line - 1,
+					character: sel.end.col - 1
+				}
+			},
+			children
+		};
+	};
+	const out = [];
+	for (const item of analysis.ast.items) switch (item.kind) {
+		case "theme": {
+			const groups = item.groups.map((group) => symbol(group.name, vscode_languageserver.SymbolKind.Namespace, group.span, group.nameSpan, group.entries.map((entry) => symbol(entry.name, vscode_languageserver.SymbolKind.Constant, entry.span, entry.nameSpan, void 0, entry.value.text))));
+			out.push(symbol("theme", vscode_languageserver.SymbolKind.Module, item.span, item.span, groups));
+			break;
+		}
+		case "global":
+			out.push(symbol("global", vscode_languageserver.SymbolKind.Module, item.span, item.span));
+			break;
+		case "recipe":
+			out.push(symbol(item.name, vscode_languageserver.SymbolKind.Function, item.span, item.nameSpan, void 0, "recipe"));
+			break;
+		case "keyframes":
+			out.push(symbol(item.name, vscode_languageserver.SymbolKind.Event, item.span, item.nameSpan, void 0, "keyframes"));
+			break;
+		case "styledecl":
+			out.push(symbol(item.name, vscode_languageserver.SymbolKind.Constant, item.span, item.nameSpan, void 0, "style"));
+			break;
+		case "component": {
+			const children = [];
+			for (const part of item.items) {
+				if (part.kind === "slots") for (const slot of part.slots) children.push(symbol(slot.name, vscode_languageserver.SymbolKind.Field, slot.span, slot.nameSpan, void 0, "slot"));
+				if (part.kind === "variants") for (const variant of part.variants) children.push(symbol(variant.name, vscode_languageserver.SymbolKind.Enum, variant.span, variant.nameSpan, variant.values.map((value) => symbol(value.name, vscode_languageserver.SymbolKind.EnumMember, value.span, value.nameSpan)), "variant"));
+				if (part.kind === "tokens") for (const group of part.groups) children.push(symbol(group.name, vscode_languageserver.SymbolKind.Namespace, group.span, group.nameSpan, group.entries.map((entry) => symbol(entry.name, vscode_languageserver.SymbolKind.Constant, entry.span, entry.nameSpan, void 0, entry.value.text)), "local tokens"));
+			}
+			out.push(symbol(item.name, vscode_languageserver.SymbolKind.Class, item.span, item.nameSpan, children, "component"));
+			break;
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/workspace.ts
+var WorkspaceState = class {
+	root;
+	/** themePath → loaded theme (null = path unreadable). */
+	themes = /* @__PURE__ */ new Map();
+	/** directory → resolved theme path for documents in it (null = none found). */
+	themeByDir = /* @__PURE__ */ new Map();
+	constructor(root) {
+		this.root = root;
+	}
+	/**
+	* Nearest theme for a document: starting at its directory and walking up to
+	* the workspace root, check `theme.arv` then `src/theme.arv` at each level.
+	* Supports monorepos with one theme per app/package.
+	*/
+	themePathFor(file) {
+		const resolved = node_path.default.resolve(file);
+		if (node_path.default.basename(resolved) === "theme.arv") return resolved;
+		let dir = node_path.default.dirname(resolved);
+		const visited = [];
+		let result = null;
+		for (;;) {
+			const cached = this.themeByDir.get(dir);
+			if (cached !== void 0) {
+				result = cached;
+				break;
+			}
+			visited.push(dir);
+			const direct = node_path.default.join(dir, "theme.arv");
+			if (node_fs.default.existsSync(direct)) {
+				result = direct;
+				break;
+			}
+			const conventional = node_path.default.join(dir, "src", "theme.arv");
+			if (node_fs.default.existsSync(conventional)) {
+				result = conventional;
+				break;
+			}
+			const parent = node_path.default.dirname(dir);
+			if (dir === node_path.default.resolve(this.root) || parent === dir) {
+				result = null;
+				break;
+			}
+			dir = parent;
+		}
+		for (const d of visited) this.themeByDir.set(d, result);
+		return result;
+	}
+	themeFor(file) {
+		const themePath = this.themePathFor(file);
+		if (!themePath) return null;
+		let info = this.themes.get(themePath);
+		if (info === void 0) {
+			info = this.loadTheme(themePath);
+			this.themes.set(themePath, info);
+		}
+		return info;
+	}
+	/** Shared env for a document — undefined for the theme file itself. */
+	envFor(file) {
+		const theme = this.themeFor(file);
+		if (!theme || theme.path === node_path.default.resolve(file)) return void 0;
+		return theme.env;
+	}
+	loadTheme(themePath) {
+		let source;
+		try {
+			source = node_fs.default.readFileSync(themePath, "utf8");
+		} catch {
+			return null;
+		}
+		const result = (0, _arviahq_compiler.analyze)(source, { filename: themePath });
+		return {
+			path: themePath,
+			env: result.diagnostics.some((d) => d.severity === "error") ? void 0 : result.env,
+			ast: result.ast,
+			source,
+			index: new _arviahq_compiler.LineIndex(source)
+		};
+	}
+	/** Drops caches for a changed/created/deleted .arv file. */
+	invalidate(file) {
+		this.themes.delete(node_path.default.resolve(file));
+		this.themeByDir.clear();
+	}
+	invalidateAll() {
+		this.themes.clear();
+		this.themeByDir.clear();
+	}
+};
+function workspaceRootFor(file) {
+	let dir = node_path.default.dirname(file);
+	for (;;) {
+		if (node_fs.default.existsSync(node_path.default.join(dir, "package.json"))) return dir;
+		const parent = node_path.default.dirname(dir);
+		if (parent === dir) return node_path.default.dirname(file);
+		dir = parent;
+	}
+}
+//#endregion
+//#region src/server.ts
+const DIAGNOSTICS_DEBOUNCE_MS = 200;
+const connection = (0, vscode_languageserver_node_js.createConnection)();
+const documents = new vscode_languageserver_node_js.TextDocuments(vscode_languageserver_textdocument.TextDocument);
+const workspaces = /* @__PURE__ */ new Map();
+function pathToFileUri(file) {
+	return (0, node_url.pathToFileURL)(file).toString();
+}
+function workspaceFor(uri) {
+	const root = workspaceRootFor(fileForUri(uri));
+	let ws = workspaces.get(root);
+	if (!ws) {
+		ws = new WorkspaceState(root);
+		workspaces.set(root, ws);
+	}
+	return ws;
+}
+const store = new DocumentStore(workspaceFor);
+const diagnosticTimers = /* @__PURE__ */ new Map();
+function publishDiagnostics(doc) {
+	const analysis = store.analysisFor(doc);
+	connection.sendDiagnostics({
+		uri: doc.uri,
+		diagnostics: toLspDiagnostics(analysis)
+	});
+}
+function scheduleDiagnostics(doc, immediate = false) {
+	const pending = diagnosticTimers.get(doc.uri);
+	if (pending) clearTimeout(pending);
+	if (immediate) {
+		publishDiagnostics(doc);
+		return;
+	}
+	diagnosticTimers.set(doc.uri, setTimeout(() => {
+		diagnosticTimers.delete(doc.uri);
+		const current = documents.get(doc.uri);
+		if (current) publishDiagnostics(current);
+	}, DIAGNOSTICS_DEBOUNCE_MS));
+}
+connection.onInitialize((_params) => {
+	return { capabilities: {
+		textDocumentSync: vscode_languageserver_node_js.TextDocumentSyncKind.Incremental,
+		completionProvider: { triggerCharacters: [
+			":",
+			".",
+			"@",
+			" "
+		] },
+		hoverProvider: true,
+		definitionProvider: true,
+		documentSymbolProvider: true,
+		colorProvider: true,
+		inlayHintProvider: true,
+		renameProvider: { prepareProvider: true }
+	} };
+});
+documents.onDidOpen((event) => {
+	scheduleDiagnostics(event.document, true);
+});
+documents.onDidChangeContent((event) => {
+	scheduleDiagnostics(event.document);
+});
+documents.onDidSave((event) => {
+	scheduleDiagnostics(event.document, true);
+});
+documents.onDidClose((event) => {
+	const pending = diagnosticTimers.get(event.document.uri);
+	if (pending) clearTimeout(pending);
+	diagnosticTimers.delete(event.document.uri);
+	store.invalidate(event.document.uri);
+	connection.sendDiagnostics({
+		uri: event.document.uri,
+		diagnostics: []
+	});
+});
+connection.onDidChangeWatchedFiles((params) => {
+	for (const change of params.changes) {
+		const file = fileForUri(change.uri);
+		for (const ws of workspaces.values()) ws.invalidate(file);
+	}
+	store.invalidateAll();
+	for (const doc of documents.all()) scheduleDiagnostics(doc);
+});
+connection.onCompletion((params) => {
+	const doc = documents.get(params.textDocument.uri);
+	if (!doc) return [];
+	return getCompletions(store.analysisFor(doc), doc.offsetAt(params.position));
+});
+connection.onHover((params) => {
+	const doc = documents.get(params.textDocument.uri);
+	if (!doc) return null;
+	const ws = workspaceFor(params.textDocument.uri);
+	return getHover(store.analysisFor(doc), doc.offsetAt(params.position), ws);
+});
+connection.onDefinition((params) => {
+	const doc = documents.get(params.textDocument.uri);
+	if (!doc) return null;
+	const ws = workspaceFor(params.textDocument.uri);
+	return getDefinition(store.analysisFor(doc), doc.offsetAt(params.position), ws);
+});
+connection.onDocumentSymbol((params) => {
+	const doc = documents.get(params.textDocument.uri);
+	if (!doc) return [];
+	return getDocumentSymbols(store.analysisFor(doc));
+});
+connection.onDocumentColor((params) => {
+	const doc = documents.get(params.textDocument.uri);
+	if (!doc) return [];
+	return getDocumentColors(store.analysisFor(doc));
+});
+connection.onColorPresentation((params) => {
+	const doc = documents.get(params.textDocument.uri);
+	if (!doc) return [];
+	return getColorPresentations(params.color, {
+		start: doc.offsetAt(params.range.start),
+		end: doc.offsetAt(params.range.end)
+	});
+});
+connection.languages.inlayHint.on((params) => {
+	const doc = documents.get(params.textDocument.uri);
+	if (!doc) return [];
+	return getInlayHints(store.analysisFor(doc), params.range);
+});
+connection.onPrepareRename((params) => {
+	const doc = documents.get(params.textDocument.uri);
+	if (!doc) return null;
+	return prepareRename(store.analysisFor(doc), doc.offsetAt(params.position));
+});
+connection.onRenameRequest((params) => {
+	const doc = documents.get(params.textDocument.uri);
+	if (!doc) return null;
+	const ws = workspaceFor(params.textDocument.uri);
+	return getRenameEdits(store.analysisFor(doc), doc.offsetAt(params.position), params.newName, ws, (file) => {
+		const open = documents.get(pathToFileUri(file));
+		return open ? open.getText() : readFileOr(file);
+	});
+});
+documents.listen(connection);
+connection.listen();
+//#endregion
+
+//# sourceMappingURL=server.cjs.map