@thomaflette/eslint-plugin-solid-2 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1897 @@
+import { ASTUtils, ESLintUtils } from "@typescript-eslint/utils";
+import * as ts from "typescript";
+//#region src/utils.ts
+const domElementRegex = /^[a-z]/;
+const isDOMElementName = (name) => domElementRegex.test(name);
+/**
+* Whether a JSX opening element is a host (DOM) element rather than a custom component. DOM-only
+* DOM-only rules must skip components, whose attributes are author-defined props with no DOM
+* semantics. A lowercase tag (`<div>`) or a namespaced tag (`<svg:rect>`) is a
+* host element; a capitalized tag (`<Card>`) or a member tag (`<Foo.Bar>`) is a component.
+*/
+const isHostElement = (opening) => {
+	const tag = opening.name;
+	if (tag.type === "JSXIdentifier") return isDOMElementName(tag.name);
+	return tag.type === "JSXNamespacedName";
+};
+const getFunctionName = (node) => {
+	if ((node.type === "FunctionDeclaration" || node.type === "FunctionExpression") && node.id != null) return node.id.name;
+	if (node.parent?.type === "VariableDeclarator" && node.parent.id.type === "Identifier") return node.parent.id.name;
+	return null;
+};
+const isFunctionNode = (node) => node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression";
+const isJSXElementOrFragment = (node) => node?.type === "JSXElement" || node?.type === "JSXFragment";
+const trace = (node, context) => {
+	if (node.type !== "Identifier") return node;
+	const variable = ASTUtils.findVariable(context.sourceCode.getScope(node), node);
+	const def = variable?.defs[0];
+	if (!variable || !def) return node;
+	switch (def.type) {
+		case "FunctionName":
+		case "ClassName":
+		case "ImportBinding": return def.node;
+		case "Variable": {
+			const declaration = def.node.parent;
+			if (declaration?.type === "VariableDeclaration" && declaration.kind === "const" && def.node.id.type === "Identifier" && def.node.init) return trace(def.node.init, context);
+			return node;
+		}
+		default: return node;
+	}
+};
+function jsxPropName(prop) {
+	if (prop.name.type === "JSXNamespacedName") return `${prop.name.namespace.name}:${prop.name.name.name}`;
+	return prop.name.name;
+}
+function* jsxGetAllProps(props) {
+	for (const attr of props) {
+		if (attr.type === "JSXSpreadAttribute" && attr.argument.type === "ObjectExpression") {
+			for (const property of attr.argument.properties) if (property.type === "Property") {
+				if (property.key.type === "Identifier") yield [property.key.name, property.key];
+				else if (property.key.type === "Literal") yield [String(property.key.value), property.key];
+			}
+			continue;
+		}
+		if (attr.type === "JSXAttribute") yield [jsxPropName(attr), attr.name];
+	}
+}
+//#endregion
+//#region src/rules/create-rule.ts
+const DOCS_BASE = "https://github.com/yumemi-thomas/eslint-plugin-solid-2/blob/main/docs";
+const createRule = ESLintUtils.RuleCreator((name) => `${DOCS_BASE}/${name}.md`);
+//#endregion
+//#region src/rules/solid-rule-utils.ts
+const SOLID_COMPONENT_TYPES = new Set([
+	"Component",
+	"VoidComponent",
+	"ParentComponent",
+	"FlowComponent"
+]);
+/** Whether a node is an `import ... from "solid-js"` declaration. The single source of truth for
+* "this binding comes from solid-js", shared by the callee, type-annotation, and alias resolvers. */
+function isSolidJsImportDeclaration(node) {
+	return node?.type === "ImportDeclaration" && node.source.type === "Literal" && node.source.value === "solid-js";
+}
+function typeReferenceName(node) {
+	if (node?.type !== "TSTypeReference") return null;
+	if (node.typeName.type === "Identifier") return node.typeName.name;
+	if (node.typeName.type === "TSQualifiedName" && node.typeName.right.type === "Identifier") return node.typeName.right.name;
+	return null;
+}
+/**
+* The identifier that carries the binding for a type reference: the type name itself for a plain
+* `Component`, or the leftmost segment for a qualified `Solid.Component` (i.e. the namespace root).
+* `qualified` distinguishes the two so the binding check can demand an explicit solid-js import for
+* the qualified form (an unresolved `Solid.Component` is not a Solid auto-import).
+*/
+function typeReferenceRootIdentifier(node) {
+	if (node?.type !== "TSTypeReference") return null;
+	let name = node.typeName;
+	let qualified = false;
+	while (name.type === "TSQualifiedName") {
+		qualified = true;
+		name = name.left;
+	}
+	return name.type === "Identifier" ? {
+		id: name,
+		qualified
+	} : null;
+}
+/**
+* Whether a component type-name identifier actually refers to Solid's type — the type-annotation
+* analogue of {@link resolveSolidCallee} (see ADR-0003). It counts as Solid when the name binds to a
+* `solid-js` import, or (for a bare name only) is unresolved — an ambient/auto-import global. A name
+* that binds to a local `type`/`interface` declaration or an import from another package is *not*
+* Solid, which is what keeps `hasSolidComponentTypeAnnotation` from firing on same-named non-Solid
+* types (a UI kit's `Component`, a local `VoidComponent`, a foreign `Ns.Component`).
+*/
+function typeNameBindsToSolid(id, qualified, context) {
+	let scope = context.sourceCode.getScope(id);
+	while (scope) {
+		for (const variable of scope.variables) {
+			if (variable.name !== id.name) continue;
+			for (const def of variable.defs) {
+				if (def.type === "ImportBinding") return isSolidJsImportDeclaration(def.node.parent);
+				if (def.type === "Type" || def.type === "ClassName" || def.type === "TSEnumName") return false;
+			}
+		}
+		scope = scope.upper;
+	}
+	return !qualified;
+}
+/**
+* Whether the function is declared with an explicit Solid component type annotation,
+* e.g. `const C: Component<P> = (props) => ...`. This is a *sound* signal of component-hood:
+* it is never true for a plain JSX-returning helper, and holds across file boundaries. The type
+* must actually resolve to Solid's `Component`/`VoidComponent`/… (not a same-named local or
+* third-party type) — see {@link typeNameBindsToSolid} and ADR-0002/0003.
+*/
+function hasSolidComponentTypeAnnotation(node, context) {
+	const parent = node.parent;
+	if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+		const annotation = parent.id.typeAnnotation?.typeAnnotation;
+		const name = typeReferenceName(annotation);
+		if (name == null || !SOLID_COMPONENT_TYPES.has(name)) return false;
+		const root = typeReferenceRootIdentifier(annotation);
+		return root != null && typeNameBindsToSolid(root.id, root.qualified, context);
+	}
+	return false;
+}
+const inFileComponentVarsCache = /* @__PURE__ */ new WeakMap();
+function getInFileComponentVariables(sourceCode) {
+	const cached = inFileComponentVarsCache.get(sourceCode);
+	if (cached) return cached;
+	const vars = /* @__PURE__ */ new Set();
+	const stack = [sourceCode.ast];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (node.type === "JSXOpeningElement" && node.name.type === "JSXIdentifier" && !isDOMElementName(node.name.name)) {
+			const variable = ASTUtils.findVariable(sourceCode.getScope(node.name), node.name.name);
+			if (variable != null) vars.add(variable);
+		}
+		for (const key in node) {
+			if (key === "parent" || key === "tokens" || key === "comments") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const item of value) if (item != null && typeof item === "object" && typeof item.type === "string") stack.push(item);
+			} else if (value != null && typeof value === "object" && typeof value.type === "string") stack.push(value);
+		}
+	}
+	inFileComponentVarsCache.set(sourceCode, vars);
+	return vars;
+}
+function expressionCanYieldJsx(node) {
+	switch (node?.type) {
+		case "JSXElement":
+		case "JSXFragment": return true;
+		case "ConditionalExpression": return expressionCanYieldJsx(node.consequent) || expressionCanYieldJsx(node.alternate);
+		case "LogicalExpression": return expressionCanYieldJsx(node.left) || expressionCanYieldJsx(node.right);
+		case "SequenceExpression": return expressionCanYieldJsx(node.expressions.at(-1));
+		default: return false;
+	}
+}
+/** Whether any `return` in the function (or an arrow's expression body) yields JSX. */
+function functionReturnsJsx(node) {
+	if (node.body.type !== "BlockStatement") return expressionCanYieldJsx(node.body);
+	const statements = [...node.body.body];
+	while (statements.length > 0) {
+		const statement = statements.pop();
+		switch (statement.type) {
+			case "BlockStatement":
+				statements.push(...statement.body);
+				break;
+			case "IfStatement":
+				statements.push(statement.consequent);
+				if (statement.alternate) statements.push(statement.alternate);
+				break;
+			case "LabeledStatement":
+			case "WithStatement":
+				statements.push(statement.body);
+				break;
+			case "SwitchStatement":
+				for (const switchCase of statement.cases) statements.push(...switchCase.consequent);
+				break;
+			case "TryStatement":
+				statements.push(statement.block);
+				if (statement.handler) statements.push(statement.handler.body);
+				if (statement.finalizer) statements.push(statement.finalizer);
+				break;
+			case "ReturnStatement":
+				if (expressionCanYieldJsx(statement.argument)) return true;
+				break;
+			default: break;
+		}
+	}
+	return false;
+}
+function getTypeAwareServices(context) {
+	const services = context.sourceCode.parserServices;
+	if (services?.program != null && services.esTreeNodeToTSNodeMap != null) return services;
+	return null;
+}
+const jsxTagSymbolsCache = /* @__PURE__ */ new WeakMap();
+function resolveAlias(symbol, checker) {
+	return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+}
+function getJsxTagSymbols(services) {
+	const program = services.program;
+	const cached = jsxTagSymbolsCache.get(program);
+	if (cached) return cached;
+	const checker = program.getTypeChecker();
+	const symbols = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+			const symbol = checker.getSymbolAtLocation(node.tagName);
+			if (symbol) symbols.add(resolveAlias(symbol, checker));
+		}
+		ts.forEachChild(node, visit);
+	};
+	for (const sourceFile of program.getSourceFiles()) {
+		if (sourceFile.isDeclarationFile || sourceFile.fileName.includes("/node_modules/")) continue;
+		visit(sourceFile);
+	}
+	jsxTagSymbolsCache.set(program, symbols);
+	return symbols;
+}
+function getFunctionSymbol(node, services) {
+	let nameNode;
+	if ((node.type === "FunctionDeclaration" || node.type === "FunctionExpression") && node.id != null) nameNode = node.id;
+	else if (node.parent?.type === "VariableDeclarator" && node.parent.id.type === "Identifier") nameNode = node.parent.id;
+	if (!nameNode) return;
+	const tsNode = services.esTreeNodeToTSNodeMap.get(nameNode);
+	return tsNode ? services.program.getTypeChecker().getSymbolAtLocation(tsNode) : void 0;
+}
+/**
+* Verdict on whether `node`'s type is array-like (an array or tuple — i.e. has a numeric index
+* signature), considering every union member:
+*
+* - `"array"` — provably array-like; safe to rewrite `.map` to `<For each>`.
+* - `"not-array"` — provably not (a `Map`/`Set`/observable); `prefer-for` skips the report.
+* - `"unknown"` — the type can't be resolved, is `any`/`unknown`, or mixes array and non-array
+*   members. `prefer-for` stays silent because a rewrite may be semantically wrong.
+*/
+function getArrayReceiverVerdict(node, services) {
+	const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+	if (!tsNode) return "unknown";
+	const checker = services.program.getTypeChecker();
+	const type = checker.getTypeAtLocation(tsNode);
+	const members = type.isUnion() ? type.types : [type];
+	if (members.some((member) => member.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown))) return "unknown";
+	const arrayMembers = members.filter((member) => checker.getIndexTypeOfType(member, ts.IndexKind.Number) != null);
+	if (arrayMembers.length === members.length) return "array";
+	return arrayMembers.length === 0 ? "not-array" : "unknown";
+}
+/**
+* Sound component detection (see docs/adr/0002). A function is treated as a Solid component only by
+* signals that are never true for a plain helper — never the leaky "capitalized JSX-returning
+* function" guess:
+*
+* - **Always:** it is annotated `Component`/`VoidComponent`/… or used as `<C/>` in the same file.
+* - **Only when `typescriptEnabled` and type info is present:** additionally, its symbol is used as
+*   a JSX tag anywhere in the program (catches exported/cross-file components).
+*
+* Both paths are sound (zero false positives); type information is purely additive — it finds more
+* real components, never flips a verdict on correct code. The trade-off is a tolerated false
+* negative: an unannotated component used only in another file is not seen without type info.
+*
+* The module owns its own whole-file index and reads `typescriptEnabled` from `context`, so a
+* caller needs nothing but the node — no `jsxComponentNames` set to build, thread, or defer. The
+* index is complete on first query (see {@link getInFileComponentVariables}), so this is correct
+* when called inline during traversal.
+*/
+function isComponent$1(node, context) {
+	if (hasSolidComponentTypeAnnotation(node, context)) return true;
+	const name = getFunctionName(node);
+	if (name != null) {
+		const fnVariable = ASTUtils.findVariable(context.sourceCode.getScope(node), name);
+		if (fnVariable != null && getInFileComponentVariables(context.sourceCode).has(fnVariable)) return true;
+	}
+	if (context.options[0]?.typescriptEnabled) {
+		const services = getTypeAwareServices(context);
+		if (services) {
+			const symbol = getFunctionSymbol(node, services);
+			if (symbol && getJsxTagSymbols(services).has(resolveAlias(symbol, services.program.getTypeChecker()))) return true;
+		}
+	}
+	return false;
+}
+/**
+* Whether `identifier` actually refers to the Solid API for one of `canonicalNames` — a name
+* imported from "solid-js" (directly or aliased), a `const` alias of one (`const c = onCleanup`),
+* or an unresolved global (auto-import). Returns false when it binds to the user's own declaration
+* or an import from another package, which prevents false positives on same-named non-Solid
+* functions (a stream library's `flush`, a state library's `createStore`, a local `onCleanup`, ...).
+*
+* Delegates to {@link resolveSolidCallee}, whose `trace` step resolves both aliased imports and
+* `const` aliases — so no caller needs to pre-collect import aliases (see ADR-0003).
+*/
+function bindsToSolid(identifier, context, canonicalNames) {
+	return resolveSolidCallee(identifier, context, canonicalNames) != null;
+}
+/** Whether `node` is the `argumentIndex`th argument of a call whose callee binds to the Solid API. */
+function isSolidApiCallbackArgument(node, argumentIndex, context, canonicalNames) {
+	return node.parent?.type === "CallExpression" && node.parent.arguments[argumentIndex] === node && node.parent.callee.type === "Identifier" && bindsToSolid(node.parent.callee, context, canonicalNames);
+}
+function getReturnedExpressions(node) {
+	if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") return [node.body];
+	if (node.body.type !== "BlockStatement") return [];
+	const returned = [];
+	const statements = [...node.body.body];
+	while (statements.length > 0) {
+		const statement = statements.pop();
+		switch (statement.type) {
+			case "BlockStatement":
+				statements.push(...statement.body);
+				break;
+			case "DoWhileStatement":
+			case "ForInStatement":
+			case "ForOfStatement":
+			case "ForStatement":
+			case "WhileStatement":
+			case "LabeledStatement":
+			case "WithStatement":
+				statements.push(statement.body);
+				break;
+			case "IfStatement":
+				statements.push(statement.consequent);
+				if (statement.alternate) statements.push(statement.alternate);
+				break;
+			case "SwitchStatement":
+				for (const switchCase of statement.cases) statements.push(...switchCase.consequent);
+				break;
+			case "TryStatement":
+				statements.push(statement.block);
+				if (statement.handler) statements.push(statement.handler.body);
+				if (statement.finalizer) statements.push(statement.finalizer);
+				break;
+			case "ReturnStatement":
+				returned.push(statement.argument ?? null);
+				break;
+			default: break;
+		}
+	}
+	return returned;
+}
+function getPropertyName$2(node) {
+	if (!node.computed && node.key.type === "Identifier") return node.key.name;
+	if (node.key.type === "Literal" && typeof node.key.value === "string") return node.key.value;
+	return null;
+}
+function getNearestFunctionAncestor(node) {
+	let current = node.parent;
+	while (current != null) {
+		if (isFunctionNode(current)) return current;
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Resolves an identifier to the canonical Solid API name it refers to, or null. The `trace` step
+* follows both aliased imports (`import { createEffect as fx }`) and `const` aliases to their
+* origin, so an aliased Solid API resolves to its **canonical** name (`"createEffect"`), not the
+* local alias. A bare canonical name is trusted only when unresolved (an auto-import/global); a
+* name bound to a local declaration or a non-solid-js import resolves to null.
+*/
+function resolveSolidCallee(node, context, canonicalNames) {
+	if (node.type !== "Identifier") return null;
+	const traced = trace(node, context);
+	if (traced.type === "Identifier" && canonicalNames.has(traced.name)) {
+		const variable = ASTUtils.findVariable(context.sourceCode.getScope(traced), traced);
+		return variable == null || variable.defs.length === 0 ? traced.name : null;
+	}
+	if (traced.type === "ImportSpecifier" && isSolidJsImportDeclaration(traced.parent)) {
+		const importedName = traced.imported.type === "Identifier" ? traced.imported.name : traced.imported.value;
+		if (canonicalNames.has(importedName)) return importedName;
+	}
+	return null;
+}
+/** Whether any scope in the file already declares `name`. */
+function isNameTaken(sourceCode, name) {
+	return sourceCode.scopeManager?.scopes.some((scope) => scope.set.has(name)) ?? false;
+}
+/**
+* Fixes that make `names` importable from solid-js at the fix site, so an autofix that emits
+* `<Show>`/`<For>`/... never produces non-compiling code. Returns `[]` when every name is already
+* imported from solid-js under its own name, a fix extending (or creating) the solid-js import for
+* the missing ones, or `null` when a missing name is already bound to something else in the file —
+* callers must then skip their autofix rather than emit a reference that resolves to the wrong
+* binding.
+*/
+function getSolidImportFixes(context, fixer, names) {
+	const sourceCode = context.sourceCode;
+	const importNode = sourceCode.ast.body.find((node) => isSolidJsImportDeclaration(node) && node.importKind !== "type");
+	const available = /* @__PURE__ */ new Set();
+	for (const specifier of importNode?.specifiers ?? []) if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === specifier.local.name) available.add(specifier.local.name);
+	const missing = names.filter((name) => !available.has(name));
+	if (missing.length === 0) return [];
+	if (missing.some((name) => isNameTaken(sourceCode, name))) return null;
+	const lastNamed = importNode?.specifiers.findLast((specifier) => specifier.type === "ImportSpecifier");
+	if (lastNamed != null) return [fixer.insertTextAfter(lastNamed, `, ${missing.join(", ")}`)];
+	const firstStatement = sourceCode.ast.body[0];
+	const importText = `import { ${missing.join(", ")} } from "solid-js";\n`;
+	return [firstStatement != null ? fixer.insertTextBefore(firstStatement, importText) : fixer.insertTextAfterRange([0, 0], importText)];
+}
+//#endregion
+//#region src/rules/components-return-once.ts
+const ACCESSOR_FACTORIES$2 = new Set(["createMemo"]);
+const PAIR_ACCESSOR_FACTORIES$2 = new Set(["createSignal", "createOptimistic"]);
+const STORE_FACTORIES$1 = new Set(["createOptimisticStore", "createStore"]);
+function getVariable(id, context) {
+	return ASTUtils.findVariable(context.sourceCode.getScope(id), id);
+}
+/** The `VariableDeclarator` that declared `variable`, when it was declared by one. */
+function getDeclarator(variable) {
+	const def = variable.defs[0];
+	return def?.type === "Variable" ? def.node : null;
+}
+/** Whether `variable` is `elements[0]` of an array-pattern declaration whose init calls a factory. */
+function isPairElementZero(variable, factories, context) {
+	const declarator = getDeclarator(variable);
+	if (declarator?.id.type !== "ArrayPattern" || declarator.init?.type !== "CallExpression" || declarator.init.callee.type !== "Identifier") return false;
+	const first = declarator.id.elements[0];
+	return first?.type === "Identifier" && first.name === variable.name && bindsToSolid(declarator.init.callee, context, factories);
+}
+/** Whether calling `variable` reads a signal/memo accessor (follows `const c = count` aliases). */
+function variableIsAccessor(variable, context, seen) {
+	if (seen.has(variable)) return false;
+	seen.add(variable);
+	if (isPairElementZero(variable, PAIR_ACCESSOR_FACTORIES$2, context)) return true;
+	const declarator = getDeclarator(variable);
+	if (declarator?.id.type !== "Identifier" || declarator.init == null) return false;
+	if (declarator.init.type === "CallExpression" && declarator.init.callee.type === "Identifier" && bindsToSolid(declarator.init.callee, context, ACCESSOR_FACTORIES$2)) return true;
+	if (declarator.init.type === "Identifier") {
+		const source = getVariable(declarator.init, context);
+		return source != null && variableIsAccessor(source, context, seen);
+	}
+	return false;
+}
+/**
+* Whether evaluating `node` provably performs a reactive read from `componentFn`'s perspective.
+* Skips nested functions (not evaluated by the guard) and JSX (reads there compile to tracked
+* scopes). Follows one-level-and-deeper `const` derivations (`const loading = props.loading`).
+*/
+function containsReactiveRead(node, componentFn, context, seen = /* @__PURE__ */ new Set()) {
+	const isPropsParameter = (variable) => variable.defs.some((def) => def.type === "Parameter" && def.node === componentFn);
+	const memberRootIsReactive = (member) => {
+		let root = member;
+		while (root.type === "MemberExpression") root = root.object;
+		if (root.type !== "Identifier") return false;
+		const variable = getVariable(root, context);
+		if (variable == null) return false;
+		if (isPropsParameter(variable) || isPairElementZero(variable, STORE_FACTORIES$1, context)) return true;
+		return derivedConstIsReactive(variable);
+	};
+	const derivedConstIsReactive = (variable) => {
+		if (seen.has(variable)) return false;
+		seen.add(variable);
+		const declarator = getDeclarator(variable);
+		return declarator?.id.type === "Identifier" && declarator.init != null && containsReactiveRead(declarator.init, componentFn, context, seen);
+	};
+	const stack = [node];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (isFunctionNode(current) || current.type === "JSXElement" || current.type === "JSXFragment") continue;
+		if (current.type === "CallExpression" && current.callee.type === "Identifier") {
+			const callee = getVariable(current.callee, context);
+			if (callee != null && variableIsAccessor(callee, context, /* @__PURE__ */ new Set())) return true;
+		}
+		if (current.type === "MemberExpression" && memberRootIsReactive(current)) return true;
+		if (current.type === "Identifier") {
+			const variable = getVariable(current, context);
+			if (variable != null && !isPropsParameter(variable) && derivedConstIsReactive(variable)) return true;
+		}
+		for (const key in current) {
+			if (key === "parent" || key === "tokens" || key === "comments") continue;
+			const value = current[key];
+			if (Array.isArray(value)) {
+				for (const item of value) if (item != null && typeof item === "object" && typeof item.type === "string") stack.push(item);
+			} else if (value != null && typeof value === "object" && typeof value.type === "string") stack.push(value);
+		}
+	}
+	return false;
+}
+/**
+* The guard expressions that decide whether execution reaches `ret`: every enclosing `if` test,
+* switch discriminant/case test, and loop condition between the return and the component function.
+*/
+function collectGuardExpressions(ret, fn) {
+	const guards = [];
+	let current = ret;
+	while (current !== fn && current.parent != null) {
+		const parent = current.parent;
+		switch (parent.type) {
+			case "IfStatement":
+				if (parent.consequent === current || parent.alternate === current) guards.push(parent.test);
+				break;
+			case "SwitchCase":
+				if (parent.test != null) guards.push(parent.test);
+				break;
+			case "SwitchStatement":
+				guards.push(parent.discriminant);
+				break;
+			case "WhileStatement":
+			case "DoWhileStatement":
+				if (parent.body === current) guards.push(parent.test);
+				break;
+			case "ForStatement":
+				if (parent.body === current && parent.test != null) guards.push(parent.test);
+				break;
+			case "ForInStatement":
+			case "ForOfStatement":
+				if (parent.body === current) guards.push(parent.right);
+				break;
+			default: break;
+		}
+		current = parent;
+	}
+	return guards;
+}
+/**
+* The decision expressions of a conditional last return: the tests of a (possibly nested) ternary
+* chain, or the left operands along a logical chain (`a && b && <X/>` → `a && b`). Branch values
+* are excluded — reads inside returned JSX are tracked and not this rule's concern.
+*/
+function conditionalDecisionExpressions(argument) {
+	const decisions = [];
+	if (argument.type === "ConditionalExpression") {
+		let current = argument;
+		while (current.type === "ConditionalExpression") {
+			decisions.push(current.test);
+			current = current.alternate;
+		}
+	} else if (argument.type === "LogicalExpression") {
+		let current = argument;
+		while (current.type === "LogicalExpression") {
+			decisions.push(current.left);
+			current = current.right;
+		}
+	}
+	return decisions;
+}
+const isNothing = (node) => {
+	if (!node) return true;
+	switch (node.type) {
+		case "Literal": return [
+			null,
+			void 0,
+			false,
+			""
+		].includes(node.value);
+		case "JSXFragment": return node.children.every((child) => isNothing(child));
+		default: return false;
+	}
+};
+const getLineLength = (loc) => loc == null ? 0 : loc.end.line - loc.start.line + 1;
+var components_return_once_default = createRule({
+	name: "components-return-once",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow early returns in components. Solid components only run once, so conditionals should stay inside JSX." },
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: { typescriptEnabled: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		messages: {
+			noConditionalReturn: "Solid components run once, so a conditional return breaks reactivity. Move the condition inside JSX, such as a fragment or `<Show />`.",
+			noEarlyReturn: "Solid components run once, so an early return breaks reactivity. Move the condition inside JSX, such as a fragment or `<Show />`."
+		}
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const functionStack = [];
+		const putIntoJSX = (node) => {
+			const text = sourceCode.getText(node);
+			return node.type === "JSXElement" || node.type === "JSXFragment" ? text : `{${text}}`;
+		};
+		const currentFunction = () => functionStack[functionStack.length - 1];
+		const onFunctionEnter = (node) => {
+			let lastReturn;
+			if (node.body.type === "BlockStatement") {
+				const last = [...node.body.body].reverse().find((statement) => !statement.type.endsWith("Declaration"));
+				if (last?.type === "ReturnStatement") lastReturn = last;
+			}
+			functionStack.push({
+				node,
+				lastReturn,
+				earlyReturns: []
+			});
+		};
+		const onFunctionExit = () => {
+			const frame = functionStack.pop();
+			if (frame && isComponent$1(frame.node, context)) reportComponent(frame);
+		};
+		const reportComponent = (frame) => {
+			const isReactiveGuard = (expression) => containsReactiveRead(expression, frame.node, context);
+			for (const earlyReturn of frame.earlyReturns) {
+				if (!collectGuardExpressions(earlyReturn, frame.node).some(isReactiveGuard)) continue;
+				context.report({
+					node: earlyReturn,
+					messageId: "noEarlyReturn"
+				});
+			}
+			const argument = frame.lastReturn?.argument;
+			if ((argument?.type === "ConditionalExpression" || argument?.type === "LogicalExpression") && !conditionalDecisionExpressions(argument).some(isReactiveGuard)) return;
+			if (argument?.type === "ConditionalExpression") context.report({
+				node: argument.parent ?? argument,
+				messageId: "noConditionalReturn",
+				fix: (fixer) => {
+					const conditions = [{
+						test: argument.test,
+						consequent: argument.consequent
+					}];
+					let fallback = argument.alternate;
+					while (fallback.type === "ConditionalExpression") {
+						conditions.push({
+							test: fallback.test,
+							consequent: fallback.consequent
+						});
+						fallback = fallback.alternate;
+					}
+					const withImports = (names, replacement) => {
+						const importFixes = getSolidImportFixes(context, fixer, names);
+						return importFixes == null ? null : [...importFixes, replacement];
+					};
+					if (conditions.length >= 2) {
+						const fallbackText = !isNothing(fallback) ? ` fallback={${sourceCode.getText(fallback)}}` : "";
+						return withImports(["Switch", "Match"], fixer.replaceText(argument, `<Switch${fallbackText}>\n${conditions.map(({ test, consequent }) => `<Match when={${sourceCode.getText(test)}}>${putIntoJSX(consequent)}</Match>`).join("\n")}\n</Switch>`));
+					}
+					if (isNothing(argument.consequent)) return withImports(["Show"], fixer.replaceText(argument, `<Show when={!(${sourceCode.getText(argument.test)})}>${putIntoJSX(argument.alternate)}</Show>`));
+					if (isNothing(fallback) || getLineLength(argument.consequent.loc) >= getLineLength(fallback.loc) * 1.5) {
+						const fallbackText = !isNothing(fallback) ? ` fallback={${sourceCode.getText(fallback)}}` : "";
+						return withImports(["Show"], fixer.replaceText(argument, `<Show when={${sourceCode.getText(argument.test)}}${fallbackText}>${putIntoJSX(argument.consequent)}</Show>`));
+					}
+					return fixer.replaceText(argument, `<>${putIntoJSX(argument)}</>`);
+				}
+			});
+			else if (argument?.type === "LogicalExpression") context.report({
+				node: argument,
+				messageId: "noConditionalReturn"
+			});
+		};
+		return {
+			FunctionDeclaration: onFunctionEnter,
+			FunctionExpression: onFunctionEnter,
+			ArrowFunctionExpression: onFunctionEnter,
+			"FunctionDeclaration:exit": onFunctionExit,
+			"FunctionExpression:exit": onFunctionExit,
+			"ArrowFunctionExpression:exit": onFunctionExit,
+			ReturnStatement(node) {
+				if (functionStack.length > 0 && node !== currentFunction().lastReturn) currentFunction().earlyReturns.push(node);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/jsx-no-duplicate-props.ts
+function hasMeaningfulChildren(element) {
+	return element.children.some((child) => {
+		if (child.type === "JSXText") return child.value.trim().length > 0;
+		if (child.type === "JSXExpressionContainer") return child.expression.type !== "JSXEmptyExpression";
+		return true;
+	});
+}
+var jsx_no_duplicate_props_default = createRule({
+	name: "jsx-no-duplicate-props",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow competing JSX content sources such as children, innerHTML, and textContent." },
+		schema: [],
+		messages: { noDuplicateChildren: "Using {{used}} at the same time is not allowed." }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { JSXOpeningElement(node) {
+			const props = /* @__PURE__ */ new Set();
+			for (const [name] of jsxGetAllProps(node.attributes)) props.add(name.toLowerCase());
+			const hasChildrenProp = props.has("children");
+			const element = node.parent;
+			const hasChildren = hasMeaningfulChildren(element);
+			const isHost = isHostElement(node);
+			const hasInnerHTML = isHost && props.has("innerhtml");
+			const hasTextContent = isHost && props.has("textcontent");
+			const used = [
+				hasChildrenProp && "`props.children`",
+				hasChildren && "JSX children",
+				hasInnerHTML && "`props.innerHTML`",
+				hasTextContent && "`props.textContent`"
+			].filter(Boolean);
+			if (used.length > 1) context.report({
+				node,
+				messageId: "noDuplicateChildren",
+				data: { used: used.join(", ") }
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-destructure.ts
+const getName = (node) => {
+	switch (node.type) {
+		case "Literal": return typeof node.value === "string" ? node.value : null;
+		case "Identifier": return node.name;
+		case "AssignmentPattern": return getName(node.left);
+		default: return ASTUtils.getStringIfConstant(node);
+	}
+};
+function getAvailableName(sourceCode, preferred) {
+	if (!isNameTaken(sourceCode, preferred)) return preferred;
+	let index = 2;
+	while (isNameTaken(sourceCode, `${preferred}${index}`)) index += 1;
+	return `${preferred}${index}`;
+}
+const getPropertyInfo = (property) => {
+	const variableName = getName(property.value);
+	if (variableName === null) return null;
+	return {
+		init: property.value.type === "AssignmentPattern" ? property.value.right : void 0,
+		computed: property.computed,
+		real: property.key,
+		variableName
+	};
+};
+var no_destructure_default = createRule({
+	name: "no-destructure",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow destructuring component props. In Solid 2, destructuring props triggers top-level untracked reads." },
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: { typescriptEnabled: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		messages: { noDestructure: "Destructuring component props breaks Solid 2 reactivity; keep the `props` object and read properties from it." }
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const onFunctionExit = (node) => {
+			const props = node.params[0];
+			if (node.params.length === 1 && props?.type === "ObjectPattern" && node.parent?.type !== "JSXExpressionContainer" && isComponent$1(node, context)) context.report({
+				node: props,
+				messageId: "noDestructure",
+				fix: (fixer) => fixDestructure(node, props, fixer)
+			});
+		};
+		function* fixDestructure(func, props, fixer) {
+			const sourceCode = context.sourceCode;
+			const importNode = sourceCode.ast.body.find((node) => node.type === "ImportDeclaration" && node.importKind !== "type" && node.source.type === "Literal" && node.source.value === "solid-js");
+			const properties = props.properties;
+			const propEntries = [];
+			let rest = null;
+			for (const property of properties) {
+				if (property.type === "RestElement") {
+					rest = property;
+					continue;
+				}
+				const info = getPropertyInfo(property);
+				if (info) propEntries.push(info);
+			}
+			const ordinaryPropertyCount = properties.filter((property) => property.type === "Property").length;
+			if (propEntries.length !== ordinaryPropertyCount || rest != null && rest.argument.type !== "Identifier") return;
+			const hasDefaults = propEntries.some((entry) => entry.init);
+			const propsName = getAvailableName(sourceCode, "props");
+			const originalPropsName = hasDefaults ? getAvailableName(sourceCode, "_props") : propsName;
+			const helperNames = /* @__PURE__ */ new Map();
+			if (importNode) for (const specifier of importNode.specifiers) {
+				if (specifier.type !== "ImportSpecifier") continue;
+				const importedName = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+				if (importedName === "merge" || importedName === "omit") helperNames.set(importedName, specifier.local.name);
+			}
+			const resolveHelper = (importedName) => {
+				const existing = helperNames.get(importedName);
+				if (existing) return existing;
+				return isNameTaken(sourceCode, importedName) ? null : importedName;
+			};
+			const mergeName = hasDefaults ? resolveHelper("merge") : null;
+			const omitName = rest ? resolveHelper("omit") : null;
+			const defaultPairs = propEntries.filter((entry) => entry.init).map((entry) => {
+				return `${entry.computed ? `[${sourceCode.getText(entry.real)}]` : sourceCode.getText(entry.real)}: ${sourceCode.getText(entry.init)}`;
+			});
+			const omittedKeys = propEntries.map((entry) => entry.real.type === "Identifier" ? JSON.stringify(entry.real.name) : sourceCode.getText(entry.real));
+			const setupLines = [];
+			if (hasDefaults && mergeName == null || rest && omitName == null) return;
+			if (hasDefaults) setupLines.push(`const ${propsName} = ${mergeName}({ ${defaultPairs.join(", ")} }, ${originalPropsName});`);
+			if (rest) {
+				const restName = rest.argument.type === "Identifier" ? rest.argument.name : "rest";
+				const omitArgs = omittedKeys.length > 0 ? `, ${omittedKeys.join(", ")}` : "";
+				setupLines.push(`const ${restName} = ${omitName}(${propsName}${omitArgs});`);
+			}
+			if (setupLines.length > 0 && func.body.type !== "BlockStatement") return;
+			const missingHelpers = [];
+			if (hasDefaults && !helperNames.has("merge")) missingHelpers.push("merge");
+			if (rest && !helperNames.has("omit")) missingHelpers.push("omit");
+			if (missingHelpers.length > 0) {
+				const importFixes = getSolidImportFixes(context, fixer, missingHelpers);
+				if (importFixes == null) return;
+				yield* importFixes;
+			}
+			if (props.typeAnnotation) yield fixer.replaceTextRange([props.range[0], props.typeAnnotation.range[0]], originalPropsName);
+			else yield fixer.replaceText(props, originalPropsName);
+			if (setupLines.length > 0) {
+				if (func.body.type === "BlockStatement") {
+					const indent = " ".repeat(func.body.body[0]?.loc?.start.column ?? 2);
+					if (func.body.body.length > 0) yield fixer.insertTextBefore(func.body.body[0], `${setupLines.join(`\n${indent}`)}\n${indent}`);
+					else yield fixer.insertTextAfterRange([func.body.range[0], func.body.range[0] + 1], `\n${indent}${setupLines.join(`\n${indent}`)}\n`);
+				}
+			}
+			const scope = sourceCode.scopeManager?.acquire(func);
+			if (!scope) return;
+			for (const entry of propEntries) {
+				const variable = scope.set.get(entry.variableName);
+				if (!variable) continue;
+				const access = entry.real.type === "Identifier" && !entry.computed ? `.${entry.real.name}` : `[${sourceCode.getText(entry.real)}]`;
+				for (const reference of variable.references) if (reference.isReadOnly()) yield fixer.replaceText(reference.identifier, `${propsName}${access}`);
+			}
+		}
+		return {
+			"FunctionDeclaration:exit": onFunctionExit,
+			"FunctionExpression:exit": onFunctionExit,
+			"ArrowFunctionExpression:exit": onFunctionExit,
+			VariableDeclarator(node) {
+				if (node.id.type !== "ObjectPattern" || node.init?.type !== "Identifier") return;
+				const def = ASTUtils.findVariable(sourceCode.getScope(node.init), node.init)?.defs[0];
+				if (def?.type !== "Parameter" || !isFunctionNode(def.node)) return;
+				const firstParam = def.node.params[0];
+				if ((firstParam?.type === "AssignmentPattern" ? firstParam.left : firstParam) === def.name && isComponent$1(def.node, context)) context.report({
+					node: node.id,
+					messageId: "noDestructure"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-leaf-owner-operations.ts
+const TRACKED_EFFECT_NAMES = new Set(["createTrackedEffect"]);
+const ON_SETTLED_NAMES = new Set(["onSettled"]);
+const OWNER_CALLBACK_NAMES = new Set([
+	"createEffect",
+	"createMemo",
+	"createRenderEffect",
+	"createRoot"
+]);
+const ON_CLEANUP_NAMES = new Set(["onCleanup"]);
+const FLUSH_NAMES = new Set(["flush"]);
+const PRIMITIVE_NAMES = new Set([
+	"createEffect",
+	"createErrorBoundary",
+	"createLoadingBoundary",
+	"createMemo",
+	"createOwner",
+	"createProjection",
+	"createRenderEffect",
+	"createRevealOrder",
+	"createRoot",
+	"createTrackedEffect",
+	"mapArray",
+	"repeat"
+]);
+const FUNCTION_FORM_PRIMITIVE_NAMES = new Set([
+	"createOptimistic",
+	"createOptimisticStore",
+	"createSignal",
+	"createStore"
+]);
+function hasProvablyFunctionFirstArgument(node, context) {
+	const first = node.arguments[0];
+	if (first == null || first.type === "SpreadElement") return false;
+	return isFunctionNode(first) || isFunctionNode(trace(first, context));
+}
+var no_leaf_owner_operations_default = createRule({
+	name: "no-leaf-owner-operations",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow onCleanup, reactive-primitive creation, and flush() inside the leaf owners createTrackedEffect and onSettled." },
+		schema: [],
+		messages: {
+			noCleanup: "Cannot use `onCleanup` inside `createTrackedEffect` or `onSettled`; return a cleanup function instead.",
+			noFlush: "Cannot call `flush()` from inside `createTrackedEffect` or `onSettled`; schedule work outside instead.",
+			noPrimitives: "Cannot create reactive primitives inside `createTrackedEffect` or `onSettled`; move them to the component body or another owner."
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		const forbiddenStack = [];
+		const onFunctionEnter = (node) => {
+			if (node.type !== "FunctionDeclaration" && node.type !== "FunctionExpression" && node.type !== "ArrowFunctionExpression") return;
+			const trackedEffect = isSolidApiCallbackArgument(node, 0, context, TRACKED_EFFECT_NAMES);
+			let ownerBackedSettled = false;
+			if (isSolidApiCallbackArgument(node, 0, context, ON_SETTLED_NAMES)) {
+				const settledCall = node.parent;
+				const enclosing = getNearestFunctionAncestor(settledCall);
+				ownerBackedSettled = enclosing != null && (isComponent$1(enclosing, context) || isSolidApiCallbackArgument(enclosing, 0, context, OWNER_CALLBACK_NAMES) || isSolidApiCallbackArgument(enclosing, 1, context, OWNER_CALLBACK_NAMES));
+			}
+			if (trackedEffect || ownerBackedSettled) forbiddenStack.push(node);
+		};
+		const onFunctionExit = (node) => {
+			if (forbiddenStack[forbiddenStack.length - 1] === node) forbiddenStack.pop();
+		};
+		return {
+			FunctionDeclaration: onFunctionEnter,
+			FunctionExpression: onFunctionEnter,
+			ArrowFunctionExpression: onFunctionEnter,
+			"FunctionDeclaration:exit": onFunctionExit,
+			"FunctionExpression:exit": onFunctionExit,
+			"ArrowFunctionExpression:exit": onFunctionExit,
+			CallExpression(node) {
+				const currentForbidden = forbiddenStack[forbiddenStack.length - 1];
+				if (!currentForbidden || getNearestFunctionAncestor(node) !== currentForbidden || node.callee.type !== "Identifier") return;
+				const callee = node.callee;
+				if (bindsToSolid(callee, context, ON_CLEANUP_NAMES)) context.report({
+					node: callee,
+					messageId: "noCleanup"
+				});
+				else if (bindsToSolid(callee, context, FLUSH_NAMES)) context.report({
+					node: callee,
+					messageId: "noFlush"
+				});
+				else if (bindsToSolid(callee, context, PRIMITIVE_NAMES)) context.report({
+					node: callee,
+					messageId: "noPrimitives"
+				});
+				else if (bindsToSolid(callee, context, FUNCTION_FORM_PRIMITIVE_NAMES) && hasProvablyFunctionFirstArgument(node, context)) context.report({
+					node: callee,
+					messageId: "noPrimitives"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-owned-scope-writes.ts
+const SETTER_FACTORIES = new Set([
+	"createOptimistic",
+	"createOptimisticStore",
+	"createSignal",
+	"createStore"
+]);
+const OWNED_WRITE_FACTORIES = new Set(["createSignal", "createOptimistic"]);
+const EFFECT_FACTORIES = new Set(["createEffect", "createRenderEffect"]);
+const COMPUTE_FACTORIES$1 = new Set([
+	"createEffect",
+	"createMemo",
+	"createRenderEffect"
+]);
+const ACTION_FACTORIES = new Set(["action"]);
+function getPropertyName$1(node) {
+	if (!node.computed && node.key.type === "Identifier") return node.key.name;
+	if (node.key.type === "Literal" && typeof node.key.value === "string") return node.key.value;
+	return null;
+}
+function hasOwnedWriteOption(node) {
+	const options = node.arguments[1];
+	if (options?.type !== "ObjectExpression") return false;
+	return options.properties.some((property) => property.type === "Property" && getPropertyName$1(property) === "ownedWrite" && property.value.type === "Literal" && property.value.value === true);
+}
+function isOwnedScopeFunction(node, context) {
+	if (isComponent$1(node, context)) return true;
+	if (node.parent?.type !== "CallExpression" || node.parent.arguments[0] !== node || node.parent.callee.type !== "Identifier") return false;
+	const callee = node.parent.callee;
+	if (!bindsToSolid(callee, context, COMPUTE_FACTORIES$1)) return false;
+	if (bindsToSolid(callee, context, EFFECT_FACTORIES)) return node.parent.arguments.length >= 2;
+	return true;
+}
+var no_owned_scope_writes_default = createRule({
+	name: "no-owned-scope-writes",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow signal/store writes inside component bodies and reactive compute scopes in Solid 2." },
+		schema: [{
+			type: "object",
+			properties: { typescriptEnabled: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		messages: {
+			noActionInOwnedScope: "Calling an action inside a component or reactive compute scope is not allowed in Solid 2. Call it from an event handler or another imperative scope.",
+			noOwnedScopeWrite: "Writing to state inside a component or reactive compute scope is not allowed in Solid 2. Derive values instead, move the write to an event handler or apply phase, or use `ownedWrite: true` for internal `createSignal` state."
+		}
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const setterVariables = /* @__PURE__ */ new Map();
+		const actionVariables = /* @__PURE__ */ new Set();
+		const functionStack = [];
+		const pendingCalls = [];
+		const pendingDirectActions = [];
+		const sourceCode = context.sourceCode;
+		const onFunctionEnter = (node) => {
+			functionStack.push(node);
+		};
+		const onFunctionExit = () => {
+			functionStack.pop();
+		};
+		return {
+			VariableDeclarator(node) {
+				if (node.id.type === "Identifier" && node.init?.type === "CallExpression" && resolveSolidCallee(node.init.callee, context, ACTION_FACTORIES) != null) {
+					const actionId = node.id;
+					const variable = sourceCode.scopeManager?.getDeclaredVariables(node).find((declared) => declared.name === actionId.name);
+					if (variable) actionVariables.add(variable);
+					return;
+				}
+				if (node.id.type === "Identifier" && node.init?.type === "Identifier") {
+					const source = ASTUtils.findVariable(sourceCode.getScope(node.init), node.init);
+					if (source && actionVariables.has(source)) {
+						const aliasId = node.id;
+						const variable = sourceCode.scopeManager?.getDeclaredVariables(node).find((declared) => declared.name === aliasId.name);
+						if (variable) actionVariables.add(variable);
+					}
+				}
+				if (node.id.type !== "ArrayPattern" || node.init?.type !== "CallExpression" || node.init.callee.type !== "Identifier") return;
+				const canonical = resolveSolidCallee(node.init.callee, context, SETTER_FACTORIES);
+				if (canonical == null) return;
+				const setterElement = node.id.elements[1];
+				if (setterElement?.type !== "Identifier") return;
+				const variable = sourceCode.scopeManager?.getDeclaredVariables(node).find((declared) => declared.name === setterElement.name);
+				if (!variable) return;
+				setterVariables.set(variable, { allowOwnedWrite: OWNED_WRITE_FACTORIES.has(canonical) && hasOwnedWriteOption(node.init) });
+			},
+			FunctionDeclaration: onFunctionEnter,
+			FunctionExpression: onFunctionEnter,
+			ArrowFunctionExpression: onFunctionEnter,
+			"FunctionDeclaration:exit": onFunctionExit,
+			"FunctionExpression:exit": onFunctionExit,
+			"ArrowFunctionExpression:exit": onFunctionExit,
+			CallExpression(node) {
+				const enclosingFn = functionStack[functionStack.length - 1];
+				if (!enclosingFn) return;
+				if (node.callee.type === "CallExpression" && resolveSolidCallee(node.callee.callee, context, ACTION_FACTORIES) != null) {
+					pendingDirectActions.push({
+						call: node,
+						enclosingFn
+					});
+					return;
+				}
+				if (node.callee.type !== "Identifier") return;
+				pendingCalls.push({
+					callee: node.callee,
+					enclosingFn
+				});
+			},
+			"Program:exit"() {
+				const ownedScopeCache = /* @__PURE__ */ new Map();
+				const isOwnedScope = (fn) => {
+					let verdict = ownedScopeCache.get(fn);
+					if (verdict === void 0) {
+						verdict = isOwnedScopeFunction(fn, context);
+						ownedScopeCache.set(fn, verdict);
+					}
+					return verdict;
+				};
+				for (const { callee, enclosingFn } of pendingCalls) {
+					const variable = ASTUtils.findVariable(sourceCode.getScope(callee), callee);
+					if (variable && actionVariables.has(variable) && isOwnedScope(enclosingFn)) {
+						context.report({
+							node: callee,
+							messageId: "noActionInOwnedScope"
+						});
+						continue;
+					}
+					const setter = variable && setterVariables.get(variable);
+					if (!setter || setter.allowOwnedWrite) continue;
+					if (isOwnedScope(enclosingFn)) context.report({
+						node: callee,
+						messageId: "noOwnedScopeWrite"
+					});
+				}
+				for (const { call, enclosingFn } of pendingDirectActions) if (isOwnedScope(enclosingFn)) context.report({
+					node: call,
+					messageId: "noActionInOwnedScope"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-reactive-read-after-await.ts
+const COMPUTE_FACTORIES = new Set([
+	"createMemo",
+	"createEffect",
+	"createRenderEffect",
+	"createProjection"
+]);
+const ACCESSOR_FACTORIES$1 = new Set(["createMemo"]);
+const PAIR_ACCESSOR_FACTORIES$1 = new Set(["createSignal", "createOptimistic"]);
+const SOLID_ACCESSOR_TYPE_NAMES = new Set(["Accessor", "SourceAccessor"]);
+function hasGuaranteedAwait(node) {
+	if (node == null) return false;
+	switch (node.type) {
+		case "AwaitExpression": return true;
+		case "SequenceExpression": return node.expressions.some(hasGuaranteedAwait);
+		case "ArrayExpression": return node.elements.some(hasGuaranteedAwait);
+		case "ObjectExpression": return node.properties.some((property) => {
+			if (property.type === "SpreadElement") return hasGuaranteedAwait(property.argument);
+			return property.computed && hasGuaranteedAwait(property.key) || hasGuaranteedAwait(property.value);
+		});
+		case "TemplateLiteral": return node.expressions.some(hasGuaranteedAwait);
+		case "TaggedTemplateExpression": return hasGuaranteedAwait(node.tag) || hasGuaranteedAwait(node.quasi);
+		case "UnaryExpression": return hasGuaranteedAwait(node.argument);
+		case "BinaryExpression": return hasGuaranteedAwait(node.left) || hasGuaranteedAwait(node.right);
+		case "AssignmentExpression": return hasGuaranteedAwait(node.right);
+		case "NewExpression": return hasGuaranteedAwait(node.callee) || node.arguments.some(hasGuaranteedAwait);
+		case "CallExpression":
+			if (node.optional) return false;
+			return hasGuaranteedAwait(node.callee) || node.arguments.some(hasGuaranteedAwait);
+		default: return false;
+	}
+}
+function statementGuaranteesAwait(stmt) {
+	switch (stmt.type) {
+		case "ExpressionStatement": return hasGuaranteedAwait(stmt.expression);
+		case "VariableDeclaration": return stmt.declarations.some((declarator) => hasGuaranteedAwait(declarator.init));
+		case "BlockStatement": return stmt.body.some(statementGuaranteesAwait);
+		default: return false;
+	}
+}
+function collectTypeParts(type, acc = [], seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(type)) return acc;
+	seen.add(type);
+	acc.push(type);
+	if (type.isUnion() || type.isIntersection()) for (const member of type.types) collectTypeParts(member, acc, seen);
+	return acc;
+}
+function symbolIsFromSolid(symbol, checker) {
+	const isSolidOrigin = (text) => text.includes("solid-js") || text.includes("@solidjs") || text.includes("solid-signals");
+	if (isSolidOrigin(checker.getFullyQualifiedName(symbol))) return true;
+	for (const declaration of symbol.getDeclarations() ?? []) if (isSolidOrigin(declaration.getSourceFile().fileName)) return true;
+	return false;
+}
+var no_reactive_read_after_await_default = createRule({
+	name: "no-reactive-read-after-await",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow reading reactive state (signal/memo accessors) after an `await` in an async reactive computation, where it is no longer tracked as a dependency." },
+		schema: [{
+			type: "object",
+			properties: { typescriptEnabled: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		messages: { reactiveReadAfterAwait: "Signal '{{name}}' is read after an `await` in this reactive computation. Reactive tracking ends at the first await, so this read does not register a dependency and the computation won't re-run when '{{name}}' changes. Read it before the await, or wrap it in `untrack()` if that's intentional." }
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const services = context.options[0]?.typescriptEnabled ?? false ? getTypeAwareServices(context) : null;
+		const checker = services?.program.getTypeChecker() ?? null;
+		const accessorVars = /* @__PURE__ */ new Set();
+		const computeCallbackCache = /* @__PURE__ */ new Map();
+		function isAfterAwait(call, fn) {
+			let current = call;
+			while (current !== fn && current.parent != null) {
+				const parent = current.parent;
+				if (parent.type === "BlockStatement" || parent.type === "StaticBlock") {
+					const index = parent.body.indexOf(current);
+					for (let i = 0; i < index; i++) if (statementGuaranteesAwait(parent.body[i])) return true;
+				} else if (parent.type === "SequenceExpression") {
+					const index = parent.expressions.indexOf(current);
+					for (let i = 0; i < index; i++) if (hasGuaranteedAwait(parent.expressions[i])) return true;
+				}
+				current = parent;
+			}
+			return false;
+		}
+		function isTypeAwareComputeCallback(fn) {
+			if (!services || !checker) return false;
+			const parent = fn.parent;
+			if (parent?.type !== "CallExpression" || parent.arguments[0] !== fn) return false;
+			const calleeNode = services.esTreeNodeToTSNodeMap.get(parent.callee);
+			if (!calleeNode) return false;
+			let symbol = checker.getSymbolAtLocation(calleeNode);
+			if (symbol && symbol.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+			return symbol != null && COMPUTE_FACTORIES.has(symbol.getName()) && symbolIsFromSolid(symbol, checker);
+		}
+		function isComputeCallback(fn) {
+			const cached = computeCallbackCache.get(fn);
+			if (cached !== void 0) return cached;
+			const result = isSolidApiCallbackArgument(fn, 0, context, COMPUTE_FACTORIES) || isTypeAwareComputeCallback(fn);
+			computeCallbackCache.set(fn, result);
+			return result;
+		}
+		function isSolidAccessorCallee(callee) {
+			if (!services || !checker) return false;
+			const calleeNode = services.esTreeNodeToTSNodeMap.get(callee);
+			if (!calleeNode) return false;
+			return collectTypeParts(checker.getTypeAtLocation(calleeNode)).some((part) => {
+				const alias = part.aliasSymbol;
+				return alias != null && SOLID_ACCESSOR_TYPE_NAMES.has(alias.getName()) && symbolIsFromSolid(alias, checker);
+			});
+		}
+		function accessorReadName(call) {
+			if (call.callee.type === "Identifier") {
+				const variable = ASTUtils.findVariable(sourceCode.getScope(call), call.callee);
+				if (variable && accessorVars.has(variable)) return call.callee.name;
+			}
+			if (services && isSolidAccessorCallee(call.callee)) return sourceCode.getText(call.callee);
+			return null;
+		}
+		return {
+			VariableDeclarator(node) {
+				if (node.id.type === "Identifier" && node.init?.type === "CallExpression" && node.init.callee.type === "Identifier" && bindsToSolid(node.init.callee, context, ACCESSOR_FACTORIES$1)) {
+					const variable = ASTUtils.findVariable(sourceCode.getScope(node.id), node.id);
+					if (variable) accessorVars.add(variable);
+					return;
+				}
+				if (node.id.type === "ArrayPattern" && node.init?.type === "CallExpression" && node.init.callee.type === "Identifier" && bindsToSolid(node.init.callee, context, PAIR_ACCESSOR_FACTORIES$1)) {
+					const first = node.id.elements[0];
+					if (first?.type === "Identifier") {
+						const variable = sourceCode.scopeManager?.getDeclaredVariables(node).find((declared) => declared.name === first.name);
+						if (variable) accessorVars.add(variable);
+					}
+					return;
+				}
+				if (node.id.type === "Identifier" && node.init?.type === "Identifier") {
+					const source = ASTUtils.findVariable(sourceCode.getScope(node.init), node.init);
+					if (source && accessorVars.has(source)) {
+						const target = ASTUtils.findVariable(sourceCode.getScope(node.id), node.id);
+						if (target) accessorVars.add(target);
+					}
+				}
+			},
+			CallExpression(node) {
+				const fn = getNearestFunctionAncestor(node);
+				if (!fn || !fn.async || !isComputeCallback(fn) || !isAfterAwait(node, fn)) return;
+				const name = accessorReadName(node);
+				if (name == null) return;
+				context.report({
+					node,
+					messageId: "reactiveReadAfterAwait",
+					data: { name }
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-stale-props-alias.ts
+const UNTRACK_NAMES = new Set(["untrack"]);
+const PROPS_HELPER_NAMES = new Set(["merge", "omit"]);
+function isPropsVariableIdentifier(node, propsVariables, sourceCode) {
+	if (node.type !== "Identifier") return false;
+	const variable = ASTUtils.findVariable(sourceCode.getScope(node), node);
+	return variable != null && propsVariables.has(variable);
+}
+/**
+* Whether the expression, evaluated at the component's top level, performs an *eager read* of the
+* props object: a member access rooted at a props variable (`props.name`, `alias.user.name`,
+* `props[key]`) or a spread of it (`{ ...props }` reads every property). A *bare* props reference
+* is not a read — passing the object around (`merge(defaults, props)`, `omit(props, "class")`,
+* `const alias = props`) keeps reactivity intact, and treating it as one flagged the canonical
+* merge/omit patterns. A callee that might read eagerly (`format(props)`) is undecidable and is a
+* tolerated false negative.
+*/
+function expressionContainsPropsRead(node, propsVariables, sourceCode, context) {
+	const stack = [node];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (isFunctionNode(current)) continue;
+		if (current.type === "CallExpression" && current.arguments[0] != null) {
+			if (current.callee.type === "Identifier" && bindsToSolid(current.callee, context, UNTRACK_NAMES)) {
+				const untracked = current.arguments[0];
+				for (const child of getChildNodes(current)) if (child !== untracked) stack.push(child);
+				continue;
+			}
+		}
+		if (current.type === "MemberExpression") {
+			let root = current;
+			while (root.type === "MemberExpression") root = root.object;
+			if (isPropsVariableIdentifier(root, propsVariables, sourceCode)) return true;
+		}
+		if (current.type === "SpreadElement" && isPropsVariableIdentifier(current.argument, propsVariables, sourceCode)) return true;
+		stack.push(...getChildNodes(current));
+	}
+	return false;
+}
+/**
+* Whether `init` is a `merge(...)`/`omit(...)` call (bound to solid-js) that receives the props
+* object as a bare argument — the canonical defaults/rest pattern whose result is a reactive
+* props-like proxy.
+*/
+function isPropsHelperAliasInit(init, propsVariables, sourceCode, context) {
+	if (init.type !== "CallExpression" || init.callee.type !== "Identifier" || !bindsToSolid(init.callee, context, PROPS_HELPER_NAMES)) return false;
+	return init.arguments.some((argument) => {
+		if (argument.type !== "Identifier") return false;
+		const variable = ASTUtils.findVariable(sourceCode.getScope(argument), argument);
+		return variable != null && propsVariables.has(variable);
+	});
+}
+function getDeclaredIdentifierVariable(declaration, sourceCode) {
+	if (declaration.id.type !== "Identifier") return null;
+	const id = declaration.id;
+	return sourceCode.scopeManager?.getDeclaredVariables(declaration).find((variable) => variable.name === id.name) ?? null;
+}
+function hasWriteAfterInit(variable) {
+	return variable.references.some((reference) => !reference.init && reference.isWrite());
+}
+function getAssignmentExpression(statement) {
+	if (statement.type !== "ExpressionStatement") return null;
+	const expression = statement.expression;
+	return expression.type === "AssignmentExpression" && expression.operator === "=" && expression.left.type === "Identifier" ? expression : null;
+}
+function getChildNodes(node) {
+	const children = [];
+	for (const key in node) {
+		if (key === "parent" || key === "tokens" || key === "comments") continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (item != null && typeof item === "object" && typeof item.type === "string") children.push(item);
+		} else if (value != null && typeof value === "object" && typeof value.type === "string") children.push(value);
+	}
+	return children;
+}
+var no_stale_props_alias_default = createRule({
+	name: "no-stale-props-alias",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow top-level aliases of component props, which read props outside tracking." },
+		schema: [{
+			type: "object",
+			properties: { typescriptEnabled: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		messages: { stalePropsAlias: "`{{name}}` aliases a prop read outside tracking. Read from `props` in JSX or a tracked scope instead." }
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const checkFunction = (node) => {
+			if (node.body.type !== "BlockStatement" || !isComponent$1(node, context)) return;
+			const props = node.params[0];
+			if (node.params.length !== 1 || props?.type !== "Identifier") return;
+			const propsVariable = ASTUtils.findVariable(sourceCode.getScope(props), props);
+			if (propsVariable == null) return;
+			const propsVariables = new Set([propsVariable]);
+			for (const statement of node.body.body) {
+				if (statement.type === "VariableDeclaration") {
+					for (const declaration of statement.declarations) {
+						const aliasId = declaration.id;
+						if (aliasId.type !== "Identifier" || declaration.init == null) continue;
+						const isPropsLikeAlias = isPropsVariableIdentifier(declaration.init, propsVariables, sourceCode) || isPropsHelperAliasInit(declaration.init, propsVariables, sourceCode, context);
+						if (!expressionContainsPropsRead(declaration.init, propsVariables, sourceCode, context)) {
+							if (isPropsLikeAlias) {
+								const declared = getDeclaredIdentifierVariable(declaration, sourceCode);
+								if (declared != null && !hasWriteAfterInit(declared)) propsVariables.add(declared);
+							}
+							continue;
+						}
+						const declared = getDeclaredIdentifierVariable(declaration, sourceCode);
+						const isStableAlias = declared != null && !hasWriteAfterInit(declared);
+						if (statement.kind === "const" || isStableAlias) context.report({
+							node: declaration,
+							messageId: "stalePropsAlias",
+							data: { name: aliasId.name }
+						});
+						if (isStableAlias) propsVariables.add(declared);
+					}
+					continue;
+				}
+				const expression = getAssignmentExpression(statement);
+				if (expression == null || expression.left.type !== "Identifier") continue;
+				const assigned = expression.left;
+				if (!expressionContainsPropsRead(expression.right, propsVariables, sourceCode, context)) continue;
+				context.report({
+					node: expression,
+					messageId: "stalePropsAlias",
+					data: { name: assigned.name }
+				});
+			}
+		};
+		return {
+			"FunctionDeclaration:exit": checkFunction,
+			"FunctionExpression:exit": checkFunction,
+			"ArrowFunctionExpression:exit": checkFunction
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-untracked-read-in-effect-apply.ts
+const EFFECT_NAMES = new Set(["createEffect", "createRenderEffect"]);
+const ACCESSOR_FACTORIES = new Set(["createMemo", "createProjection"]);
+const PAIR_ACCESSOR_FACTORIES = new Set(["createOptimistic", "createSignal"]);
+const STORE_FACTORIES = new Set(["createOptimisticStore", "createStore"]);
+const SAFE_HELPERS = new Set(["deep", "snapshot"]);
+var no_untracked_read_in_effect_apply_default = createRule({
+	name: "no-untracked-read-in-effect-apply",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow reading reactive state (signal accessors or store proxies) in a createEffect apply callback, which runs untracked." },
+		schema: [],
+		messages: {
+			signalRead: "Signal '{{name}}' is called directly in an effect apply callback. The apply phase runs untracked — read it in the compute phase and use the passed value, or wrap it in `untrack()`.",
+			storeProxyRead: "Effect apply callbacks run untracked in Solid 2. Extract store properties in the compute phase or use `deep()` before reading them here."
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const reactiveVars = /* @__PURE__ */ new Map();
+		const applyCallbacks = /* @__PURE__ */ new Set();
+		const pendingAccessorCalls = [];
+		const storeVars = /* @__PURE__ */ new Set();
+		const storeShapes = /* @__PURE__ */ new Map();
+		const getMemberPath = (node) => {
+			const path = [];
+			let current = node;
+			while (current.type === "MemberExpression") {
+				if (current.computed || current.property.type !== "Identifier") return null;
+				path.unshift(current.property.name);
+				current = current.object;
+			}
+			return current.type === "Identifier" ? {
+				root: current,
+				path
+			} : null;
+		};
+		const pathLandsOnProxy = (shape, path) => {
+			if (shape == null) return "unknown";
+			let current = shape;
+			for (const key of path) {
+				if (current.type !== "ObjectExpression") return "unknown";
+				let next;
+				for (const candidate of current.properties) if (candidate.type === "Property" && getPropertyName$2(candidate) === key) {
+					next = candidate.value;
+					break;
+				}
+				if (next == null) return "unknown";
+				current = next;
+			}
+			return current.type === "ObjectExpression" || current.type === "ArrayExpression";
+		};
+		const getInlineFunction = (value) => {
+			if (value == null || value.type === "SpreadElement") return null;
+			if (isFunctionNode(value)) return value;
+			const traced = trace(value, context);
+			return isFunctionNode(traced) ? traced : null;
+		};
+		const getInlineApplyCallback = (value) => {
+			const direct = getInlineFunction(value);
+			if (direct) return direct;
+			if (value?.type !== "ObjectExpression") return null;
+			for (const property of value.properties) {
+				if (property.type !== "Property" || getPropertyName$2(property) !== "effect") continue;
+				const fn = getInlineFunction(property.value);
+				if (fn) return fn;
+			}
+			return null;
+		};
+		const findContainingApplyCallback = (node) => {
+			const nearest = getNearestFunctionAncestor(node);
+			return nearest != null && applyCallbacks.has(nearest) ? nearest : null;
+		};
+		const getFunctionValue = (value) => {
+			if (value == null || value.type === "SpreadElement") return null;
+			if (value.type === "FunctionExpression" || value.type === "ArrowFunctionExpression") return value;
+			const traced = trace(value, context);
+			return traced.type === "FunctionExpression" || traced.type === "ArrowFunctionExpression" ? traced : null;
+		};
+		const getTracedApplyCallback = (value) => {
+			const direct = getFunctionValue(value);
+			if (direct) return direct;
+			if (value?.type !== "ObjectExpression") return null;
+			for (const property of value.properties) {
+				if (property.type !== "Property" || getPropertyName$2(property) !== "effect") continue;
+				const effect = getFunctionValue(property.value);
+				if (effect) return effect;
+			}
+			return null;
+		};
+		const isStoreSourceExpression = (node) => {
+			if (node == null) return false;
+			if (node.type === "CallExpression" && resolveSolidCallee(node.callee, context, SAFE_HELPERS) != null) return false;
+			if (node.type === "Identifier") {
+				const variable = ASTUtils.findVariable(sourceCode.getScope(node), node);
+				return variable != null && storeVars.has(variable);
+			}
+			if (node.type === "MemberExpression") {
+				const resolved = getMemberPath(node);
+				if (resolved == null) return false;
+				const variable = ASTUtils.findVariable(sourceCode.getScope(resolved.root), resolved.root);
+				if (variable == null || !storeVars.has(variable)) return false;
+				return pathLandsOnProxy(storeShapes.get(variable) ?? null, resolved.path) === true;
+			}
+			return false;
+		};
+		const checkStoreProxyInApply = (node) => {
+			if (resolveSolidCallee(node.callee, context, EFFECT_NAMES) == null || node.arguments.length < 2) return;
+			const compute = getFunctionValue(node.arguments[0]);
+			const apply = getTracedApplyCallback(node.arguments[1]);
+			if (!compute || !apply) return;
+			const returned = getReturnedExpressions(compute).filter((value) => value != null);
+			if (returned.length === 0) return;
+			if (!returned.some((value) => isStoreSourceExpression(value)) || apply.params.length === 0) return;
+			const applyParam = apply.params[0];
+			if (applyParam.type !== "Identifier") return;
+			const variable = ASTUtils.findVariable(sourceCode.getScope(applyParam), applyParam);
+			if (!variable) return;
+			for (const reference of variable.references) {
+				const identifier = reference.identifier;
+				if (reference.init) continue;
+				if (getNearestFunctionAncestor(identifier) !== apply) continue;
+				if (identifier.parent?.type === "VariableDeclarator" && identifier.parent.init === identifier && (identifier.parent.id.type === "ObjectPattern" || identifier.parent.id.type === "ArrayPattern")) {
+					context.report({
+						node: identifier.parent,
+						messageId: "storeProxyRead"
+					});
+					break;
+				}
+				if (identifier.parent?.type === "SpreadElement") {
+					context.report({
+						node: identifier.parent,
+						messageId: "storeProxyRead"
+					});
+					break;
+				}
+				if (identifier.parent?.type === "MemberExpression" && identifier.parent.object === identifier) {
+					context.report({
+						node: identifier.parent,
+						messageId: "storeProxyRead"
+					});
+					break;
+				}
+			}
+		};
+		return {
+			VariableDeclarator(node) {
+				if (node.id.type === "Identifier" && node.init?.type === "CallExpression" && node.init.callee.type === "Identifier" && bindsToSolid(node.init.callee, context, ACCESSOR_FACTORIES)) {
+					const variable = ASTUtils.findVariable(sourceCode.getScope(node.id), node.id);
+					if (variable) reactiveVars.set(variable, "accessor");
+					return;
+				}
+				if (node.id.type === "ArrayPattern" && node.init?.type === "CallExpression" && node.init.callee.type === "Identifier" && bindsToSolid(node.init.callee, context, PAIR_ACCESSOR_FACTORIES)) {
+					const first = node.id.elements[0];
+					if (first?.type === "Identifier") {
+						const variable = sourceCode.scopeManager?.getDeclaredVariables(node).find((declared) => declared.name === first.name);
+						if (variable) reactiveVars.set(variable, "accessor");
+					}
+					return;
+				}
+				if (node.id.type === "Identifier" && node.init?.type === "Identifier") {
+					const source = ASTUtils.findVariable(sourceCode.getScope(node.init), node.init);
+					if (source && reactiveVars.get(source) === "accessor") {
+						const target = ASTUtils.findVariable(sourceCode.getScope(node.id), node.id);
+						if (target) reactiveVars.set(target, "accessor");
+					}
+				}
+				if (node.id.type === "ArrayPattern" && node.init?.type === "CallExpression" && resolveSolidCallee(node.init.callee, context, STORE_FACTORIES) != null) {
+					const first = node.id.elements[0];
+					if (first?.type === "Identifier") {
+						const variable = sourceCode.scopeManager?.getDeclaredVariables(node).find((declared) => declared.name === first.name);
+						if (variable) {
+							storeVars.add(variable);
+							const initialValue = node.init.arguments[0];
+							storeShapes.set(variable, initialValue?.type === "ObjectExpression" ? initialValue : null);
+						}
+					}
+				}
+			},
+			CallExpression(node) {
+				if (node.callee.type === "Identifier" && bindsToSolid(node.callee, context, EFFECT_NAMES) && node.arguments.length >= 2) {
+					const apply = getInlineApplyCallback(node.arguments[1]);
+					if (apply) applyCallbacks.add(apply);
+				}
+				checkStoreProxyInApply(node);
+				if (node.callee.type === "Identifier") pendingAccessorCalls.push(node);
+			},
+			"Program:exit"() {
+				for (const node of pendingAccessorCalls) {
+					const callee = node.callee;
+					if (callee.type !== "Identifier") continue;
+					const variable = ASTUtils.findVariable(sourceCode.getScope(node), callee);
+					if (variable && reactiveVars.get(variable) === "accessor" && findContainingApplyCallback(node) != null) context.report({
+						node,
+						messageId: "signalRead",
+						data: { name: callee.name }
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/prefer-for.ts
+const PURE_ARRAY_TRANSFORMS = new Set([
+	"filter",
+	"slice",
+	"concat",
+	"map",
+	"flat",
+	"flatMap",
+	"sort",
+	"reverse",
+	"toSorted",
+	"toReversed",
+	"toSpliced",
+	"with"
+]);
+const getPropertyName = (node) => {
+	if (!node.computed && node.property.type === "Identifier") return node.property.name;
+	if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") return node.property.value;
+	return null;
+};
+function isStaticArrayReceiver(node, context) {
+	if (node.type === "ArrayExpression") return true;
+	if (node.type === "Identifier") {
+		const traced = trace(node, context);
+		return traced !== node && traced.type === "ArrayExpression";
+	}
+	if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" && PURE_ARRAY_TRANSFORMS.has(node.callee.property.name)) return isStaticArrayReceiver(node.callee.object, context);
+	return false;
+}
+function isRenderedInJsx(node) {
+	let current = node;
+	for (let parent = current.parent; parent != null; parent = current.parent) {
+		if (parent.type === "ChainExpression") {} else if (parent.type === "LogicalExpression" && parent.operator === "&&" && parent.right === current) {} else if (parent.type === "ConditionalExpression" && (parent.consequent === current || parent.alternate === current)) {} else if (parent.type === "JSXExpressionContainer") return isJSXElementOrFragment(parent.parent);
+		else return false;
+		current = parent;
+	}
+	return false;
+}
+var prefer_for_default = createRule({
+	name: "prefer-for",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer Solid's <For /> component over Array#map when rendering JSX lists." },
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: { typescriptEnabled: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		messages: { preferFor: "Use Solid's `<For />` component for rendering JSX lists instead of `Array#map(...)`." }
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const typescriptEnabled = context.options[0]?.typescriptEnabled ?? false;
+		return { CallExpression(node) {
+			if (!isRenderedInJsx(node)) return;
+			const callee = node.callee;
+			if (callee.type !== "MemberExpression" || node.arguments.length === 0) return;
+			if (node.arguments[0].type === "SpreadElement") return;
+			if (getPropertyName(callee) !== "map") return;
+			if (isStaticArrayReceiver(callee.object, context)) return;
+			const mapFn = node.arguments[0];
+			if (!isFunctionNode(mapFn) || !functionReturnsJsx(mapFn)) return;
+			let receiverVerdict = "unknown";
+			if (typescriptEnabled) {
+				const services = getTypeAwareServices(context);
+				if (services) {
+					receiverVerdict = getArrayReceiverVerdict(callee.object, services);
+					if (receiverVerdict === "not-array") return;
+				}
+			}
+			const containerNode = node.parent?.type === "ChainExpression" ? node.parent : node;
+			const directContainer = containerNode.parent?.type === "JSXExpressionContainer" && isJSXElementOrFragment(containerNode.parent.parent);
+			const canAutoFix = receiverVerdict === "array" && directContainer && node.arguments.length === 1 && mapFn.type === "ArrowFunctionExpression" && mapFn.params.length <= 2 && mapFn.params.every((param) => param.type === "Identifier") && sourceCode.scopeManager?.acquire(mapFn) != null;
+			if (receiverVerdict !== "array") return;
+			context.report({
+				node,
+				messageId: "preferFor",
+				fix: canAutoFix ? (fixer) => {
+					const importFixes = getSolidImportFixes(context, fixer, ["For"]);
+					if (importFixes == null) return null;
+					const jsxExpressionContainerNode = containerNode.parent;
+					const arrayNode = callee.object;
+					const mapFnNode = node.arguments[0];
+					const scope = sourceCode.scopeManager.acquire(mapFn);
+					const fixes = [
+						...importFixes,
+						fixer.replaceTextRange([jsxExpressionContainerNode.range[0], arrayNode.range[0]], "<For each={"),
+						fixer.replaceTextRange([arrayNode.range[1], mapFnNode.range[0]], "}>{"),
+						fixer.replaceTextRange([mapFnNode.range[1], jsxExpressionContainerNode.range[1]], "}</For>")
+					];
+					const indexParam = mapFn.params[1];
+					if (indexParam?.type === "Identifier") {
+						const variable = scope.set.get(indexParam.name);
+						if (variable) {
+							for (const reference of variable.references) if (reference.isReadOnly()) fixes.push(fixer.replaceText(reference.identifier, `${indexParam.name}()`));
+						}
+					}
+					return fixes;
+				} : void 0
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/prefer-show.ts
+const EXPENSIVE_TYPES = new Set(["JSXElement", "JSXFragment"]);
+var prefer_show_default = createRule({
+	name: "prefer-show",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer Solid's <Show /> component for JSX conditionals." },
+		fixable: "code",
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			preferShowAnd: "Use Solid's `<Show />` component for conditionally showing content.",
+			preferShowTernary: "Use Solid's `<Show />` component for conditionally showing content with a fallback.",
+			convertToShow: "Convert to `<Show />`."
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const putIntoJSX = (node) => {
+			const text = sourceCode.getText(node);
+			return isJSXElementOrFragment(node) ? text : `{${text}}`;
+		};
+		const replaceTarget = (node) => node.parent?.type === "JSXExpressionContainer" && isJSXElementOrFragment(node.parent.parent) ? node.parent : node;
+		const withShowImport = (fixer, replacement) => {
+			const importFixes = getSolidImportFixes(context, fixer, ["Show"]);
+			return importFixes == null ? null : [...importFixes, replacement];
+		};
+		const logicalExpressionHandler = (node) => {
+			if (node.operator !== "&&" || !EXPENSIVE_TYPES.has(node.right.type)) return;
+			context.report({
+				node,
+				messageId: "preferShowAnd",
+				suggest: [{
+					messageId: "convertToShow",
+					fix: (fixer) => withShowImport(fixer, fixer.replaceText(replaceTarget(node), `<Show when={${sourceCode.getText(node.left)}}>${putIntoJSX(node.right)}</Show>`))
+				}]
+			});
+		};
+		const conditionalExpressionHandler = (node) => {
+			if (!EXPENSIVE_TYPES.has(node.consequent.type) && !EXPENSIVE_TYPES.has(node.alternate.type)) return;
+			context.report({
+				node,
+				messageId: "preferShowTernary",
+				fix: (fixer) => withShowImport(fixer, fixer.replaceText(replaceTarget(node), `<Show when={${sourceCode.getText(node.test)}} fallback={${sourceCode.getText(node.alternate)}}>${putIntoJSX(node.consequent)}</Show>`))
+			});
+		};
+		const renderedExpression = (expression) => {
+			if (expression.type !== "ArrowFunctionExpression") return expression;
+			if (expression.body.type !== "BlockStatement") return expression.body;
+			return [...expression.body.body].reverse().find((statement) => statement.type === "ReturnStatement")?.argument ?? expression;
+		};
+		return { JSXExpressionContainer(node) {
+			if (!isJSXElementOrFragment(node.parent)) return;
+			const expression = renderedExpression(node.expression);
+			if (expression.type === "LogicalExpression") logicalExpressionHandler(expression);
+			else if (expression.type === "ConditionalExpression") conditionalExpressionHandler(expression);
+		} };
+	}
+});
+//#endregion
+//#region src/rules/self-closing-comp.ts
+const voidDOMElementRegex = /^(?:area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$/;
+const isComponent = (node) => node.name.type === "JSXIdentifier" && !isDOMElementName(node.name.name) || node.name.type === "JSXMemberExpression";
+const isVoidDOMElementName = (name) => voidDOMElementRegex.test(name);
+const childrenIsEmpty = (node) => node.parent.children.length === 0;
+const childrenIsMultilineSpaces = (node) => {
+	const children = node.parent.children;
+	return children.length === 1 && children[0].type === "JSXText" && children[0].value.includes("\n") && children[0].value.replace(/(?!\xA0)\s/g, "") === "";
+};
+const plugin = {
+	meta: { name: "eslint-plugin-solid" },
+	rules: {
+		"components-return-once": components_return_once_default,
+		"jsx-no-duplicate-props": jsx_no_duplicate_props_default,
+		"no-destructure": no_destructure_default,
+		"no-leaf-owner-operations": no_leaf_owner_operations_default,
+		"no-owned-scope-writes": no_owned_scope_writes_default,
+		"no-reactive-read-after-await": no_reactive_read_after_await_default,
+		"no-stale-props-alias": no_stale_props_alias_default,
+		"no-untracked-read-in-effect-apply": no_untracked_read_in_effect_apply_default,
+		"prefer-for": prefer_for_default,
+		"prefer-show": prefer_show_default,
+		"self-closing-comp": createRule({
+			name: "self-closing-comp",
+			meta: {
+				type: "layout",
+				docs: { description: "Disallow extra closing tags for components without children." },
+				fixable: "code",
+				schema: [{
+					type: "object",
+					properties: {
+						component: {
+							enum: ["all", "none"],
+							type: "string"
+						},
+						html: {
+							enum: [
+								"all",
+								"void",
+								"none"
+							],
+							type: "string"
+						}
+					},
+					additionalProperties: false
+				}],
+				messages: {
+					dontSelfClose: "This element should not be self-closing.",
+					selfClose: "Empty components are self-closing."
+				}
+			},
+			defaultOptions: [],
+			create(context) {
+				const sourceCode = context.sourceCode;
+				const shouldBeSelfClosedWhenPossible = (node) => {
+					if (isComponent(node)) return (context.options[0]?.component ?? "all") === "all";
+					if (isHostElement(node)) switch (context.options[0]?.html ?? "all") {
+						case "all": return true;
+						case "void": return node.name.type === "JSXIdentifier" && isVoidDOMElementName(node.name.name);
+						case "none": return false;
+					}
+					return true;
+				};
+				return { JSXOpeningElement(node) {
+					if (!(childrenIsEmpty(node) || childrenIsMultilineSpaces(node))) return;
+					const shouldSelfClose = shouldBeSelfClosedWhenPossible(node);
+					if (shouldSelfClose && !node.selfClosing) context.report({
+						node,
+						messageId: "selfClose",
+						fix: (fixer) => {
+							const openingElementEnding = node.range[1] - 1;
+							const closingElementEnding = node.parent.closingElement.range[1];
+							return fixer.replaceTextRange([openingElementEnding, closingElementEnding], " />");
+						}
+					});
+					else if (!shouldSelfClose && node.selfClosing) context.report({
+						node,
+						messageId: "dontSelfClose",
+						fix: (fixer) => {
+							const tagName = sourceCode.getText(node.name);
+							const selfCloseEnding = node.range[1];
+							const lastTokens = sourceCode.getLastTokens(node, { count: 3 });
+							const range = [sourceCode.isSpaceBetween(lastTokens[0], lastTokens[1]) ? selfCloseEnding - 3 : selfCloseEnding - 2, selfCloseEnding];
+							return fixer.replaceTextRange(range, `></${tagName}>`);
+						}
+					});
+				} };
+			}
+		})
+	}
+};
+//#endregion
+//#region src/configs/recommended.ts
+const recommended = {
+	name: "solid/recommended",
+	plugins: { solid: plugin },
+	rules: {
+		"solid/components-return-once": "warn",
+		"solid/jsx-no-duplicate-props": "error",
+		"solid/no-destructure": "warn",
+		"solid/no-leaf-owner-operations": "error",
+		"solid/no-owned-scope-writes": "error",
+		"solid/no-reactive-read-after-await": "warn",
+		"solid/no-stale-props-alias": "warn",
+		"solid/no-untracked-read-in-effect-apply": "warn",
+		"solid/prefer-show": "warn",
+		"solid/self-closing-comp": "warn"
+	}
+};
+//#endregion
+//#region src/configs/recommended-type-checked.ts
+const typeAwareOverrides = {
+	"solid/components-return-once": ["warn", { typescriptEnabled: true }],
+	"solid/no-destructure": ["warn", { typescriptEnabled: true }],
+	"solid/no-owned-scope-writes": ["error", { typescriptEnabled: true }],
+	"solid/no-reactive-read-after-await": ["warn", { typescriptEnabled: true }],
+	"solid/prefer-for": ["warn", { typescriptEnabled: true }]
+};
+const recommendedTypeChecked = {
+	name: "solid/recommended-type-checked",
+	plugins: { solid: plugin },
+	rules: {
+		...recommended.rules,
+		...typeAwareOverrides
+	}
+};
+//#endregion
+//#region src/index.ts
+const pluginWithConfigs = {
+	...plugin,
+	configs: {
+		recommended,
+		"flat/recommended": recommended,
+		"recommended-type-checked": recommendedTypeChecked,
+		"flat/recommended-type-checked": recommendedTypeChecked
+	}
+};
+//#endregion
+export { pluginWithConfigs as default };