@aihu/language-server 0.1.1 → 0.2.1

package/dist/{core-BHishSOT.js → volar-plugin-cOusBZ0l.js}

@@ -1,7 +1,199 @@
+import { t as __commonJSMin } from "./chunk-DcSSxlwY.js";
+import { promisify } from "node:util";
 import { execFile } from "node:child_process";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
+//#region ../../node_modules/.bun/@volar+source-map@2.4.28/node_modules/@volar/source-map/lib/binarySearch.js
+var require_binarySearch = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.binarySearch = binarySearch;
+	function binarySearch(values, searchValue) {
+		let low = 0;
+		let high = values.length - 1;
+		let match;
+		while (low <= high) {
+			const mid = Math.floor((low + high) / 2);
+			const midValue = values[mid];
+			if (midValue < searchValue) low = mid + 1;
+			else if (midValue > searchValue) high = mid - 1;
+			else {
+				low = mid;
+				high = mid;
+				match = mid;
+				break;
+			}
+		}
+		return {
+			low: Math.max(Math.min(low, high, values.length - 1), 0),
+			high: Math.min(Math.max(low, high, 0), values.length - 1),
+			match
+		};
+	}
+}));
+//#endregion
+//#region ../../node_modules/.bun/@volar+source-map@2.4.28/node_modules/@volar/source-map/lib/translateOffset.js
+var require_translateOffset = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.translateOffset = translateOffset;
+	let warned = false;
+	function translateOffset(start, fromOffsets, toOffsets, fromLengths, toLengths = fromLengths, preferEnd = false) {
+		if (!fromOffsets.every((value, index) => index === 0 || fromOffsets[index - 1] <= value)) {
+			for (let i = 0; i < fromOffsets.length; i++) {
+				const fromOffset = fromOffsets[i];
+				const fromLength = fromLengths[i];
+				if (start >= fromOffset && start <= fromOffset + fromLength) {
+					const toLength = toLengths[i];
+					const toOffset = toOffsets[i];
+					let rangeOffset;
+					const relativePos = start - fromOffset;
+					if (preferEnd && toLength > fromLength && relativePos === fromLength) rangeOffset = toLength;
+					else rangeOffset = Math.min(relativePos, toLength);
+					return toOffset + rangeOffset;
+				}
+			}
+			if (!warned) {
+				warned = true;
+				console.warn("fromOffsets should be sorted in ascending order");
+			}
+		}
+		let low = 0;
+		let high = fromOffsets.length - 1;
+		while (low <= high) {
+			const mid = Math.floor((low + high) / 2);
+			const fromOffset = fromOffsets[mid];
+			const fromLength = fromLengths[mid];
+			if (start >= fromOffset && start <= fromOffset + fromLength) {
+				const toLength = toLengths[mid];
+				const toOffset = toOffsets[mid];
+				let rangeOffset;
+				const relativePos = start - fromOffset;
+				if (preferEnd && toLength > fromLength && relativePos === fromLength) rangeOffset = toLength;
+				else rangeOffset = Math.min(relativePos, toLength);
+				return toOffset + rangeOffset;
+			} else if (start < fromOffset) high = mid - 1;
+			else low = mid + 1;
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.bun/@volar+source-map@2.4.28/node_modules/@volar/source-map/lib/sourceMap.js
+var require_sourceMap = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.SourceMap = void 0;
+	const binarySearch_1 = require_binarySearch();
+	const translateOffset_1 = require_translateOffset();
+	var SourceMap = class {
+		constructor(mappings) {
+			this.mappings = mappings;
+		}
+		toSourceRange(generatedStart, generatedEnd, fallbackToAnyMatch, filter) {
+			return this.findMatchingStartEnd(generatedStart, generatedEnd, fallbackToAnyMatch, "generatedOffsets", filter);
+		}
+		toGeneratedRange(sourceStart, sourceEnd, fallbackToAnyMatch, filter) {
+			return this.findMatchingStartEnd(sourceStart, sourceEnd, fallbackToAnyMatch, "sourceOffsets", filter);
+		}
+		toSourceLocation(generatedOffset, filter) {
+			return this.findMatchingOffsets(generatedOffset, "generatedOffsets", filter);
+		}
+		toGeneratedLocation(sourceOffset, filter) {
+			return this.findMatchingOffsets(sourceOffset, "sourceOffsets", filter);
+		}
+		*findMatchingOffsets(offset, fromRange, filter, preferEnd = false) {
+			const memo = this.getMemoBasedOnRange(fromRange);
+			if (memo.offsets.length === 0) return;
+			const { low: start, high: end } = (0, binarySearch_1.binarySearch)(memo.offsets, offset);
+			const skip = /* @__PURE__ */ new Set();
+			const toRange = fromRange === "sourceOffsets" ? "generatedOffsets" : "sourceOffsets";
+			for (let i = start; i <= end; i++) for (const mapping of memo.mappings[i]) {
+				if (skip.has(mapping)) continue;
+				skip.add(mapping);
+				if (filter && !filter(mapping.data)) continue;
+				const mapped = (0, translateOffset_1.translateOffset)(offset, mapping[fromRange], mapping[toRange], getLengths(mapping, fromRange), getLengths(mapping, toRange), preferEnd);
+				if (mapped !== void 0) yield [mapped, mapping];
+			}
+		}
+		*findMatchingStartEnd(start, end, fallbackToAnyMatch, fromRange, filter) {
+			const toRange = fromRange === "sourceOffsets" ? "generatedOffsets" : "sourceOffsets";
+			const preferEnd = toRange === "sourceOffsets";
+			const mappedStarts = [];
+			let hadMatch = false;
+			for (const [mappedStart, mapping] of this.findMatchingOffsets(start, fromRange)) {
+				if (filter && !filter(mapping.data)) continue;
+				mappedStarts.push([mappedStart, mapping]);
+				const mappedEnd = (0, translateOffset_1.translateOffset)(end, mapping[fromRange], mapping[toRange], getLengths(mapping, fromRange), getLengths(mapping, toRange), preferEnd);
+				if (mappedEnd !== void 0) {
+					hadMatch = true;
+					yield [
+						mappedStart,
+						mappedEnd,
+						mapping,
+						mapping
+					];
+				}
+			}
+			if (!hadMatch && fallbackToAnyMatch) for (const [mappedStart, mappingStart] of mappedStarts) for (const [mappedEnd, mappingEnd] of this.findMatchingOffsets(end, fromRange, void 0, preferEnd)) {
+				if (filter && !filter(mappingEnd.data) || mappedEnd < mappedStart) continue;
+				yield [
+					mappedStart,
+					mappedEnd,
+					mappingStart,
+					mappingEnd
+				];
+				break;
+			}
+		}
+		getMemoBasedOnRange(fromRange) {
+			return fromRange === "sourceOffsets" ? this.sourceCodeOffsetsMemo ??= this.createMemo("sourceOffsets") : this.generatedCodeOffsetsMemo ??= this.createMemo("generatedOffsets");
+		}
+		createMemo(key) {
+			const offsetsSet = /* @__PURE__ */ new Set();
+			for (const mapping of this.mappings) for (let i = 0; i < mapping[key].length; i++) {
+				offsetsSet.add(mapping[key][i]);
+				offsetsSet.add(mapping[key][i] + getLengths(mapping, key)[i]);
+			}
+			const offsets = [...offsetsSet].sort((a, b) => a - b);
+			const mappings = offsets.map(() => /* @__PURE__ */ new Set());
+			for (const mapping of this.mappings) for (let i = 0; i < mapping[key].length; i++) {
+				const startIndex = (0, binarySearch_1.binarySearch)(offsets, mapping[key][i]).match;
+				const endIndex = (0, binarySearch_1.binarySearch)(offsets, mapping[key][i] + getLengths(mapping, key)[i]).match;
+				for (let i = startIndex; i <= endIndex; i++) mappings[i].add(mapping);
+			}
+			return {
+				offsets,
+				mappings
+			};
+		}
+	};
+	exports.SourceMap = SourceMap;
+	function getLengths(mapping, key) {
+		return key === "sourceOffsets" ? mapping.lengths : mapping.generatedLengths ?? mapping.lengths;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.bun/@volar+source-map@2.4.28/node_modules/@volar/source-map/index.js
+var require_source_map = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __exportStar = exports && exports.__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(require_sourceMap(), exports);
+	__exportStar(require_translateOffset(), exports);
+}));
+//#endregion
 //#region ../compiler/js/codemods/macro-simplification/migrate.ts
 const INDENT = "  ";
 function migrate(source) {
@@ -1752,6 +1944,8 @@ const HOVER_TABLE = {
 		"function name(args) { return batch(() => { body }) }",
 		"```",
 		"",
+		"",
+		"> **Agent-side context:** `$action` is primarily for agent/MCP handler scope. In `@state` blocks, prefer `$computed` for derived values or direct function declarations. See macro-vocabulary-v2 §5.",
 		"[v2 spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
 	].join("\n"),
 	$resource: [
@@ -1880,7 +2074,352 @@ const HOVER_TABLE = {
 		"",
 		"Usage: `$emit.name(payload)`",
 		"",
-		"[v2 spec](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+		"[Template syntax v2 spec](docs/superpowers/specs/2026-05-06-spec-template-syntax-v2.md)"
+	].join("\n"),
+	$watch: [
+		"**aihu macro: `$watch`**",
+		"",
+		"Imperative subscription to a value with access to prev and next values.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"let _prev = source",
+		"effect(() => { const _next = source; if (_next !== _prev) { callback(_next, _prev); _prev = _next } })",
+		"```",
+		"",
+		"Does NOT run on mount. Callback runs in an untracked context.",
+		"",
+		"[v1 spec §2.6](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$expose: [
+		"**aihu macro: `$expose`**",
+		"",
+		"Marks `@state` declarations as accessible from a parent via template ref",
+		"(equivalent to Vue `defineExpose`). By default `@state` entries are private.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"defineExpose({ name1, name2, ... })",
+		"```",
+		"",
+		"Usage: `$expose name1, name2` or `$expose { name1, name2 }`",
+		"",
+		"**Deprecated in v2 (C440)** when used INSIDE `@agent`. The agent-side",
+		"`$expose` (and `$expose.write`) are removed; replace with per-name",
+		"`expose: { read: true }` or `expose: { read: true, write: true }` on the",
+		"corresponding `@state` collection entry.",
+		"",
+		"[v1 spec §2.9](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)",
+		"[v2 spec §4 (C440)](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$shared: [
+		"**aihu macro: `$shared`**",
+		"",
+		"SSR-safe global state shared across components; survives hydration.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"const name = useSharedState(key ?? 'auto-' + componentId + '-' + name, defaultValue)",
+		"```",
+		"",
+		"Usage: `$shared name: type = defaultValue` or `$shared(key) name: type = default`",
+		"",
+		"[v1 spec §2.10](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$cookie: [
+		"**aihu macro: `$cookie`**",
+		"",
+		"Reactive binding to a cookie value (SSR-safe).",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"const name = useCookie<type>('name', { defaultValue, ...options })",
+		"```",
+		"",
+		"Usage: `$cookie name: string = \"\"` or `$cookie({ maxAge: 86400 }) sessionId: string = \"\"`",
+		"",
+		"[v1 spec §2.11](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$server: [
+		"**aihu macro: `$server`**",
+		"",
+		"Declares a function that runs only on the server; client calls via RPC.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"// Server: actual implementation in _aihu-server/actions/{component-id}/{name}.ts",
+		"const name = createServerCall<Args, Return>('component-id/name')",
+		"```",
+		"",
+		"Function body is never bundled to the client. Args/return must be serializable.",
+		"",
+		"[v1 spec §2.12](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$meta: [
+		"**aihu macro: `$meta`**",
+		"",
+		"Declares page metadata (title, description, OG tags).",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"useHead({ title, description, og })",
+		"// or dynamic: useHead(() => ({ title: dynamicTitle }))",
+		"```",
+		"",
+		"Multiple `$meta` blocks merge (later overrides earlier). SSR-emitted into `<head>`.",
+		"",
+		"[v1 spec §2.13](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$key: [
+		"**aihu template directive: `$key`**",
+		"",
+		"Stable identity for list reconciliation inside `$each`.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"createEachBoundary({ key: (item) => keyExpr, ... })",
+		"```",
+		"",
+		"Usage: `<li $each=\"users as u\" $key=\"u.id\">{u.name}</li>`",
+		"",
+		"[v1 spec §3.6](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$raw: [
+		"**aihu template directive: `$raw`**",
+		"",
+		"Skip compilation of the element subtree. Boolean-only (no value).",
+		"",
+		"Interpolations like `{x}`, macros, and bindings inside are NOT processed —",
+		"the subtree renders as static content.",
+		"",
+		"Usage: `<pre $raw>{this looks like interpolation but isn't}</pre>`",
+		"",
+		"[v1 spec §3.8](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$once: [
+		"**aihu template directive: `$once`**",
+		"",
+		"Render subtree once at mount; never update. Boolean-only.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"createOnceBoundary({ build: () => subtree, parent: parentEl })",
+		"```",
+		"",
+		"No reactive subscriptions inside. Subtree never re-renders.",
+		"",
+		"[v1 spec §3.9](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$memo: [
+		"**aihu template directive: `$memo`**",
+		"",
+		"Memoize an element subtree by explicit dependencies (curly form only).",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"createMemoBoundary({ deps: () => [dep1, dep2], build: () => subtree })",
+		"```",
+		"",
+		"Usage: `<ExpensiveChart $memo={[data, settings]} />`",
+		"",
+		"[v1 spec §3.10](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	"<$slot>": [
+		"**aihu template element: `<$slot>`**",
+		"",
+		"Children passthrough or named slot.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"const slotN = useSlot('name', defaultContent)",
+		"slotN.render({ exposed: { user, index } })",
+		"```",
+		"",
+		"Usage: `<$slot />`, `<$slot name=\"header\">default</$slot>`,",
+		"`<$slot name=\"row\" expose=\"user, index\" />`",
+		"",
+		"[v1 spec §3.12](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	"<$suspense>": [
+		"**aihu template element: `<$suspense>`**",
+		"",
+		"Loading boundary for async data (`$resource`).",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"createSuspenseBoundary({ fallback, fallbackProps, build, parent })",
+		"```",
+		"",
+		"While any tracked resource is loading, renders `fallback`. Once all ready,",
+		"swaps to actual content. Streaming SSR-compatible.",
+		"",
+		"[v1 spec §3.13](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	"<$shield>": [
+		"**aihu template element: `<$shield>`**",
+		"",
+		"Error boundary.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"createShieldBoundary({ fallback, onError, build, parent })",
+		"```",
+		"",
+		"Catches errors during render, in effects, and unhandled `$resource` errors.",
+		"Slot context: `shield.error`, `shield.retry`.",
+		"",
+		"[v1 spec §3.14](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	"<$guard>": [
+		"**aihu template element: `<$guard>`**",
+		"",
+		"Access-control boundary (scope, permissions, rate limit).",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"createGuardBoundary({ scope, permissions, rateLimit, fallback, redirect, onDeny, build })",
+		"```",
+		"",
+		"Usage: `<$guard scope=\"authenticated\" fallback=\"LoginPrompt\"><Page /></$guard>`",
+		"Slot context: `guard.user`, `guard.reason`, `guard.path`.",
+		"",
+		"[v1 spec §3.15](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	"<$warp>": [
+		"**aihu template element: `<$warp>`**",
+		"",
+		"Render content into a different DOM location (portal).",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"createWarpBoundary({ target: () => to, condition: () => $if, build })",
+		"```",
+		"",
+		"Usage: `<$warp to=\"#modal-root\"><Dialog /></$warp>`",
+		"",
+		"[v1 spec §3.16](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$reactive: [
+		"**aihu @style macro: `$reactive`**",
+		"",
+		"Bind a CSS property to a reactive expression via a CSS custom property.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"effect(() => rootEl.style.setProperty('--reactive-N', String(expr)))",
+		"/* CSS: .aihu-component { property: var(--reactive-N) } */",
+		"```",
+		"",
+		"Usage: `h1 { color: $reactive(error ? \"red\" : \"black\") }`",
+		"",
+		"[v1 spec §4.1](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$tokens: [
+		"**aihu @style macro: `$tokens`**",
+		"",
+		"Import design tokens from project config (`aihu.config.ts` `style.tokens`).",
+		"",
+		"Lowering depends on mode:",
+		"- `tokens` mode → CSS custom properties (e.g. `--color-primary`)",
+		"- `tailwind` mode → mapped to Tailwind class equivalents",
+		"- `plain` mode → inlined raw values",
+		"",
+		"Usage: `$tokens(spacing, color, typography)`",
+		"",
+		"[v1 spec §4.2](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$global: [
+		"**aihu @style macro: `$global`**",
+		"",
+		"Emit unscoped CSS rules (escape from component scoping).",
+		"",
+		"Usage:",
+		"```",
+		"@style {",
+		"  $global { body { margin: 0 } * { box-sizing: border-box } }",
+		"}",
+		"```",
+		"",
+		"`$reactive` inside `$global` targets `document.documentElement`.",
+		"",
+		"[v1 spec §4.3](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$media: [
+		"**aihu @style macro: `$media`**",
+		"",
+		"CSS media-query block.",
+		"",
+		"Compiles to:",
+		"```css",
+		"@media (query) { rules }",
+		"```",
+		"",
+		"Usage: `$media(min-width: 768px) { h1 { font-size: 2rem } }`",
+		"",
+		"[v1 spec §4.4](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$when: [
+		"**aihu @style macro: `$when`**",
+		"",
+		"Apply styles conditionally based on a signal value.",
+		"",
+		"Compiles to:",
+		"```typescript",
+		"effect(() => { rootEl.dataset.whenN = String(condition) })",
+		"/* CSS: .aihu-component[data-when-N=\"true\"] { rules } */",
+		"```",
+		"",
+		"Usage: `$when(loading) { root { opacity: 0.5 } }`",
+		"",
+		"[v1 spec §4.5](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)"
+	].join("\n"),
+	$scope: [
+		"**aihu @agent macro: `$scope`**",
+		"",
+		"Declares the auth scope required to access this component agent surface.",
+		"",
+		"Compiles to scope metadata attached to all MCP resources/tools registered",
+		"for this component. Every agent request is checked against the scope.",
+		"",
+		"Usage: `$scope authenticated`",
+		"",
+		"[v2 spec §4](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	"$rate-limit": [
+		"**aihu @agent macro: `$rate-limit`**",
+		"",
+		"Override the default rate limit for this component agent surface.",
+		"",
+		"Compiles to rate-limit metadata attached to MCP tools. Per-component limit",
+		"composes with scope-level limits (tighter wins). Counted per user per component.",
+		"",
+		"Usage: `$rate-limit \"100/min\"`, `$rate-limit \"unlimited\"`",
+		"",
+		"[v2 spec §4](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
+	].join("\n"),
+	$describe: [
+		"**aihu @agent macro: `$describe`**",
+		"",
+		"**Deprecated in v2 (C440)**. Replace with per-name `describe: \"<text>\"`",
+		"on the corresponding `@state` collection entry.",
+		"",
+		"v1 form (for migration reference only):",
+		"```",
+		"$describe name \"description string\"",
+		"$describe { name1: \"...\", name2: \"...\" }",
+		"```",
+		"",
+		"v2 replacement:",
+		"```",
+		"@state {",
+		"  $prop: {",
+		"    name: { default: undefined, describe: 'description string' },",
+		"  }",
+		"}",
+		"```",
+		"",
+		"[v1 spec §5.6](docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)",
+		"[v2 spec §4 (C440)](docs/superpowers/specs/2026-05-05-spec-macro-vocabulary-v2.md)"
 	].join("\n")
 };
 function getBlockContext(lines, lineIndex) {
@@ -1888,15 +2427,19 @@ function getBlockContext(lines, lineIndex) {
 		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";
+		if (/^@style\s*\{/.test(trimmed)) return "style";
+		if (/^@agent\s*\{/.test(trimmed)) return "agent";
+		if (/^@route\s*\{/.test(trimmed)) return "route";
 	}
 	return "unknown";
 }
 function getMacroAtPosition(lineText, character) {
 	let m;
-	const namespacedRe = /\$(on|bind)(?:[.:][A-Za-z_$][\w$]*)?/g;
+	const elementRe = /<\$(slot|suspense|shield|guard|warp)\b/g;
+	while ((m = elementRe.exec(lineText)) !== null) if (character >= m.index && character <= m.index + m[0].length) return `<$${m[1]}>`;
+	const namespacedRe = /\$(on|bind|effect|lifecycle|expose|emit)(?:[.:][A-Za-z_$][\w$]*)?\b/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;
+	const bareRe = /\$(prop|computed|action|resource|effect|lifecycle|emit|if|each|html|show|watch|shared|cookie|server|meta|key|raw|once|memo|reactive|tokens|global|media|when|scope|rate-limit|describe)\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]}`;
@@ -1906,6 +2449,408 @@ function getHoverContent(macro) {
 	return HOVER_TABLE[macro] ?? null;
 }
 //#endregion
-export { parseMachineErrors as a, MIGRATE_CODES as c, compileWithDiagnostics as i, buildMigrateFix as l, getHoverContent as n, BLOCK_COMPLETIONS as o, getMacroAtPosition as r, STATE_MACRO_COMPLETIONS as s, getBlockContext as t };
+//#region src/core/state-generator.ts
+const VIRTUAL_HEADER = [
+	"import type { createResource as _cr } from '@aihu/runtime'",
+	"export {}",
+	"declare const __aihu_state__: unique symbol",
+	""
+].join("\n");
+/**
+* Find the matching closing brace for an opening brace at `openPos` in `text`.
+* Returns the index of the `}` character, or -1 if not found.
+*/
+function findMatchingBrace(text, openPos) {
+	let depth = 0;
+	for (let i = openPos; i < text.length; i++) if (text[i] === "{") depth++;
+	else if (text[i] === "}") {
+		depth--;
+		if (depth === 0) return i;
+	}
+	return -1;
+}
+/**
+* Extract the value text for a macro key starting at `colonPos` (position of
+* the `:` after the macro key name) using a brace-depth walk. Returns the raw
+* value string (may be a brace-enclosed object or a simple expression).
+*/
+function extractMacroValue(text, colonPos) {
+	let start = colonPos + 1;
+	while (start < text.length && (text[start] === " " || text[start] === "	")) start++;
+	if (start >= text.length) return "";
+	if (text[start] === "{") {
+		const close = findMatchingBrace(text, start);
+		if (close === -1) return text.slice(start);
+		return text.slice(start, close + 1);
+	}
+	const end = text.indexOf("\n", start);
+	return end === -1 ? text.slice(start) : text.slice(start, end);
+}
+/**
+* Infer the TypeScript type from a `default:` value in a macro entry object.
+* Handles number, string, boolean literals, null/undefined, and verbatim `type:` key.
+*/
+function inferType(entryText) {
+	const typeMatch = /\btype\s*:\s*(['"`]?)(\w[\w.<>, [\]|&?]*)\1/.exec(entryText);
+	if (typeMatch) return typeMatch[2];
+	const defMatch = /\bdefault\s*:\s*([^,}\n]+)/.exec(entryText);
+	if (!defMatch) return "unknown";
+	const val = defMatch[1].trim();
+	if (/^-?\d+(\.\d+)?$/.test(val)) return "number";
+	if (/^(['"`]).*\1$/.test(val)) return "string";
+	if (val === "true" || val === "false") return "boolean";
+	if (val === "null" || val === "undefined") return "unknown";
+	return "unknown";
+}
+/**
+* Extract the default value string from a macro entry for use in the virtual
+* TS initialiser. Numbers stay as-is; strings stay as-is; others → 0 as any.
+*/
+function inferDefault(entryText, type) {
+	const defMatch = /\bdefault\s*:\s*([^,}\n]+)/.exec(entryText);
+	if (!defMatch) return "0 as any";
+	const val = defMatch[1].trim();
+	if (type === "number") return `${val} as any`;
+	if (type === "string") return `${val} as any`;
+	if (type === "boolean") return `${val} as any`;
+	return "0 as any";
+}
+const MAPPED_DATA = {
+	verification: false,
+	completion: true,
+	semantic: true,
+	navigation: true,
+	structure: true
+};
+function lowerMacro(macroKey, valueText, macroKeyOffset, source) {
+	const results = [];
+	const inner = valueText.startsWith("{") ? valueText.slice(1, valueText.length - 1) : valueText;
+	let depth = 0;
+	let i = 0;
+	while (i < inner.length) {
+		const ch = inner[i];
+		if (ch === "{") {
+			depth++;
+			i++;
+			continue;
+		}
+		if (ch === "}") {
+			depth--;
+			i++;
+			continue;
+		}
+		if (depth === 0 && ch !== void 0) {
+			const identMatch = /^(\w[\w-]*)(\s*):/.exec(inner.slice(i));
+			if (identMatch) {
+				const name = identMatch[1];
+				const colonPos = i + identMatch[0].length - 1;
+				let entryValue = "";
+				if (inner.slice(colonPos + 1).trimStart().startsWith("{")) {
+					let s = colonPos + 1;
+					while (s < inner.length && (inner[s] === " " || inner[s] === "	" || inner[s] === "\n")) s++;
+					if (inner[s] === "{") {
+						const close = findMatchingBrace(inner, s);
+						entryValue = close === -1 ? inner.slice(s) : inner.slice(s, close + 1);
+						i = close !== -1 ? close + 1 : inner.length;
+					} else {
+						const eol = inner.indexOf("\n", s);
+						entryValue = eol === -1 ? inner.slice(s) : inner.slice(s, eol);
+						i = eol !== -1 ? eol + 1 : inner.length;
+					}
+				} else {
+					const eol = inner.indexOf("\n", colonPos + 1);
+					entryValue = eol === -1 ? inner.slice(colonPos + 1) : inner.slice(colonPos + 1, eol);
+					i = eol !== -1 ? eol + 1 : inner.length;
+				}
+				const searchFrom = macroKeyOffset;
+				const nameInSource = source.indexOf(name, searchFrom);
+				const decl = buildDecl(macroKey, name, entryValue, nameInSource);
+				if (decl) results.push(decl);
+				continue;
+			}
+		}
+		i++;
+	}
+	return results;
+}
+function buildDecl(macroKey, name, entryText, sourceNameOffset) {
+	switch (macroKey) {
+		case "$prop":
+		case "$shared":
+		case "$cookie": {
+			const type = inferType(entryText);
+			return {
+				code: `const ${name}: ${type} = ${inferDefault(entryText, type)}`,
+				sourceNameOffset,
+				mapped: true,
+				nameLen: name.length
+			};
+		}
+		case "$computed": return {
+			code: `const ${name} = ${entryText.trim().replace(/^['"`]|['"`]$/g, "") || "undefined"}`,
+			sourceNameOffset,
+			mapped: true,
+			nameLen: name.length
+		};
+		case "$action": {
+			const bodyMatch = /=>\s*(\{[\s\S]*\}|\S+)/.exec(entryText);
+			return {
+				code: `function ${name}(): void ${bodyMatch ? bodyMatch[1] : "{}"}`,
+				sourceNameOffset,
+				mapped: true,
+				nameLen: name.length
+			};
+		}
+		case "$resource": return {
+			code: `const ${name} = (null as any as ReturnType<typeof _cr>)`,
+			sourceNameOffset,
+			mapped: true,
+			nameLen: name.length
+		};
+		case "$effect": {
+			const bodyMatch = /=>\s*(?:\{([^}]*)\}|([^,}\n]+))/.exec(entryText);
+			return {
+				code: `/* effect: ${name} */; ${(bodyMatch ? (bodyMatch[1] ?? bodyMatch[2] ?? "").trim() : "") || "void 0"}`,
+				sourceNameOffset,
+				mapped: true,
+				nameLen: name.length
+			};
+		}
+		case "$lifecycle": return {
+			code: `/* lifecycle.${name} */`,
+			sourceNameOffset,
+			mapped: false,
+			nameLen: name.length
+		};
+		case "$watch": {
+			const srcMatch = /\bsrc\s*:\s*([^,}\n]+)/.exec(entryText);
+			return {
+				code: `/* watch: ${name} */; ${srcMatch ? srcMatch[1].trim() : name}`,
+				sourceNameOffset,
+				mapped: true,
+				nameLen: name.length
+			};
+		}
+		case "$expose": return {
+			code: `/* expose: ${name} */`,
+			sourceNameOffset,
+			mapped: false,
+			nameLen: name.length
+		};
+		case "$server": {
+			const bodyMatch = /=>\s*(\{[\s\S]*?\})/.exec(entryText);
+			return {
+				code: `async function ${name}(): Promise<unknown> ${bodyMatch ? bodyMatch[1] : "{}"}`,
+				sourceNameOffset,
+				mapped: true,
+				nameLen: name.length
+			};
+		}
+		case "$meta": return {
+			code: `/* meta: ${name} */`,
+			sourceNameOffset,
+			mapped: false,
+			nameLen: name.length
+		};
+		default: return null;
+	}
+}
+/**
+* Generate the virtual TypeScript file for the @state block of a .aihu source.
+* Returns `{ virtualCode: '', mappings: [] }` if no @state block is found.
+*/
+function generateStateVirtualCode(input) {
+	const source = input.source;
+	const openerMatch = /^@state\s*\{/m.exec(source);
+	if (!openerMatch) return {
+		virtualCode: "",
+		mappings: []
+	};
+	const openBracePos = openerMatch.index + openerMatch[0].length - 1;
+	const closeBracePos = findMatchingBrace(source, openBracePos);
+	if (closeBracePos === -1) return {
+		virtualCode: "",
+		mappings: []
+	};
+	const blockBody = source.slice(openBracePos + 1, closeBracePos);
+	const macroRe = /^\s*(\$(?:\w[\w-]*))\s*:/gm;
+	const declarations = [];
+	let macroMatch;
+	while ((macroMatch = macroRe.exec(blockBody)) !== null) {
+		const macroKey = macroMatch[1];
+		const macroKeyOffsetInSource = openBracePos + 1 + macroMatch.index;
+		const lowered = lowerMacro(macroKey, extractMacroValue(source, openBracePos + 1 + macroMatch.index + macroMatch[0].length - 1), macroKeyOffsetInSource, source);
+		declarations.push(...lowered);
+	}
+	if (declarations.length === 0) return {
+		virtualCode: "",
+		mappings: []
+	};
+	let virtualCode = VIRTUAL_HEADER;
+	const mappings = [];
+	for (const decl of declarations) {
+		const generatedOffset = virtualCode.length;
+		virtualCode += `${decl.code}\n`;
+		if (decl.mapped && decl.sourceNameOffset >= 0) {
+			let generatedNameOffset = generatedOffset;
+			const codeLine = decl.code;
+			const nameStr = source.slice(decl.sourceNameOffset, decl.sourceNameOffset + decl.nameLen);
+			const nameInGenerated = codeLine.indexOf(nameStr);
+			if (nameInGenerated >= 0) generatedNameOffset = generatedOffset + nameInGenerated;
+			mappings.push({
+				sourceOffsets: [decl.sourceNameOffset],
+				generatedOffsets: [generatedNameOffset],
+				lengths: [decl.nameLen],
+				data: { ...MAPPED_DATA }
+			});
+		}
+	}
+	return {
+		virtualCode,
+		mappings
+	};
+}
+//#endregion
+//#region src/core/volar-plugin.ts
+/** Wrap a string in a minimal IScriptSnapshot implementation. */
+function createSnapshot(text) {
+	return {
+		getText(start, end) {
+			return text.slice(start, end);
+		},
+		getLength() {
+			return text.length;
+		},
+		getChangeRange() {}
+	};
+}
+/**
+* Create the Volar LanguagePlugin for .aihu files.
+* Returns "aihu" language ID for .aihu URIs; generates a virtual __state__.ts
+* code block from the @state macro body.
+*/
+function createAihuLanguagePlugin() {
+	return {
+		getLanguageId(scriptId) {
+			return (typeof scriptId === "string" ? scriptId : scriptId.fsPath ?? scriptId.path ?? "").endsWith(".aihu") ? "aihu" : void 0;
+		},
+		createVirtualCode(_scriptId, languageId, snapshot, _ctx) {
+			if (languageId !== "aihu") return void 0;
+			const output = generateStateVirtualCode({
+				source: snapshot.getText(0, snapshot.getLength()),
+				snapshot
+			});
+			if (!output.virtualCode) return void 0;
+			return {
+				id: "__state__",
+				languageId: "typescript",
+				snapshot: createSnapshot(output.virtualCode),
+				mappings: output.mappings
+			};
+		},
+		updateVirtualCode(scriptId, _virtualCode, newSnapshot, ctx) {
+			return this.createVirtualCode(scriptId, "aihu", newSnapshot, ctx);
+		}
+	};
+}
+/**
+* Create the Volar LanguageServicePlugin for aihu.
+* Wraps the existing getMacroAtPosition / getHoverContent from core/hover.ts.
+* Per architect-brief §4.2 — "direct translation" of the existing onHover handler.
+*/
+function createAihuLanguageServicePlugin() {
+	return {
+		capabilities: {
+			hoverProvider: true,
+			completionProvider: { triggerCharacters: ["$", "@"] },
+			diagnosticProvider: {
+				interFileDependencies: false,
+				workspaceDiagnostics: false
+			},
+			codeActionProvider: { codeActionKinds: ["quickfix"] }
+		},
+		create(_context) {
+			return {
+				provideHover(document, position, _token) {
+					const macro = getMacroAtPosition(document.getText({
+						start: {
+							line: position.line,
+							character: 0
+						},
+						end: {
+							line: position.line,
+							character: Number.MAX_SAFE_INTEGER
+						}
+					}), position.character);
+					if (!macro) return null;
+					const content = getHoverContent(macro);
+					if (!content) return null;
+					return { contents: {
+						kind: "markdown",
+						value: content
+					} };
+				},
+				provideCompletionItems(document, position, _context, _token) {
+					const ctx = getBlockContext(document.getText().split("\n"), position.line);
+					if (ctx === "state") return {
+						isIncomplete: false,
+						items: STATE_MACRO_COMPLETIONS
+					};
+					if (ctx === "template") return {
+						isIncomplete: false,
+						items: []
+					};
+					return {
+						isIncomplete: false,
+						items: BLOCK_COMPLETIONS
+					};
+				},
+				async provideDiagnostics(document, _token) {
+					const filePath = document.uri.replace(/^file:\/\//, "");
+					return (await compileWithDiagnostics(document.getText(), filePath)).diagnostics.map((diag) => ({
+						severity: 1,
+						range: diag.range ?? {
+							start: {
+								line: 0,
+								character: 0
+							},
+							end: {
+								line: 0,
+								character: 0
+							}
+						},
+						message: diag.message,
+						code: diag.code,
+						source: "aihu"
+					}));
+				},
+				provideCodeActions(document, _range, context, _token) {
+					if (context.diagnostics.filter((d) => typeof d.code === "string" && MIGRATE_CODES.has(d.code)).length === 0) return [];
+					const fix = buildMigrateFix(document.getText());
+					if (!fix) return [];
+					return [{
+						title: fix.title,
+						kind: "quickfix",
+						edit: { changes: { [document.uri]: [{
+							range: {
+								start: {
+									line: 0,
+									character: 0
+								},
+								end: {
+									line: Number.MAX_SAFE_INTEGER,
+									character: 0
+								}
+							},
+							newText: fix.rewritten
+						}] } }
+					}];
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { getHoverContent as a, parseMachineErrors as c, MIGRATE_CODES as d, buildMigrateFix as f, getBlockContext as i, BLOCK_COMPLETIONS as l, createAihuLanguageServicePlugin as n, getMacroAtPosition as o, require_source_map as p, generateStateVirtualCode as r, compileWithDiagnostics as s, createAihuLanguagePlugin as t, STATE_MACRO_COMPLETIONS as u };
 
-//# sourceMappingURL=core-BHishSOT.js.map
+//# sourceMappingURL=volar-plugin-cOusBZ0l.js.map