@aihu/language-server 0.1.0

package/dist/bin.js

@@ -0,0 +1,2119 @@
+#!/usr/bin/env node
+import { CodeActionKind, CompletionList, DiagnosticSeverity, MarkupKind, ProposedFeatures, TextDocumentSyncKind, TextDocuments, TextEdit, createConnection } from "vscode-languageserver/node.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { execFile } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+//#region ../compiler/js/codemods/macro-simplification/migrate.ts
+const INDENT = "  ";
+function migrate(source) {
+	const warnings = [];
+	const stateBlock = findBlock(source, "state");
+	const agentBlock = findBlock(source, "agent");
+	const sidecar = /* @__PURE__ */ new Map();
+	const preservedAgentLines = [];
+	if (agentBlock) parseAgent(agentBlock.body, sidecar, preservedAgentLines, warnings);
+	if (!stateBlock) return {
+		rewritten: source,
+		warnings
+	};
+	const buckets = walkState(stateBlock.body, sidecar, warnings);
+	const newStateBlock = `@state {\n${emitStateBody(buckets)}\n}`;
+	const newAgentBlock = preservedAgentLines.length > 0 ? `@agent {\n${preservedAgentLines.join("\n")}\n}` : null;
+	let out = source.slice(0, stateBlock.start) + newStateBlock + source.slice(stateBlock.end);
+	if (agentBlock) {
+		const agentRelocated = findBlock(out, "agent");
+		if (agentRelocated) if (newAgentBlock) out = out.slice(0, agentRelocated.start) + newAgentBlock + out.slice(agentRelocated.end);
+		else {
+			const dropStart = expandLeftToLineStart(out, agentRelocated.start);
+			const dropEnd = expandRightThroughBlankLines(out, agentRelocated.end);
+			out = out.slice(0, dropStart) + out.slice(dropEnd);
+		}
+	}
+	const stateNames = new Set([
+		...buckets.props.map((p) => p.name),
+		...buckets.computed.map((c) => c.name),
+		...buckets.action.map((a) => a.name),
+		...buckets.resource.map((r) => r.name),
+		...buckets.effectNamed.map((e) => e.name),
+		...buckets.plain.map((p) => p.name).filter((x) => !!x)
+	]);
+	for (const [name] of sidecar) if (!stateNames.has(name)) warnings.push(`@agent references '${name}' but no @state declaration found`);
+	return {
+		rewritten: out,
+		warnings
+	};
+}
+function findBlock(source, name) {
+	const m = new RegExp(`(^|\\n)([ \\t]*)@${name}\\s*\\{`, "g").exec(source);
+	if (!m) return null;
+	const startMatch = m.index + (m[1] === "\n" ? 1 : 0);
+	const openIdx = m.index + m[0].length - 1;
+	const closeIdx = matchBrace(source, openIdx);
+	if (closeIdx < 0) return null;
+	return {
+		start: startMatch,
+		end: closeIdx + 1,
+		bodyStart: openIdx + 1,
+		bodyEnd: closeIdx,
+		body: source.slice(openIdx + 1, closeIdx)
+	};
+}
+function matchBrace(s, i) {
+	if (s[i] !== "{") return -1;
+	let depth = 0;
+	let j = i;
+	while (j < s.length) {
+		const c = s[j];
+		if (c === "/" && s[j + 1] === "/") {
+			const nl = s.indexOf("\n", j);
+			j = nl < 0 ? s.length : nl;
+			continue;
+		}
+		if (c === "/" && s[j + 1] === "*") {
+			const end = s.indexOf("*/", j + 2);
+			j = end < 0 ? s.length : end + 2;
+			continue;
+		}
+		if (c === "\"" || c === "'" || c === "`") {
+			j = skipString(s, j);
+			continue;
+		}
+		if (c === "{") depth++;
+		else if (c === "}") {
+			depth--;
+			if (depth === 0) return j;
+		}
+		j++;
+	}
+	return -1;
+}
+function skipString(s, i) {
+	const quote = s[i];
+	let j = i + 1;
+	while (j < s.length) {
+		const c = s[j];
+		if (c === "\\") {
+			j += 2;
+			continue;
+		}
+		if (quote === "`" && c === "$" && s[j + 1] === "{") {
+			const close = matchBrace(s, j + 1);
+			j = close < 0 ? s.length : close + 1;
+			continue;
+		}
+		if (c === quote) return j + 1;
+		j++;
+	}
+	return s.length;
+}
+function matchParen(s, i) {
+	if (s[i] !== "(") return -1;
+	let depth = 0;
+	let j = i;
+	while (j < s.length) {
+		const c = s[j];
+		if (c === "/" && s[j + 1] === "/") {
+			const nl = s.indexOf("\n", j);
+			j = nl < 0 ? s.length : nl;
+			continue;
+		}
+		if (c === "/" && s[j + 1] === "*") {
+			const end = s.indexOf("*/", j + 2);
+			j = end < 0 ? s.length : end + 2;
+			continue;
+		}
+		if (c === "\"" || c === "'" || c === "`") {
+			j = skipString(s, j);
+			continue;
+		}
+		if (c === "{") {
+			const close = matchBrace(s, j);
+			j = close < 0 ? s.length : close + 1;
+			continue;
+		}
+		if (c === "(") depth++;
+		else if (c === ")") {
+			depth--;
+			if (depth === 0) return j;
+		}
+		j++;
+	}
+	return -1;
+}
+function parseAgent(body, sidecar, preservedAgentLines, _warnings) {
+	const upsert = (name, patch) => {
+		sidecar.set(name, {
+			...sidecar.get(name) ?? {},
+			...patch
+		});
+	};
+	for (const rawLine of body.split("\n")) {
+		const line = rawLine.trim();
+		if (line === "" || line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) continue;
+		if (line.startsWith("$expose.write ")) {
+			const names = parseNameList(line.slice(14));
+			for (const n of names) upsert(n, {
+				exposeRead: true,
+				exposeWrite: true
+			});
+			continue;
+		}
+		if (line.startsWith("$expose ")) {
+			const names = parseNameList(line.slice(8));
+			for (const n of names) upsert(n, { exposeRead: true });
+			continue;
+		}
+		if (line.startsWith("$action ")) {
+			const rest = line.slice(8).trim();
+			const m = /^([A-Za-z_$][\w$]*)/.exec(rest);
+			if (m) upsert(m[1], {
+				isAction: true,
+				exposeRead: true,
+				exposeWrite: true
+			});
+			continue;
+		}
+		if (line.startsWith("$describe ")) {
+			const rest = line.slice(10).trim();
+			const nameMatch = /^([A-Za-z_$][\w$]*)\s+(["'])([\s\S]*)\2\s*$/.exec(rest);
+			if (nameMatch) upsert(nameMatch[1], { describe: nameMatch[3] });
+			continue;
+		}
+		if (line.startsWith("$scope ")) {
+			preservedAgentLines.push(`  ${line}`);
+			continue;
+		}
+		if (line.startsWith("$rate-limit ")) preservedAgentLines.push(`  ${line}`);
+	}
+}
+function parseNameList(s) {
+	return s.split(",").map((x) => x.trim()).filter((x) => /^[A-Za-z_$][\w$]*$/.test(x));
+}
+function walkState(body, sidecar, warnings) {
+	const buckets = {
+		props: [],
+		computed: [],
+		action: [],
+		resource: [],
+		effectNamed: [],
+		effectAnon: [],
+		lifecycle: [],
+		plain: [],
+		passthrough: []
+	};
+	let i = 0;
+	while (i < body.length && (body[i] === "\n" || body[i] === "\r")) i++;
+	let leadingBuf = "";
+	let position = 0;
+	const consumeWS = () => {
+		while (i < body.length) {
+			const lineEnd = body.indexOf("\n", i);
+			const end = lineEnd < 0 ? body.length : lineEnd;
+			const line = body.slice(i, end);
+			const trimmed = line.trim();
+			if (trimmed === "") {
+				leadingBuf += `${line}\n`;
+				i = end + 1;
+				continue;
+			}
+			if (trimmed.startsWith("//")) {
+				leadingBuf += `${line}\n`;
+				i = end + 1;
+				continue;
+			}
+			if (trimmed.startsWith("/*")) {
+				const close = body.indexOf("*/", i);
+				if (close < 0) {
+					leadingBuf += body.slice(i);
+					i = body.length;
+					return;
+				}
+				const commentEnd = body.indexOf("\n", close);
+				const realEnd = commentEnd < 0 ? body.length : commentEnd + 1;
+				leadingBuf += body.slice(i, realEnd);
+				i = realEnd;
+				continue;
+			}
+			return;
+		}
+	};
+	while (i < body.length) {
+		consumeWS();
+		if (i >= body.length) break;
+		const lineStart = i;
+		const lineEnd = body.indexOf("\n", i);
+		const lineEndIdx = lineEnd < 0 ? body.length : lineEnd;
+		const lineText = body.slice(lineStart, lineEndIdx);
+		const trimmed = lineText.trim();
+		const leading = leadingBuf;
+		leadingBuf = "";
+		const trimStart = lineStart + (lineText.length - lineText.trimStart().length);
+		if (trimmed.startsWith("import ")) {
+			buckets.passthrough.push({
+				raw: lineText.trim(),
+				leading,
+				position: position++
+			});
+			i = lineEndIdx + 1;
+			continue;
+		}
+		{
+			const v2 = tryParseV2Collection(body, trimStart, sidecar, buckets, leading, () => position++);
+			if (v2 !== null) {
+				i = v2;
+				continue;
+			}
+		}
+		if (/^\$effect\s*:\s*(?:\(|async\b)/.test(trimmed)) {
+			const handled = tryParseV2AnonEffect(body, trimStart, buckets, leading, position++);
+			if (handled !== null) {
+				i = handled;
+				continue;
+			}
+		}
+		if (trimmed.startsWith("$prop ")) {
+			const handled = handleProp(body, trimStart, sidecar, buckets, leading);
+			if (handled !== null) {
+				i = handled;
+				continue;
+			}
+			buckets.passthrough.push({
+				raw: trimmed,
+				leading,
+				position: position++
+			});
+			i = lineEndIdx + 1;
+			continue;
+		}
+		if (trimmed.startsWith("$computed ")) {
+			const handled = handleComputed(body, trimStart, sidecar, buckets, leading);
+			if (handled !== null) {
+				i = handled;
+				continue;
+			}
+			buckets.passthrough.push({
+				raw: trimmed,
+				leading,
+				position: position++
+			});
+			i = lineEndIdx + 1;
+			continue;
+		}
+		if (trimmed.startsWith("$resource ")) {
+			const handled = handleResource(body, trimStart, sidecar, buckets, leading);
+			if (handled !== null) {
+				i = handled;
+				continue;
+			}
+			buckets.passthrough.push({
+				raw: trimmed,
+				leading,
+				position: position++
+			});
+			i = lineEndIdx + 1;
+			continue;
+		}
+		if (trimmed.startsWith("$action ")) {
+			const handled = handleAction(body, trimStart, sidecar, buckets, leading);
+			if (handled !== null) {
+				i = handled;
+				continue;
+			}
+			buckets.passthrough.push({
+				raw: trimmed,
+				leading,
+				position: position++
+			});
+			i = lineEndIdx + 1;
+			continue;
+		}
+		if (trimmed.startsWith("$lifecycle.mount(") || trimmed.startsWith("$lifecycle.dispose(")) {
+			const handled = handleLifecycle(body, trimStart, buckets, leading, position++);
+			if (handled !== null) {
+				i = handled;
+				continue;
+			}
+			buckets.passthrough.push({
+				raw: trimmed,
+				leading,
+				position: position++
+			});
+			i = lineEndIdx + 1;
+			continue;
+		}
+		if (trimmed.startsWith("$effect(")) {
+			const handled = handleEffectAnon(body, trimStart, buckets, leading, position++, warnings);
+			if (handled !== null) {
+				i = handled;
+				continue;
+			}
+			buckets.passthrough.push({
+				raw: trimmed,
+				leading,
+				position: position++
+			});
+			i = lineEndIdx + 1;
+			continue;
+		}
+		if (trimmed.startsWith("$effect.on(")) {
+			const handled = consumePassthroughCall(body, trimStart);
+			buckets.passthrough.push({
+				raw: body.slice(trimStart, handled).trim(),
+				leading,
+				position: position++
+			});
+			i = handled;
+			continue;
+		}
+		if (/^\$[A-Za-z_][\w.$]*\s*\(/.test(trimmed)) {
+			const handled = consumePassthroughCall(body, trimStart);
+			buckets.passthrough.push({
+				raw: body.slice(trimStart, handled).trimEnd(),
+				leading,
+				position: position++
+			});
+			i = handled;
+			continue;
+		}
+		if (/^\$[A-Za-z_][\w.$-]*\s+[A-Za-z_$]/.test(trimmed)) {
+			buckets.passthrough.push({
+				raw: trimmed,
+				leading,
+				position: position++
+			});
+			i = lineEndIdx + 1;
+			continue;
+		}
+		const plain = tryParsePlainDecl(body, trimStart);
+		if (plain !== null) {
+			const sc = plain.name ? sidecar.get(plain.name) : void 0;
+			if (sc) buckets.props.push({
+				name: plain.name,
+				rawType: plain.rawType,
+				rawDefault: plain.rawDefault,
+				describe: sc.describe,
+				expose: sidecarToExpose(sc),
+				leading
+			});
+			else buckets.plain.push({
+				raw: plain.raw,
+				leading,
+				name: plain.name,
+				rawType: plain.rawType,
+				rawDefault: plain.rawDefault
+			});
+			i = plain.endIdx;
+			continue;
+		}
+		buckets.passthrough.push({
+			raw: trimmed,
+			leading,
+			position: position++
+		});
+		i = lineEndIdx + 1;
+	}
+	return buckets;
+}
+function sidecarToExpose(sc) {
+	if (!sc.exposeRead && !sc.exposeWrite && !sc.isAction) return void 0;
+	return {
+		read: !!sc.exposeRead,
+		write: !!sc.exposeWrite
+	};
+}
+function handleProp(body, start, sidecar, buckets, leading) {
+	const after = start + 6;
+	const nameMatch = /^\s*([A-Za-z_$][\w$]*)\s*:/.exec(body.slice(after));
+	if (!nameMatch) return null;
+	const name = nameMatch[1];
+	let cursor = after + nameMatch[0].length;
+	const typeStart = cursor;
+	const typeEnd = scanUntilTopLevel(body, cursor, [
+		"=",
+		"\n",
+		";"
+	]);
+	const rawType = body.slice(typeStart, typeEnd).trim();
+	cursor = typeEnd;
+	let rawDefault;
+	if (body[cursor] === "=") {
+		cursor++;
+		const defStart = cursor;
+		const defEnd = scanUntilTopLevel(body, cursor, ["\n", ";"]);
+		rawDefault = body.slice(defStart, defEnd).trim();
+		cursor = defEnd;
+	}
+	if (body[cursor] === ";" || body[cursor] === "\n") cursor++;
+	const sc = sidecar.get(name);
+	buckets.props.push({
+		name,
+		rawType: flattenWhitespace(rawType),
+		rawDefault: rawDefault !== void 0 ? flattenWhitespace(rawDefault) : void 0,
+		describe: sc?.describe,
+		expose: sc ? sidecarToExpose(sc) : void 0,
+		leading
+	});
+	return cursor;
+}
+function handleComputed(body, start, sidecar, buckets, leading) {
+	const after = start + 10;
+	const nameMatch = /^\s*([A-Za-z_$][\w$]*)\s*=/.exec(body.slice(after));
+	if (!nameMatch) return null;
+	const name = nameMatch[1];
+	let cursor = after + nameMatch[0].length;
+	const exprStart = cursor;
+	const exprEnd = scanComputedOrResourceExpr(body, cursor);
+	const expr = body.slice(exprStart, exprEnd).trim();
+	cursor = exprEnd;
+	const sc = sidecar.get(name);
+	buckets.computed.push({
+		name,
+		expr,
+		describe: sc?.describe,
+		expose: sc ? sidecarToExpose(sc) : void 0,
+		leading
+	});
+	return cursor;
+}
+function handleResource(body, start, sidecar, buckets, leading) {
+	const after = start + 10;
+	const nameMatch = /^\s*([A-Za-z_$][\w$]*)\s*=/.exec(body.slice(after));
+	if (!nameMatch) return null;
+	const name = nameMatch[1];
+	let cursor = after + nameMatch[0].length;
+	const exprStart = cursor;
+	const exprEnd = scanComputedOrResourceExpr(body, cursor);
+	const expr = body.slice(exprStart, exprEnd).trim();
+	cursor = exprEnd;
+	const sc = sidecar.get(name);
+	buckets.resource.push({
+		name,
+		expr,
+		describe: sc?.describe,
+		expose: sc ? sidecarToExpose(sc) : void 0,
+		leading
+	});
+	return cursor;
+}
+function handleAction(body, start, sidecar, buckets, leading) {
+	const after = start + 8;
+	const nameMatch = /^\s*([A-Za-z_$][\w$]*)\s*\(/.exec(body.slice(after));
+	if (!nameMatch) return null;
+	const name = nameMatch[1];
+	const parenIdx = after + nameMatch[0].length - 1;
+	const parenClose = matchParen(body, parenIdx);
+	if (parenClose < 0) return null;
+	const args = body.slice(parenIdx + 1, parenClose).trim();
+	let cursor = parenClose + 1;
+	let retType;
+	const retStart = cursor;
+	while (cursor < body.length && body[cursor] !== "{") {
+		if (body[cursor] === "\n") break;
+		cursor++;
+	}
+	const between = body.slice(retStart, cursor).trim();
+	if (between.startsWith(":")) retType = between.slice(1).trim();
+	if (body[cursor] !== "{") return null;
+	const braceClose = matchBrace(body, cursor);
+	if (braceClose < 0) return null;
+	const bodySrc = body.slice(cursor + 1, braceClose);
+	cursor = braceClose + 1;
+	const sc = sidecar.get(name);
+	buckets.action.push({
+		name,
+		args,
+		retType,
+		body: bodySrc,
+		describe: sc?.describe,
+		expose: sc ? sidecarToExpose(sc) : void 0,
+		leading
+	});
+	return cursor;
+}
+function handleLifecycle(body, start, buckets, leading, position) {
+	const kind = body.slice(start).trim().startsWith("$lifecycle.mount(") ? "mount" : "dispose";
+	const parenIdx = body.indexOf("(", start);
+	if (parenIdx < 0) return null;
+	const parenClose = matchParen(body, parenIdx);
+	if (parenClose < 0) return null;
+	const cb = body.slice(parenIdx + 1, parenClose).trim();
+	const fn = parseArrowOrFunctionExpr(cb);
+	buckets.lifecycle.push({
+		kind,
+		body: fn ? fn.body : cb,
+		leading,
+		position
+	});
+	let cursor = parenClose + 1;
+	if (body[cursor] === ";" || body[cursor] === "\n") cursor++;
+	return cursor;
+}
+function handleEffectAnon(body, start, buckets, leading, position, _warnings) {
+	const parenIdx = body.indexOf("(", start);
+	if (parenIdx < 0) return null;
+	const parenClose = matchParen(body, parenIdx);
+	if (parenClose < 0) return null;
+	const cb = body.slice(parenIdx + 1, parenClose).trim();
+	const fn = parseArrowOrFunctionExpr(cb);
+	buckets.effectAnon.push({
+		body: fn ? fn.body : cb,
+		leading,
+		position
+	});
+	let cursor = parenClose + 1;
+	if (body[cursor] === ";" || body[cursor] === "\n") cursor++;
+	return cursor;
+}
+function consumePassthroughCall(body, start) {
+	const parenIdx = body.indexOf("(", start);
+	if (parenIdx < 0) {
+		const nl = body.indexOf("\n", start);
+		return nl < 0 ? body.length : nl + 1;
+	}
+	const close = matchParen(body, parenIdx);
+	if (close < 0) {
+		const nl = body.indexOf("\n", start);
+		return nl < 0 ? body.length : nl + 1;
+	}
+	let cursor = close + 1;
+	if (body[cursor] === ";" || body[cursor] === "\n") cursor++;
+	return cursor;
+}
+function tryParsePlainDecl(body, start) {
+	const m = /^([ \t]*)([A-Za-z_$][\w$]*)\s*:/.exec(body.slice(start));
+	if (!m) return null;
+	const name = m[2];
+	let cursor = start + m[0].length;
+	const typeStart = cursor;
+	const typeEnd = scanUntilTopLevel(body, cursor, [
+		"=",
+		"\n",
+		";"
+	]);
+	const rawType = body.slice(typeStart, typeEnd).trim();
+	cursor = typeEnd;
+	let rawDefault;
+	if (body[cursor] === "=") {
+		cursor++;
+		const defStart = cursor;
+		const defEnd = scanUntilTopLevel(body, cursor, ["\n", ";"]);
+		rawDefault = body.slice(defStart, defEnd).trim();
+		cursor = defEnd;
+	}
+	if (body[cursor] === ";") cursor++;
+	if (body[cursor] === "\n") cursor++;
+	return {
+		name,
+		rawType,
+		rawDefault,
+		raw: body.slice(start, cursor).replace(/\n+$/, ""),
+		endIdx: cursor
+	};
+}
+function parseArrowOrFunctionExpr(s) {
+	s = s.trim();
+	if (s.startsWith("(")) {
+		const closeIdx = matchParen(s, 0);
+		if (closeIdx < 0) return null;
+		const args = s.slice(1, closeIdx);
+		let cur = closeIdx + 1;
+		while (cur < s.length && /\s/.test(s[cur])) cur++;
+		let retType;
+		if (s[cur] === ":") {
+			cur++;
+			const arrowAt = s.indexOf("=>", cur);
+			if (arrowAt < 0) return null;
+			retType = s.slice(cur, arrowAt).trim();
+			cur = arrowAt;
+		}
+		if (s.slice(cur, cur + 2) !== "=>") return null;
+		cur += 2;
+		while (cur < s.length && /\s/.test(s[cur])) cur++;
+		if (s[cur] === "{") {
+			const close = matchBrace(s, cur);
+			if (close < 0) return null;
+			return {
+				args,
+				body: s.slice(cur + 1, close),
+				retType,
+				isArrow: true
+			};
+		}
+		return {
+			args,
+			body: ` return ${s.slice(cur).trim()} `,
+			retType,
+			isArrow: true
+		};
+	}
+	const fnMatch = /^function\s*(?:[A-Za-z_$][\w$]*)?\s*\(/.exec(s);
+	if (fnMatch) {
+		const parenIdx = fnMatch[0].length - 1;
+		const parenClose = matchParen(s, parenIdx);
+		if (parenClose < 0) return null;
+		const args = s.slice(parenIdx + 1, parenClose);
+		let cur = parenClose + 1;
+		while (cur < s.length && /\s/.test(s[cur])) cur++;
+		let retType;
+		if (s[cur] === ":") {
+			cur++;
+			const braceAt = s.indexOf("{", cur);
+			if (braceAt < 0) return null;
+			retType = s.slice(cur, braceAt).trim();
+			cur = braceAt;
+		}
+		if (s[cur] !== "{") return null;
+		const close = matchBrace(s, cur);
+		if (close < 0) return null;
+		return {
+			args,
+			body: s.slice(cur + 1, close),
+			retType,
+			isArrow: false
+		};
+	}
+	return null;
+}
+function scanUntilTopLevel(s, start, stops) {
+	let j = start;
+	while (j < s.length) {
+		const c = s[j];
+		if (c === "/" && s[j + 1] === "/") {
+			const nl = s.indexOf("\n", j);
+			if (stops.includes("\n")) return nl < 0 ? s.length : nl;
+			j = nl < 0 ? s.length : nl + 1;
+			continue;
+		}
+		if (c === "/" && s[j + 1] === "*") {
+			const end = s.indexOf("*/", j + 2);
+			j = end < 0 ? s.length : end + 2;
+			continue;
+		}
+		if (c === "\"" || c === "'" || c === "`") {
+			j = skipString(s, j);
+			continue;
+		}
+		if (c === "{") {
+			const close = matchBrace(s, j);
+			j = close < 0 ? s.length : close + 1;
+			continue;
+		}
+		if (c === "(") {
+			const close = matchParen(s, j);
+			j = close < 0 ? s.length : close + 1;
+			continue;
+		}
+		if (c === "<") {
+			const close = scanGeneric(s, j);
+			if (close > j) {
+				j = close;
+				continue;
+			}
+		}
+		if (stops.includes(c)) return j;
+		j++;
+	}
+	return s.length;
+}
+function scanGeneric(s, start) {
+	if (s[start] !== "<") return start;
+	let depth = 0;
+	let j = start;
+	while (j < s.length) {
+		const c = s[j];
+		if (c === "<") depth++;
+		else if (c === ">") {
+			depth--;
+			if (depth === 0) return j + 1;
+		} else if (c === "\n") return start;
+		else if (c === "(" || c === "{") return start;
+		else if (c === "=" || c === ";") return start;
+		j++;
+	}
+	return start;
+}
+function scanComputedOrResourceExpr(body, start) {
+	const startLineIndent = countIndent(body, body.lastIndexOf("\n", start - 1) + 1);
+	let j = start;
+	const lineEnd = body.indexOf("\n", j);
+	if (lineEnd < 0) return body.length;
+	j = lineEnd + 1;
+	while (j < body.length) {
+		const nextLineEnd = body.indexOf("\n", j);
+		const lineEndIdx = nextLineEnd < 0 ? body.length : nextLineEnd;
+		const trimmed = body.slice(j, lineEndIdx).trim();
+		if (trimmed === "") return j;
+		const indent = countIndent(body, j);
+		if (indent > startLineIndent || indent === startLineIndent && /^[?:&|+\-*/<>=,.[\](){}]/.test(trimmed) && !trimmed.startsWith("//")) {
+			j = nextLineEnd < 0 ? body.length : nextLineEnd + 1;
+			continue;
+		}
+		return j;
+	}
+	return j;
+}
+function countIndent(body, lineStart) {
+	let n = 0;
+	while (lineStart + n < body.length) {
+		const c = body[lineStart + n];
+		if (c === " " || c === "	") n++;
+		else break;
+	}
+	return n;
+}
+function emitStateBody(buckets) {
+	const out = [];
+	const imports = buckets.passthrough.filter((p) => p.raw.startsWith("import "));
+	const otherPassthrough = buckets.passthrough.filter((p) => !p.raw.startsWith("import "));
+	for (const imp of imports) {
+		if (imp.leading.trim()) out.push(rstrip(imp.leading));
+		out.push(`${INDENT}${imp.raw}`);
+	}
+	if (imports.length > 0) out.push("");
+	if (buckets.props.length > 0) pushBlock(out, emitProps(buckets.props));
+	for (const p of buckets.plain) {
+		if (p.leading.trim()) out.push(rstrip(p.leading));
+		out.push(rebaseLeadingIndent(p.raw, INDENT));
+		out.push("");
+	}
+	trimTrailingBlanks(out);
+	if (buckets.computed.length > 0) pushBlock(out, emitComputed(buckets.computed));
+	if (buckets.action.length > 0) pushBlock(out, emitAction(buckets.action));
+	if (buckets.resource.length > 0) pushBlock(out, emitResource(buckets.resource));
+	if (buckets.effectNamed.length > 0) pushBlock(out, emitEffectNamed(buckets.effectNamed));
+	if (buckets.lifecycle.length > 0) pushBlock(out, emitLifecycle(buckets.lifecycle));
+	if (buckets.effectAnon.length > 0) pushBlock(out, emitEffectAnon(buckets.effectAnon));
+	for (const p of otherPassthrough) {
+		if (p.leading.trim()) out.push(rstrip(p.leading));
+		if (p.raw.includes("\n")) out.push(rebaseLeadingIndent(p.raw, INDENT));
+		else out.push(`${INDENT}${p.raw}`);
+		out.push("");
+	}
+	trimTrailingBlanks(out);
+	return out.join("\n");
+}
+function pushBlock(out, block) {
+	if (out.length > 0 && out[out.length - 1] !== "") out.push("");
+	out.push(block);
+	out.push("");
+}
+function trimTrailingBlanks(out) {
+	while (out.length > 0 && out[out.length - 1] === "") out.pop();
+}
+function emitProps(entries) {
+	const lines = [];
+	const firstLeading = entries[0]?.leading;
+	const headerLeading = firstLeading?.trim() ? firstLeading : "";
+	const inner = [];
+	for (const [idx, e] of entries.entries()) {
+		if (idx > 0 && e.leading.trim()) inner.push(rstrip(indentBlock(e.leading, `${INDENT}${INDENT}`)));
+		inner.push(formatPropEntry(e));
+	}
+	if (headerLeading) lines.push(rstrip(headerLeading));
+	lines.push(`${INDENT}$prop: {`);
+	lines.push(...inner);
+	lines.push(`${INDENT}}`);
+	return lines.join("\n");
+}
+function formatPropEntry(e) {
+	const keys = [];
+	if (shouldKeepType(e.rawType, e.rawDefault) && e.rawType) keys.push({
+		k: "type",
+		v: e.rawType
+	});
+	if (e.rawDefault !== void 0) keys.push({
+		k: "default",
+		v: e.rawDefault
+	});
+	if (e.describe) keys.push({
+		k: "describe",
+		v: quoteSingle(e.describe)
+	});
+	if (e.expose) keys.push({
+		k: "expose",
+		v: formatExpose(e.expose)
+	});
+	const inline = `${e.name}: { ${keys.map(({ k, v }) => `${k}: ${v}`).join(", ")} }`;
+	const baseIndent = 4;
+	const linePrefix = " ".repeat(baseIndent);
+	if (keys.length <= 3 && baseIndent + inline.length + 1 <= 100) return `${linePrefix}${inline},`;
+	const lines = [`${linePrefix}${e.name}: {`];
+	const inner = " ".repeat(baseIndent + 2);
+	for (const { k, v } of keys) lines.push(`${inner}${k}: ${v},`);
+	lines.push(`${linePrefix}},`);
+	return lines.join("\n");
+}
+function shouldKeepType(rawType, rawDefault) {
+	if (!rawType) return false;
+	if (rawDefault === void 0) return true;
+	const trimmed = rawDefault.trim();
+	if (trimmed === "null" || trimmed === "undefined") return true;
+	if (trimmed === "[]") return true;
+	if (trimmed === "{}") return true;
+	if (/^['"`]/.test(trimmed) && rawType.includes("|")) return true;
+	if (/[<>{}]/.test(rawType)) {
+		if (/^[0-9.+-]/.test(trimmed) || trimmed === "true" || trimmed === "false") return true;
+		if (/^['"`]/.test(trimmed)) return true;
+		return true;
+	}
+	return false;
+}
+function emitComputed(entries) {
+	return emitValueCollection("$computed", entries);
+}
+function emitResource(entries) {
+	return emitValueCollection("$resource", entries);
+}
+function emitEffectNamed(entries) {
+	return emitValueCollection("$effect", entries);
+}
+function emitValueCollection(macro, entries) {
+	const firstLeading = entries[0]?.leading;
+	const headerLeading = firstLeading?.trim() ? firstLeading : "";
+	const inner = [];
+	for (const [idx, e] of entries.entries()) {
+		if (idx > 0 && e.leading.trim()) inner.push(rstrip(indentBlock(e.leading, `${INDENT}${INDENT}`)));
+		inner.push(formatValueEntry(e));
+	}
+	const lines = [];
+	if (headerLeading) lines.push(rstrip(headerLeading));
+	lines.push(`${INDENT}${macro}: {`);
+	lines.push(...inner);
+	lines.push(`${INDENT}}`);
+	return lines.join("\n");
+}
+function formatValueEntry(e) {
+	const baseIndent = 4;
+	const linePrefix = " ".repeat(baseIndent);
+	if (!e.describe && !e.expose) {
+		if (!e.expr.includes("\n")) {
+			const inline = `${linePrefix}${e.name}: () => ${e.expr},`;
+			if (inline.length <= 100) return inline;
+		}
+		const indented = reindentExpr(e.expr, baseIndent + 2);
+		return `${linePrefix}${e.name}: () => ${indented},`;
+	}
+	const keys = [];
+	if (e.describe) keys.push({
+		k: "describe",
+		v: quoteSingle(e.describe)
+	});
+	if (e.expose) keys.push({
+		k: "expose",
+		v: formatExpose(e.expose)
+	});
+	const valueExpr = e.expr.includes("\n") ? `() => ${reindentExpr(e.expr, baseIndent + 4)}` : `() => ${e.expr}`;
+	keys.push({
+		k: "value",
+		v: valueExpr
+	});
+	const lines = [`${linePrefix}${e.name}: {`];
+	const inner = " ".repeat(baseIndent + 2);
+	for (const { k, v } of keys) lines.push(`${inner}${k}: ${v},`);
+	lines.push(`${linePrefix}},`);
+	return lines.join("\n");
+}
+function emitAction(entries) {
+	const firstLeading = entries[0]?.leading;
+	const headerLeading = firstLeading?.trim() ? firstLeading : "";
+	const inner = [];
+	for (const [idx, e] of entries.entries()) {
+		if (idx > 0 && e.leading.trim()) inner.push(rstrip(indentBlock(e.leading, `${INDENT}${INDENT}`)));
+		inner.push(formatActionEntry(e));
+	}
+	const lines = [];
+	if (headerLeading) lines.push(rstrip(headerLeading));
+	lines.push(`${INDENT}$action: {`);
+	lines.push(...inner);
+	lines.push(`${INDENT}}`);
+	return lines.join("\n");
+}
+function formatActionEntry(e) {
+	const ret = e.retType ? `: ${e.retType}` : "";
+	const arrow = `(${e.args})${ret} => `;
+	const baseIndent = 4;
+	const linePrefix = " ".repeat(baseIndent);
+	if (e.describe || e.expose) {
+		const keys = [];
+		if (e.describe) keys.push({
+			k: "describe",
+			v: quoteSingle(e.describe)
+		});
+		if (e.expose) keys.push({
+			k: "expose",
+			v: formatExpose(e.expose)
+		});
+		const bodyIndented = reindentBlockBody(e.body, baseIndent + 4);
+		keys.push({
+			k: "handler",
+			v: `${arrow}{${bodyIndented}}`
+		});
+		const lines = [`${linePrefix}${e.name}: {`];
+		const inner = " ".repeat(baseIndent + 2);
+		for (const { k, v } of keys) lines.push(`${inner}${k}: ${v},`);
+		lines.push(`${linePrefix}},`);
+		return lines.join("\n");
+	}
+	const bodyIndented = reindentBlockBody(e.body, baseIndent + 2);
+	return `${linePrefix}${e.name}: ${arrow}{${bodyIndented}},`;
+}
+function emitLifecycle(hooks) {
+	const firstLeading = hooks[0]?.leading;
+	const headerLeading = firstLeading?.trim() ? firstLeading : "";
+	const inner = [];
+	const baseIndent = 4;
+	const linePrefix = " ".repeat(baseIndent);
+	for (const [idx, h] of hooks.entries()) {
+		if (idx > 0 && h.leading.trim()) inner.push(rstrip(indentBlock(h.leading, linePrefix)));
+		const bodyIndented = reindentBlockBody(h.body, baseIndent + 2);
+		inner.push(`${linePrefix}${h.kind}: () => {${bodyIndented}},`);
+	}
+	const lines = [];
+	if (headerLeading) lines.push(rstrip(headerLeading));
+	lines.push(`${INDENT}$lifecycle: {`);
+	lines.push(...inner);
+	lines.push(`${INDENT}}`);
+	return lines.join("\n");
+}
+function emitEffectAnon(effects) {
+	const out = [];
+	const baseIndent = 2;
+	const linePrefix = " ".repeat(baseIndent);
+	for (const [idx, e] of effects.entries()) {
+		if (idx > 0) out.push("");
+		if (e.leading.trim()) out.push(rstrip(e.leading));
+		const bodyIndented = reindentBlockBody(e.body, baseIndent + 2);
+		out.push(`${linePrefix}$effect: () => {${bodyIndented}}`);
+	}
+	return out.join("\n");
+}
+function formatExpose(e) {
+	const parts = [];
+	if (e.read) parts.push("read: true");
+	if (e.write) parts.push("write: true");
+	return `{ ${parts.join(", ")} }`;
+}
+function quoteSingle(s) {
+	return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function rstrip(s) {
+	return s.replace(/[ \t]+(\n|$)/g, "$1").replace(/^\n+/, "").replace(/\n+$/g, "");
+}
+function rebaseLeadingIndent(s, indent) {
+	const lines = s.split("\n");
+	const first = lines[0] ?? "";
+	let n = 0;
+	while (n < first.length && (first[n] === " " || first[n] === "	")) n++;
+	if (n === 0) return [indent + first, ...lines.slice(1)].join("\n");
+	return lines.map((line) => {
+		if (line.length === 0) return line;
+		let m = 0;
+		while (m < line.length && m < n && (line[m] === " " || line[m] === "	")) m++;
+		return indent + line.slice(m);
+	}).join("\n");
+}
+function indentBlock(s, indent) {
+	return s.split("\n").map((line) => line.length > 0 ? indent + line : line).join("\n");
+}
+function flattenWhitespace(s) {
+	return s.replace(/\s+/g, " ").trim();
+}
+function reindentBlockBody(bodyText, targetInner) {
+	const lines = bodyText.split("\n");
+	let firstReal = 0;
+	while (firstReal < lines.length && lines[firstReal].trim() === "") firstReal++;
+	let lastReal = lines.length - 1;
+	while (lastReal >= 0 && lines[lastReal].trim() === "") lastReal--;
+	if (firstReal > lastReal) return "";
+	let minIndent = Infinity;
+	for (let k = firstReal; k <= lastReal; k++) {
+		const line = lines[k];
+		if (line.trim() === "") continue;
+		let n = 0;
+		while (n < line.length && (line[n] === " " || line[n] === "	")) n++;
+		if (n < minIndent) minIndent = n;
+	}
+	if (!Number.isFinite(minIndent)) minIndent = 0;
+	const rebased = [""];
+	const targetSpaces = " ".repeat(targetInner);
+	for (let k = firstReal; k <= lastReal; k++) {
+		const line = lines[k];
+		if (line.trim() === "") {
+			rebased.push("");
+			continue;
+		}
+		rebased.push((targetSpaces + line.slice(minIndent)).replace(/[ \t]+$/, ""));
+	}
+	rebased.push(" ".repeat(Math.max(targetInner - 2, 0)));
+	return rebased.join("\n");
+}
+function reindentExpr(expr, targetInner) {
+	const lines = expr.split("\n");
+	if (lines.length === 1) return expr;
+	const firstLine = lines[0];
+	const rest = lines.slice(1);
+	let minIndent = Infinity;
+	for (const line of rest) {
+		if (line.trim() === "") continue;
+		let n = 0;
+		while (n < line.length && (line[n] === " " || line[n] === "	")) n++;
+		if (n < minIndent) minIndent = n;
+	}
+	if (!Number.isFinite(minIndent)) minIndent = 0;
+	const targetSpaces = " ".repeat(targetInner);
+	return [firstLine, ...rest.map((line) => line.trim() === "" ? "" : targetSpaces + line.slice(minIndent))].join("\n");
+}
+function expandLeftToLineStart(s, idx) {
+	let j = idx;
+	while (j > 0 && s[j - 1] !== "\n") j--;
+	if (j > 0 && s[j - 1] === "\n") {
+		let k = j - 1;
+		while (k > 0 && (s[k - 1] === " " || s[k - 1] === "	")) k--;
+		if (k > 0 && s[k - 1] === "\n") j = k;
+	}
+	return j;
+}
+function expandRightThroughBlankLines(s, idx) {
+	let j = idx;
+	while (j < s.length && (s[j] === " " || s[j] === "	")) j++;
+	if (s[j] === "\n") j++;
+	while (j < s.length) {
+		let k = j;
+		while (k < s.length && (s[k] === " " || s[k] === "	")) k++;
+		if (s[k] === "\n") {
+			j = k + 1;
+			continue;
+		}
+		break;
+	}
+	return j;
+}
+function tryParseV2Collection(body, start, sidecar, buckets, leading, nextPosition) {
+	const m = /^\$(prop|computed|action|resource|effect|lifecycle)\s*:\s*\{/.exec(body.slice(start));
+	if (!m) return null;
+	const macro = m[1];
+	const braceIdx = start + m[0].length - 1;
+	const closeIdx = matchBrace(body, braceIdx);
+	if (closeIdx < 0) return null;
+	const entries = splitTopLevelEntries(body.slice(braceIdx + 1, closeIdx));
+	let outerLeadingConsumed = false;
+	for (const e of entries) {
+		const parsed = parseV2Entry(e.text);
+		if (!parsed) continue;
+		let entryLeading;
+		if (!outerLeadingConsumed) {
+			entryLeading = e.leading.trim() ? e.leading : leading;
+			outerLeadingConsumed = true;
+		} else entryLeading = e.leading.trim() ? e.leading : "";
+		routeV2Entry(macro, parsed, sidecar, buckets, entryLeading, nextPosition);
+	}
+	let cursor = closeIdx + 1;
+	if (body[cursor] === ";") cursor++;
+	if (body[cursor] === "\n") cursor++;
+	return cursor;
+}
+function tryParseV2AnonEffect(body, start, buckets, leading, position) {
+	const colonIdx = body.indexOf(":", start);
+	if (colonIdx < 0) return null;
+	let cursor = colonIdx + 1;
+	while (cursor < body.length && /[ \t]/.test(body[cursor])) cursor++;
+	if (body.slice(cursor, cursor + 5) === "async") cursor += 5;
+	while (cursor < body.length && /[ \t]/.test(body[cursor])) cursor++;
+	if (body[cursor] !== "(") return null;
+	const exprStart = cursor;
+	const fn = parseArrowOrFunctionExpr(body.slice(exprStart));
+	if (!fn) return null;
+	const closeIdx = scanArrowExprEnd(body, exprStart);
+	if (closeIdx < 0) return null;
+	buckets.effectAnon.push({
+		body: fn.body,
+		leading,
+		position
+	});
+	let c = closeIdx;
+	if (body[c] === ";") c++;
+	if (body[c] === "\n") c++;
+	return c;
+}
+function scanArrowExprEnd(s, start) {
+	if (s[start] !== "(") return -1;
+	const parenClose = matchParen(s, start);
+	if (parenClose < 0) return -1;
+	let cur = parenClose + 1;
+	while (cur < s.length && /[ \t]/.test(s[cur])) cur++;
+	if (s[cur] === ":") {
+		cur++;
+		const arrowAt = s.indexOf("=>", cur);
+		if (arrowAt < 0) return -1;
+		cur = arrowAt;
+	}
+	if (s.slice(cur, cur + 2) !== "=>") return -1;
+	cur += 2;
+	while (cur < s.length && /[ \t\n]/.test(s[cur])) cur++;
+	if (s[cur] === "{") {
+		const close = matchBrace(s, cur);
+		if (close < 0) return -1;
+		return close + 1;
+	}
+	const nl = s.indexOf("\n", cur);
+	return nl < 0 ? s.length : nl;
+}
+function splitTopLevelEntries(inner) {
+	const out = [];
+	let depthBrace = 0;
+	let depthParen = 0;
+	let depthBracket = 0;
+	let start = 0;
+	let j = 0;
+	while (j < inner.length) {
+		const c = inner[j];
+		if (c === "/" && inner[j + 1] === "/") {
+			const nl = inner.indexOf("\n", j);
+			j = nl < 0 ? inner.length : nl;
+			continue;
+		}
+		if (c === "/" && inner[j + 1] === "*") {
+			const end = inner.indexOf("*/", j + 2);
+			j = end < 0 ? inner.length : end + 2;
+			continue;
+		}
+		if (c === "\"" || c === "'" || c === "`") {
+			j = skipString(inner, j);
+			continue;
+		}
+		if (c === "{") depthBrace++;
+		else if (c === "}") depthBrace--;
+		else if (c === "(") depthParen++;
+		else if (c === ")") depthParen--;
+		else if (c === "[") depthBracket++;
+		else if (c === "]") depthBracket--;
+		else if (c === "," && depthBrace === 0 && depthParen === 0 && depthBracket === 0) {
+			pushSplitEntry(out, inner.slice(start, j));
+			start = j + 1;
+		}
+		j++;
+	}
+	if (start < inner.length) pushSplitEntry(out, inner.slice(start));
+	return out;
+}
+function pushSplitEntry(out, piece) {
+	let head = "";
+	let i = 0;
+	while (i < piece.length) {
+		const lineEnd = piece.indexOf("\n", i);
+		const end = lineEnd < 0 ? piece.length : lineEnd;
+		const line = piece.slice(i, end);
+		if (line.trim() === "" || line.trim().startsWith("//") || line.trim().startsWith("/*")) {
+			head += `${line}\n`;
+			i = end + 1;
+			if (lineEnd < 0) break;
+			continue;
+		}
+		break;
+	}
+	const text = piece.slice(i).trim();
+	if (text === "") return;
+	out.push({
+		text,
+		leading: head
+	});
+}
+function parseV2Entry(text) {
+	const m = /^([A-Za-z_$][\w$]*)\s*:\s*/.exec(text);
+	if (!m) return null;
+	const name = m[1];
+	const rest = text.slice(m[0].length).trim();
+	if (rest.startsWith("{")) {
+		const close = matchBrace(rest, 0);
+		if (close < 0) return null;
+		return {
+			name,
+			rhs: rest.slice(1, close).trim(),
+			isWrapped: true
+		};
+	}
+	return {
+		name,
+		rhs: rest,
+		isWrapped: false
+	};
+}
+function parseWrappedFields(body) {
+	const out = {};
+	const entries = splitTopLevelEntries(body);
+	for (const e of entries) {
+		const m = /^([A-Za-z_$][\w$]*)\s*:\s*/.exec(e.text);
+		if (!m) continue;
+		const k = m[1];
+		const v = e.text.slice(m[0].length).trim();
+		if (k === "describe") out.describe = unquoteString(v);
+		else if (k === "expose") {
+			const parsed = parseExposeLiteral(v);
+			if (parsed) out.expose = parsed;
+		} else if (k === "value") out.value = v;
+		else if (k === "handler") out.handler = v;
+		else if (k === "default") out.default = v;
+		else if (k === "type") out.type = v;
+		else if (k === "on") out.on = v;
+	}
+	return out;
+}
+function unquoteString(s) {
+	s = s.trim();
+	if (s.startsWith("'") && s.endsWith("'") || s.startsWith("\"") && s.endsWith("\"")) return s.slice(1, -1).replace(/\\'/g, "'").replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+	return s;
+}
+function parseExposeLiteral(s) {
+	s = s.trim();
+	if (!s.startsWith("{")) return void 0;
+	const close = matchBrace(s, 0);
+	if (close < 0) return void 0;
+	const body = s.slice(1, close);
+	return {
+		read: /\bread\s*:\s*true\b/.test(body),
+		write: /\bwrite\s*:\s*true\b/.test(body)
+	};
+}
+function routeV2Entry(macro, entry, _sidecar, buckets, leading, nextPosition) {
+	if (macro === "prop") {
+		if (entry.isWrapped) {
+			const f = parseWrappedFields(entry.rhs);
+			buckets.props.push({
+				name: entry.name,
+				rawType: f.type,
+				rawDefault: f.default,
+				describe: f.describe,
+				expose: f.expose,
+				leading
+			});
+		}
+		return;
+	}
+	if (macro === "computed" || macro === "resource") {
+		let expr;
+		let describe;
+		let expose;
+		if (entry.isWrapped) {
+			const f = parseWrappedFields(entry.rhs);
+			expr = stripThunk(f.value ?? "");
+			describe = f.describe;
+			expose = f.expose;
+		} else expr = stripThunk(entry.rhs);
+		(macro === "computed" ? buckets.computed : buckets.resource).push({
+			name: entry.name,
+			expr,
+			describe,
+			expose,
+			leading
+		});
+		return;
+	}
+	if (macro === "action") {
+		let handlerSrc;
+		let describe;
+		let expose;
+		if (entry.isWrapped) {
+			const f = parseWrappedFields(entry.rhs);
+			handlerSrc = f.handler ?? "";
+			describe = f.describe;
+			expose = f.expose;
+		} else handlerSrc = entry.rhs;
+		const fn = parseArrowOrFunctionExpr(handlerSrc);
+		if (!fn) return;
+		buckets.action.push({
+			name: entry.name,
+			args: fn.args,
+			retType: fn.retType,
+			body: fn.body,
+			describe,
+			expose,
+			leading
+		});
+		return;
+	}
+	if (macro === "effect") {
+		let expr;
+		let describe;
+		let expose;
+		if (entry.isWrapped) {
+			const f = parseWrappedFields(entry.rhs);
+			expr = stripThunk(f.value ?? "");
+			describe = f.describe;
+			expose = f.expose;
+		} else expr = stripThunk(entry.rhs);
+		buckets.effectNamed.push({
+			name: entry.name,
+			expr,
+			describe,
+			expose,
+			leading
+		});
+		return;
+	}
+	if (macro === "lifecycle") {
+		if (entry.name !== "mount" && entry.name !== "dispose") return;
+		const fn = parseArrowOrFunctionExpr(entry.isWrapped ? entry.rhs : entry.rhs);
+		if (!fn) return;
+		buckets.lifecycle.push({
+			kind: entry.name,
+			body: fn.body,
+			leading,
+			position: nextPosition()
+		});
+		return;
+	}
+}
+function stripThunk(s) {
+	s = s.trim();
+	const m = /^\(\s*\)\s*(?::\s*[^=]+)?=>\s*/.exec(s);
+	if (!m) return s;
+	const rest = s.slice(m[0].length);
+	if (rest.startsWith("{")) {
+		const close = matchBrace(rest, 0);
+		if (close < 0) return rest;
+		return rest.slice(1, close).trim();
+	}
+	return rest.trim();
+}
+//#endregion
+//#region src/core/code-action.ts
+/**
+* packages/language-server/src/core/code-action.ts
+*
+* QuickFix code-action backing — bridges compiler diagnostic codes C440-C444
+* (rejected old-spec macro forms) to the macro-simplification codemod
+* (`migrate()`), which rewrites a full document to v2 collection-form syntax.
+*
+* Editor-agnostic: this module computes WHAT the fix is (the rewritten text +
+* any warnings). The connection layer (src/server.ts) turns that into a protocol
+* `WorkspaceEdit`/`CodeAction`. This keeps the codemod bridge a clean seam for a
+* future Volar code-action provider.
+*
+* The migrate() codemod is internal monorepo source under @aihu/compiler (not a
+* public package export); imported via the workspace-relative path the same way
+* the original embedded server did.
+*/
+/** Compiler diagnostic codes whose QuickFix is the v2 macro migration codemod. */
+const MIGRATE_CODES = new Set([
+	"C440",
+	"C441",
+	"C442",
+	"C443",
+	"C444"
+]);
+/**
+* Run the macro-simplification codemod over `source` and return the fix payload.
+* Returns `null` when the codemod throws (malformed source) so callers can fall
+* back to offering no action rather than surfacing a crash.
+*/
+function buildMigrateFix(source) {
+	let result;
+	try {
+		result = migrate(source);
+	} catch {
+		return null;
+	}
+	const { rewritten, warnings } = result;
+	let title = "Migrate to v2 macro syntax (aihu codemod)";
+	if (warnings.length > 0) title += ` (${warnings.length} warning(s) - see Output panel)`;
+	return {
+		rewritten,
+		warnings,
+		title
+	};
+}
+//#endregion
+//#region src/core/completion.ts
+/**
+* packages/language-server/src/core/completion.ts
+*
+* LSP completion items for aihu v2 macro-kind collection-form snippets.
+* Triggered by '$' inside @state block, '@' at top level.
+*
+* Uses inline numeric constants for CompletionItemKind and InsertTextFormat
+* to avoid importing vscode-languageserver at module load time (enables testing
+* without the vscode-languageserver package installed, and keeps this module
+* editor-agnostic — the clean seam for a future Volar adoption).
+*/
+const SNIPPET_KIND = 15;
+const SNIPPET_FORMAT = 2;
+/** v2 macro-kind snippet completions (triggered by '$' in @state block). */
+const STATE_MACRO_COMPLETIONS = [
+	{
+		label: "$prop",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "v2 collection-form prop declarations",
+		sortText: "0_$prop",
+		insertText: [
+			"$prop: {",
+			"  ${1:name}: { default: ${2:undefined}, describe: '${3:description}' },",
+			"}"
+		].join("\n")
+	},
+	{
+		label: "$computed",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "v2 collection-form computed declarations",
+		sortText: "0_$computed",
+		insertText: [
+			"$computed: {",
+			"  ${1:name}: () => ${2:expression},",
+			"}"
+		].join("\n")
+	},
+	{
+		label: "$action",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "v2 collection-form action declarations",
+		sortText: "0_$action",
+		insertText: [
+			"$action: {",
+			"  ${1:name}: (${2:args}) => { ${3:body} },",
+			"}"
+		].join("\n")
+	},
+	{
+		label: "$resource",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "v2 collection-form resource declarations",
+		sortText: "0_$resource",
+		insertText: [
+			"$resource: {",
+			"  ${1:name}: () => ${2:fetchExpr()},",
+			"}"
+		].join("\n")
+	},
+	{
+		label: "$effect",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "v2 anonymous effect declaration",
+		sortText: "0_$effect",
+		insertText: [
+			"$effect: () => {",
+			"  ${1:body}",
+			"}"
+		].join("\n")
+	},
+	{
+		label: "$lifecycle",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "v2 collection-form lifecycle hooks",
+		sortText: "0_$lifecycle",
+		insertText: [
+			"$lifecycle: {",
+			"  mount: () => { ${1:initBody} },",
+			"  dispose: () => { ${2:cleanupBody} },",
+			"}"
+		].join("\n")
+	},
+	{
+		label: "$emit",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "typed custom event declarations",
+		sortText: "0_$emit",
+		insertText: [
+			"$emit: {",
+			"  ${1:eventName}: (payload: ${2:PayloadType}) => void",
+			"}"
+		].join("\n")
+	},
+	{
+		label: "$on",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "event listener attribute (template)",
+		sortText: "0_$on",
+		insertText: "$on.${1:click}={${2:handler}}"
+	},
+	{
+		label: "$bind",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "two-way attribute binding (template)",
+		sortText: "0_$bind",
+		insertText: "$bind.${1:value}={${2:signal}}"
+	}
+];
+/** Top-level block completions (triggered by '@' at top level). */
+const BLOCK_COMPLETIONS = [
+	{
+		label: "@state",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "aihu @state block",
+		sortText: "0_@state",
+		insertText: "@state"
+	},
+	{
+		label: "@template",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "aihu @template block",
+		sortText: "0_@template",
+		insertText: "@template"
+	},
+	{
+		label: "@style",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "aihu @style block",
+		sortText: "0_@style",
+		insertText: "@style"
+	},
+	{
+		label: "@agent",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "aihu @agent block for MCP tool exposure",
+		sortText: "0_@agent",
+		insertText: "@agent"
+	},
+	{
+		label: "@route",
+		kind: SNIPPET_KIND,
+		insertTextFormat: SNIPPET_FORMAT,
+		detail: "aihu @route block for file-based routing",
+		sortText: "0_@route",
+		insertText: "@route"
+	}
+];
+//#endregion
+//#region src/core/diagnostics.ts
+/**
+* packages/language-server/src/core/diagnostics.ts
+*
+* Async wrapper around the aihu-compile Rust binary with --machine-errors support.
+* Invoked by the LSP server on every textDocument/didOpen and textDocument/didChange.
+*
+* NOTE: Uses node:child_process execFile (not exec) with argv arrays — safe from
+* shell injection. The LSP server process runs out-of-process for editor isolation.
+*
+* This module is editor-agnostic: it returns plain `AihuDiagnostic` records with
+* 0-based LSP positions. The transport/connection layer (src/server.ts) maps these
+* onto protocol `Diagnostic` objects. Keeping the parse logic here is the clean
+* seam for a future `@volar/language-core` virtual-code adoption (arch-4 §2.7).
+*/
+const execFileAsync = promisify(execFile);
+const ext = process.platform === "win32" ? ".exe" : "";
+const binPath = process.env.AIHU_COMPILE_BIN ?? resolve(dirname(fileURLToPath(import.meta.url)), `../../../compiler/bin/aihu-compile${ext}`);
+function toAihuDiagnostic(raw) {
+	let lspRange = null;
+	if (raw.range && raw.range.line > 0) {
+		const startLine = raw.range.line - 1;
+		const endLine = raw.range.end_line - 1;
+		lspRange = {
+			start: {
+				line: startLine,
+				character: raw.range.col
+			},
+			end: {
+				line: endLine,
+				character: raw.range.end_col
+			}
+		};
+	}
+	return {
+		code: raw.code,
+		message: raw.message,
+		hint: raw.hint,
+		fix: raw.fix,
+		fromText: raw.from ?? null,
+		toText: raw.to ?? null,
+		range: lspRange
+	};
+}
+/**
+* Fallback: parse a plain-text compiler error into a synthetic diagnostic.
+* Used when the binary does not emit JSON (very old binary or stdin parse error).
+* TODO: remove when --machine-errors covers all error paths.
+*/
+function parsePlainError(stderr, _filePath) {
+	const m = /\b(\d+):\s*(.+)/.exec(stderr);
+	const line = m ? Math.max(0, Number.parseInt(m[1], 10) - 1) : 0;
+	return {
+		code: "C000",
+		message: m ? m[2] : stderr.trim() || "Unknown compiler error",
+		fromText: null,
+		toText: null,
+		range: {
+			start: {
+				line,
+				character: 0
+			},
+			end: {
+				line,
+				character: 0
+			}
+		}
+	};
+}
+/**
+* Parse the Rust binary's `--machine-errors` stderr stream into structured
+* diagnostics. Each JSON line is one error; non-JSON lines are skipped. When no
+* JSON is present at all, falls back to a single synthetic plain-text diagnostic.
+*
+* Pure function — no I/O. Exposed so editors/tests can exercise the mapping
+* without spawning the compiler.
+*/
+function parseMachineErrors(stderr, filePath) {
+	const diagnostics = [];
+	let jsonParsed = false;
+	for (const line of stderr.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed?.startsWith("{")) continue;
+		try {
+			const raw = JSON.parse(trimmed);
+			diagnostics.push(toAihuDiagnostic(raw));
+			jsonParsed = true;
+		} catch {}
+	}
+	if (!jsonParsed) diagnostics.push(parsePlainError(stderr, filePath));
+	return diagnostics;
+}
+/**
+* Compile a .aihu source string via stdin, returning structured diagnostics.
+*/
+async function compileWithDiagnostics(source, filePath) {
+	const stem = filePath.replace(/\\/g, "/").split("/").pop()?.replace(/\.aihu$/, "") ?? "component";
+	try {
+		const { stdout } = await execFileAsync(binPath, [
+			"--stdin",
+			"--tag",
+			stem,
+			"--path",
+			filePath,
+			"--machine-errors"
+		], {
+			input: source,
+			encoding: "utf8",
+			maxBuffer: 8 * 1024 * 1024
+		});
+		return {
+			code: stdout,
+			diagnostics: []
+		};
+	} catch (err) {
+		return {
+			code: null,
+			diagnostics: parseMachineErrors(err.stderr ?? "", filePath)
+		};
+	}
+}
+//#endregion
+//#region src/core/hover.ts
+/**
+* packages/language-server/src/core/hover.ts
+*
+* Static hover lookup table for aihu macro keywords.
+* Used by the LSP server textDocument/hover handler.
+*
+* Editor-agnostic: returns Markdown strings + does pure position math. The
+* connection layer wraps the result in a protocol `Hover`. Clean seam for a
+* future Volar virtual-code hover provider.
+*/
+const HOVER_TABLE = {
+	$prop: [
+		"**aihu macro: `$prop`**",
+		"",
+		"Declares reactive prop signals from parent attributes.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"const name = computed(() => ctx.attrs.name)",
+		"```",
+		"",
+		"[v2 spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$computed: [
+		"**aihu macro: `$computed`**",
+		"",
+		"Declares a derived signal.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"const name = computed(() => expr)",
+		"```",
+		"",
+		"[v2 spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$action: [
+		"**aihu macro: `$action`**",
+		"",
+		"Declares a callable action in component scope.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"function name(args) { return batch(() => { body }) }",
+		"```",
+		"",
+		"[v2 spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$resource: [
+		"**aihu macro: `$resource`**",
+		"",
+		"Declares an async data resource signal.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"const name = createResource(() => expr)",
+		"```",
+		"",
+		"[v2 spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$effect: [
+		"**aihu macro: `$effect`**",
+		"",
+		"Declares a reactive side effect.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"effect(() => { body })",
+		"```",
+		"",
+		"[v2 spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$lifecycle: [
+		"**aihu macro: `$lifecycle`**",
+		"",
+		"Declares lifecycle hooks (mount, dispose, adopt, attributeChange).",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"onMount(() => { ... })",
+		"onCleanup(() => { ... })",
+		"```",
+		"",
+		"[v2 spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$if: [
+		"**aihu template directive: `$if` / `{#if}`**",
+		"",
+		"Conditional rendering.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"branch(condition, () => trueBranch)",
+		"```",
+		"",
+		"[Template spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$each: [
+		"**aihu template directive: `$each` / `{#each}`**",
+		"",
+		"List rendering.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"branch.each(items, (item) => leaf(...))",
+		"```",
+		"",
+		"[Template spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$html: [
+		"**aihu template directive: `$html` / `{@html}`**",
+		"",
+		"Raw HTML injection. Use with trusted content only.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"leaf({ nodeValue: htmlContent })",
+		"```",
+		"",
+		"[Template spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$show: [
+		"**aihu template directive: `$show`**",
+		"",
+		"Toggles element visibility without removing it from the DOM.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"el.style.display = condition ? \"\" : \"none\"",
+		"```",
+		"",
+		"[Template spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$on: [
+		"**aihu template directive: `$on`**",
+		"",
+		"Attaches an event listener to a DOM element.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"element.addEventListener(\"event\", handler)",
+		"```",
+		"",
+		"Usage: `$on.click={handler}`",
+		"",
+		"[Template spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$bind: [
+		"**aihu template directive: `$bind`**",
+		"",
+		"Two-way binding between a signal and an element attribute.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"// two-way binding via signal setter",
+		"el.addEventListener(\"input\", e => setSignal(e.target.value))",
+		"```",
+		"",
+		"Usage: `$bind.value={signal}`",
+		"",
+		"[Template spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$emit: [
+		"**aihu macro: `$emit`**",
+		"",
+		"Declares and dispatches typed custom events.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"this.dispatchEvent(new CustomEvent(name, { detail: payload }))",
+		"```",
+		"",
+		"Usage: `$emit.name(payload)`",
+		"",
+		"[v2 spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n")
+};
+function getBlockContext(lines, lineIndex) {
+	for (let i = lineIndex; i >= 0; i--) {
+		const trimmed = lines[i].trimStart();
+		if (/^@state\s*\{/.test(trimmed)) return "state";
+		if (/^@template\s*\{/.test(trimmed)) return "template";
+		if (/^@(style|agent|route)\s*\{/.test(trimmed)) return "unknown";
+	}
+	return "unknown";
+}
+function getMacroAtPosition(lineText, character) {
+	let m;
+	const namespacedRe = /\$(on|bind)(?:[.:][A-Za-z_$][\w$]*)?/g;
+	while ((m = namespacedRe.exec(lineText)) !== null) if (character >= m.index && character <= m.index + m[0].length) return `$${m[1]}`;
+	const bareRe = /\$(prop|computed|action|resource|effect|lifecycle|emit|if|each|html|show)\b/g;
+	while ((m = bareRe.exec(lineText)) !== null) if (character >= m.index && character <= m.index + m[0].length) return `$${m[1]}`;
+	const blockRe = /\{(?:#(if|each)|@(html))\b/g;
+	while ((m = blockRe.exec(lineText)) !== null) if (character >= m.index && character <= m.index + m[0].length) return `$${m[1] ?? m[2]}`;
+	return null;
+}
+function getHoverContent(macro) {
+	return HOVER_TABLE[macro] ?? null;
+}
+//#endregion
+//#region src/server.ts
+/**
+* packages/language-server/src/server.ts
+*
+* The aihu cross-editor Language Server — transport/connection layer.
+*
+* Started as an out-of-process Node.js child by any LSP client (VS Code via
+* vscode-languageclient, Neovim, Helix, …) over stdio. The runnable binary
+* (`aihu-language-server`) is `src/bin.ts`, which calls `startServer()`.
+*
+* Features implemented:
+*   - Diagnostics: shell out to aihu-compile --machine-errors (debounced 300ms)
+*   - Code actions: QuickFix for C440-C444 via the migrate() codemod
+*   - Hover: static lookup table for 13 macro keywords
+*   - Completion: 9 macro-kind snippets ($ trigger) + 5 block names (@ trigger)
+*
+* All feature logic lives in ./core (editor-agnostic). This file only wires the
+* core functions onto the LSP connection — the clean seam for a future Volar
+* adoption (arch-4 §2.6/§2.7).
+*/
+/**
+* Build and wire the LSP server onto a connection, returning it without calling
+* `.listen()`. Exposed so tests / alternative transports can drive the server.
+* The default `createConnection(ProposedFeatures.all)` reads stdio.
+*/
+function createServer(connection = createConnection(ProposedFeatures.all)) {
+	const documents = new TextDocuments(TextDocument);
+	connection.onInitialize((_params) => {
+		connection.console.log("Aihu LSP server started");
+		return { capabilities: {
+			textDocumentSync: TextDocumentSyncKind.Incremental,
+			hoverProvider: true,
+			completionProvider: { triggerCharacters: ["$", "@"] },
+			codeActionProvider: { codeActionKinds: [CodeActionKind.QuickFix] }
+		} };
+	});
+	const pendingValidations = /* @__PURE__ */ new Map();
+	function scheduleValidation(doc) {
+		const uri = doc.uri;
+		const existing = pendingValidations.get(uri);
+		if (existing !== void 0) clearTimeout(existing);
+		const handle = setTimeout(() => {
+			pendingValidations.delete(uri);
+			validateDocument(doc);
+		}, 300);
+		pendingValidations.set(uri, handle);
+	}
+	async function validateDocument(doc) {
+		const filePath = doc.uri.replace(/^file:\/\/\/([A-Za-z]:)/, "$1").replace(/^file:\/\//, "");
+		let result;
+		try {
+			result = await compileWithDiagnostics(doc.getText(), filePath);
+		} catch (err) {
+			connection.console.error(`Aihu LSP: validation crashed for ${doc.uri}: ${String(err)}`);
+			return;
+		}
+		const diagnostics = result.diagnostics.map(toDiagnostic);
+		connection.sendDiagnostics({
+			uri: doc.uri,
+			diagnostics
+		});
+	}
+	function toDiagnostic(d) {
+		return {
+			range: d.range ? {
+				start: d.range.start,
+				end: d.range.end
+			} : {
+				start: {
+					line: 0,
+					character: 0
+				},
+				end: {
+					line: 0,
+					character: 0
+				}
+			},
+			message: d.message,
+			severity: DiagnosticSeverity.Error,
+			code: d.code,
+			source: "aihu-compile"
+		};
+	}
+	documents.onDidOpen((e) => scheduleValidation(e.document));
+	documents.onDidChangeContent((e) => scheduleValidation(e.document));
+	documents.onDidClose((e) => {
+		const uri = e.document.uri;
+		const pending = pendingValidations.get(uri);
+		if (pending !== void 0) {
+			clearTimeout(pending);
+			pendingValidations.delete(uri);
+		}
+		connection.sendDiagnostics({
+			uri,
+			diagnostics: []
+		});
+	});
+	connection.onCodeAction((params) => {
+		const doc = documents.get(params.textDocument.uri);
+		if (!doc) return [];
+		const migrateDiags = params.context.diagnostics.filter((d) => typeof d.code === "string" && MIGRATE_CODES.has(d.code));
+		if (migrateDiags.length === 0) return [];
+		const fix = buildMigrateFix(doc.getText());
+		if (!fix) {
+			connection.console.error("Aihu LSP: migrate() threw — no code action offered");
+			return [];
+		}
+		for (const w of fix.warnings) connection.console.warn(`Aihu codemod warning: ${w}`);
+		const fullRange = {
+			start: {
+				line: 0,
+				character: 0
+			},
+			end: {
+				line: doc.lineCount,
+				character: 0
+			}
+		};
+		const edit = { changes: { [params.textDocument.uri]: [TextEdit.replace(fullRange, fix.rewritten)] } };
+		return [{
+			title: fix.title,
+			kind: CodeActionKind.QuickFix,
+			diagnostics: migrateDiags,
+			edit,
+			isPreferred: true
+		}];
+	});
+	connection.onHover((params) => {
+		const doc = documents.get(params.textDocument.uri);
+		if (!doc) return null;
+		const pos = params.position;
+		const macro = getMacroAtPosition(doc.getText({
+			start: {
+				line: pos.line,
+				character: 0
+			},
+			end: {
+				line: pos.line,
+				character: Number.MAX_SAFE_INTEGER
+			}
+		}), pos.character);
+		if (!macro) return null;
+		getBlockContext(doc.getText().split("\n"), pos.line);
+		const content = getHoverContent(macro);
+		if (!content) return null;
+		return { contents: {
+			kind: MarkupKind.Markdown,
+			value: content
+		} };
+	});
+	connection.onCompletion((params) => {
+		const doc = documents.get(params.textDocument.uri);
+		if (!doc) return null;
+		const pos = params.position;
+		const lineText = doc.getText({
+			start: {
+				line: pos.line,
+				character: 0
+			},
+			end: {
+				line: pos.line,
+				character: pos.character
+			}
+		});
+		const triggerChar = params.context?.triggerCharacter;
+		if (triggerChar === "$" || lineText.trimEnd().endsWith("$")) {
+			if (getBlockContext(doc.getText().split("\n"), pos.line) === "state") return CompletionList.create(STATE_MACRO_COMPLETIONS, false);
+			const templateItems = STATE_MACRO_COMPLETIONS.filter((c) => [
+				"$on",
+				"$bind",
+				"$show"
+			].includes(c.label));
+			return CompletionList.create(templateItems, false);
+		}
+		if (triggerChar === "@" || /^\s*@$/.test(lineText)) return CompletionList.create(BLOCK_COMPLETIONS, false);
+		return null;
+	});
+	documents.listen(connection);
+	return connection;
+}
+/**
+* Start the language server on stdio and begin listening. This is the entry
+* point the `aihu-language-server` bin calls.
+*
+* Bind the connection to `process.stdin`/`process.stdout` explicitly so the
+* binary works when launched directly (e.g. `{ command: "aihu-language-server" }`
+* in Neovim/Helix). vscode-languageserver's bare `createConnection` otherwise
+* requires a `--stdio` / `--node-ipc` CLI flag and throws without one.
+*/
+function startServer() {
+	const connection = createServer(createConnection(ProposedFeatures.all, process.stdin, process.stdout));
+	connection.listen();
+	return connection;
+}
+//#endregion
+//#region src/bin.ts
+/**
+* packages/language-server/src/bin.ts
+*
+* Runnable entry for the `aihu-language-server` binary. Editors launch this over
+* stdio (e.g. VS Code via vscode-languageclient, or any LSP-aware editor with a
+* `{ command: "aihu-language-server" }` server spec).
+*
+* The rolldown build prepends a `#!/usr/bin/env node` shebang to dist/bin.js.
+*/
+startServer();
+//#endregion
+export {};