@thomaflette/eslint-plugin-solid-2 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -55,34 +55,218 @@ function* jsxGetAllProps(props) {
 	}
 }
 //#endregion
+//#region src/analysis/typescript-semantics.ts
+function getTypeAwareServices(context) {
+	const services = context.sourceCode.parserServices;
+	if (services?.program != null && services.esTreeNodeToTSNodeMap != null) return services;
+	return null;
+}
+function resolveTypeScriptAlias(symbol, checker) {
+	return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+}
+const SOLID_ACCESSOR_TYPE_NAMES = new Set(["Accessor", "SourceAccessor"]);
+function isSolidOrigin(text) {
+	return text.includes("solid-js") || text.includes("@solidjs") || text.includes("solid-signals");
+}
+const solidSymbolCache = /* @__PURE__ */ new WeakMap();
+function symbolIsFromSolid(symbol, checker) {
+	const cached = solidSymbolCache.get(symbol);
+	if (cached !== void 0) return cached;
+	const result = isSolidOrigin(checker.getFullyQualifiedName(symbol)) || (symbol.getDeclarations() ?? []).some((declaration) => isSolidOrigin(declaration.getSourceFile().fileName));
+	solidSymbolCache.set(symbol, result);
+	return result;
+}
+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;
+}
+const solidAccessorNodeCache = /* @__PURE__ */ new WeakMap();
+function isSolidAccessorExpression(node, services) {
+	const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+	if (!tsNode) return false;
+	const cached = solidAccessorNodeCache.get(tsNode);
+	if (cached !== void 0) return cached;
+	const checker = services.program.getTypeChecker();
+	const result = collectTypeParts(checker.getTypeAtLocation(tsNode)).some((part) => {
+		const alias = part.aliasSymbol;
+		return alias != null && SOLID_ACCESSOR_TYPE_NAMES.has(alias.getName()) && symbolIsFromSolid(alias, checker);
+	});
+	solidAccessorNodeCache.set(tsNode, result);
+	return result;
+}
+function resolveTypeAwareSolidCallee(node, services, canonicalNames) {
+	const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+	if (!tsNode) return null;
+	const checker = services.program.getTypeChecker();
+	const symbol = checker.getSymbolAtLocation(tsNode);
+	if (!symbol) return null;
+	const resolved = resolveTypeScriptAlias(symbol, checker);
+	const name = resolved.getName();
+	return canonicalNames.has(name) && symbolIsFromSolid(resolved, checker) ? name : null;
+}
+function isTypeAwareSolidCallee(node, services, canonicalNames) {
+	return resolveTypeAwareSolidCallee(node, services, canonicalNames) != null;
+}
+//#endregion
+//#region src/analysis/solid-bindings.ts
+const SINGLE_RESULT_FACTORIES = new Map([
+	["action", "action"],
+	["createMemo", "accessor"],
+	["createProjection", "store"]
+]);
+const PAIR_RESULT_FACTORIES = new Map([
+	["createOptimistic", ["accessor", "setter"]],
+	["createOptimisticStore", ["store", "setter"]],
+	["createSignal", ["accessor", "setter"]],
+	["createStore", ["store", "setter"]]
+]);
+const REACTIVE_FACTORIES = new Set([...SINGLE_RESULT_FACTORIES.keys(), ...PAIR_RESULT_FACTORIES.keys()]);
+/** Whether a node is an `import ... from "solid-js"` declaration. */
+function isSolidJsImportDeclaration(node) {
+	return node?.type === "ImportDeclaration" && node.source.type === "Literal" && node.source.value === "solid-js";
+}
+function namespaceMemberName(node, context) {
+	if (node.type !== "MemberExpression" || node.optional || node.object.type !== "Identifier" || node.property.type !== "Identifier" || node.computed) return null;
+	const imported = ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object)?.defs.some((def) => def.type === "ImportBinding" && def.node.type === "ImportNamespaceSpecifier" && isSolidJsImportDeclaration(def.node.parent));
+	return {
+		name: node.property.name,
+		imported: imported === true
+	};
+}
+/**
+* Resolves a direct, aliased, or namespace-qualified expression to its canonical Solid export.
+* Bare canonical names count only when truly unresolved (auto-import/global).
+*/
+function resolveSolidCallee(node, context, canonicalNames) {
+	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;
+		return canonicalNames.has(importedName) ? importedName : null;
+	}
+	const member = namespaceMemberName(traced, context);
+	return member?.imported === true && canonicalNames.has(member.name) ? member.name : null;
+}
+function bindsToSolid(node, context, canonicalNames) {
+	return resolveSolidCallee(node, context, canonicalNames) != null;
+}
+function getChildNodes$1(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;
+}
+function declaredVariable(declarator, id, sourceCode) {
+	return sourceCode.scopeManager?.getDeclaredVariables(declarator).find((variable) => variable.name === id.name) ?? null;
+}
+const baseReactiveBindingCache = /* @__PURE__ */ new WeakMap();
+const typeAwareReactiveBindingCache = /* @__PURE__ */ new WeakMap();
+function buildReactiveBindingFacts(sourceCode, context) {
+	const facts = /* @__PURE__ */ new Map();
+	const aliases = [];
+	const services = context.options[0]?.typescriptEnabled ? getTypeAwareServices(context) : null;
+	const stack = [sourceCode.ast];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (node.type === "VariableDeclarator") {
+			const declaration = node.parent;
+			if (declaration?.type === "VariableDeclaration" && declaration.kind === "const" && node.id.type === "Identifier" && node.init?.type === "Identifier") {
+				const target = declaredVariable(node, node.id, sourceCode);
+				const source = ASTUtils.findVariable(sourceCode.getScope(node.init), node.init);
+				if (target && source) aliases.push({
+					target,
+					source
+				});
+			}
+			if (node.init?.type === "CallExpression") {
+				const factory = resolveSolidCallee(node.init.callee, context, REACTIVE_FACTORIES) ?? (services == null ? null : resolveTypeAwareSolidCallee(node.init.callee, services, REACTIVE_FACTORIES));
+				if (factory != null) {
+					const singleRole = SINGLE_RESULT_FACTORIES.get(factory);
+					if (singleRole != null && node.id.type === "Identifier") {
+						const variable = declaredVariable(node, node.id, sourceCode);
+						if (variable) facts.set(variable, {
+							role: singleRole,
+							factory,
+							declaration: node,
+							tupleIndex: null
+						});
+					}
+					const pairRoles = PAIR_RESULT_FACTORIES.get(factory);
+					if (pairRoles != null && node.id.type === "ArrayPattern") for (const tupleIndex of [0, 1]) {
+						const id = node.id.elements[tupleIndex];
+						if (id?.type !== "Identifier") continue;
+						const variable = declaredVariable(node, id, sourceCode);
+						if (variable) facts.set(variable, {
+							role: pairRoles[tupleIndex],
+							factory,
+							declaration: node,
+							tupleIndex
+						});
+					}
+				}
+			}
+		}
+		stack.push(...getChildNodes$1(node));
+	}
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const { target, source } of aliases) {
+			if (facts.has(target)) continue;
+			const fact = facts.get(source);
+			if (fact) {
+				facts.set(target, fact);
+				changed = true;
+			}
+		}
+	}
+	return facts;
+}
+function getReactiveBindingFacts(context) {
+	const sourceCode = context.sourceCode;
+	const cache = context.options[0]?.typescriptEnabled === true ? typeAwareReactiveBindingCache : baseReactiveBindingCache;
+	const cached = cache.get(sourceCode);
+	if (cached) return cached;
+	const facts = buildReactiveBindingFacts(sourceCode, context);
+	cache.set(sourceCode, facts);
+	return facts;
+}
+function getReactiveBindingFact(node, context) {
+	const variable = ASTUtils.findVariable(context.sourceCode.getScope(node), node);
+	return variable ? getReactiveBindingFacts(context).get(variable) ?? null : null;
+}
+function getReactiveBindingFactForVariable(variable, context) {
+	return getReactiveBindingFacts(context).get(variable) ?? null;
+}
+//#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
+//#region src/analysis/component-recognition.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;
@@ -96,14 +280,6 @@ function typeReferenceRootIdentifier(node) {
 		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) {
@@ -118,35 +294,26 @@ function typeNameBindsToSolid(id, qualified, context) {
 	}
 	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;
+	if (parent?.type !== "VariableDeclarator" || parent.id.type !== "Identifier") return false;
+	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);
 }
 const inFileComponentVarsCache = /* @__PURE__ */ new WeakMap();
 function getInFileComponentVariables(sourceCode) {
 	const cached = inFileComponentVarsCache.get(sourceCode);
 	if (cached) return cached;
-	const vars = /* @__PURE__ */ new Set();
+	const variables = /* @__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);
+			if (variable) variables.add(variable);
 		}
 		for (const key in node) {
 			if (key === "parent" || key === "tokens" || key === "comments") continue;
@@ -156,9 +323,73 @@ function getInFileComponentVariables(sourceCode) {
 			} else if (value != null && typeof value === "object" && typeof value.type === "string") stack.push(value);
 		}
 	}
-	inFileComponentVarsCache.set(sourceCode, vars);
-	return vars;
+	inFileComponentVarsCache.set(sourceCode, variables);
+	return variables;
+}
+const jsxTagSymbolsCache = /* @__PURE__ */ new WeakMap();
+function getJsxTagSymbols(services) {
+	const cached = jsxTagSymbolsCache.get(services.program);
+	if (cached) return cached;
+	const checker = services.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(resolveTypeScriptAlias(symbol, checker));
+		}
+		ts.forEachChild(node, visit);
+	};
+	for (const sourceFile of services.program.getSourceFiles()) if (!sourceFile.isDeclarationFile && !sourceFile.fileName.includes("/node_modules/")) visit(sourceFile);
+	jsxTagSymbolsCache.set(services.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;
+}
+const baseEvidenceCache = /* @__PURE__ */ new WeakMap();
+const typeAwareEvidenceCache = /* @__PURE__ */ new WeakMap();
+function cachedEvidence(cache, sourceCode, node, compute) {
+	let byFunction = cache.get(sourceCode);
+	if (!byFunction) {
+		byFunction = /* @__PURE__ */ new WeakMap();
+		cache.set(sourceCode, byFunction);
+	}
+	const cached = byFunction.get(node);
+	if (cached !== void 0) return cached;
+	const evidence = compute();
+	byFunction.set(node, evidence);
+	return evidence;
+}
+function hasBaseEvidence(node, context) {
+	return cachedEvidence(baseEvidenceCache, context.sourceCode, node, () => {
+		if (hasSolidComponentTypeAnnotation(node, context)) return true;
+		const name = getFunctionName(node);
+		if (name == null) return false;
+		const variable = ASTUtils.findVariable(context.sourceCode.getScope(node), name);
+		return variable != null && getInFileComponentVariables(context.sourceCode).has(variable);
+	});
 }
