@pyreon/lint 0.11.4 → 0.11.6

package/lib/cli.js

@@ -0,0 +1,3290 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, readdirSync, statSync, watch, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { Visitor, parseSync } from "oxc-parser";
+
+//#region src/cache.ts
+/**
+* Simple in-memory cache for parsed ASTs keyed by file content hash.
+*
+* Uses FNV-1a hash of source text as cache key for fast lookups
+* during repeat runs (e.g., watch mode).
+*
+* @example
+* ```ts
+* import { AstCache } from "@pyreon/lint"
+*
+* const cache = new AstCache()
+* const cached = cache.get(sourceText)
+* if (!cached) {
+*   const parsed = parse(sourceText)
+*   cache.set(sourceText, parsed)
+* }
+* ```
+*/
+var AstCache = class {
+	cache = /* @__PURE__ */ new Map();
+	get(sourceText) {
+		const key = fnv1aHash(sourceText);
+		return this.cache.get(key);
+	}
+	set(sourceText, value) {
+		const key = fnv1aHash(sourceText);
+		this.cache.set(key, value);
+	}
+	clear() {
+		this.cache.clear();
+	}
+	get size() {
+		return this.cache.size;
+	}
+};
+/** FNV-1a hash — fast, non-cryptographic, low collision rate. */
+function fnv1aHash(str) {
+	let hash = 2166136261;
+	for (let i = 0; i < str.length; i++) {
+		hash ^= str.charCodeAt(i);
+		hash = hash * 16777619 | 0;
+	}
+	return (hash >>> 0).toString(36);
+}
+
+//#endregion
+//#region src/config/ignore.ts
+/**
+* Create a filter function that returns true if a file path should be ignored.
+*
+* Loads patterns from `.pyreonlintignore` and `.gitignore` in the given directory.
+*
+* @example
+* ```ts
+* import { createIgnoreFilter } from "@pyreon/lint"
+*
+* const isIgnored = createIgnoreFilter(process.cwd())
+* if (!isIgnored("src/app.tsx")) lintFile(...)
+* ```
+*/
+function createIgnoreFilter(cwd, extraIgnore) {
+	const patterns = [];
+	const resolvedCwd = resolve(cwd);
+	loadPatternsFromFile(join(resolvedCwd, ".pyreonlintignore"), patterns);
+	loadPatternsFromFile(join(resolvedCwd, ".gitignore"), patterns);
+	if (extraIgnore) loadPatternsFromFile(resolve(extraIgnore), patterns);
+	const matchers = patterns.map((p) => compileMatcher(p));
+	return (filePath) => {
+		const normalized = relative(resolvedCwd, resolve(filePath)).replace(/\\/g, "/");
+		for (const matcher of matchers) if (matcher(normalized)) return true;
+		return false;
+	};
+}
+function loadPatternsFromFile(filePath, patterns) {
+	if (!existsSync(filePath)) return;
+	try {
+		const content = readFileSync(filePath, "utf-8");
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			patterns.push(trimmed);
+		}
+	} catch {}
+}
+/**
+* Compile a gitignore-style pattern into a matcher function.
+* Supports: `*` (any non-slash chars), `**` (any path segment), `?` (single char),
+* leading `/` (root-anchored), trailing `/` (directory only).
+*/
+function compileMatcher(pattern) {
+	let p = pattern;
+	let anchored = false;
+	if (p.startsWith("!")) return () => false;
+	if (p.startsWith("/")) {
+		anchored = true;
+		p = p.slice(1);
+	}
+	let dirOnly = false;
+	if (p.endsWith("/")) {
+		dirOnly = true;
+		p = p.slice(0, -1);
+	}
+	const regex = globToRegex(p);
+	return (path) => {
+		if (dirOnly) {
+			if (anchored) return regex.test(path) || path.startsWith(`${p}/`) || path === p;
+			return regex.test(path) || path.includes(`/${p}/`) || path.startsWith(`${p}/`) || path === p;
+		}
+		if (anchored) return regex.test(path);
+		if (regex.test(path)) return true;
+		const lastSlash = path.lastIndexOf("/");
+		if (lastSlash !== -1) {
+			const basename = path.slice(lastSlash + 1);
+			return regex.test(basename);
+		}
+		return false;
+	};
+}
+const GLOB_CHAR_MAP = {
+	"?": "[^/]",
+	".": "\\.",
+	"/": "/"
+};
+function handleStar(glob, pos) {
+	if (glob[pos + 1] === "*") {
+		if (glob[pos + 2] === "/") return {
+			pattern: "(?:.*/)?",
+			advance: 3
+		};
+		return {
+			pattern: ".*",
+			advance: 2
+		};
+	}
+	return {
+		pattern: "[^/]*",
+		advance: 1
+	};
+}
+function globToRegex(glob) {
+	let result = "^";
+	let i = 0;
+	while (i < glob.length) {
+		const ch = glob[i];
+		if (ch === "*") {
+			const star = handleStar(glob, i);
+			result += star.pattern;
+			i += star.advance;
+		} else {
+			result += GLOB_CHAR_MAP[ch] ?? escapeRegex(ch);
+			i++;
+		}
+	}
+	result += "$";
+	return new RegExp(result);
+}
+function escapeRegex(str) {
+	return str.replace(/[\\^$+{}[\]|()]/g, "\\$&");
+}
+
+//#endregion
+//#region src/config/loader.ts
+const CONFIG_FILENAMES = [
+	".pyreonlintrc.json",
+	".pyreonlintrc",
+	"pyreonlint.config.json"
+];
+/**
+* Load a lint config file from the given directory or its parents.
+*
+* Search order:
+* 1. `.pyreonlintrc.json`
+* 2. `.pyreonlintrc`
+* 3. `pyreonlint.config.json`
+* 4. `package.json` `"pyreonlint"` field
+*
+* @example
+* ```ts
+* import { loadConfig } from "@pyreon/lint"
+*
+* const config = loadConfig(process.cwd())
+* if (config) console.log(config.preset)
+* ```
+*/
+function loadConfig(cwd) {
+	let dir = resolve(cwd);
+	const root = dirname(dir);
+	while (true) {
+		const found = searchDirectory(dir);
+		if (found !== null) return found;
+		const parent = dirname(dir);
+		if (parent === dir || parent === root) break;
+		dir = parent;
+	}
+	return null;
+}
+function searchDirectory(dir) {
+	for (const filename of CONFIG_FILENAMES) {
+		const content = tryReadJson(join(dir, filename));
+		if (content !== null) return content;
+	}
+	return extractPkgConfig(join(dir, "package.json"));
+}
+function extractPkgConfig(pkgPath) {
+	const pkg = tryReadJson(pkgPath);
+	if (pkg === null || typeof pkg !== "object" || !("pyreonlint" in pkg)) return null;
+	const field = pkg.pyreonlint;
+	if (field && typeof field === "object") return field;
+	return null;
+}
+/**
+* Load a config file from a specific path.
+*/
+function loadConfigFromPath(filePath) {
+	return tryReadJson(resolve(filePath));
+}
+function tryReadJson(filePath) {
+	if (!existsSync(filePath)) return null;
+	try {
+		const raw = readFileSync(filePath, "utf-8").trim();
+		if (!raw) return null;
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/utils/imports.ts
+const PYREON_PREFIX = "@pyreon/";
+const HEAVY_PACKAGES = new Set([
+	"@pyreon/charts",
+	"@pyreon/code",
+	"@pyreon/document",
+	"@pyreon/flow"
+]);
+const BROWSER_GLOBALS = new Set([
+	"window",
+	"document",
+	"navigator",
+	"location",
+	"history",
+	"localStorage",
+	"sessionStorage",
+	"indexedDB",
+	"fetch",
+	"XMLHttpRequest",
+	"WebSocket",
+	"requestAnimationFrame",
+	"cancelAnimationFrame",
+	"IntersectionObserver",
+	"MutationObserver",
+	"ResizeObserver",
+	"matchMedia",
+	"getComputedStyle",
+	"addEventListener",
+	"removeEventListener"
+]);
+function isPyreonImport(source) {
+	return source.startsWith(PYREON_PREFIX);
+}
+function extractImportInfo(node) {
+	if (node.type !== "ImportDeclaration") return null;
+	const source = node.source?.value;
+	if (!source) return null;
+	const specifiers = [];
+	let isDefault = false;
+	let isNamespace = false;
+	for (const spec of node.specifiers ?? []) if (spec.type === "ImportDefaultSpecifier") {
+		isDefault = true;
+		specifiers.push({
+			imported: "default",
+			local: spec.local?.name ?? ""
+		});
+	} else if (spec.type === "ImportNamespaceSpecifier") {
+		isNamespace = true;
+		specifiers.push({
+			imported: "*",
+			local: spec.local?.name ?? ""
+		});
+	} else if (spec.type === "ImportSpecifier") {
+		const imported = spec.imported?.type === "Identifier" ? spec.imported.name : spec.imported?.value ?? "";
+		specifiers.push({
+			imported,
+			local: spec.local?.name ?? ""
+		});
+	}
+	return {
+		source,
+		specifiers,
+		isDefault,
+		isNamespace
+	};
+}
+
+//#endregion
+//#region src/utils/ast.ts
+/** Check if a node is a call expression to a specific function name. */
+function isCallTo(node, name) {
+	return node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === name;
+}
+/** Check if a node is a member call like `obj.method()`. */
+function isMemberCallTo(node, objectName, methodName) {
+	return node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === objectName && node.callee.property?.type === "Identifier" && node.callee.property.name === methodName;
+}
+/** Get a JSX attribute by name from an opening element. */
+function getJSXAttribute(openingElement, attrName) {
+	const attrs = openingElement.attributes ?? [];
+	for (const attr of attrs) if (attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === attrName) return attr;
+	return null;
+}
+/** Check if a JSX opening element has an attribute. */
+function hasJSXAttribute(openingElement, attrName) {
+	return getJSXAttribute(openingElement, attrName) !== null;
+}
+/** Check if a node is an array .map() call. */
+function isArrayMapCall(node) {
+	return node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.property?.type === "Identifier" && node.callee.property.name === "map";
+}
+/** Check if a node is a destructuring pattern. */
+function isDestructuring(node) {
+	return node.type === "ObjectPattern" || node.type === "ArrayPattern";
+}
+/** Check if a node is a ternary with JSX in either branch. */
+function isTernaryWithJSX(node) {
+	if (node.type !== "ConditionalExpression") return false;
+	return containsJSX(node.consequent) || containsJSX(node.alternate);
+}
+/** Check if a node contains JSX anywhere. */
+function containsJSX(node) {
+	if (!node) return false;
+	if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
+	if (node.type === "ParenthesizedExpression") return containsJSX(node.expression);
+	return false;
+}
+/** Check if a node is a logical AND with JSX. */
+function isLogicalAndWithJSX(node) {
+	if (node.type !== "LogicalExpression" || node.operator !== "&&") return false;
+	return containsJSX(node.right);
+}
+/** Check if a node is a .peek() call. */
+function isPeekCall(node) {
+	return node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.property?.type === "Identifier" && node.callee.property.name === "peek";
+}
+/** Check if a node is a .set() call. */
+function isSetCall(node) {
+	return node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.property?.type === "Identifier" && node.callee.property.name === "set";
+}
+/** Get the span (byte offsets) of a node. */
+function getSpan(node) {
+	return {
+		start: node.start,
+		end: node.end
+	};
+}
+
+//#endregion
+//#region src/rules/accessibility/dialog-a11y.ts
+const dialogA11y = {
+	meta: {
+		id: "pyreon/dialog-a11y",
+		category: "accessibility",
+		description: "Warn when <dialog> is missing aria-label or aria-labelledby.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { JSXOpeningElement(node) {
+			const name = node.name;
+			if (!name || name.type !== "JSXIdentifier" || name.name !== "dialog") return;
+			const hasLabel = hasJSXAttribute(node, "aria-label");
+			const hasLabelledBy = hasJSXAttribute(node, "aria-labelledby");
+			if (!hasLabel && !hasLabelledBy) context.report({
+				message: "`<dialog>` missing `aria-label` or `aria-labelledby` — provide an accessible label for screen readers.",
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/accessibility/overlay-a11y.ts
+const overlayA11y = {
+	meta: {
+		id: "pyreon/overlay-a11y",
+		category: "accessibility",
+		description: "Warn when <Overlay> is missing role, aria-label, or aria-labelledby.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { JSXOpeningElement(node) {
+			const name = node.name;
+			if (!name || name.type !== "JSXIdentifier" || name.name !== "Overlay") return;
+			const hasRole = hasJSXAttribute(node, "role");
+			const hasLabel = hasJSXAttribute(node, "aria-label");
+			const hasLabelledBy = hasJSXAttribute(node, "aria-labelledby");
+			if (!hasRole && !hasLabel && !hasLabelledBy) context.report({
+				message: "`<Overlay>` missing `role`, `aria-label`, or `aria-labelledby` — provide accessibility attributes for screen readers.",
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/accessibility/toast-a11y.ts
+const toastA11y = {
+	meta: {
+		id: "pyreon/toast-a11y",
+		category: "accessibility",
+		description: "Warn when toast-like components are missing role or aria-live attributes.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { JSXOpeningElement(node) {
+			const name = node.name;
+			if (!name || name.type !== "JSXIdentifier") return;
+			const tagName = name.name;
+			if (tagName === "Toaster") return;
+			const firstChar = tagName[0];
+			if (!firstChar || firstChar !== firstChar.toUpperCase()) return;
+			if (!tagName.toLowerCase().includes("toast")) return;
+			const hasRole = hasJSXAttribute(node, "role");
+			const hasAriaLive = hasJSXAttribute(node, "aria-live");
+			if (!hasRole && !hasAriaLive) context.report({
+				message: `Toast component \`<${tagName}>\` missing \`role\` or \`aria-live\` — add \`role="alert"\` and \`aria-live="polite"\` for screen reader accessibility.`,
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/architecture/dev-guard-warnings.ts
+const devGuardWarnings = {
+	meta: {
+		id: "pyreon/dev-guard-warnings",
+		category: "architecture",
+		description: "Require console.warn/error calls to be wrapped in `if (__DEV__)` guards.",
+		severity: "error",
+		fixable: false
+	},
+	create(context) {
+		const filePath = context.getFilePath();
+		if (filePath.includes("/tests/") || filePath.includes("/test/") || filePath.includes("/examples/") || filePath.includes(".test.") || filePath.includes(".spec.")) return {};
+		let devGuardDepth = 0;
+		return {
+			IfStatement(node) {
+				if (node.test?.type === "Identifier" && node.test.name === "__DEV__") devGuardDepth++;
+			},
+			"IfStatement:exit"(node) {
+				if (node.test?.type === "Identifier" && node.test.name === "__DEV__") devGuardDepth--;
+			},
+			CallExpression(node) {
+				if (devGuardDepth > 0) return;
+				const callee = node.callee;
+				if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === "console" && callee.property?.type === "Identifier" && (callee.property.name === "warn" || callee.property.name === "error")) context.report({
+					message: `\`console.${callee.property.name}()\` without \`__DEV__\` guard — dev warnings must be tree-shakeable in production. Wrap in \`if (__DEV__) { ... }\`.`,
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/architecture/no-circular-import.ts
+const LAYER_ORDER = {
+	"@pyreon/reactivity": 0,
+	"@pyreon/core": 1,
+	"@pyreon/compiler": 1,
+	"@pyreon/runtime-dom": 2,
+	"@pyreon/runtime-server": 2,
+	"@pyreon/router": 3,
+	"@pyreon/head": 4,
+	"@pyreon/server": 5
+};
+function getLayer(source) {
+	return LAYER_ORDER[source] ?? null;
+}
+function getFileLayer(filePath) {
+	for (const [pkg, layer] of Object.entries(LAYER_ORDER)) {
+		const pkgName = pkg.replace("@pyreon/", "");
+		if (filePath.includes(`/packages/core/${pkgName}/`)) return layer;
+	}
+	return null;
+}
+const noCircularImport = {
+	meta: {
+		id: "pyreon/no-circular-import",
+		category: "architecture",
+		description: "Enforce package layer order to prevent circular imports between core packages.",
+		severity: "error",
+		fixable: false
+	},
+	create(context) {
+		const fileLayer = getFileLayer(context.getFilePath());
+		if (fileLayer === null) return {};
+		return { ImportDeclaration(node) {
+			const source = node.source?.value;
+			if (!source || !isPyreonImport(source)) return;
+			const importLayer = getLayer(source);
+			if (importLayer === null) return;
+			if (importLayer >= fileLayer) context.report({
+				message: `Importing \`${source}\` (layer ${importLayer}) from layer ${fileLayer} — this violates the package layer order and may cause circular imports.`,
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/architecture/no-cross-layer-import.ts
+const CORE_PACKAGES = new Set([
+	"@pyreon/reactivity",
+	"@pyreon/core",
+	"@pyreon/compiler",
+	"@pyreon/runtime-dom",
+	"@pyreon/runtime-server",
+	"@pyreon/router",
+	"@pyreon/head",
+	"@pyreon/server"
+]);
+const UI_PACKAGES = new Set([
+	"@pyreon/ui-core",
+	"@pyreon/styler",
+	"@pyreon/unistyle",
+	"@pyreon/elements",
+	"@pyreon/attrs",
+	"@pyreon/rocketstyle",
+	"@pyreon/coolgrid",
+	"@pyreon/kinetic",
+	"@pyreon/kinetic-presets",
+	"@pyreon/connector-document",
+	"@pyreon/document-primitives"
+]);
+function getImportCategory(source) {
+	if (CORE_PACKAGES.has(source)) return "core";
+	if (UI_PACKAGES.has(source)) return "ui-system";
+	return null;
+}
+function getFileCategory(filePath) {
+	if (filePath.includes("/packages/core/")) return "core";
+	if (filePath.includes("/packages/ui-system/")) return "ui-system";
+	if (filePath.includes("/packages/fundamentals/")) return "fundamentals";
+	if (filePath.includes("/packages/tools/")) return "tools";
+	return null;
+}
+const noCrossLayerImport = {
+	meta: {
+		id: "pyreon/no-cross-layer-import",
+		category: "architecture",
+		description: "Prevent core packages from importing ui-system packages.",
+		severity: "error",
+		fixable: false
+	},
+	create(context) {
+		if (getFileCategory(context.getFilePath()) !== "core") return {};
+		return { ImportDeclaration(node) {
+			const source = node.source?.value;
+			if (!source || !isPyreonImport(source)) return;
+			if (getImportCategory(source) === "ui-system") context.report({
+				message: `Core package importing ui-system package \`${source}\` — core packages must not depend on ui-system.`,
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/architecture/no-deep-import.ts
+const DEEP_IMPORT_PATTERN = /@pyreon\/[^/]+\/(src|dist|lib)\//;
+const noDeepImport = {
+	meta: {
+		id: "pyreon/no-deep-import",
+		category: "architecture",
+		description: "Disallow importing from @pyreon/*/src/, /dist/, or /lib/ — use public exports instead.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { ImportDeclaration(node) {
+			const source = node.source?.value;
+			if (!source || !isPyreonImport(source)) return;
+			if (DEEP_IMPORT_PATTERN.test(source)) context.report({
+				message: `Deep import \`${source}\` — import from the package's public exports instead.`,
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/architecture/no-error-without-prefix.ts
+const noErrorWithoutPrefix = {
+	meta: {
+		id: "pyreon/no-error-without-prefix",
+		category: "architecture",
+		description: "Require error messages to be prefixed with [Pyreon].",
+		severity: "warn",
+		fixable: true
+	},
+	create(context) {
+		const filePath = context.getFilePath();
+		if (filePath.includes("/tests/") || filePath.includes("/test/") || filePath.includes(".test.") || filePath.includes(".spec.")) return {};
+		return { ThrowStatement(node) {
+			const arg = node.argument;
+			if (!arg || arg.type !== "NewExpression") return;
+			const callee = arg.callee;
+			if (!callee || callee.type !== "Identifier" || callee.name !== "Error") return;
+			const args = arg.arguments;
+			if (!args || args.length === 0) return;
+			const firstArg = args[0];
+			if (!firstArg) return;
+			if (firstArg.type === "Literal" || firstArg.type === "StringLiteral") {
+				const value = firstArg.value;
+				if (typeof value === "string" && !value.startsWith("[Pyreon]")) {
+					const argSpan = getSpan(firstArg);
+					const quote = context.getSourceText()[argSpan.start];
+					const fixedValue = `${quote}[Pyreon] ${value}${quote}`;
+					context.report({
+						message: "Error message missing `[Pyreon]` prefix — all framework errors should be prefixed for identification.",
+						span: getSpan(node),
+						fix: {
+							span: argSpan,
+							replacement: fixedValue
+						}
+					});
+				}
+			}
+			if (firstArg.type === "TemplateLiteral") {
+				const quasis = firstArg.quasis;
+				if (quasis && quasis.length > 0) {
+					const first = quasis[0];
+					if (!(first.value?.raw ?? first.value?.cooked ?? "").startsWith("[Pyreon]")) {
+						const argSpan = getSpan(firstArg);
+						const fixed = context.getSourceText().slice(argSpan.start, argSpan.end).replace(/^`/, "`[Pyreon] ");
+						context.report({
+							message: "Error message missing `[Pyreon]` prefix — all framework errors should be prefixed for identification.",
+							span: getSpan(node),
+							fix: {
+								span: argSpan,
+								replacement: fixed
+							}
+						});
+					}
+				}
+			}
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/form/no-submit-without-validation.ts
+const noSubmitWithoutValidation = {
+	meta: {
+		id: "pyreon/no-submit-without-validation",
+		category: "form",
+		description: "Warn when useForm() has onSubmit but no validators or schema.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { CallExpression(node) {
+			if (!isCallTo(node, "useForm")) return;
+			const args = node.arguments;
+			if (!args || args.length === 0) return;
+			const options = args[0];
+			if (!options || options.type !== "ObjectExpression") return;
+			let hasOnSubmit = false;
+			let hasValidation = false;
+			for (const prop of options.properties ?? []) {
+				if (prop.type !== "Property") continue;
+				const key = prop.key;
+				if (!key) continue;
+				const name = key.type === "Identifier" ? key.name : null;
+				if (name === "onSubmit") hasOnSubmit = true;
+				if (name === "validators" || name === "schema") hasValidation = true;
+			}
+			if (hasOnSubmit && !hasValidation) context.report({
+				message: "`useForm()` has `onSubmit` without `validators` or `schema` — consider adding validation for data integrity.",
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/form/no-unregistered-field.ts
+const noUnregisteredField = {
+	meta: {
+		id: "pyreon/no-unregistered-field",
+		category: "form",
+		description: "Warn when useField() is called without a corresponding register() call.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		const fieldDecls = /* @__PURE__ */ new Map();
+		const registeredNames = /* @__PURE__ */ new Set();
+		return {
+			VariableDeclarator(node) {
+				const init = node.init;
+				if (!init || !isCallTo(init, "useField")) return;
+				const id = node.id;
+				if (!id || id.type !== "Identifier") return;
+				fieldDecls.set(id.name, { span: getSpan(node) });
+			},
+			CallExpression(node) {
+				const callee = node.callee;
+				if (!callee || callee.type !== "MemberExpression") return;
+				if (callee.property?.type !== "Identifier" || callee.property.name !== "register") return;
+				if (callee.object?.type === "Identifier") registeredNames.add(callee.object.name);
+			},
+			"Program:exit"() {
+				for (const [name, { span }] of fieldDecls) if (!registeredNames.has(name)) context.report({
+					message: `\`useField()\` result \`${name}\` is never registered — call \`${name}.register()\` to connect it to the form.`,
+					span
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/form/prefer-field-array.ts
+const preferFieldArray = {
+	meta: {
+		id: "pyreon/prefer-field-array",
+		category: "form",
+		description: "Suggest useFieldArray() instead of signal([]) in files that import @pyreon/form.",
+		severity: "info",
+		fixable: false
+	},
+	create(context) {
+		let importsForm = false;
+		return {
+			ImportDeclaration(node) {
+				const info = extractImportInfo(node);
+				if (info && info.source === "@pyreon/form") importsForm = true;
+			},
+			CallExpression(node) {
+				if (!importsForm) return;
+				if (!isCallTo(node, "signal")) return;
+				const args = node.arguments;
+				if (!args || args.length === 0) return;
+				if (args[0]?.type === "ArrayExpression") context.report({
+					message: "`signal([])` in a form file — consider using `useFieldArray()` for dynamic array fields with stable keys.",
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/hooks/no-raw-addeventlistener.ts
+const noRawAddEventListener = {
+	meta: {
+		id: "pyreon/no-raw-addeventlistener",
+		category: "hooks",
+		description: "Suggest useEventListener() instead of raw .addEventListener() calls.",
+		severity: "info",
+		fixable: false
+	},
+	create(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (!callee || callee.type !== "MemberExpression") return;
+			if (callee.property?.type !== "Identifier" || callee.property.name !== "addEventListener") return;
+			context.report({
+				message: "Raw `.addEventListener()` — consider using `useEventListener()` from `@pyreon/hooks` for auto-cleanup on unmount.",
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/hooks/no-raw-localstorage.ts
+const STORAGE_OBJECTS = new Set(["localStorage", "sessionStorage"]);
+const STORAGE_METHODS = new Set([
+	"getItem",
+	"setItem",
+	"removeItem"
+]);
+const noRawLocalStorage = {
+	meta: {
+		id: "pyreon/no-raw-localstorage",
+		category: "hooks",
+		description: "Suggest useStorage() instead of raw localStorage/sessionStorage access.",
+		severity: "info",
+		fixable: false
+	},
+	create(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (!callee || callee.type !== "MemberExpression") return;
+			if (callee.object?.type === "Identifier" && STORAGE_OBJECTS.has(callee.object.name) && callee.property?.type === "Identifier" && STORAGE_METHODS.has(callee.property.name)) context.report({
+				message: `Raw \`${callee.object.name}.${callee.property.name}()\` — consider using \`useStorage()\` from \`@pyreon/storage\` for reactive, cross-tab synced storage.`,
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/hooks/no-raw-setinterval.ts
+const TIMER_FNS = new Set(["setInterval", "setTimeout"]);
+const noRawSetInterval = {
+	meta: {
+		id: "pyreon/no-raw-setinterval",
+		category: "hooks",
+		description: "Suggest wrapping setInterval/setTimeout in onMount for automatic cleanup.",
+		severity: "info",
+		fixable: false
+	},
+	create(context) {
+		let mountDepth = 0;
+		return {
+			CallExpression(node) {
+				if (isCallTo(node, "onMount")) mountDepth++;
+				if (mountDepth > 0) return;
+				const callee = node.callee;
+				if (!callee || callee.type !== "Identifier") return;
+				if (TIMER_FNS.has(callee.name)) context.report({
+					message: `\`${callee.name}()\` outside \`onMount\` — wrap in \`onMount(() => { ... return () => clear... })\` for automatic cleanup.`,
+					span: getSpan(node)
+				});
+			},
+			"CallExpression:exit"(node) {
+				if (isCallTo(node, "onMount")) mountDepth--;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/jsx/no-and-conditional.ts
+const noAndConditional = {
+	meta: {
+		id: "pyreon/no-and-conditional",
+		category: "jsx",
+		description: "Prefer <Show> over `&&` with JSX in expression containers.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let jsxExpressionDepth = 0;
+		return {
+			JSXExpressionContainer() {
+				jsxExpressionDepth++;
+			},
+			"JSXExpressionContainer:exit"() {
+				jsxExpressionDepth--;
+			},
+			LogicalExpression(node) {
+				if (jsxExpressionDepth === 0) return;
+				if (!isLogicalAndWithJSX(node)) return;
+				context.report({
+					message: "`&&` with JSX — use `<Show>` for conditional rendering.",
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/jsx/no-children-access.ts
+const noChildrenAccess = {
+	meta: {
+		id: "pyreon/no-children-access",
+		category: "jsx",
+		description: "Inform about direct props.children access in renderer files.",
+		severity: "info",
+		fixable: false
+	},
+	create(context) {
+		const imports = [];
+		let isRendererFile = false;
+		return {
+			ImportDeclaration(node) {
+				const info = extractImportInfo(node);
+				if (info) {
+					imports.push(info);
+					if (info.source === "@pyreon/runtime-server" || info.source === "@pyreon/runtime-dom") isRendererFile = true;
+				}
+			},
+			MemberExpression(node) {
+				if (!isRendererFile) return;
+				if (node.object?.type === "Identifier" && node.property?.type === "Identifier" && node.property.name === "children") context.report({
+					message: "Direct `props.children` access in a renderer file — children are already merged via `mergeChildrenIntoProps`.",
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/jsx/no-classname.ts
+const noClassName = {
+	meta: {
+		id: "pyreon/no-classname",
+		category: "jsx",
+		description: "Use `class` instead of `className` — Pyreon uses standard HTML attributes.",
+		severity: "error",
+		fixable: true
+	},
+	create(context) {
+		return { JSXAttribute(node) {
+			if (node.name?.type !== "JSXIdentifier") return;
+			if (node.name.name !== "className") return;
+			const nameSpan = getSpan(node.name);
+			context.report({
+				message: "Use `class` instead of `className` — Pyreon uses standard HTML attributes.",
+				span: getSpan(node),
+				fix: {
+					span: nameSpan,
+					replacement: "class"
+				}
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/jsx/no-htmlfor.ts
+const noHtmlFor = {
+	meta: {
+		id: "pyreon/no-htmlfor",
+		category: "jsx",
+		description: "Use `for` instead of `htmlFor` — Pyreon uses standard HTML attributes.",
+		severity: "error",
+		fixable: true
+	},
+	create(context) {
+		return { JSXAttribute(node) {
+			if (node.name?.type !== "JSXIdentifier") return;
+			if (node.name.name !== "htmlFor") return;
+			const nameSpan = getSpan(node.name);
+			context.report({
+				message: "Use `for` instead of `htmlFor` — Pyreon uses standard HTML attributes.",
+				span: getSpan(node),
+				fix: {
+					span: nameSpan,
+					replacement: "for"
+				}
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/jsx/no-index-as-by.ts
+const noIndexAsBy = {
+	meta: {
+		id: "pyreon/no-index-as-by",
+		category: "jsx",
+		description: "Disallow using index as `by` prop on <For> — use a unique key instead.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { JSXOpeningElement(node) {
+			const name = node.name;
+			if (!name || name.type !== "JSXIdentifier" || name.name !== "For") return;
+			const byAttr = getJSXAttribute(node, "by");
+			if (!byAttr) return;
+			const value = byAttr.value;
+			if (!value || value.type !== "JSXExpressionContainer") return;
+			const expr = value.expression;
+			if (!expr) return;
+			if (expr.type === "ArrowFunctionExpression" || expr.type === "FunctionExpression") {
+				const params = expr.params;
+				if (!params || params.length < 2) return;
+				const secondParam = params[1];
+				if (!secondParam || secondParam.type !== "Identifier") return;
+				const indexName = secondParam.name;
+				const body = expr.body;
+				if (body?.type === "Identifier" && body.name === indexName) context.report({
+					message: "Using index as `by` prop on `<For>` — use a unique key from the data instead.",
+					span: getSpan(byAttr)
+				});
+				if (body?.type === "BlockStatement") {
+					const stmts = body.body;
+					if (stmts?.length === 1) {
+						const stmt = stmts[0];
+						if (stmt.type === "ReturnStatement" && stmt.argument?.type === "Identifier" && stmt.argument.name === indexName) context.report({
+							message: "Using index as `by` prop on `<For>` — use a unique key from the data instead.",
+							span: getSpan(byAttr)
+						});
+					}
+				}
+			}
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/jsx/no-map-in-jsx.ts
+const noMapInJsx = {
+	meta: {
+		id: "pyreon/no-map-in-jsx",
+		category: "jsx",
+		description: "Prefer <For> over .map() inside JSX for reactive list rendering.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let jsxDepth = 0;
+		return {
+			JSXElement() {
+				jsxDepth++;
+			},
+			"JSXElement:exit"() {
+				jsxDepth--;
+			},
+			JSXFragment() {
+				jsxDepth++;
+			},
+			"JSXFragment:exit"() {
+				jsxDepth--;
+			},
+			CallExpression(node) {
+				if (jsxDepth === 0) return;
+				if (!isArrayMapCall(node)) return;
+				const args = node.arguments;
+				if (!args || args.length === 0) return;
+				if (!args[0]) return;
+				context.report({
+					message: "`.map()` in JSX — use `<For>` for reactive list rendering instead.",
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/jsx/no-missing-for-by.ts
+const noMissingForBy = {
+	meta: {
+		id: "pyreon/no-missing-for-by",
+		category: "jsx",
+		description: "Warn when <For> is used without a `by` prop.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { JSXOpeningElement(node) {
+			const name = node.name;
+			if (!name || name.type !== "JSXIdentifier" || name.name !== "For") return;
+			if (hasJSXAttribute(node, "by")) return;
+			context.report({
+				message: "`<For>` without `by` prop — provide a key function for efficient reconciliation.",
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/jsx/no-onchange.ts
+const INPUT_TAGS = new Set([
+	"input",
+	"textarea",
+	"select"
+]);
+const noOnChange = {
+	meta: {
+		id: "pyreon/no-onchange",
+		category: "jsx",
+		description: "Prefer `onInput` over `onChange` on input elements for keypress-by-keypress updates.",
+		severity: "warn",
+		fixable: true
+	},
+	create(context) {
+		let currentTag = null;
+		return { JSXOpeningElement(node) {
+			const name = node.name;
+			if (name?.type === "JSXIdentifier" && INPUT_TAGS.has(name.name)) currentTag = name.name;
+			else currentTag = null;
+			if (!currentTag) return;
+			const attrs = node.attributes ?? [];
+			for (const attr of attrs) if (attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === "onChange") {
+				const nameSpan = getSpan(attr.name);
+				context.report({
+					message: `Use \`onInput\` instead of \`onChange\` on \`<${currentTag}>\` for keypress-by-keypress updates.`,
+					span: getSpan(attr),
+					fix: {
+						span: nameSpan,
+						replacement: "onInput"
+					}
+				});
+			}
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/jsx/no-props-destructure.ts
+function containsJSXReturn(node) {
+	if (!node) return false;
+	if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
+	if (node.type === "ParenthesizedExpression") return containsJSXReturn(node.expression);
+	if (node.type === "BlockStatement") {
+		for (const stmt of node.body ?? []) if (stmt.type === "ReturnStatement" && containsJSXReturn(stmt.argument)) return true;
+	}
+	return false;
+}
+const noPropsDestructure = {
+	meta: {
+		id: "pyreon/no-props-destructure",
+		category: "jsx",
+		description: "Disallow destructuring props in component functions — it breaks signal reactivity.",
+		severity: "error",
+		fixable: false
+	},
+	create(context) {
+		return {
+			ArrowFunctionExpression(node) {
+				checkFunction(node, context);
+			},
+			FunctionDeclaration(node) {
+				checkFunction(node, context);
+			},
+			FunctionExpression(node) {
+				checkFunction(node, context);
+			}
+		};
+	}
+};
+function checkFunction(node, context) {
+	const params = node.params;
+	if (!params || params.length === 0) return;
+	const firstParam = params[0];
+	if (!isDestructuring(firstParam)) return;
+	const body = node.body;
+	if (!body) return;
+	if (containsJSXReturn(body)) context.report({
+		message: "Destructured props in a component function — this breaks signal reactivity. Use `props.x` or `splitProps()` instead.",
+		span: getSpan(firstParam)
+	});
+}
+
+//#endregion
+//#region src/rules/jsx/no-ternary-conditional.ts
+const noTernaryConditional = {
+	meta: {
+		id: "pyreon/no-ternary-conditional",
+		category: "jsx",
+		description: "Prefer <Show> over ternary expressions with JSX branches.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let jsxExpressionDepth = 0;
+		return {
+			JSXExpressionContainer() {
+				jsxExpressionDepth++;
+			},
+			"JSXExpressionContainer:exit"() {
+				jsxExpressionDepth--;
+			},
+			ConditionalExpression(node) {
+				if (jsxExpressionDepth === 0) return;
+				if (!isTernaryWithJSX(node)) return;
+				context.report({
+					message: "Ternary with JSX — use `<Show>` for more efficient conditional rendering.",
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/jsx/use-by-not-key.ts
+const useByNotKey = {
+	meta: {
+		id: "pyreon/use-by-not-key",
+		category: "jsx",
+		description: "Use `by` prop on <For> instead of `key` — JSX reserves `key` for VNode reconciliation.",
+		severity: "error",
+		fixable: true
+	},
+	create(context) {
+		return { JSXOpeningElement(node) {
+			if ((node.name?.type === "JSXIdentifier" ? node.name.name : null) !== "For") return;
+			const keyAttr = getJSXAttribute(node, "key");
+			if (!keyAttr) return;
+			if (hasJSXAttribute(node, "by")) return;
+			const attrSpan = getSpan(keyAttr.name);
+			context.report({
+				message: "Use `by` prop on `<For>` instead of `key` — JSX reserves `key` for VNode reconciliation.",
+				span: getSpan(keyAttr),
+				fix: {
+					span: attrSpan,
+					replacement: "by"
+				}
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/lifecycle/no-dom-in-setup.ts
+const DOM_METHODS = new Set([
+	"querySelector",
+	"querySelectorAll",
+	"getElementById",
+	"getElementsByClassName",
+	"getElementsByTagName"
+]);
+const noDomInSetup = {
+	meta: {
+		id: "pyreon/no-dom-in-setup",
+		category: "lifecycle",
+		description: "Warn when DOM query methods are used outside onMount or effect.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let safeDepth = 0;
+		return {
+			CallExpression(node) {
+				if (isCallTo(node, "onMount") || isCallTo(node, "effect")) safeDepth++;
+				if (safeDepth > 0) return;
+				const callee = node.callee;
+				if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === "document" && callee.property?.type === "Identifier" && DOM_METHODS.has(callee.property.name)) context.report({
+					message: `\`document.${callee.property.name}()\` outside \`onMount\`/\`effect\` — DOM is not available during SSR or setup phase.`,
+					span: getSpan(node)
+				});
+			},
+			"CallExpression:exit"(node) {
+				if (isCallTo(node, "onMount") || isCallTo(node, "effect")) safeDepth--;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/lifecycle/no-effect-in-mount.ts
+const noEffectInMount = {
+	meta: {
+		id: "pyreon/no-effect-in-mount",
+		category: "lifecycle",
+		description: "Inform when effect() is created inside onMount — effects are typically created at setup time.",
+		severity: "info",
+		fixable: false
+	},
+	create(context) {
+		let mountDepth = 0;
+		return {
+			CallExpression(node) {
+				if (isCallTo(node, "onMount")) mountDepth++;
+				if (mountDepth > 0 && isCallTo(node, "effect")) context.report({
+					message: "`effect()` inside `onMount` — effects are typically created at component setup time, not inside lifecycle hooks.",
+					span: getSpan(node)
+				});
+			},
+			"CallExpression:exit"(node) {
+				if (isCallTo(node, "onMount")) mountDepth--;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/lifecycle/no-missing-cleanup.ts
+const NEEDS_CLEANUP = new Set(["setInterval", "addEventListener"]);
+const noMissingCleanup = {
+	meta: {
+		id: "pyreon/no-missing-cleanup",
+		category: "lifecycle",
+		description: "Warn when onMount uses setInterval/addEventListener without returning a cleanup function.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { CallExpression(node) {
+			if (!isCallTo(node, "onMount")) return;
+			const args = node.arguments;
+			if (!args || args.length === 0) return;
+			const fn = args[0];
+			if (!fn) return;
+			if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression") return;
+			const body = fn.body;
+			if (!body) return;
+			if (body.type !== "BlockStatement") return;
+			let hasCleanupTarget = false;
+			let hasReturn = false;
+			function walk(n) {
+				if (!n) return;
+				if (n.type === "CallExpression") {
+					const callee = n.callee;
+					if (callee?.type === "Identifier" && NEEDS_CLEANUP.has(callee.name)) hasCleanupTarget = true;
+					if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier" && NEEDS_CLEANUP.has(callee.property.name)) hasCleanupTarget = true;
+				}
+				if (n.type === "ReturnStatement" && n.argument) hasReturn = true;
+				for (const key of Object.keys(n)) {
+					const child = n[key];
+					if (child && typeof child === "object") {
+						if (Array.isArray(child)) {
+							for (const item of child) if (item && typeof item.type === "string") walk(item);
+						} else if (typeof child.type === "string") walk(child);
+					}
+				}
+			}
+			walk(body);
+			if (hasCleanupTarget && !hasReturn) context.report({
+				message: "`onMount` uses `setInterval`/`addEventListener` without returning a cleanup function — this will cause a memory leak.",
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/lifecycle/no-mount-in-effect.ts
+const noMountInEffect = {
+	meta: {
+		id: "pyreon/no-mount-in-effect",
+		category: "lifecycle",
+		description: "Warn when onMount is called inside effect().",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let effectDepth = 0;
+		return {
+			CallExpression(node) {
+				if (isCallTo(node, "effect")) effectDepth++;
+				if (effectDepth > 0 && isCallTo(node, "onMount")) context.report({
+					message: "`onMount` inside `effect()` — `onMount` runs once on mount, not on every effect re-run.",
+					span: getSpan(node)
+				});
+			},
+			"CallExpression:exit"(node) {
+				if (isCallTo(node, "effect")) effectDepth--;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/performance/no-eager-import.ts
+const noEagerImport = {
+	meta: {
+		id: "pyreon/no-eager-import",
+		category: "performance",
+		description: "Suggest lazy-loading heavy Pyreon packages (charts, code, document, flow).",
+		severity: "info",
+		fixable: false
+	},
+	create(context) {
+		return { ImportDeclaration(node) {
+			const source = node.source?.value;
+			if (!source) return;
+			if (HEAVY_PACKAGES.has(source)) context.report({
+				message: `Static import of \`${source}\` — consider using \`lazy()\` or dynamic \`import()\` to reduce initial bundle size.`,
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/performance/no-effect-in-for.ts
+const noEffectInFor = {
+	meta: {
+		id: "pyreon/no-effect-in-for",
+		category: "performance",
+		description: "Warn when effect() is created inside <For> — creates effects per item on every reconciliation.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let forJsxDepth = 0;
+		return {
+			JSXOpeningElement(node) {
+				const name = node.name;
+				if (name?.type === "JSXIdentifier" && name.name === "For") forJsxDepth++;
+			},
+			JSXClosingElement(node) {
+				const name = node.name;
+				if (name?.type === "JSXIdentifier" && name.name === "For") forJsxDepth--;
+			},
+			CallExpression(node) {
+				if (forJsxDepth === 0) return;
+				if (isCallTo(node, "effect")) context.report({
+					message: "`effect()` inside `<For>` — this creates a new effect for every item on each reconciliation. Lift the effect outside.",
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/performance/no-large-for-without-by.ts
+const noLargeForWithoutBy = {
+	meta: {
+		id: "pyreon/no-large-for-without-by",
+		category: "performance",
+		description: "Error when <For> is used without a `by` prop — critical for reconciliation performance.",
+		severity: "error",
+		fixable: false
+	},
+	create(context) {
+		return { JSXOpeningElement(node) {
+			const name = node.name;
+			if (!name || name.type !== "JSXIdentifier" || name.name !== "For") return;
+			if (hasJSXAttribute(node, "by")) return;
+			context.report({
+				message: "`<For>` without `by` prop — provide a key function for efficient reconciliation.",
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/performance/prefer-show-over-display.ts
+const preferShowOverDisplay = {
+	meta: {
+		id: "pyreon/prefer-show-over-display",
+		category: "performance",
+		description: "Suggest <Show> over conditional `display` style property in JSX.",
+		severity: "info",
+		fixable: false
+	},
+	create(context) {
+		return { JSXAttribute(node) {
+			if (node.name?.type !== "JSXIdentifier" || node.name.name !== "style") return;
+			const value = node.value;
+			if (!value || value.type !== "JSXExpressionContainer") return;
+			const expr = value.expression;
+			if (!expr || expr.type !== "ObjectExpression") return;
+			for (const prop of expr.properties ?? []) {
+				if (prop.type !== "Property") continue;
+				const key = prop.key;
+				if (!key) continue;
+				if ((key.type === "Identifier" ? key.name : key.type === "Literal" ? key.value : null) === "display") {
+					const val = prop.value;
+					if (val?.type === "ConditionalExpression" || val?.type === "LogicalExpression" || val?.type === "CallExpression") context.report({
+						message: "Conditional `display` style — consider using `<Show>` for conditional rendering instead of toggling CSS display.",
+						span: getSpan(prop)
+					});
+				}
+			}
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/reactivity/no-bare-signal-in-jsx.ts
+const SKIP_PREFIXES = /^(use|get|is|has|[A-Z])/;
+const noBareSignalInJsx = {
+	meta: {
+		id: "pyreon/no-bare-signal-in-jsx",
+		category: "reactivity",
+		description: "Disallow bare signal calls in JSX text positions. Wrap in `() =>` for reactivity.",
+		severity: "error",
+		fixable: true
+	},
+	create(context) {
+		let jsxDepth = 0;
+		return {
+			JSXElement() {
+				jsxDepth++;
+			},
+			"JSXElement:exit"() {
+				jsxDepth--;
+			},
+			JSXFragment() {
+				jsxDepth++;
+			},
+			"JSXFragment:exit"() {
+				jsxDepth--;
+			},
+			JSXExpressionContainer(node) {
+				if (jsxDepth === 0) return;
+				const expr = node.expression;
+				if (!expr || expr.type !== "CallExpression") return;
+				const callee = expr.callee;
+				if (!callee || callee.type !== "Identifier") return;
+				const name = callee.name;
+				if (SKIP_PREFIXES.test(name)) return;
+				const span = getSpan(node);
+				const fixed = `{() => ${context.getSourceText().slice(span.start, span.end).slice(1, -1)}}`;
+				context.report({
+					message: `Bare signal call \`${name}()\` in JSX text — wrap in \`() => ${name}()\` for fine-grained reactivity.`,
+					span,
+					fix: {
+						span,
+						replacement: fixed
+					}
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/reactivity/no-context-destructure.ts
+/**
+* Detects destructuring the return value of useContext().
+*
+* `const { mode } = useContext(ctx)` loses reactivity when the context
+* provides getter properties. The value is captured once at setup time.
+*
+* Correct: `const ctx = useContext(Ctx)` then read `ctx.mode` lazily.
+*/
+const noContextDestructure = {
+	meta: {
+		id: "pyreon/no-context-destructure",
+		category: "reactivity",
+		description: "Disallow destructuring useContext() — it breaks reactivity when context provides getters.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { VariableDeclarator(node) {
+			const id = node.id;
+			const init = node.init;
+			if (!id || !init) return;
+			if (id.type !== "ObjectPattern") return;
+			if (init.type !== "CallExpression" || init.callee?.type !== "Identifier" || init.callee.name !== "useContext") return;
+			context.report({
+				message: "Destructuring useContext() captures values once — reactive getters lose reactivity. Keep the object reference: `const ctx = useContext(Ctx)` and access `ctx.mode` lazily.",
+				span: getSpan(id)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/reactivity/no-effect-assignment.ts
+function isUpdateCall(node) {
+	return node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.property?.type === "Identifier" && node.callee.property.name === "update";
+}
+const noEffectAssignment = {
+	meta: {
+		id: "pyreon/no-effect-assignment",
+		category: "reactivity",
+		description: "Warn when an effect only contains a single .update() call.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { CallExpression(node) {
+			if (!isCallTo(node, "effect")) return;
+			const args = node.arguments;
+			if (!args || args.length === 0) return;
+			const fn = args[0];
+			if (!fn) return;
+			let body = null;
+			if (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionExpression") body = fn.body;
+			if (!body) return;
+			if (isUpdateCall(body)) {
+				context.report({
+					message: "Effect contains a single `.update()` — consider using `computed()` for derived values.",
+					span: getSpan(node)
+				});
+				return;
+			}
+			if (body.type === "BlockStatement") {
+				const stmts = body.body;
+				if (stmts && stmts.length === 1) {
+					const stmt = stmts[0];
+					if (stmt.type === "ExpressionStatement" && isUpdateCall(stmt.expression)) context.report({
+						message: "Effect contains a single `.update()` — consider using `computed()` for derived values.",
+						span: getSpan(node)
+					});
+				}
+			}
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/reactivity/no-nested-effect.ts
+const noNestedEffect = {
+	meta: {
+		id: "pyreon/no-nested-effect",
+		category: "reactivity",
+		description: "Warn against nesting effect() inside another effect().",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let effectDepth = 0;
+		return {
+			CallExpression(node) {
+				if (!isCallTo(node, "effect")) return;
+				if (effectDepth > 0) context.report({
+					message: "Nested `effect()` — consider using `computed()` for derived values instead.",
+					span: getSpan(node)
+				});
+				effectDepth++;
+			},
+			"CallExpression:exit"(node) {
+				if (isCallTo(node, "effect")) effectDepth--;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/reactivity/no-peek-in-tracked.ts
+const noPeekInTracked = {
+	meta: {
+		id: "pyreon/no-peek-in-tracked",
+		category: "reactivity",
+		description: "Disallow .peek() inside effect() or computed() — it bypasses tracking.",
+		severity: "error",
+		fixable: false
+	},
+	create(context) {
+		let trackedDepth = 0;
+		return {
+			CallExpression(node) {
+				if (isCallTo(node, "effect") || isCallTo(node, "computed")) trackedDepth++;
+				if (trackedDepth > 0 && isPeekCall(node)) context.report({
+					message: "`.peek()` inside a tracked scope (effect/computed) bypasses dependency tracking — use a normal signal read instead.",
+					span: getSpan(node)
+				});
+			},
+			"CallExpression:exit"(node) {
+				if (isCallTo(node, "effect") || isCallTo(node, "computed")) trackedDepth--;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/reactivity/no-signal-in-loop.ts
+const noSignalInLoop = {
+	meta: {
+		id: "pyreon/no-signal-in-loop",
+		category: "reactivity",
+		description: "Disallow creating signals or computeds inside loops.",
+		severity: "error",
+		fixable: false
+	},
+	create(context) {
+		let loopDepth = 0;
+		return {
+			ForStatement() {
+				loopDepth++;
+			},
+			"ForStatement:exit"() {
+				loopDepth--;
+			},
+			ForInStatement() {
+				loopDepth++;
+			},
+			"ForInStatement:exit"() {
+				loopDepth--;
+			},
+			ForOfStatement() {
+				loopDepth++;
+			},
+			"ForOfStatement:exit"() {
+				loopDepth--;
+			},
+			WhileStatement() {
+				loopDepth++;
+			},
+			"WhileStatement:exit"() {
+				loopDepth--;
+			},
+			DoWhileStatement() {
+				loopDepth++;
+			},
+			"DoWhileStatement:exit"() {
+				loopDepth--;
+			},
+			CallExpression(node) {
+				if (loopDepth === 0) return;
+				const callee = node.callee;
+				if (!callee || callee.type !== "Identifier") return;
+				if (callee.name === "signal" || callee.name === "computed") context.report({
+					message: `\`${callee.name}()\` inside a loop — signals should be created once at component setup, not on every iteration.`,
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/reactivity/no-signal-leak.ts
+const noSignalLeak = {
+	meta: {
+		id: "pyreon/no-signal-leak",
+		category: "reactivity",
+		description: "Warn about unused signal declarations (potential leaks).",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		const signalDecls = /* @__PURE__ */ new Map();
+		const identifierOccurrences = /* @__PURE__ */ new Map();
+		return {
+			VariableDeclarator(node) {
+				const init = node.init;
+				if (!init || !isCallTo(init, "signal")) return;
+				const id = node.id;
+				if (!id || id.type !== "Identifier") return;
+				signalDecls.set(id.name, {
+					span: getSpan(node),
+					declStart: id.start,
+					declEnd: id.end
+				});
+			},
+			Identifier(node) {
+				const name = node.name;
+				const existing = identifierOccurrences.get(name);
+				if (existing) existing.push({
+					start: node.start,
+					end: node.end
+				});
+				else identifierOccurrences.set(name, [{
+					start: node.start,
+					end: node.end
+				}]);
+			},
+			"Program:exit"() {
+				for (const [name, { span, declStart, declEnd }] of signalDecls) if ((identifierOccurrences.get(name) ?? []).filter((o) => o.start !== declStart || o.end !== declEnd).length === 0) context.report({
+					message: `Signal \`${name}\` is declared but never used — this may be a signal leak.`,
+					span
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/reactivity/no-unbatched-updates.ts
+const noUnbatchedUpdates = {
+	meta: {
+		id: "pyreon/no-unbatched-updates",
+		category: "reactivity",
+		description: "Warn when 3+ .set() calls occur in the same function without batch().",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		const scopeStack = [];
+		let batchDepth = 0;
+		function enterScope(node) {
+			scopeStack.push({
+				setCalls: [],
+				hasBatch: false,
+				insideBatch: batchDepth > 0,
+				node
+			});
+		}
+		function exitScope() {
+			const scope = scopeStack.pop();
+			if (!scope) return;
+			if (!scope.hasBatch && !scope.insideBatch && scope.setCalls.length >= 3) context.report({
+				message: `${scope.setCalls.length} signal \`.set()\` calls without \`batch()\` — wrap in \`batch(() => { ... })\` to avoid unnecessary re-renders.`,
+				span: getSpan(scope.node)
+			});
+		}
+		return {
+			FunctionDeclaration(node) {
+				enterScope(node);
+			},
+			"FunctionDeclaration:exit"() {
+				exitScope();
+			},
+			FunctionExpression(node) {
+				enterScope(node);
+			},
+			"FunctionExpression:exit"() {
+				exitScope();
+			},
+			ArrowFunctionExpression(node) {
+				enterScope(node);
+			},
+			"ArrowFunctionExpression:exit"() {
+				exitScope();
+			},
+			CallExpression(node) {
+				const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+				if (isCallTo(node, "batch")) {
+					batchDepth++;
+					if (currentScope) currentScope.hasBatch = true;
+				}
+				if (currentScope && isSetCall(node)) currentScope.setCalls.push({ span: getSpan(node) });
+			},
+			"CallExpression:exit"(node) {
+				if (isCallTo(node, "batch")) batchDepth--;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/reactivity/prefer-computed.ts
+const preferComputed = {
+	meta: {
+		id: "pyreon/prefer-computed",
+		category: "reactivity",
+		description: "Suggest computed() when an effect only contains a single .set() call.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { CallExpression(node) {
+			if (!isCallTo(node, "effect")) return;
+			const args = node.arguments;
+			if (!args || args.length === 0) return;
+			const fn = args[0];
+			if (!fn) return;
+			let body = null;
+			if (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionExpression") body = fn.body;
+			if (!body) return;
+			if (body.type === "CallExpression" && isSetCall(body)) {
+				context.report({
+					message: "Effect contains a single `.set()` — consider using `computed()` instead for derived values.",
+					span: getSpan(node)
+				});
+				return;
+			}
+			if (body.type === "BlockStatement") {
+				const stmts = body.body;
+				if (stmts && stmts.length === 1) {
+					const stmt = stmts[0];
+					if (stmt.type === "ExpressionStatement" && isSetCall(stmt.expression)) context.report({
+						message: "Effect contains a single `.set()` — consider using `computed()` instead for derived values.",
+						span: getSpan(node)
+					});
+				}
+			}
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/router/no-href-navigation.ts
+const EXTERNAL_PREFIXES = [
+	"http://",
+	"https://",
+	"mailto:",
+	"tel:"
+];
+const noHrefNavigation = {
+	meta: {
+		id: "pyreon/no-href-navigation",
+		category: "router",
+		description: "Warn when `<a href>` is used in files that import @pyreon/router — use `<Link>` instead.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let importsRouter = false;
+		return {
+			ImportDeclaration(node) {
+				const info = extractImportInfo(node);
+				if (info && info.source === "@pyreon/router") importsRouter = true;
+			},
+			JSXOpeningElement(node) {
+				if (!importsRouter) return;
+				const name = node.name;
+				if (!name || name.type !== "JSXIdentifier" || name.name !== "a") return;
+				const hrefAttr = getJSXAttribute(node, "href");
+				if (!hrefAttr) return;
+				const value = hrefAttr.value;
+				if (value?.type === "Literal" && typeof value.value === "string") {
+					const href = value.value;
+					if (href.startsWith("#") || EXTERNAL_PREFIXES.some((p) => href.startsWith(p))) return;
+				}
+				context.report({
+					message: "`<a href>` in a router file — use `<Link>` or `<RouterLink>` for client-side navigation.",
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/router/no-imperative-navigate-in-render.ts
+const noImperativeNavigateInRender = {
+	meta: {
+		id: "pyreon/no-imperative-navigate-in-render",
+		category: "router",
+		description: "Error when navigate() or router.push() is called at the top level of a component — causes infinite render loops.",
+		severity: "error",
+		fixable: false
+	},
+	create(context) {
+		let componentBodyDepth = 0;
+		let safeDepth = 0;
+		return {
+			FunctionDeclaration(node) {
+				const name = node.id?.name ?? "";
+				if (/^[A-Z]/.test(name)) componentBodyDepth++;
+			},
+			"FunctionDeclaration:exit"(node) {
+				const name = node.id?.name ?? "";
+				if (/^[A-Z]/.test(name)) componentBodyDepth--;
+			},
+			VariableDeclarator(node) {
+				const name = node.id?.name ?? "";
+				if (/^[A-Z]/.test(name) && node.init?.type === "ArrowFunctionExpression") componentBodyDepth++;
+			},
+			"VariableDeclarator:exit"(node) {
+				const name = node.id?.name ?? "";
+				if (/^[A-Z]/.test(name) && node.init?.type === "ArrowFunctionExpression") componentBodyDepth--;
+			},
+			CallExpression(node) {
+				if (componentBodyDepth <= 0) return;
+				if (isSafeWrapperCall(node)) safeDepth++;
+				if (safeDepth > 0) return;
+				if (isCallTo(node, "navigate") || isMemberCallTo(node, "router", "push")) context.report({
+					message: "Imperative navigation at the top level of a component — this runs on every render and causes infinite loops. Move inside `onMount`, `effect`, or an event handler.",
+					span: getSpan(node)
+				});
+			},
+			"CallExpression:exit"(node) {
+				if (componentBodyDepth <= 0) return;
+				if (isSafeWrapperCall(node)) safeDepth--;
+			}
+		};
+	}
+};
+function isSafeWrapperCall(node) {
+	const callee = node.callee;
+	if (!callee || callee.type !== "Identifier") return false;
+	const name = callee.name;
+	return name === "onMount" || name === "effect" || name === "onUnmount";
+}
+
+//#endregion
+//#region src/rules/router/no-missing-fallback.ts
+function isCatchAllPath(value) {
+	return value === "*" || value.endsWith("*");
+}
+function getPathValue(prop) {
+	const key = prop.key;
+	if (!key) return null;
+	if ((key.type === "Identifier" ? key.name : null) !== "path") return null;
+	const val = prop.value;
+	if (val?.type === "Literal" && typeof val.value === "string") return val.value;
+	return null;
+}
+function hasPathProperty(obj) {
+	if (!obj || obj.type !== "ObjectExpression") return false;
+	for (const prop of obj.properties ?? []) {
+		if (prop.type !== "Property") continue;
+		if (getPathValue(prop) !== null) return true;
+	}
+	return false;
+}
+function hasCatchAllRoute(elements) {
+	for (const elem of elements) {
+		if (!elem || elem.type !== "ObjectExpression") continue;
+		for (const prop of elem.properties ?? []) {
+			if (prop.type !== "Property") continue;
+			const pathVal = getPathValue(prop);
+			if (pathVal !== null && isCatchAllPath(pathVal)) return true;
+		}
+	}
+	return false;
+}
+const noMissingFallback = {
+	meta: {
+		id: "pyreon/no-missing-fallback",
+		category: "router",
+		description: "Warn when route config has no catch-all route (`path: \"*\"` or `path: \"/:rest*\"`).",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let importsRouter = false;
+		let routeArraySpan = null;
+		let foundCatchAll = false;
+		return {
+			ImportDeclaration(node) {
+				const info = extractImportInfo(node);
+				if (info && info.source === "@pyreon/router") importsRouter = true;
+			},
+			ArrayExpression(node) {
+				if (!importsRouter) return;
+				const elements = node.elements ?? [];
+				if (!elements.some((e) => hasPathProperty(e))) return;
+				if (!routeArraySpan) routeArraySpan = getSpan(node);
+				if (hasCatchAllRoute(elements)) foundCatchAll = true;
+			},
+			"Program:exit"() {
+				if (!importsRouter || !routeArraySpan || foundCatchAll) return;
+				context.report({
+					message: "Route config has no catch-all route — add a `{ path: \"*\", component: NotFound }` for unmatched URLs.",
+					span: routeArraySpan
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/router/prefer-use-is-active.ts
+const preferUseIsActive = {
+	meta: {
+		id: "pyreon/prefer-use-is-active",
+		category: "router",
+		description: "Suggest useIsActive() instead of `location.pathname === \"/foo\"` or `route.path === \"/foo\"` patterns.",
+		severity: "info",
+		fixable: false
+	},
+	create(context) {
+		return { BinaryExpression(node) {
+			if (node.operator !== "===" && node.operator !== "==") return;
+			if (isPathComparison(node.left) || isPathComparison(node.right)) context.report({
+				message: "Manual path comparison — use `useIsActive()` for reactive route matching with segment-aware prefix matching.",
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+function isPathComparison(node) {
+	if (!node || node.type !== "MemberExpression") return false;
+	const obj = node.object;
+	const prop = node.property;
+	if (!obj || !prop || prop.type !== "Identifier") return false;
+	if (obj.type === "Identifier" && obj.name === "location" && prop.name === "pathname") return true;
+	if (obj.type === "Identifier" && obj.name === "route" && prop.name === "path") return true;
+	return false;
+}
+
+//#endregion
+//#region src/rules/ssr/no-mismatch-risk.ts
+const noMismatchRisk = {
+	meta: {
+		id: "pyreon/no-mismatch-risk",
+		category: "ssr",
+		description: "Warn about non-deterministic calls (Date.now, Math.random, crypto.randomUUID) in JSX context that cause hydration mismatches.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let jsxDepth = 0;
+		return {
+			JSXElement() {
+				jsxDepth++;
+			},
+			"JSXElement:exit"() {
+				jsxDepth--;
+			},
+			JSXFragment() {
+				jsxDepth++;
+			},
+			"JSXFragment:exit"() {
+				jsxDepth--;
+			},
+			CallExpression(node) {
+				if (jsxDepth === 0) return;
+				if (isMemberCallTo(node, "Date", "now") || isMemberCallTo(node, "Math", "random") || isMemberCallTo(node, "crypto", "randomUUID")) {
+					const callee = node.callee;
+					const name = `${callee.object.name}.${callee.property.name}`;
+					context.report({
+						message: `\`${name}()\` in JSX context — this produces different values on server and client, causing hydration mismatches.`,
+						span: getSpan(node)
+					});
+				}
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/ssr/no-window-in-ssr.ts
+const noWindowInSsr = {
+	meta: {
+		id: "pyreon/no-window-in-ssr",
+		category: "ssr",
+		description: "Disallow browser globals outside onMount/effect/typeof guards — they break SSR.",
+		severity: "error",
+		fixable: false
+	},
+	create(context) {
+		let safeDepth = 0;
+		let typeofGuardDepth = 0;
+		return {
+			CallExpression(node) {
+				if (isCallTo(node, "onMount") || isCallTo(node, "effect")) safeDepth++;
+			},
+			"CallExpression:exit"(node) {
+				if (isCallTo(node, "onMount") || isCallTo(node, "effect")) safeDepth--;
+			},
+			IfStatement(node) {
+				const test = node.test;
+				if (test?.type === "BinaryExpression" && test.left?.type === "UnaryExpression" && test.left.operator === "typeof") typeofGuardDepth++;
+			},
+			"IfStatement:exit"(node) {
+				const test = node.test;
+				if (test?.type === "BinaryExpression" && test.left?.type === "UnaryExpression" && test.left.operator === "typeof") typeofGuardDepth--;
+			},
+			Identifier(node, parent) {
+				if (safeDepth > 0 || typeofGuardDepth > 0) return;
+				if (!BROWSER_GLOBALS.has(node.name)) return;
+				if (parent?.type === "UnaryExpression" && parent.operator === "typeof") return;
+				if (parent?.type === "ImportSpecifier" || parent?.type === "ImportDefaultSpecifier" || parent?.type === "ImportNamespaceSpecifier") return;
+				if (parent?.type === "MemberExpression" && parent.property === node && !parent.computed) return;
+				context.report({
+					message: `Browser global \`${node.name}\` used outside \`onMount\`/\`effect\`/typeof guard — this will fail during SSR. Wrap in \`onMount(() => { ... })\`.`,
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/ssr/prefer-request-context.ts
+const preferRequestContext = {
+	meta: {
+		id: "pyreon/prefer-request-context",
+		category: "ssr",
+		description: "Warn about module-level signal()/createStore() in server files — use request context instead.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		const filePath = context.getFilePath();
+		if (!(filePath.includes("server") || filePath.includes(".server.") || filePath.endsWith("server.ts") || filePath.endsWith("server.tsx"))) return {};
+		let functionDepth = 0;
+		return {
+			FunctionDeclaration() {
+				functionDepth++;
+			},
+			"FunctionDeclaration:exit"() {
+				functionDepth--;
+			},
+			FunctionExpression() {
+				functionDepth++;
+			},
+			"FunctionExpression:exit"() {
+				functionDepth--;
+			},
+			ArrowFunctionExpression() {
+				functionDepth++;
+			},
+			"ArrowFunctionExpression:exit"() {
+				functionDepth--;
+			},
+			CallExpression(node) {
+				if (functionDepth > 0) return;
+				if (isCallTo(node, "signal") || isCallTo(node, "createStore")) {
+					const name = node.callee.name;
+					context.report({
+						message: `Module-level \`${name}()\` in a server file — this state is shared across all requests. Use \`runWithRequestContext()\` for per-request isolation.`,
+						span: getSpan(node)
+					});
+				}
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/store/no-duplicate-store-id.ts
+const noDuplicateStoreId = {
+	meta: {
+		id: "pyreon/no-duplicate-store-id",
+		category: "store",
+		description: "Disallow duplicate defineStore() IDs in the same file.",
+		severity: "error",
+		fixable: false
+	},
+	create(context) {
+		const storeIds = /* @__PURE__ */ new Map();
+		return { CallExpression(node) {
+			if (!isCallTo(node, "defineStore")) return;
+			const args = node.arguments;
+			if (!args || args.length === 0) return;
+			const firstArg = args[0];
+			if (!firstArg) return;
+			let id = null;
+			if (firstArg.type === "Literal" || firstArg.type === "StringLiteral") id = firstArg.value;
+			if (typeof id !== "string") return;
+			if (storeIds.has(id)) context.report({
+				message: `Duplicate store ID \`"${id}"\` — each \`defineStore()\` must have a unique ID.`,
+				span: getSpan(node)
+			});
+			else storeIds.set(id, getSpan(node));
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/store/no-mutate-store-state.ts
+const noMutateStoreState = {
+	meta: {
+		id: "pyreon/no-mutate-store-state",
+		category: "store",
+		description: "Warn when directly calling .set() on store signals — use store actions instead.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (!callee || callee.type !== "MemberExpression") return;
+			if (callee.property?.type !== "Identifier" || callee.property.name !== "set") return;
+			const obj = callee.object;
+			if (!obj || obj.type !== "MemberExpression") return;
+			const outerObj = obj.object;
+			if (!outerObj || outerObj.type !== "Identifier") return;
+			const name = outerObj.name;
+			if (name.toLowerCase().includes("store")) context.report({
+				message: `Direct \`.set()\` on store state \`${name}\` — use store actions to mutate state for better traceability.`,
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/store/no-store-outside-provider.ts
+const noStoreOutsideProvider = {
+	meta: {
+		id: "pyreon/no-store-outside-provider",
+		category: "store",
+		description: "Warn when store hooks are used in SSR files without a provider import.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		const filePath = context.getFilePath();
+		if (!(filePath.includes("server") || filePath.includes(".server.") || filePath.endsWith("server.ts") || filePath.endsWith("server.tsx"))) return {};
+		let hasProviderImport = false;
+		const storeHookCalls = [];
+		return {
+			ImportDeclaration(node) {
+				const info = extractImportInfo(node);
+				if (!info) return;
+				if (info.specifiers.some((s) => s.imported === "setStoreRegistryProvider" || s.imported === "runWithRequestContext")) hasProviderImport = true;
+			},
+			CallExpression(node) {
+				const callee = node.callee;
+				if (!callee || callee.type !== "Identifier") return;
+				const name = callee.name;
+				if (name.endsWith("Store") && name.startsWith("use")) storeHookCalls.push({
+					name,
+					span: getSpan(node)
+				});
+			},
+			"Program:exit"() {
+				if (hasProviderImport) return;
+				for (const call of storeHookCalls) context.report({
+					message: `\`${call.name}()\` in a server file without a store registry provider — use \`runWithRequestContext()\` or \`setStoreRegistryProvider()\` for SSR isolation.`,
+					span: call.span
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/styling/no-dynamic-styled.ts
+const noDynamicStyled = {
+	meta: {
+		id: "pyreon/no-dynamic-styled",
+		category: "styling",
+		description: "Warn when styled() is called inside a function — it creates new CSS on every render.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let functionDepth = 0;
+		return {
+			FunctionDeclaration() {
+				functionDepth++;
+			},
+			"FunctionDeclaration:exit"() {
+				functionDepth--;
+			},
+			FunctionExpression() {
+				functionDepth++;
+			},
+			"FunctionExpression:exit"() {
+				functionDepth--;
+			},
+			ArrowFunctionExpression() {
+				functionDepth++;
+			},
+			"ArrowFunctionExpression:exit"() {
+				functionDepth--;
+			},
+			CallExpression(node) {
+				if (functionDepth === 0) return;
+				if (isCallTo(node, "styled")) context.report({
+					message: "`styled()` inside a function — this creates new CSS rules on every render. Move `styled()` to module scope.",
+					span: getSpan(node)
+				});
+			},
+			TaggedTemplateExpression(node) {
+				if (functionDepth === 0) return;
+				const tag = node.tag;
+				if (!tag) return;
+				if (tag.type === "CallExpression" && isCallTo(tag, "styled")) context.report({
+					message: "`styled()` tagged template inside a function — this creates new CSS rules on every render. Move to module scope.",
+					span: getSpan(node)
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/styling/no-inline-style-object.ts
+const noInlineStyleObject = {
+	meta: {
+		id: "pyreon/no-inline-style-object",
+		category: "styling",
+		description: "Warn against inline style objects in JSX — prefer styled() or css``.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { JSXAttribute(node) {
+			if (node.name?.type !== "JSXIdentifier" || node.name.name !== "style") return;
+			const value = node.value;
+			if (!value || value.type !== "JSXExpressionContainer") return;
+			if (value.expression?.type === "ObjectExpression") context.report({
+				message: "Inline style object in JSX — consider using `styled()` or `css\\`...\\`` for better performance and caching.",
+				span: getSpan(node)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/styling/no-theme-outside-provider.ts
+const noThemeOutsideProvider = {
+	meta: {
+		id: "pyreon/no-theme-outside-provider",
+		category: "styling",
+		description: "Warn when useTheme() is used without PyreonUI or ThemeProvider in the same file.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		let hasProviderImport = false;
+		const themeCalls = [];
+		return {
+			ImportDeclaration(node) {
+				const info = extractImportInfo(node);
+				if (!info) return;
+				if (info.specifiers.some((s) => s.imported === "PyreonUI" || s.imported === "ThemeProvider")) hasProviderImport = true;
+			},
+			CallExpression(node) {
+				if (isCallTo(node, "useTheme")) themeCalls.push({ span: getSpan(node) });
+			},
+			"Program:exit"() {
+				if (hasProviderImport) return;
+				for (const call of themeCalls) context.report({
+					message: "`useTheme()` without a `PyreonUI` or `ThemeProvider` import — the theme context may not be available.",
+					span: call.span
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/rules/styling/prefer-cx.ts
+const preferCx = {
+	meta: {
+		id: "pyreon/prefer-cx",
+		category: "styling",
+		description: "Suggest cx() for class composition instead of string concatenation or template literals.",
+		severity: "info",
+		fixable: false
+	},
+	create(context) {
+		return { JSXAttribute(node) {
+			if (node.name?.type !== "JSXIdentifier" || node.name.name !== "class") return;
+			const value = node.value;
+			if (!value || value.type !== "JSXExpressionContainer") return;
+			const expr = value.expression;
+			if (!expr) return;
+			if (expr.type === "BinaryExpression" && expr.operator === "+") {
+				context.report({
+					message: "String concatenation in `class` attribute — use `cx()` for cleaner class composition.",
+					span: getSpan(expr)
+				});
+				return;
+			}
+			if (expr.type === "TemplateLiteral" && expr.expressions?.length > 0) context.report({
+				message: "Template literal in `class` attribute — use `cx()` for cleaner class composition.",
+				span: getSpan(expr)
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/rules/index.ts
+const allRules = [
+	noBareSignalInJsx,
+	noContextDestructure,
+	noSignalInLoop,
+	noNestedEffect,
+	noPeekInTracked,
+	noUnbatchedUpdates,
+	preferComputed,
+	noEffectAssignment,
+	noSignalLeak,
+	noMapInJsx,
+	useByNotKey,
+	noClassName,
+	noHtmlFor,
+	noOnChange,
+	noTernaryConditional,
+	noAndConditional,
+	noIndexAsBy,
+	noMissingForBy,
+	noPropsDestructure,
+	noChildrenAccess,
+	noMissingCleanup,
+	noMountInEffect,
+	noEffectInMount,
+	noDomInSetup,
+	noLargeForWithoutBy,
+	noEffectInFor,
+	noEagerImport,
+	preferShowOverDisplay,
+	noWindowInSsr,
+	noMismatchRisk,
+	preferRequestContext,
+	noCircularImport,
+	noDeepImport,
+	noCrossLayerImport,
+	devGuardWarnings,
+	noErrorWithoutPrefix,
+	noStoreOutsideProvider,
+	noMutateStoreState,
+	noDuplicateStoreId,
+	noUnregisteredField,
+	noSubmitWithoutValidation,
+	preferFieldArray,
+	noInlineStyleObject,
+	noDynamicStyled,
+	preferCx,
+	noThemeOutsideProvider,
+	noRawAddEventListener,
+	noRawSetInterval,
+	noRawLocalStorage,
+	toastA11y,
+	dialogA11y,
+	overlayA11y,
+	noHrefNavigation,
+	noImperativeNavigateInRender,
+	noMissingFallback,
+	preferUseIsActive
+];
+
+//#endregion
+//#region src/config/presets.ts
+/** Build a config where every rule uses its default severity. */
+function buildRecommended() {
+	const rules = {};
+	for (const rule of allRules) rules[rule.meta.id] = rule.meta.severity;
+	return { rules };
+}
+/** Build a config where every warn is promoted to error. */
+function buildStrict() {
+	const base = buildRecommended();
+	const rules = {};
+	for (const [id, sev] of Object.entries(base.rules)) rules[id] = sev === "warn" ? "error" : sev;
+	return { rules };
+}
+/** Build app config — recommended but disable library-only rules. */
+function buildApp() {
+	return { rules: {
+		...buildRecommended().rules,
+		"pyreon/dev-guard-warnings": "off",
+		"pyreon/no-error-without-prefix": "off",
+		"pyreon/no-circular-import": "off",
+		"pyreon/no-cross-layer-import": "off"
+	} };
+}
+/** Build lib config — strict + all architecture rules as error. */
+function buildLib() {
+	return { rules: {
+		...buildStrict().rules,
+		"pyreon/no-circular-import": "error",
+		"pyreon/no-cross-layer-import": "error",
+		"pyreon/dev-guard-warnings": "error",
+		"pyreon/no-error-without-prefix": "error"
+	} };
+}
+const presetBuilders = {
+	recommended: buildRecommended,
+	strict: buildStrict,
+	app: buildApp,
+	lib: buildLib
+};
+function getPreset(name) {
+	return presetBuilders[name]();
+}
+
+//#endregion
+//#region src/utils/source.ts
+/**
+* Fast offset→line/column conversion using binary search over precomputed line starts.
+*/
+var LineIndex = class {
+	lineStarts;
+	constructor(sourceText) {
+		this.lineStarts = [0];
+		for (let i = 0; i < sourceText.length; i++) if (sourceText[i] === "\n") this.lineStarts.push(i + 1);
+	}
+	/** Convert a byte offset to a 1-based line and 0-based column. */
+	locate(offset) {
+		let lo = 0;
+		let hi = this.lineStarts.length - 1;
+		while (lo <= hi) {
+			const mid = lo + hi >>> 1;
+			if (this.lineStarts[mid] <= offset) lo = mid + 1;
+			else hi = mid - 1;
+		}
+		const line = lo;
+		return {
+			line,
+			column: offset - this.lineStarts[line - 1]
+		};
+	}
+};
+
+//#endregion
+//#region src/utils/index.ts
+/** Supported JS/TS file extensions for linting. */
+const JS_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs"
+]);
+/** Check if a file path has a supported JS/TS extension. */
+function hasJsExtension(filePath) {
+	const ext = filePath.slice(filePath.lastIndexOf("."));
+	return JS_EXTENSIONS.has(ext);
+}
+
+//#endregion
+//#region src/runner.ts
+function getExtension(filePath) {
+	const lastDot = filePath.lastIndexOf(".");
+	return lastDot === -1 ? "" : filePath.slice(lastDot);
+}
+function getLang(ext) {
+	if (ext === ".tsx" || ext === ".jsx") return "tsx";
+	if (ext === ".ts" || ext === ".mts") return "ts";
+	return "js";
+}
+function createRuleContext(rule, severity, diagnostics, lineIndex, sourceText, filePath) {
+	return {
+		report(partial) {
+			diagnostics.push({
+				ruleId: rule.meta.id,
+				severity,
+				message: partial.message,
+				span: partial.span,
+				loc: lineIndex.locate(partial.span.start),
+				fix: partial.fix
+			});
+		},
+		getSourceText() {
+			return sourceText;
+		},
+		getFilePath() {
+			return filePath;
+		}
+	};
+}
+function mergeCallbacks(allCallbacks) {
+	const callbacksByKey = {};
+	for (const callbacks of allCallbacks) for (const [key, fn] of Object.entries(callbacks)) {
+		const existing = callbacksByKey[key];
+		if (existing) existing.push(fn);
+		else callbacksByKey[key] = [fn];
+	}
+	const merged = {};
+	for (const [key, fns] of Object.entries(callbacksByKey)) {
+		const first = fns[0];
+		if (fns.length === 1 && first) merged[key] = first;
+		else merged[key] = (node) => {
+			for (const fn of fns) fn(node);
+		};
+	}
+	return merged;
+}
+/**
+* Lint a single file and return diagnostics.
+*
+* @example
+* ```ts
+* const result = lintFile("app.tsx", source, allRules, getPreset("recommended"))
+* for (const d of result.diagnostics) console.log(d.message)
+* ```
+*/
+function lintFile(filePath, sourceText, rules, config, cache) {
+	const ext = getExtension(filePath);
+	if (!JS_EXTENSIONS.has(ext)) return {
+		filePath,
+		diagnostics: []
+	};
+	let lineIndex;
+	let program;
+	const cached = cache?.get(sourceText);
+	if (cached) {
+		lineIndex = cached.lineIndex;
+		program = cached.program;
+	} else {
+		lineIndex = new LineIndex(sourceText);
+		try {
+			program = parseSync(filePath, sourceText, {
+				sourceType: "module",
+				lang: getLang(ext)
+			}).program;
+		} catch {
+			return {
+				filePath,
+				diagnostics: []
+			};
+		}
+		cache?.set(sourceText, {
+			program,
+			lineIndex
+		});
+	}
+	const diagnostics = [];
+	const allCallbacks = [];
+	for (const rule of rules) {
+		const severity = config.rules[rule.meta.id];
+		if (severity === void 0 || severity === "off") continue;
+		const ctx = createRuleContext(rule, severity, diagnostics, lineIndex, sourceText, filePath);
+		allCallbacks.push(rule.create(ctx));
+	}
+	new Visitor(mergeCallbacks(allCallbacks)).visit(program);
+	diagnostics.sort((a, b) => a.span.start - b.span.start);
+	return {
+		filePath,
+		diagnostics
+	};
+}
+/**
+* Apply all auto-fixes to a source text.
+* Fixes are applied in reverse order to maintain correct offsets.
+*/
+function applyFixes(sourceText, diagnostics) {
+	const fixable = diagnostics.filter((d) => d.fix !== void 0);
+	if (fixable.length === 0) return sourceText;
+	const sorted = [...fixable].sort((a, b) => {
+		const aFix = a.fix;
+		const bFix = b.fix;
+		if (!aFix || !bFix) return 0;
+		return bFix.span.start - aFix.span.start;
+	});
+	let result = sourceText;
+	for (const diag of sorted) {
+		const fix = diag.fix;
+		if (!fix) continue;
+		result = result.slice(0, fix.span.start) + fix.replacement + result.slice(fix.span.end);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/lint.ts
+function isHiddenOrVendor(entry) {
+	return entry.startsWith(".") || entry === "node_modules" || entry === "lib" || entry === "dist";
+}
+function matchesPatterns(filePath, include, exclude) {
+	if (exclude) {
+		for (const pattern of exclude) if (filePath.includes(pattern)) return false;
+	}
+	if (include && include.length > 0) {
+		for (const pattern of include) if (filePath.includes(pattern)) return true;
+		return false;
+	}
+	return true;
+}
+function walkDirectory(dir, files, isIgnored, include, exclude) {
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (isHiddenOrVendor(entry)) continue;
+		const full = join(dir, entry);
+		if (isIgnored(full)) continue;
+		processEntry(full, files, isIgnored, include, exclude);
+	}
+}
+function processEntry(full, files, isIgnored, include, exclude) {
+	let stat;
+	try {
+		stat = statSync(full);
+	} catch {
+		return;
+	}
+	if (stat.isDirectory()) walkDirectory(full, files, isIgnored, include, exclude);
+	else if (stat.isFile() && hasJsExtension(full) && matchesPatterns(full, include, exclude)) files.push(full);
+}
+function collectFiles(dir, isIgnored, include, exclude) {
+	const files = [];
+	walkDirectory(dir, files, isIgnored, include, exclude);
+	return files;
+}
+function buildConfig(options) {
+	const cwd = resolve(".");
+	const fileConfig = options.config ? loadConfigFromPath(options.config) : loadConfig(cwd);
+	const config = getPreset(options.preset ?? fileConfig?.preset ?? "recommended");
+	if (fileConfig?.rules) for (const [id, severity] of Object.entries(fileConfig.rules)) config.rules[id] = severity;
+	if (options.ruleOverrides) for (const [id, severity] of Object.entries(options.ruleOverrides)) config.rules[id] = severity;
+	return {
+		config,
+		include: fileConfig?.include,
+		exclude: fileConfig?.exclude,
+		isIgnored: createIgnoreFilter(cwd, options.ignore)
+	};
+}
+function gatherFiles(paths, isIgnored, include, exclude) {
+	const files = [];
+	for (const p of paths) {
+		const resolved = resolve(p);
+		let stat;
+		try {
+			stat = statSync(resolved);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) files.push(...collectFiles(resolved, isIgnored, include, exclude));
+		else if (stat.isFile() && !isIgnored(resolved)) files.push(resolved);
+	}
+	return files;
+}
+function applyFixesToFile(fileResult, source) {
+	if (fileResult.diagnostics.filter((d) => d.fix).length === 0) return;
+	const fixed = applyFixes(source, fileResult.diagnostics);
+	writeFileSync(fileResult.filePath, fixed, "utf-8");
+	fileResult.fixedSource = fixed;
+	fileResult.diagnostics = fileResult.diagnostics.filter((d) => !d.fix);
+}
+function countDiagnostics(fileResult, results) {
+	for (const d of fileResult.diagnostics) if (d.severity === "error") results.totalErrors++;
+	else if (d.severity === "warn") results.totalWarnings++;
+	else if (d.severity === "info") results.totalInfos++;
+}
+/**
+* Lint files and return results.
+*
+* @example
+* ```ts
+* import { lint } from "@pyreon/lint"
+*
+* const result = lint({ paths: ["src/"], preset: "recommended" })
+* console.log(result.totalErrors) // 0
+* ```
+*/
+function lint(options) {
+	const { config, include, exclude, isIgnored } = buildConfig(options);
+	const cache = new AstCache();
+	const files = gatherFiles(options.paths, isIgnored, include, exclude);
+	const results = {
+		files: [],
+		totalErrors: 0,
+		totalWarnings: 0,
+		totalInfos: 0
+	};
+	for (const filePath of files) {
+		let source;
+		try {
+			source = readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const fileResult = lintFile(filePath, source, allRules, config, cache);
+		if (options.fix) applyFixesToFile(fileResult, source);
+		if (options.quiet) fileResult.diagnostics = fileResult.diagnostics.filter((d) => d.severity === "error");
+		countDiagnostics(fileResult, results);
+		results.files.push(fileResult);
+	}
+	return results;
+}
+/**
+* List all available rules with their metadata.
+*
+* @example
+* ```ts
+* import { listRules } from "@pyreon/lint"
+*
+* for (const rule of listRules()) {
+*   console.log(`${rule.id} (${rule.severity}): ${rule.description}`)
+* }
+* ```
+*/
+function listRules() {
+	return allRules.map((r) => r.meta);
+}
+
+//#endregion
+//#region src/lsp/index.ts
+/**
+* Minimal LSP server for @pyreon/lint.
+*
+* Provides real-time Pyreon-specific diagnostics in editors that support
+* the Language Server Protocol (VS Code, Neovim, etc.).
+*
+* Usage: pyreon-lint --lsp
+*
+* The server communicates via JSON-RPC over stdin/stdout following the
+* LSP specification (https://microsoft.github.io/language-server-protocol/).
+*
+* Supported capabilities:
+* - textDocument/didOpen — lint on open
+* - textDocument/didSave — lint on save
+* - textDocument/didChange — lint on change (debounced)
+*
+* @module
+*/
+const cache = new AstCache();
+const config = getPreset("recommended");
+function toLspDiagnostics(diagnostics) {
+	return diagnostics.map((d) => ({
+		range: {
+			start: {
+				line: d.loc.line - 1,
+				character: d.loc.column - 1
+			},
+			end: {
+				line: d.loc.line - 1,
+				character: d.loc.column - 1 + (d.span.end - d.span.start)
+			}
+		},
+		severity: d.severity === "error" ? 1 : d.severity === "warn" ? 2 : 3,
+		source: "pyreon-lint",
+		message: d.message,
+		code: d.ruleId
+	}));
+}
+function lintDocument(uri, text) {
+	try {
+		return toLspDiagnostics(lintFile(uri.replace("file://", ""), text, allRules, config, cache).diagnostics);
+	} catch {
+		return [];
+	}
+}
+const DEBOUNCE_MS = 150;
+const debounceTimers = /* @__PURE__ */ new Map();
+function debounceLint(uri, text) {
+	const existing = debounceTimers.get(uri);
+	if (existing) clearTimeout(existing);
+	debounceTimers.set(uri, setTimeout(() => {
+		debounceTimers.delete(uri);
+		sendNotification("textDocument/publishDiagnostics", {
+			uri,
+			diagnostics: lintDocument(uri, text)
+		});
+	}, DEBOUNCE_MS));
+}
+const openDocuments = /* @__PURE__ */ new Map();
+function handleMessage(msg) {
+	if (msg.method === "initialize") return {
+		jsonrpc: "2.0",
+		id: msg.id,
+		result: {
+			capabilities: {
+				textDocumentSync: 1,
+				diagnosticProvider: {
+					interFileDependencies: false,
+					workspaceDiagnostics: false
+				}
+			},
+			serverInfo: {
+				name: "pyreon-lint",
+				version: "0.11.5"
+			}
+		}
+	};
+	if (msg.method === "initialized") return null;
+	if (msg.method === "textDocument/didOpen") {
+		const { uri, text } = msg.params.textDocument;
+		openDocuments.set(uri, text);
+		sendNotification("textDocument/publishDiagnostics", {
+			uri,
+			diagnostics: lintDocument(uri, text)
+		});
+		return null;
+	}
+	if (msg.method === "textDocument/didChange") {
+		const uri = msg.params.textDocument.uri;
+		const text = msg.params.contentChanges[0]?.text;
+		if (text != null) {
+			openDocuments.set(uri, text);
+			debounceLint(uri, text);
+		}
+		return null;
+	}
+	if (msg.method === "textDocument/didSave") {
+		const uri = msg.params.textDocument.uri;
+		const text = openDocuments.get(uri);
+		if (text) sendNotification("textDocument/publishDiagnostics", {
+			uri,
+			diagnostics: lintDocument(uri, text)
+		});
+		return null;
+	}
+	if (msg.method === "textDocument/didClose") {
+		const uri = msg.params.textDocument.uri;
+		openDocuments.delete(uri);
+		sendNotification("textDocument/publishDiagnostics", {
+			uri,
+			diagnostics: []
+		});
+		return null;
+	}
+	if (msg.method === "shutdown") return {
+		jsonrpc: "2.0",
+		id: msg.id,
+		result: null
+	};
+	if (msg.method === "exit") process.exit(0);
+	if (msg.id != null) return {
+		jsonrpc: "2.0",
+		id: msg.id,
+		result: null
+	};
+	return null;
+}
+function sendMessage(msg) {
+	const body = JSON.stringify(msg);
+	const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`;
+	process.stdout.write(header + body);
+}
+function sendNotification(method, params) {
+	sendMessage({
+		jsonrpc: "2.0",
+		method,
+		params
+	});
+}
+/**
+* Start the LSP server. Reads JSON-RPC messages from stdin,
+* processes them, and writes responses to stdout.
+*/
+function startLspServer() {
+	let buffer = "";
+	process.stdin.setEncoding("utf-8");
+	process.stdin.on("data", (chunk) => {
+		buffer += chunk;
+		while (true) {
+			const headerEnd = buffer.indexOf("\r\n\r\n");
+			if (headerEnd === -1) break;
+			const match = buffer.slice(0, headerEnd).match(/Content-Length:\s*(\d+)/i);
+			if (!match) {
+				buffer = buffer.slice(headerEnd + 4);
+				continue;
+			}
+			const contentLength = Number.parseInt(match[1], 10);
+			const bodyStart = headerEnd + 4;
+			if (buffer.length < bodyStart + contentLength) break;
+			const body = buffer.slice(bodyStart, bodyStart + contentLength);
+			buffer = buffer.slice(bodyStart + contentLength);
+			try {
+				const response = handleMessage(JSON.parse(body));
+				if (response) sendMessage(response);
+			} catch {}
+		}
+	});
+	process.stderr.write("[pyreon-lint] LSP server started\n");
+}
+
+//#endregion
+//#region src/reporter.ts
+const BOLD = "\x1B[1m";
+const RED = "\x1B[31m";
+const YELLOW = "\x1B[33m";
+const BLUE = "\x1B[34m";
+const DIM = "\x1B[2m";
+const RESET = "\x1B[0m";
+const SEVERITY_SYMBOL = {
+	error: `${RED}\u2716${RESET}`,
+	warn: `${YELLOW}\u26A0${RESET}`,
+	info: `${BLUE}\u2139${RESET}`,
+	off: ""
+};
+const SEVERITY_LABEL = {
+	error: `${RED}error${RESET}`,
+	warn: `${YELLOW}warning${RESET}`,
+	info: `${BLUE}info${RESET}`,
+	off: ""
+};
+/**
+* Format results as human-readable colored text.
+*/
+function formatText(result) {
+	const lines = [];
+	for (const file of result.files) {
+		if (file.diagnostics.length === 0) continue;
+		lines.push("");
+		lines.push(`${BOLD}${file.filePath}${RESET}`);
+		for (const d of file.diagnostics) {
+			const loc = `${DIM}${d.loc.line}:${d.loc.column}${RESET}`;
+			const severity = SEVERITY_LABEL[d.severity];
+			const ruleId = `${DIM}${d.ruleId}${RESET}`;
+			lines.push(`  ${loc}  ${severity}  ${d.message}  ${ruleId}`);
+		}
+	}
+	if (result.totalErrors + result.totalWarnings + result.totalInfos > 0) {
+		lines.push("");
+		const parts = [];
+		if (result.totalErrors > 0) parts.push(`${RED}${result.totalErrors} error${result.totalErrors === 1 ? "" : "s"}${RESET}`);
+		if (result.totalWarnings > 0) parts.push(`${YELLOW}${result.totalWarnings} warning${result.totalWarnings === 1 ? "" : "s"}${RESET}`);
+		if (result.totalInfos > 0) parts.push(`${BLUE}${result.totalInfos} info${RESET}`);
+		lines.push(`${SEVERITY_SYMBOL.error} ${parts.join(", ")}`);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* Format results as JSON.
+*/
+function formatJSON(result) {
+	return JSON.stringify(result, null, 2);
+}
+/**
+* Format results as compact single-line-per-diagnostic output.
+*/
+function formatCompact(result) {
+	const lines = [];
+	for (const file of result.files) for (const d of file.diagnostics) lines.push(`${file.filePath}:${d.loc.line}:${d.loc.column}: ${d.severity} [${d.ruleId}] ${d.message}`);
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/watcher.ts
+function formatOutput(result, format) {
+	if (format === "json") return formatJSON(result);
+	if (format === "compact") return formatCompact(result);
+	return formatText(result);
+}
+/**
+* Watch directories and re-lint changed files.
+*
+* Uses `fs.watch` (recursive) with 100ms debounce.
+* Caches ASTs for unchanged files.
+*
+* @example
+* ```ts
+* import { watchAndLint } from "@pyreon/lint"
+*
+* watchAndLint({ paths: ["src/"], preset: "recommended", format: "text" })
+* ```
+*/
+function watchAndLint(options) {
+	const cache = new AstCache();
+	const config = getPreset(options.preset ?? "recommended");
+	applyOverrides(config, options.ruleOverrides);
+	const isIgnored = createIgnoreFilter(resolve("."), options.ignore);
+	const pending = /* @__PURE__ */ new Map();
+	console.log(`\x1b[2m[pyreon-lint] Watching for changes...\x1b[0m\n`);
+	for (const p of options.paths) {
+		const dir = resolve(p);
+		try {
+			watch(dir, { recursive: true }, (_event, filename) => {
+				if (!filename) return;
+				const filePath = resolve(dir, filename);
+				if (!hasJsExtension(filePath) || isIgnored(filePath)) return;
+				const existing = pending.get(filePath);
+				if (existing) clearTimeout(existing);
+				pending.set(filePath, setTimeout(() => {
+					pending.delete(filePath);
+					relintFile(filePath, config, cache, options.format);
+				}, 100));
+			});
+		} catch {
+			console.error(`[pyreon-lint] Could not watch: ${dir}`);
+		}
+	}
+}
+function applyOverrides(config, overrides) {
+	if (!overrides) return;
+	for (const [id, severity] of Object.entries(overrides)) config.rules[id] = severity;
+}
+function relintFile(filePath, config, cache, format) {
+	let source;
+	try {
+		source = readFileSync(filePath, "utf-8");
+	} catch {
+		return;
+	}
+	const fileResult = lintFile(filePath, source, allRules, config, cache);
+	if (fileResult.diagnostics.length === 0) return;
+	const result = {
+		files: [fileResult],
+		totalErrors: 0,
+		totalWarnings: 0,
+		totalInfos: 0
+	};
+	for (const d of fileResult.diagnostics) if (d.severity === "error") result.totalErrors++;
+	else if (d.severity === "warn") result.totalWarnings++;
+	else if (d.severity === "info") result.totalInfos++;
+	process.stdout.write("\x1B[2J\x1B[H");
+	console.log(formatOutput(result, format));
+}
+
+//#endregion
+//#region src/cli.ts
+const VERSION = "0.11.4";
+function printUsage() {
+	console.log(`
+  pyreon-lint [options] [path...]
+
+  Options:
+    --preset <name>    Preset: recommended (default), strict, app, lib
+    --fix              Auto-fix fixable issues
+    --format <fmt>     Output: text (default), json, compact
+    --quiet            Only show errors
+    --list             List all available rules
+    --rule <id>=<sev>  Override rule severity
+    --config <path>    Config file path
+    --ignore <path>    Ignore file path
+    --watch            Watch mode — re-lint on file changes
+    --lsp              Start LSP server (stdin/stdout JSON-RPC)
+    --help, -h         Show this help
+    --version, -v      Show version
+`);
+}
+function printList() {
+	const rules = listRules();
+	const maxId = Math.max(...rules.map((r) => r.id.length));
+	const maxCat = Math.max(...rules.map((r) => r.category.length));
+	for (const rule of rules) {
+		const fixLabel = rule.fixable ? " [fixable]" : "";
+		const id = rule.id.padEnd(maxId);
+		const cat = rule.category.padEnd(maxCat);
+		const sev = rule.severity.padEnd(5);
+		console.log(`  ${id}  ${cat}  ${sev}  ${rule.description}${fixLabel}`);
+	}
+	console.log(`\n  ${rules.length} rules total`);
+}
+const BOOLEAN_FLAGS = {
+	"--help": "showHelp",
+	"-h": "showHelp",
+	"--version": "showVersion",
+	"-v": "showVersion",
+	"--list": "showList",
+	"--fix": "fix",
+	"--quiet": "quiet",
+	"--watch": "watchMode",
+	"--lsp": "lspMode"
+};
+function parseArgs(argv) {
+	const result = {
+		preset: "recommended",
+		fix: false,
+		format: "text",
+		quiet: false,
+		showList: false,
+		showHelp: false,
+		showVersion: false,
+		watchMode: false,
+		lspMode: false,
+		configPath: void 0,
+		ignorePath: void 0,
+		ruleOverrides: {},
+		paths: []
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		const boolKey = BOOLEAN_FLAGS[arg];
+		if (boolKey) {
+			result[boolKey] = true;
+			continue;
+		}
+		const consumed = parseValueFlag(arg, argv[i + 1], result);
+		i += consumed;
+	}
+	return result;
+}
+/** Returns number of extra args consumed (0 or 1). */
+function parseValueFlag(arg, nextArg, result) {
+	if (arg === "--preset") {
+		result.preset = nextArg ?? "recommended";
+		return 1;
+	}
+	if (arg === "--format") {
+		result.format = nextArg ?? "text";
+		return 1;
+	}
+	if (arg === "--config") {
+		result.configPath = nextArg;
+		return 1;
+	}
+	if (arg === "--ignore") {
+		result.ignorePath = nextArg;
+		return 1;
+	}
+	if (arg === "--rule") {
+		parseRuleOverride(nextArg, result.ruleOverrides);
+		return 1;
+	}
+	if (arg) result.paths.push(arg);
+	return 0;
+}
+function parseRuleOverride(val, overrides) {
+	if (!val) return;
+	const eqIdx = val.lastIndexOf("=");
+	if (eqIdx === -1) return;
+	const ruleId = val.slice(0, eqIdx);
+	overrides[ruleId] = val.slice(eqIdx + 1);
+}
+function main() {
+	const args = parseArgs(process.argv.slice(2));
+	if (args.showHelp) {
+		printUsage();
+		process.exit(0);
+	}
+	if (args.showVersion) {
+		console.log(`pyreon-lint v${VERSION}`);
+		process.exit(0);
+	}
+	if (args.showList) {
+		printList();
+		process.exit(0);
+	}
+	if (args.lspMode) {
+		startLspServer();
+		return;
+	}
+	if (args.paths.length === 0) args.paths.push(".");
+	if (args.watchMode) {
+		watchAndLint({
+			paths: args.paths,
+			preset: args.preset,
+			fix: args.fix,
+			quiet: args.quiet,
+			ruleOverrides: args.ruleOverrides,
+			config: args.configPath,
+			ignore: args.ignorePath,
+			format: args.format
+		});
+		return;
+	}
+	const result = lint({
+		paths: args.paths,
+		preset: args.preset,
+		fix: args.fix,
+		quiet: args.quiet,
+		ruleOverrides: args.ruleOverrides,
+		config: args.configPath,
+		ignore: args.ignorePath
+	});
+	if (args.format === "json") console.log(formatJSON(result));
+	else if (args.format === "compact") console.log(formatCompact(result));
+	else {
+		const output = formatText(result);
+		if (output) console.log(output);
+	}
+	if (result.totalErrors > 0) process.exit(1);
+}
+main();
+
+//#endregion
+//# sourceMappingURL=cli.js.map