+function hasTypeAwareEvidence(node, context) {
+	return cachedEvidence(typeAwareEvidenceCache, context.sourceCode, node, () => {
+		const services = getTypeAwareServices(context);
+		if (!services) return false;
+		const checker = services.program.getTypeChecker();
+		const symbol = getFunctionSymbol(node, services);
+		return symbol != null && getJsxTagSymbols(services).has(resolveTypeScriptAlias(symbol, checker));
+	});
+}
+/** Sound, self-indexing Solid component recognition. See ADR-0002. */
+function isComponent$1(node, context) {
+	if (hasBaseEvidence(node, context)) return true;
+	return context.options[0]?.typescriptEnabled === true && hasTypeAwareEvidence(node, context);
+}
+//#endregion
+//#region src/rules/solid-rule-utils.ts
 function expressionCanYieldJsx(node) {
 	switch (node?.type) {
 		case "JSXElement":
@@ -203,43 +434,6 @@ function functionReturnsJsx(node) {
 	}
 	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:
@@ -260,57 +454,6 @@ function getArrayReceiverVerdict(node, services) {
 	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 [];
@@ -364,26 +507,6 @@ function getNearestFunctionAncestor(node) {
 	}
 	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;
@@ -412,9 +535,6 @@ function getSolidImportFixes(context, fixer, names) {
 }
 //#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);
 }
@@ -423,27 +543,6 @@ 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
@@ -457,7 +556,7 @@ function containsReactiveRead(node, componentFn, context, seen = /* @__PURE__ */
 		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;
+		if (isPropsParameter(variable) || getReactiveBindingFactForVariable(variable, context)?.role === "store") return true;
 		return derivedConstIsReactive(variable);
 	};
 	const derivedConstIsReactive = (variable) => {
@@ -472,7 +571,7 @@ function containsReactiveRead(node, componentFn, context, seen = /* @__PURE__ */
 		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 (callee != null && getReactiveBindingFactForVariable(callee, context)?.role === "accessor") return true;
 		}
 		if (current.type === "MemberExpression" && memberRootIsReactive(current)) return true;
 		if (current.type === "Identifier") {
@@ -885,24 +984,34 @@ var no_leaf_owner_operations_default = createRule({
 	meta: {
 		type: "problem",
 		docs: { description: "Disallow onCleanup, reactive-primitive creation, and flush() inside the leaf owners createTrackedEffect and onSettled." },
-		schema: [],
+		schema: [{
+			type: "object",
+			properties: { typescriptEnabled: { type: "boolean" } },
+			additionalProperties: false
+		}],
 		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: [],
+	defaultOptions: [{}],
 	create(context) {
+		const services = context.options[0]?.typescriptEnabled ? getTypeAwareServices(context) : null;
+		const isSolidApi = (node, names) => resolveSolidCallee(node, context, names) != null || services != null && resolveTypeAwareSolidCallee(node, services, names) != null;
+		const isSolidCallbackArgument = (node, argumentIndex, names) => {
+			const call = node.parent;
+			return call?.type === "CallExpression" && call.arguments[argumentIndex] === node && isSolidApi(call.callee, names);
+		};
 		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);
+			const trackedEffect = isSolidCallbackArgument(node, 0, TRACKED_EFFECT_NAMES);
 			let ownerBackedSettled = false;
-			if (isSolidApiCallbackArgument(node, 0, context, ON_SETTLED_NAMES)) {
+			if (isSolidCallbackArgument(node, 0, 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));
+				ownerBackedSettled = enclosing != null && (isComponent$1(enclosing, context) || isSolidCallbackArgument(enclosing, 0, OWNER_CALLBACK_NAMES) || isSolidCallbackArgument(enclosing, 1, OWNER_CALLBACK_NAMES));
 			}
 			if (trackedEffect || ownerBackedSettled) forbiddenStack.push(node);
 		};
@@ -918,21 +1027,21 @@ var no_leaf_owner_operations_default = createRule({
 			"ArrowFunctionExpression:exit": onFunctionExit,
 			CallExpression(node) {
 				const currentForbidden = forbiddenStack[forbiddenStack.length - 1];
-				if (!currentForbidden || getNearestFunctionAncestor(node) !== currentForbidden || node.callee.type !== "Identifier") return;
+				if (!currentForbidden || getNearestFunctionAncestor(node) !== currentForbidden) return;
 				const callee = node.callee;
-				if (bindsToSolid(callee, context, ON_CLEANUP_NAMES)) context.report({
+				if (isSolidApi(callee, ON_CLEANUP_NAMES)) context.report({
 					node: callee,
 					messageId: "noCleanup"
 				});
-				else if (bindsToSolid(callee, context, FLUSH_NAMES)) context.report({
+				else if (isSolidApi(callee, FLUSH_NAMES)) context.report({
 					node: callee,
 					messageId: "noFlush"
 				});
-				else if (bindsToSolid(callee, context, PRIMITIVE_NAMES)) context.report({
+				else if (isSolidApi(callee, PRIMITIVE_NAMES)) context.report({
 					node: callee,
 					messageId: "noPrimitives"
 				});
-				else if (bindsToSolid(callee, context, FUNCTION_FORM_PRIMITIVE_NAMES) && hasProvablyFunctionFirstArgument(node, context)) context.report({
+				else if (isSolidApi(callee, FUNCTION_FORM_PRIMITIVE_NAMES) && hasProvablyFunctionFirstArgument(node, context)) context.report({
 					node: callee,
 					messageId: "noPrimitives"
 				});
@@ -941,21 +1050,61 @@ var no_leaf_owner_operations_default = createRule({
 	}
 });
 //#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([
+//#region src/analysis/computation-roles.ts
+const CALLBACK_FACTORIES = new Set([
 	"createEffect",
 	"createMemo",
-	"createRenderEffect"
+	"createProjection",
+	"createRenderEffect",
+	"createSignal",
+	"createStore",
+	"createTrackedEffect",
+	"onSettled"
 ]);
+/** Classifies a function's exact, binding-proven Solid execution role. */
+function getComputationCallbackRole(node, context) {
+	if (isComponent$1(node, context)) return "component";
+	if (node.type === "FunctionDeclaration") return null;
+	const call = node.parent;
+	if (call?.type !== "CallExpression") return null;
+	const argumentIndex = call.arguments.indexOf(node);
+	if (argumentIndex < 0) return null;
+	const services = context.options[0]?.typescriptEnabled ? getTypeAwareServices(context) : null;
+	switch (resolveSolidCallee(call.callee, context, CALLBACK_FACTORIES) ?? (services == null ? null : resolveTypeAwareSolidCallee(call.callee, services, CALLBACK_FACTORIES))) {
+		case "createMemo": return argumentIndex === 0 ? "memo-compute" : null;
+		case "createProjection": return argumentIndex === 0 ? "projection-compute" : null;
+		case "createSignal": return argumentIndex === 0 ? "derived-signal" : null;
+		case "createStore": return argumentIndex === 0 && call.arguments.length >= 2 ? "derived-store" : null;
+		case "createEffect":
+		case "createRenderEffect":
+			if (call.arguments.length < 2) return argumentIndex === 0 ? "legacy-effect-compute" : null;
+			return argumentIndex === 0 ? "split-effect-compute" : argumentIndex === 1 ? "effect-apply" : null;
+		case "createTrackedEffect": return argumentIndex === 0 ? "leaf-owner" : null;
+		case "onSettled": return argumentIndex === 0 ? "settled" : null;
+		default: return null;
+	}
+}
+const OWNED_WRITE_FORBIDDEN_ROLES = new Set([
+	"component",
+	"derived-signal",
+	"derived-store",
+	"memo-compute",
+	"projection-compute",
+	"split-effect-compute"
+]);
+const ASYNC_TRACKED_COMPUTE_ROLES = new Set([
+	"derived-signal",
+	"derived-store",
+	"legacy-effect-compute",
+	"memo-compute",
+	"projection-compute",
+	"split-effect-compute"
+]);
+//#endregion
+//#region src/rules/no-owned-scope-writes.ts
+const OWNED_WRITE_FACTORIES = new Set(["createSignal", "createOptimistic"]);
 const ACTION_FACTORIES = new Set(["action"]);
+const REFRESH_NAMES = new Set(["refresh"]);
 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;
@@ -967,12 +1116,8 @@ function hasOwnedWriteOption(node) {
 	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;
+	const role = getComputationCallbackRole(node, context);
+	return role != null && OWNED_WRITE_FORBIDDEN_ROLES.has(role);
 }
 var no_owned_scope_writes_default = createRule({
 	name: "no-owned-scope-writes",
@@ -986,17 +1131,18 @@ var no_owned_scope_writes_default = createRule({
 		}],
 		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.",
+			noOwnedScopeRefresh: "Calling refresh() inside a component or reactive compute scope is not allowed in Solid 2. Move the invalidation to an event handler, effect apply phase, 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 services = context.options[0]?.typescriptEnabled ? getTypeAwareServices(context) : null;
+		const isSolidApi = (node, names) => resolveSolidCallee(node, context, names) != null || services != null && resolveTypeAwareSolidCallee(node, services, names) != null;
 		const functionStack = [];
 		const pendingCalls = [];
 		const pendingDirectActions = [];
-		const sourceCode = context.sourceCode;
+		const pendingRefreshes = [];
 		const onFunctionEnter = (node) => {
 			functionStack.push(node);
 		};
@@ -1004,30 +1150,6 @@ var no_owned_scope_writes_default = createRule({
 			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,
@@ -1037,13 +1159,20 @@ var no_owned_scope_writes_default = createRule({
 			CallExpression(node) {
 				const enclosingFn = functionStack[functionStack.length - 1];
 				if (!enclosingFn) return;
-				if (node.callee.type === "CallExpression" && resolveSolidCallee(node.callee.callee, context, ACTION_FACTORIES) != null) {
+				if (node.callee.type === "CallExpression" && isSolidApi(node.callee.callee, ACTION_FACTORIES)) {
 					pendingDirectActions.push({
 						call: node,
 						enclosingFn
 					});
 					return;
 				}
+				if (isSolidApi(node.callee, REFRESH_NAMES)) {
+					pendingRefreshes.push({
+						call: node,
+						enclosingFn
+					});
+					return;
+				}
 				if (node.callee.type !== "Identifier") return;
 				pendingCalls.push({
 					callee: node.callee,
@@ -1061,16 +1190,17 @@ var no_owned_scope_writes_default = createRule({
 					return verdict;
 				};
 				for (const { callee, enclosingFn } of pendingCalls) {
-					const variable = ASTUtils.findVariable(sourceCode.getScope(callee), callee);
-					if (variable && actionVariables.has(variable) && isOwnedScope(enclosingFn)) {
+					const fact = getReactiveBindingFact(callee, context);
+					if (fact?.role === "action" && isOwnedScope(enclosingFn)) {
 						context.report({
 							node: callee,
 							messageId: "noActionInOwnedScope"
 						});
 						continue;
 					}
-					const setter = variable && setterVariables.get(variable);
-					if (!setter || setter.allowOwnedWrite) continue;
+					if (fact?.role !== "setter") continue;
+					const factoryCall = fact.declaration.init;
+					if (factoryCall?.type === "CallExpression" && OWNED_WRITE_FACTORIES.has(fact.factory) && hasOwnedWriteOption(factoryCall)) continue;
 					if (isOwnedScope(enclosingFn)) context.report({
 						node: callee,
 						messageId: "noOwnedScopeWrite"
@@ -1080,6 +1210,10 @@ var no_owned_scope_writes_default = createRule({
 					node: call,
 					messageId: "noActionInOwnedScope"
 				});
+				for (const { call, enclosingFn } of pendingRefreshes) if (isOwnedScope(enclosingFn)) context.report({
+					node: call,
+					messageId: "noOwnedScopeRefresh"
+				});
 			}
 		};
 	}
@@ -1090,11 +1224,10 @@ const COMPUTE_FACTORIES = new Set([
 	"createMemo",
 	"createEffect",
 	"createRenderEffect",
-	"createProjection"
+	"createProjection",
+	"createSignal",
+	"createStore"
 ]);
-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) {
@@ -1125,19 +1258,6 @@ function statementGuaranteesAwait(stmt) {
 		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: {
@@ -1154,8 +1274,6 @@ var no_reactive_read_after_await_default = createRule({
 	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;
@@ -1173,77 +1291,236 @@ var no_reactive_read_after_await_default = createRule({
 			return false;
 		}
 		function isTypeAwareComputeCallback(fn) {
-			if (!services || !checker) return false;
+			if (!services) 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);
+			return isTypeAwareSolidCallee(parent.callee, services, COMPUTE_FACTORIES);
 		}
 		function isComputeCallback(fn) {
 			const cached = computeCallbackCache.get(fn);
 			if (cached !== void 0) return cached;
-			const result = isSolidApiCallbackArgument(fn, 0, context, COMPUTE_FACTORIES) || isTypeAwareComputeCallback(fn);
+			const result = (() => {
+				const role = getComputationCallbackRole(fn, context);
+				return role != null && ASYNC_TRACKED_COMPUTE_ROLES.has(role);
+			})() || 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);
-			});
+			if (!services) return false;
+			return isSolidAccessorExpression(callee, services);
 		}
 		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 (getReactiveBindingFact(call.callee, context)?.role === "accessor") 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 }
-				});
-			}
-		};
+		return { 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/analysis/control-flow-children.ts
+const CONTROL_FLOW_NAMES = new Set([
+	"For",
+	"Match",
+	"Repeat",
+	"Show"
+]);
+function importedControlFlowName(name, context) {
+	if (name.type === "JSXIdentifier") {
+		const variable = ASTUtils.findVariable(context.sourceCode.getScope(name), name.name);
+		for (const def of variable?.defs ?? []) if (def.type === "ImportBinding" && def.node.type === "ImportSpecifier" && isSolidJsImportDeclaration(def.node.parent)) {
+			const imported = def.node.imported.type === "Identifier" ? def.node.imported.name : def.node.imported.value;
+			return CONTROL_FLOW_NAMES.has(imported) ? imported : null;
+		}
+		return null;
+	}
+	if (name.type === "JSXMemberExpression" && name.object.type === "JSXIdentifier" && name.property.type === "JSXIdentifier" && CONTROL_FLOW_NAMES.has(name.property.name)) return ASTUtils.findVariable(context.sourceCode.getScope(name.object), name.object.name)?.defs.some((def) => def.type === "ImportBinding" && def.node.type === "ImportNamespaceSpecifier" && isSolidJsImportDeclaration(def.node.parent)) === true ? name.property.name : null;
+	return null;
+}
+function provenControlFlowName(name, context) {
+	const imported = importedControlFlowName(name, context);
+	if (imported != null) return imported;
+	const services = context.options[0]?.typescriptEnabled ? getTypeAwareServices(context) : null;
+	return services == null ? null : resolveTypeAwareSolidCallee(name, services, CONTROL_FLOW_NAMES);
+}
+function resolveFunction(value, context) {
+	if (value == null || value.type === "SpreadElement") return null;
+	if (isFunctionNode(value)) return value;
+	const resolved = trace(value, context);
+	return isFunctionNode(resolved) ? resolved : null;
+}
+function keyedMode(element, context) {
+	const keyed = element.openingElement.attributes.find((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "keyed");
+	if (!keyed) return "absent";
+	if (keyed.value == null) return "true";
+	if (keyed.value.type !== "JSXExpressionContainer") return "unknown";
+	const value = keyed.value.expression;
+	if (value.type === "Literal" && value.value === true) return "true";
+	if (value.type === "Literal" && value.value === false) return "false";
+	if (resolveFunction(value, context) != null) return "custom";
+	return "unknown";
+}
+function accessorParameters(fn, controlFlowName, element, context) {
+	const identifiers = fn.params.map((param) => param.type === "Identifier" ? param : null);
+	const mode = keyedMode(element, context);
+	if (controlFlowName === "For") {
+		if (mode === "false") return identifiers[0] ? [identifiers[0]] : [];
+		if (mode === "custom") return identifiers.filter((param) => param != null);
+		if (mode === "absent" || mode === "true") return identifiers[1] ? [identifiers[1]] : [];
+		return [];
+	}
+	if (controlFlowName === "Show" || controlFlowName === "Match") return mode === "absent" || mode === "false" ? identifiers[0] ? [identifiers[0]] : [] : [];
+	return [];
+}
+function functionsFromElement(element, context) {
+	const controlFlowName = provenControlFlowName(element.openingElement.name, context);
+	if (controlFlowName == null) return [];
+	const functions = [];
+	const add = (fn) => {
+		functions.push({
+			function: fn,
+			accessorParameters: accessorParameters(fn, controlFlowName, element, context)
+		});
+	};
+	for (const attribute of element.openingElement.attributes) if (attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "children" && attribute.value?.type === "JSXExpressionContainer") {
+		const fn = resolveFunction(attribute.value.expression, context);
+		if (fn) add(fn);
+	}
+	for (const child of element.children) {
+		if (child.type !== "JSXExpressionContainer") continue;
+		const fn = resolveFunction(child.expression, context);
+		if (fn) add(fn);
+	}
+	return functions;
+}
+function childNodes$1(node) {
+	const result = [];
+	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") result.push(item);
+		} else if (value != null && typeof value === "object" && typeof value.type === "string") result.push(value);
+	}
+	return result;
+}
+/** Finds binding-proven Solid control-flow function children inside a component body. */
+function getControlFlowFunctionChildren(component, context) {
+	const functions = [];
+	const seenFunctions = /* @__PURE__ */ new Set();
+	const stack = [component.body];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (node !== component.body && isFunctionNode(node)) continue;
+		if (node.type === "JSXElement") for (const child of functionsFromElement(node, context)) {
+			if (seenFunctions.has(child.function)) continue;
+			seenFunctions.add(child.function);
+			functions.push(child);
+			stack.push(child.function.body);
+		}
+		stack.push(...childNodes$1(node));
+	}
+	return functions;
+}
+//#endregion
+//#region src/analysis/reactive-reads.ts
+const UNTRACK_NAMES$1 = new Set(["untrack"]);
+function getReactiveReadTypeServices(context) {
+	return context.options[0]?.typescriptEnabled ? getTypeAwareServices(context) : null;
+}
+function variableFor(node, context) {
+	return ASTUtils.findVariable(context.sourceCode.getScope(node), node);
+}
+function rootIdentifier(node) {
+	let root = node;
+	while (root.type === "MemberExpression") root = root.object;
+	return root.type === "Identifier" ? root : null;
+}
+function variableRole(variable, environment, context) {
+	if (variable == null) return null;
+	if (environment.propsVariables?.has(variable)) return "props";
+	if (environment.accessorVariables?.has(variable)) return "accessor";
+	const fact = getReactiveBindingFactForVariable(variable, context);
+	return fact?.role === "accessor" ? "accessor" : fact?.role === "store" ? "store" : null;
+}
+function childNodes(node) {
+	const result = [];
+	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") result.push(item);
+		} else if (value != null && typeof value === "object" && typeof value.type === "string") result.push(value);
+	}
+	return result;
+}
+/** Finds the first provable reactive read executed directly in a structure-building scope. */
+function findReactiveRead(root, environment, context) {
+	const stack = [root];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (isFunctionNode(node) || node.type === "JSXElement" || node.type === "JSXFragment") continue;
+		if (node.type === "CallExpression") {
+			if (bindsToSolid(node.callee, context, UNTRACK_NAMES$1)) continue;
+			const callee = node.callee;
+			if (callee.type === "Identifier") {
+				if (variableRole(variableFor(callee, context), environment, context) === "accessor") return {
+					kind: "accessor",
+					node
+				};
+			}
+			if (environment.typescript != null && isSolidAccessorExpression(callee, environment.typescript)) return {
+				kind: "accessor",
+				node
+			};
+		}
+		if (node.type === "VariableDeclarator" && (node.id.type === "ObjectPattern" || node.id.type === "ArrayPattern") && node.init?.type === "Identifier") {
+			const role = variableRole(variableFor(node.init, context), environment, context);
+			if (role === "props" || role === "store") return {
+				kind: role,
+				node
+			};
+		}
+		if (node.type === "AssignmentExpression" && (node.left.type === "ObjectPattern" || node.left.type === "ArrayPattern") && node.right.type === "Identifier") {
+			const role = variableRole(variableFor(node.right, context), environment, context);
+			if (role === "props" || role === "store") return {
+				kind: role,
+				node
+			};
+		}
+		if (node.type === "MemberExpression") {
+			const rootId = rootIdentifier(node);
+			const role = rootId ? variableRole(variableFor(rootId, context), environment, context) : null;
+			if (role === "props" || role === "store") return {
+				kind: role,
+				node
+			};
+		}
+		if (node.type === "SpreadElement" && node.argument.type === "Identifier") {
+			const role = variableRole(variableFor(node.argument, context), environment, context);
+			if (role === "props" || role === "store") return {
+				kind: role,
+				node
+			};
+		}
+		stack.push(...childNodes(node));
+	}
+	return null;
+}
+//#endregion
 //#region src/rules/no-stale-props-alias.ts
 const UNTRACK_NAMES = new Set(["untrack"]);
 const PROPS_HELPER_NAMES = new Set(["merge", "omit"]);
@@ -1324,35 +1601,60 @@ 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." },
+		docs: { description: "Disallow provable untracked reactive reads in component and Solid control-flow structure-building scopes." },
 		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." }
+		messages: {
+			stalePropsAlias: "`{{name}}` aliases a prop read outside tracking. Read from `props` in JSX or a tracked scope instead.",
+			stalePropsRead: "This prop is read directly in a Solid control-flow function child, where it will not update. Read it inside returned JSX or an explicit tracked scope instead.",
+			staleReactiveRead: "Reactive state is read directly in a component or Solid control-flow function child, where it will not update. Read it inside JSX, a reactive computation, or explicit `untrack()` instead."
+		}
 	},
 	defaultOptions: [{}],
 	create(context) {
 		const sourceCode = context.sourceCode;
+		const typescript = getReactiveReadTypeServices(context);
 		const checkFunction = (node) => {
-			if (node.body.type !== "BlockStatement" || !isComponent$1(node, context)) return;
+			if (!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 (node.params.length > 1 || props != null && props.type !== "Identifier") return;
+			const propsVariables = /* @__PURE__ */ new Set();
+			if (props?.type === "Identifier") {
+				const propsVariable = ASTUtils.findVariable(sourceCode.getScope(props), props);
+				if (propsVariable == null) return;
+				propsVariables.add(propsVariable);
+			}
+			const environment = {
+				propsVariables,
+				typescript
+			};
+			for (const statement of node.body.type === "BlockStatement" ? 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;
+						if (declaration.init == null) continue;
+						if (aliasId.type !== "Identifier") {
+							const read = findReactiveRead(declaration, environment, context);
+							if (read) context.report({
+								node: read.node,
+								messageId: "staleReactiveRead"
+							});
+							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);
 							}
+							const read = findReactiveRead(declaration.init, environment, context);
+							if (read) context.report({
+								node: read.node,
+								messageId: "staleReactiveRead"
+							});
 							continue;
 						}
 						const declared = getDeclaredIdentifierVariable(declaration, sourceCode);
@@ -1367,15 +1669,45 @@ var no_stale_props_alias_default = createRule({
 					continue;
 				}
 				const expression = getAssignmentExpression(statement);
-				if (expression == null || expression.left.type !== "Identifier") continue;
+				if (expression == null || expression.left.type !== "Identifier") {
+					const read = findReactiveRead(statement, environment, context);
+					if (read) context.report({
+						node: read.node,
+						messageId: "staleReactiveRead"
+					});
+					continue;
+				}
 				const assigned = expression.left;
-				if (!expressionContainsPropsRead(expression.right, propsVariables, sourceCode, context)) continue;
+				if (!expressionContainsPropsRead(expression.right, propsVariables, sourceCode, context)) {
+					const read = findReactiveRead(expression.right, environment, context);
+					if (read) context.report({
+						node: read.node,
+						messageId: "staleReactiveRead"
+					});
+					continue;
+				}
 				context.report({
 					node: expression,
 					messageId: "stalePropsAlias",
 					data: { name: assigned.name }
 				});
 			}
+			for (const child of getControlFlowFunctionChildren(node, context)) {
+				const accessorVariables = /* @__PURE__ */ new Set();
+				for (const parameter of child.accessorParameters) {
+					const variable = ASTUtils.findVariable(sourceCode.getScope(parameter), parameter);
+					if (variable) accessorVariables.add(variable);
+				}
+				const read = findReactiveRead(child.function.body, {
+					propsVariables,
+					accessorVariables,
+					typescript
+				}, context);
+				if (read) context.report({
+					node: read.node,
+					messageId: read.kind === "props" ? "stalePropsRead" : "staleReactiveRead"
+				});
+			}
 		};
 		return {
 			"FunctionDeclaration:exit": checkFunction,
@@ -1387,29 +1719,29 @@ var no_stale_props_alias_default = createRule({
 //#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: [],
+		schema: [{
+			type: "object",
+			properties: { typescriptEnabled: { type: "boolean" } },
+			additionalProperties: false
+		}],
 		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: [],
+	defaultOptions: [{}],
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const reactiveVars = /* @__PURE__ */ new Map();
+		const services = context.options[0]?.typescriptEnabled ? getTypeAwareServices(context) : null;
+		const isEffectFactory = (node) => resolveSolidCallee(node, context, EFFECT_NAMES) != null || services != null && isTypeAwareSolidCallee(node, services, EFFECT_NAMES);
 		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;
@@ -1438,6 +1770,13 @@ var no_untracked_read_in_effect_apply_default = createRule({
 			}
 			return current.type === "ObjectExpression" || current.type === "ArrayExpression";
 		};
+		const getStoreShape = (fact) => {
+			const init = fact.declaration.init;
+			if (init?.type !== "CallExpression") return null;
+			const first = init.arguments[0];
+			const seed = first != null && first.type !== "SpreadElement" && (first.type === "FunctionExpression" || first.type === "ArrowFunctionExpression") ? init.arguments[1] : first;
+			return seed?.type === "ObjectExpression" ? seed : null;
+		};
 		const getInlineFunction = (value) => {
 			if (value == null || value.type === "SpreadElement") return null;
 			if (isFunctionNode(value)) return value;
@@ -1479,21 +1818,18 @@ var no_untracked_read_in_effect_apply_default = createRule({
 		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 === "Identifier") return getReactiveBindingFact(node, context)?.role === "store";
 			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;
+				const fact = getReactiveBindingFact(resolved.root, context);
+				if (fact?.role !== "store") return false;
+				return pathLandsOnProxy(getStoreShape(fact), resolved.path) === true;
 			}
 			return false;
 		};
 		const checkStoreProxyInApply = (node) => {
-			if (resolveSolidCallee(node.callee, context, EFFECT_NAMES) == null || node.arguments.length < 2) return;
+			if (!isEffectFactory(node.callee) || node.arguments.length < 2) return;
 			const compute = getFunctionValue(node.arguments[0]);
 			const apply = getTracedApplyCallback(node.arguments[1]);
 			if (!compute || !apply) return;
@@ -1532,56 +1868,23 @@ var no_untracked_read_in_effect_apply_default = createRule({
 			}
 		};
 		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) {
+				if (isEffectFactory(node.callee) && 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);
+				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({
+					const astAccessor = callee.type === "Identifier" && getReactiveBindingFact(callee, context)?.role === "accessor";
+					const typedAccessor = services != null && isSolidAccessorExpression(callee, services);
+					if ((astAccessor || typedAccessor) && findContainingApplyCallback(node) != null) context.report({
 						node,
 						messageId: "signalRead",
-						data: { name: callee.name }
+						data: { name: sourceCode.getText(callee) }
 					});
 				}
 			}
@@ -1765,122 +2068,161 @@ 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."
+var self_closing_comp_default = 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"
 				}
 			},
-			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}>`);
-						}
-					});
-				} };
+			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/rule-catalog.ts
+/**
+* The authoritative internal catalog for public rule registration and recommendation policy.
+* Documentation remains hand-authored and is verified through public-interface invariant tests.
+*/
+const ruleCatalog = {
+	"components-return-once": {
+		rule: components_return_once_default,
+		recommended: "warn",
+		recommendedTypeChecked: ["warn", { typescriptEnabled: true }]
+	},
+	"jsx-no-duplicate-props": {
+		rule: jsx_no_duplicate_props_default,
+		recommended: "error"
+	},
+	"no-destructure": {
+		rule: no_destructure_default,
+		recommended: "warn",
+		recommendedTypeChecked: ["warn", { typescriptEnabled: true }]
+	},
+	"no-leaf-owner-operations": {
+		rule: no_leaf_owner_operations_default,
+		recommended: "error",
+		recommendedTypeChecked: ["error", { typescriptEnabled: true }]
+	},
+	"no-owned-scope-writes": {
+		rule: no_owned_scope_writes_default,
+		recommended: "error",
+		recommendedTypeChecked: ["error", { typescriptEnabled: true }]
+	},
+	"no-reactive-read-after-await": {
+		rule: no_reactive_read_after_await_default,
+		recommended: "warn",
+		recommendedTypeChecked: ["warn", { typescriptEnabled: true }]
+	},
+	"no-stale-props-alias": {
+		rule: no_stale_props_alias_default,
+		recommended: "warn",
+		recommendedTypeChecked: ["warn", { typescriptEnabled: true }]
+	},
+	"no-untracked-read-in-effect-apply": {
+		rule: no_untracked_read_in_effect_apply_default,
+		recommended: "warn",
+		recommendedTypeChecked: ["warn", { typescriptEnabled: true }]
+	},
+	"prefer-for": {
+		rule: prefer_for_default,
+		recommendedTypeChecked: ["warn", { typescriptEnabled: true }]
+	},
+	"prefer-show": {
+		rule: prefer_show_default,
+		recommended: "warn"
+	},
+	"self-closing-comp": {
+		rule: self_closing_comp_default,
+		recommended: "warn"
+	}
+};
+const rules = Object.fromEntries(Object.entries(ruleCatalog).map(([name, entry]) => [name, entry.rule]));
+function buildRuleMap(policy) {
+	return Object.fromEntries(Object.entries(ruleCatalog).flatMap(([name, entry]) => {
+		const typedEntry = entry;
+		const config = policy === "recommended" ? typedEntry.recommended : typedEntry.recommendedTypeChecked ?? typedEntry.recommended;
+		return config == null ? [] : [[`solid/${name}`, config]];
+	}));
+}
+const recommendedRules = buildRuleMap("recommended");
+const recommendedTypeCheckedRules = buildRuleMap("recommendedTypeChecked");
+//#endregion
+//#region src/plugin.ts
+const plugin = {
+	meta: { name: "eslint-plugin-solid" },
+	rules
 };
 //#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"
-	}
+	rules: recommendedRules
 };
 //#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
-	}
+	rules: recommendedTypeCheckedRules
 };
 //#endregion
 //#region src/index.ts