@exadev/eslint-config 2.3.0 → 2.5.0

package/dist/index.js

@@ -2,8 +2,9 @@ import tseslint from "typescript-eslint";
 import { posix } from "node:path";
 import { AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
 import * as ts from "typescript";
+import { isTypeReference } from "ts-api-utils";
 //#region package.json
-var version = "2.3.0";
+var version = "2.5.0";
 //#endregion
 //#region src/rules/barrel-helpers.ts
 const INDEX_BASENAME$1 = /^index\.[cm]?[tj]sx?$/;
@@ -239,6 +240,109 @@ const barrelPolicy = {
 	}
 };
 //#endregion
+//#region src/rules/no-array-isarray-mutation.ts
+const MUTATING_INSERT_METHODS$1 = /* @__PURE__ */ new Set([
+	"push",
+	"unshift",
+	"splice",
+	"fill",
+	"copyWithin"
+]);
+const createRule$6 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+function isArrayIsArrayCall(node) {
+	return node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.object.name === "Array" && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "isArray";
+}
+function definitelyExits$2(statement) {
+	if (statement.type === AST_NODE_TYPES.ReturnStatement || statement.type === AST_NODE_TYPES.ThrowStatement || statement.type === AST_NODE_TYPES.ContinueStatement || statement.type === AST_NODE_TYPES.BreakStatement) return true;
+	if (statement.type === AST_NODE_TYPES.BlockStatement) {
+		const last = statement.body.at(-1);
+		return last !== void 0 && definitelyExits$2(last);
+	}
+	return false;
+}
+const noArrayIsArrayMutation = createRule$6({
+	name: "no-array-isarray-mutation",
+	meta: {
+		type: "problem",
+		schema: [],
+		docs: { description: "Disallow mutating-insertion calls on a parameter whose real type includes a readonly array, narrowed via Array.isArray, which silently discards the declared readonly guarantee." },
+		messages: { unsound: "'{{ method }}' mutates a parameter narrowed by Array.isArray -- Array.isArray's own type declaration cannot preserve a readonly modifier through the guard, so a caller's genuinely readonly array can be mutated here even though the parameter's real type includes a readonly array. Copy the array before inserting (e.g. a spread into a new array), or narrow with a check that preserves readonly instead of Array.isArray." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		function parameterHasReadonlyArrayConstituent(parameterNode) {
+			const tsNode = services.esTreeNodeToTSNodeMap.get(parameterNode);
+			const parameterType = checker.getTypeAtLocation(tsNode);
+			return (parameterType.isUnion() ? parameterType.types : [parameterType]).some((constituent) => checker.isArrayType(constituent) && constituent.getSymbol()?.name === "ReadonlyArray");
+		}
+		return { CallExpression(node) {
+			const { callee } = node;
+			if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES.Identifier || callee.property.type !== AST_NODE_TYPES.Identifier || !MUTATING_INSERT_METHODS$1.has(callee.property.name)) return;
+			const variable = context.sourceCode.getScope(node).references.find((reference) => reference.identifier === callee.object)?.resolved;
+			if (!variable) return;
+			const parameterDefinition = variable.defs.find((definition) => definition.type === TSESLint.Scope.DefinitionType.Parameter);
+			if (!parameterDefinition) return;
+			const parameterNode = parameterDefinition.name;
+			if (parameterNode.type !== AST_NODE_TYPES.Identifier) return;
+			if (!parameterHasReadonlyArrayConstituent(parameterNode)) return;
+			if (!isGuardedByArrayIsArray(node, variable, context)) return;
+			context.report({
+				node,
+				messageId: "unsound",
+				data: { method: callee.property.name }
+			});
+		} };
+		function resolvesToVariable(identifier, target, atNode, ruleContext) {
+			return ruleContext.sourceCode.getScope(atNode).references.find((reference) => reference.identifier === identifier)?.resolved === target;
+		}
+		function isNegatedArrayIsArrayCall(testNode, target, ruleContext) {
+			if (testNode.type !== AST_NODE_TYPES.UnaryExpression || testNode.operator !== "!") return false;
+			return matchesArrayIsArrayOn(testNode.argument, target, ruleContext);
+		}
+		function matchesArrayIsArrayOn(testNode, target, ruleContext) {
+			if (!isArrayIsArrayCall(testNode)) return false;
+			const [argument] = testNode.arguments;
+			return argument?.type === AST_NODE_TYPES.Identifier && resolvesToVariable(argument, target, testNode, ruleContext);
+		}
+		function isGuardedByArrayIsArray(startNode, parameterVariable, ruleContext) {
+			let current = startNode;
+			while (current.parent) {
+				const { parent } = current;
+				if (parent.type === AST_NODE_TYPES.IfStatement) {
+					if (parent.consequent === current && matchesArrayIsArrayOn(parent.test, parameterVariable, ruleContext)) return true;
+					if (parent.alternate === current && isNegatedArrayIsArrayCall(parent.test, parameterVariable, ruleContext)) return true;
+				}
+				if (parent.type === AST_NODE_TYPES.LogicalExpression && parent.operator === "&&" && parent.right === current && matchesArrayIsArrayOn(parent.left, parameterVariable, ruleContext)) return true;
+				if (parent.type === AST_NODE_TYPES.ConditionalExpression && parent.consequent === current && matchesArrayIsArrayOn(parent.test, parameterVariable, ruleContext)) return true;
+				current = parent;
+			}
+			return isGuardedByPrecedingEarlyReturn(startNode, parameterVariable, ruleContext);
+		}
+		function isGuardedByPrecedingEarlyReturn(startNode, parameterVariable, ruleContext) {
+			let current = startNode;
+			while (current.parent) {
+				const { parent } = current;
+				if (parent.type === AST_NODE_TYPES.BlockStatement || parent.type === AST_NODE_TYPES.Program) {
+					const statements = parent.body;
+					let ownIndex = -1;
+					for (let i = 0; i < statements.length; i++) if (statements[i] === current) {
+						ownIndex = i;
+						break;
+					}
+					if (ownIndex > 0) for (let i = ownIndex - 1; i >= 0; i--) {
+						const sibling = statements[i];
+						if (sibling?.type === AST_NODE_TYPES.IfStatement && !sibling.alternate && isNegatedArrayIsArrayCall(sibling.test, parameterVariable, ruleContext) && definitelyExits$2(sibling.consequent)) return true;
+					}
+				}
+				current = parent;
+			}
+			return false;
+		}
+	}
+});
+//#endregion
 //#region src/rules/no-enum-number-widening.ts
 const noEnumNumberWidening = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`)({
 	name: "no-enum-number-widening",
@@ -284,6 +388,67 @@ const noEnumNumberWidening = ESLintUtils.RuleCreator((name) => `https://github.c
 	}
 });
 //#endregion
+//#region src/rules/no-enum-reverse-lookup-widening.ts
+const noEnumReverseLookupWidening = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`)({
+	name: "no-enum-reverse-lookup-widening",
+	meta: {
+		type: "problem",
+		hasSuggestions: true,
+		docs: { description: "Disallow indexing a numeric enum's reverse mapping with a bare (non-literal) number -- TypeScript types the result as plain 'string' for any number, including one outside the enum's actual member range, where it genuinely returns 'undefined' at runtime." },
+		schema: [],
+		messages: {
+			widening: "Indexing the numeric enum '{{ enumName }}' with a plain 'number' relies on its reverse mapping, which TypeScript types as 'string' for any number -- including one outside the enum's actual members, where this genuinely returns 'undefined' at runtime. Narrow the index to a known member first (a runtime membership check against the enum's own values), or accept that the result may be 'undefined' and handle it.",
+			suggestWidenAnnotation: "Widen this variable's annotation to 'string | undefined' so later uses of it as a bare 'string' surface as real compile errors you can resolve."
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return { MemberExpression(node) {
+			if (!node.computed) return;
+			const objectTsNode = services.esTreeNodeToTSNodeMap.get(node.object);
+			if (!ts.isExpression(objectTsNode)) return;
+			const objectType = checker.getTypeAtLocation(objectTsNode);
+			const objectSymbol = objectType.getSymbol();
+			if (!objectSymbol || !(objectSymbol.flags & ts.SymbolFlags.Enum)) return;
+			if (!checker.getIndexInfoOfType(objectType, ts.IndexKind.Number)) return;
+			const propertyTsNode = services.esTreeNodeToTSNodeMap.get(node.property);
+			if (!ts.isExpression(propertyTsNode)) return;
+			const rawPropertyType = checker.getTypeAtLocation(propertyTsNode);
+			const propertyType = checker.getBaseConstraintOfType(rawPropertyType) ?? rawPropertyType;
+			if (propertyType.flags & ts.TypeFlags.EnumLike) {
+				if (checker.isTypeAssignableTo(propertyType, checker.getDeclaredTypeOfSymbol(objectSymbol))) return;
+			} else {
+				if (propertyType.isLiteral()) return;
+				if (!(propertyType.flags & ts.TypeFlags.NumberLike)) return;
+			}
+			const enumName = checker.typeToString(checker.getDeclaredTypeOfSymbol(objectSymbol));
+			const parent = node.parent;
+			if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === AST_NODE_TYPES.Identifier && parent.id.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES.TSStringKeyword) {
+				const stringKeyword = parent.id.typeAnnotation.typeAnnotation;
+				context.report({
+					node,
+					messageId: "widening",
+					data: { enumName },
+					suggest: [{
+						messageId: "suggestWidenAnnotation",
+						fix(fixer) {
+							return fixer.replaceText(stringKeyword, "string | undefined");
+						}
+					}]
+				});
+				return;
+			}
+			context.report({
+				node,
+				messageId: "widening",
+				data: { enumName }
+			});
+		} };
+	}
+});
+//#endregion
 //#region src/rules/no-index-files.ts
 const noIndexFiles = {
 	meta: {
@@ -302,6 +467,107 @@ const noIndexFiles = {
 	}
 };
 //#endregion
+//#region src/rules/no-map-instanceof-mutation.ts
+const createRule$5 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const MUTATING_MAP_METHODS = /* @__PURE__ */ new Set([
+	"set",
+	"delete",
+	"clear"
+]);
+function isInstanceofMapExpression(node) {
+	return node.type === AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof" && node.right.type === AST_NODE_TYPES.Identifier && node.right.name === "Map";
+}
+function definitelyExits$1(statement) {
+	if (statement.type === AST_NODE_TYPES.ReturnStatement || statement.type === AST_NODE_TYPES.ThrowStatement || statement.type === AST_NODE_TYPES.ContinueStatement || statement.type === AST_NODE_TYPES.BreakStatement) return true;
+	if (statement.type === AST_NODE_TYPES.BlockStatement) {
+		const last = statement.body.at(-1);
+		return last !== void 0 && definitelyExits$1(last);
+	}
+	return false;
+}
+const noMapInstanceofMutation = createRule$5({
+	name: "no-map-instanceof-mutation",
+	meta: {
+		type: "problem",
+		schema: [],
+		docs: { description: "Disallow mutating calls on a parameter whose real type includes a ReadonlyMap, narrowed via `instanceof Map`, which silently discards the declared readonly guarantee." },
+		messages: { unsound: "'{{ method }}' mutates a parameter narrowed by 'instanceof Map' -- Map is declared as extending ReadonlyMap, so 'instanceof Map' narrows straight past the readonly guarantee to the full mutable interface, and a caller's genuinely read-only ReadonlyMap can be mutated here even though the parameter's real type includes ReadonlyMap. Copy the map before mutating (e.g. `new Map(input)`), or narrow with a check that preserves readonly instead of 'instanceof Map'." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		function parameterHasReadonlyMapConstituent(parameterNode) {
+			const tsNode = services.esTreeNodeToTSNodeMap.get(parameterNode);
+			const parameterType = checker.getTypeAtLocation(tsNode);
+			return (parameterType.isUnion() ? parameterType.types : [parameterType]).some((constituent) => constituent.getSymbol()?.name === "ReadonlyMap");
+		}
+		return { CallExpression(node) {
+			const { callee } = node;
+			if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES.Identifier || callee.property.type !== AST_NODE_TYPES.Identifier || !MUTATING_MAP_METHODS.has(callee.property.name)) return;
+			const variable = context.sourceCode.getScope(node).references.find((reference) => reference.identifier === callee.object)?.resolved;
+			if (!variable) return;
+			const parameterDefinition = variable.defs.find((definition) => definition.type === TSESLint.Scope.DefinitionType.Parameter);
+			if (!parameterDefinition) return;
+			const parameterNode = parameterDefinition.name;
+			if (parameterNode.type !== AST_NODE_TYPES.Identifier) return;
+			if (!parameterHasReadonlyMapConstituent(parameterNode)) return;
+			if (!isGuardedByInstanceofMap(node, variable, context)) return;
+			context.report({
+				node,
+				messageId: "unsound",
+				data: { method: callee.property.name }
+			});
+		} };
+		function resolvesToVariable(identifier, target, atNode, ruleContext) {
+			return ruleContext.sourceCode.getScope(atNode).references.find((reference) => reference.identifier === identifier)?.resolved === target;
+		}
+		function isNegatedInstanceofMapExpression(testNode, target, ruleContext) {
+			if (testNode.type !== AST_NODE_TYPES.UnaryExpression || testNode.operator !== "!") return false;
+			return matchesInstanceofMapOn(testNode.argument, target, ruleContext);
+		}
+		function matchesInstanceofMapOn(testNode, target, ruleContext) {
+			if (!isInstanceofMapExpression(testNode)) return false;
+			const { left } = testNode;
+			return left.type === AST_NODE_TYPES.Identifier && resolvesToVariable(left, target, testNode, ruleContext);
+		}
+		function isGuardedByInstanceofMap(startNode, parameterVariable, ruleContext) {
+			let current = startNode;
+			while (current.parent) {
+				const { parent } = current;
+				if (parent.type === AST_NODE_TYPES.IfStatement) {
+					if (parent.consequent === current && matchesInstanceofMapOn(parent.test, parameterVariable, ruleContext)) return true;
+					if (parent.alternate === current && isNegatedInstanceofMapExpression(parent.test, parameterVariable, ruleContext)) return true;
+				}
+				if (parent.type === AST_NODE_TYPES.LogicalExpression && parent.operator === "&&" && parent.right === current && matchesInstanceofMapOn(parent.left, parameterVariable, ruleContext)) return true;
+				if (parent.type === AST_NODE_TYPES.ConditionalExpression && parent.consequent === current && matchesInstanceofMapOn(parent.test, parameterVariable, ruleContext)) return true;
+				current = parent;
+			}
+			return isGuardedByPrecedingEarlyReturn(startNode, parameterVariable, ruleContext);
+		}
+		function isGuardedByPrecedingEarlyReturn(startNode, parameterVariable, ruleContext) {
+			let current = startNode;
+			while (current.parent) {
+				const { parent } = current;
+				if (parent.type === AST_NODE_TYPES.BlockStatement || parent.type === AST_NODE_TYPES.Program) {
+					const statements = parent.body;
+					let ownIndex = -1;
+					for (let i = 0; i < statements.length; i++) if (statements[i] === current) {
+						ownIndex = i;
+						break;
+					}
+					if (ownIndex > 0) for (let i = ownIndex - 1; i >= 0; i--) {
+						const sibling = statements[i];
+						if (sibling?.type === AST_NODE_TYPES.IfStatement && !sibling.alternate && isNegatedInstanceofMapExpression(sibling.test, parameterVariable, ruleContext) && definitelyExits$1(sibling.consequent)) return true;
+					}
+				}
+				current = parent;
+			}
+			return false;
+		}
+	}
+});
+//#endregion
 //#region src/rules/no-mutable-union-array-param.ts
 const MUTATING_INSERT_METHODS = /* @__PURE__ */ new Set([
 	"push",
@@ -310,7 +576,7 @@ const MUTATING_INSERT_METHODS = /* @__PURE__ */ new Set([
 	"fill",
 	"copyWithin"
 ]);
-const createRule$1 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const createRule$4 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
 function isUnionArrayType(typeAnnotation) {
 	if (typeAnnotation.type === AST_NODE_TYPES.TSArrayType && typeAnnotation.elementType.type === AST_NODE_TYPES.TSUnionType) return typeAnnotation.elementType;
 	if (typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "Array" && typeAnnotation.typeArguments?.params.length === 1) {
@@ -318,7 +584,7 @@ function isUnionArrayType(typeAnnotation) {
 		if (firstParam?.type === AST_NODE_TYPES.TSUnionType) return firstParam;
 	}
 }
-const noMutableUnionArrayParam = createRule$1({
+const noMutableUnionArrayParam = createRule$4({
 	name: "no-mutable-union-array-param",
 	meta: {
 		type: "problem",
@@ -444,14 +710,14 @@ const noNonBarrelReexport = {
 };
 //#endregion
 //#region src/rules/no-object-assign.ts
-const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const createRule$3 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
 function resolveFrom$1(scope, name) {
 	for (let current = scope; current; current = current.upper) {
 		const found = current.set.get(name);
 		if (found) return found;
 	}
 }
-const noObjectAssign = createRule({
+const noObjectAssign = createRule$3({
 	name: "no-object-assign",
 	meta: {
 		type: "problem",
@@ -526,6 +792,293 @@ function resolveFrom(scope, name) {
 		if (found) return found;
 	}
 }
+const noPointlessReassignment = {
+	meta: {
+		type: "problem",
+		fixable: "code",
+		schema: [],
+		messages: { pointlessReassignment: "Pointless reassignment: '{{ name }}' is just an alias for '{{ value }}'. Use the original directly." }
+	},
+	create(context) {
+		return { VariableDeclarator(node) {
+			if (node.id.type !== "Identifier" || node.init?.type !== "Identifier" || node.id.name.startsWith("_")) return;
+			if (node.parent.type !== "VariableDeclaration" || node.parent.kind !== "const") return;
+			const scope = context.sourceCode.getScope(node);
+			const sourceVariable = scope.references.find((reference) => reference.identifier === node.init)?.resolved;
+			if (!sourceVariable || sourceVariable.references.some((reference) => reference.isWrite() && reference.init !== true)) return;
+			const aliasName = node.id.name;
+			const originalName = node.init.name;
+			const aliasIsAnnotated = hasTypeAnnotation(node.id);
+			context.report({
+				node,
+				messageId: "pointlessReassignment",
+				data: {
+					name: aliasName,
+					value: originalName
+				},
+				fix(fixer) {
+					const variable = scope.set.get(aliasName);
+					if (!variable) return null;
+					if (aliasIsAnnotated) return null;
+					if (variable.references.filter((reference) => reference.isWrite() && reference.identifier !== node.id).length > 0) return null;
+					const readRefs = variable.references.filter((reference) => reference.isRead() && isIdentifierReference(reference));
+					if (readRefs.some((reference) => {
+						const afterToken = context.sourceCode.getTokenAfter(reference.identifier);
+						if (afterToken?.value === ":") return false;
+						if (afterToken?.value !== "}" && afterToken?.value !== ",") return false;
+						let token = context.sourceCode.getTokenBefore(reference.identifier);
+						while (token) {
+							if (token.value === "{") return true;
+							if (token.value === "[" || token.value === "(") return false;
+							if (token.value === ":") return false;
+							token = context.sourceCode.getTokenBefore(token);
+						}
+						return false;
+					})) return null;
+					if (readRefs.some((reference) => resolveFrom(reference.from, originalName) !== sourceVariable)) return null;
+					const fixes = readRefs.map((reference) => fixer.replaceText(reference.identifier, originalName));
+					const declaration = node.parent;
+					if (declaration.type !== "VariableDeclaration" || declaration.declarations.length !== 1) return null;
+					fixes.push(fixer.remove(declaration.parent.type === "ExportNamedDeclaration" ? declaration.parent : declaration));
+					return fixes;
+				}
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/no-set-instanceof-mutation.ts
+const MUTATING_SET_METHODS = /* @__PURE__ */ new Set([
+	"add",
+	"delete",
+	"clear"
+]);
+const createRule$2 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+function isSetInstanceofExpression(node) {
+	return node.type === AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof" && node.right.type === AST_NODE_TYPES.Identifier && node.right.name === "Set";
+}
+function definitelyExits(statement) {
+	if (statement.type === AST_NODE_TYPES.ReturnStatement || statement.type === AST_NODE_TYPES.ThrowStatement || statement.type === AST_NODE_TYPES.ContinueStatement || statement.type === AST_NODE_TYPES.BreakStatement) return true;
+	if (statement.type === AST_NODE_TYPES.BlockStatement) {
+		const last = statement.body.at(-1);
+		return last !== void 0 && definitelyExits(last);
+	}
+	return false;
+}
+const noSetInstanceofMutation = createRule$2({
+	name: "no-set-instanceof-mutation",
+	meta: {
+		type: "problem",
+		schema: [],
+		docs: { description: "Disallow mutating calls on a parameter whose real type includes a ReadonlySet, narrowed via instanceof Set, which silently discards the declared read-only guarantee." },
+		messages: { unsound: "'{{ method }}' mutates a parameter narrowed by instanceof Set -- instanceof Set's own narrowing widens straight to the mutable Set interface, so a caller's genuinely read-only set can be mutated here even though the parameter's real type includes a ReadonlySet. Copy the set before mutating (e.g. new Set(input)), or narrow with a check that preserves read-only instead of instanceof Set." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		function parameterHasReadonlySetConstituent(parameterNode) {
+			const tsNode = services.esTreeNodeToTSNodeMap.get(parameterNode);
+			const parameterType = checker.getTypeAtLocation(tsNode);
+			return (parameterType.isUnion() ? parameterType.types : [parameterType]).some((constituent) => constituent.getSymbol()?.name === "ReadonlySet");
+		}
+		return { CallExpression(node) {
+			const { callee } = node;
+			if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES.Identifier || callee.property.type !== AST_NODE_TYPES.Identifier || !MUTATING_SET_METHODS.has(callee.property.name)) return;
+			const variable = context.sourceCode.getScope(node).references.find((reference) => reference.identifier === callee.object)?.resolved;
+			if (!variable) return;
+			const parameterDefinition = variable.defs.find((definition) => definition.type === TSESLint.Scope.DefinitionType.Parameter);
+			if (!parameterDefinition) return;
+			const parameterNode = parameterDefinition.name;
+			if (parameterNode.type !== AST_NODE_TYPES.Identifier) return;
+			if (!parameterHasReadonlySetConstituent(parameterNode)) return;
+			if (!isGuardedBySetInstanceof(node, variable, context)) return;
+			context.report({
+				node,
+				messageId: "unsound",
+				data: { method: callee.property.name }
+			});
+		} };
+		function resolvesToVariable(identifier, target, atNode, ruleContext) {
+			return ruleContext.sourceCode.getScope(atNode).references.find((reference) => reference.identifier === identifier)?.resolved === target;
+		}
+		function isNegatedSetInstanceofExpression(testNode, target, ruleContext) {
+			if (testNode.type !== AST_NODE_TYPES.UnaryExpression || testNode.operator !== "!") return false;
+			return matchesSetInstanceofOn(testNode.argument, target, ruleContext);
+		}
+		function matchesSetInstanceofOn(testNode, target, ruleContext) {
+			if (!isSetInstanceofExpression(testNode)) return false;
+			const { left } = testNode;
+			return left.type === AST_NODE_TYPES.Identifier && resolvesToVariable(left, target, testNode, ruleContext);
+		}
+		function isGuardedBySetInstanceof(startNode, parameterVariable, ruleContext) {
+			let current = startNode;
+			while (current.parent) {
+				const { parent } = current;
+				if (parent.type === AST_NODE_TYPES.IfStatement) {
+					if (parent.consequent === current && matchesSetInstanceofOn(parent.test, parameterVariable, ruleContext)) return true;
+					if (parent.alternate === current && isNegatedSetInstanceofExpression(parent.test, parameterVariable, ruleContext)) return true;
+				}
+				if (parent.type === AST_NODE_TYPES.LogicalExpression && parent.operator === "&&" && parent.right === current && matchesSetInstanceofOn(parent.left, parameterVariable, ruleContext)) return true;
+				if (parent.type === AST_NODE_TYPES.ConditionalExpression && parent.consequent === current && matchesSetInstanceofOn(parent.test, parameterVariable, ruleContext)) return true;
+				current = parent;
+			}
+			return isGuardedByPrecedingEarlyReturn(startNode, parameterVariable, ruleContext);
+		}
+		function isGuardedByPrecedingEarlyReturn(startNode, parameterVariable, ruleContext) {
+			let current = startNode;
+			while (current.parent) {
+				const { parent } = current;
+				if (parent.type === AST_NODE_TYPES.BlockStatement || parent.type === AST_NODE_TYPES.Program) {
+					const statements = parent.body;
+					let ownIndex = -1;
+					for (let i = 0; i < statements.length; i++) if (statements[i] === current) {
+						ownIndex = i;
+						break;
+					}
+					if (ownIndex > 0) for (let i = ownIndex - 1; i >= 0; i--) {
+						const sibling = statements[i];
+						if (sibling?.type === AST_NODE_TYPES.IfStatement && !sibling.alternate && isNegatedSetInstanceofExpression(sibling.test, parameterVariable, ruleContext) && definitelyExits(sibling.consequent)) return true;
+					}
+				}
+				current = parent;
+			}
+			return false;
+		}
+	}
+});
+//#endregion
+//#region src/rules/no-side-effects-in-index.ts
+const noSideEffectsInIndex = {
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: { notAPureReexport: "A barrel (index) file may contain only re-export statements ('export * from ...' / 'export { x } from ...' / 'export type { x } from ...') -- nothing else, so it can never have a side effect at import time by construction. Found: {{ description }}." }
+	},
+	create(context) {
+		if (!isIndexFile(context.filename)) return {};
+		return { Program(node) {
+			for (const statement of node.body) if (!isPureReexport(statement)) context.report({
+				node: statement,
+				messageId: "notAPureReexport",
+				data: { description: statement.type }
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/prefer-numeric-sort-compare.ts
+const createRule$1 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const SORT_METHOD_NAMES = /* @__PURE__ */ new Set(["sort", "toSorted"]);
+function isDefinitelyNumberType(type) {
+	if (type.isUnion()) return type.types.every((constituent) => isDefinitelyNumberType(constituent));
+	return (type.flags & ts.TypeFlags.NumberLike) !== 0;
+}
+const preferNumericSortCompare = createRule$1({
+	name: "prefer-numeric-sort-compare",
+	meta: {
+		type: "suggestion",
+		hasSuggestions: true,
+		docs: { description: "Suggest an ascending numeric compare function for a bare '.sort()'/'.toSorted()' call on an array whose element type is definitively 'number' -- the default comparator sorts lexicographically, so a bare numeric sort is essentially always a bug." },
+		schema: [],
+		messages: {
+			preferNumericCompare: "'.{{ method }}()' on a number array with no compare function sorts lexicographically (e.g. [1, 2, 10].sort() becomes [1, 10, 2]), not in ascending numeric order. Provide a compare function.",
+			addAscendingCompare: "Add an ascending numeric compare function: '(a, b) => a - b'."
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return { CallExpression(node) {
+			if (node.arguments.length > 0) return;
+			const { callee } = node;
+			if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed) return;
+			if (callee.property.type !== AST_NODE_TYPES.Identifier || !SORT_METHOD_NAMES.has(callee.property.name)) return;
+			const receiverTsNode = services.esTreeNodeToTSNodeMap.get(callee.object);
+			if (!ts.isExpression(receiverTsNode)) return;
+			const receiverType = checker.getTypeAtLocation(receiverTsNode);
+			if (!checker.isArrayType(receiverType)) return;
+			if (!isTypeReference(receiverType)) return;
+			const [elementType] = checker.getTypeArguments(receiverType);
+			if (!elementType || !isDefinitelyNumberType(elementType)) return;
+			context.report({
+				node,
+				messageId: "preferNumericCompare",
+				data: { method: callee.property.name },
+				suggest: [{
+					messageId: "addAscendingCompare",
+					fix(fixer) {
+						const closingParen = context.sourceCode.getLastToken(node);
+						if (!closingParen) return null;
+						return fixer.insertTextBefore(closingParen, "(a, b) => a - b");
+					}
+				}]
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/prefer-readonly-array-param.ts
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+function getFixableArrayOrTupleType(typeNode) {
+	if (typeNode.type === AST_NODE_TYPES.TSTypeOperator && typeNode.operator === "readonly") return void 0;
+	if (typeNode.type === AST_NODE_TYPES.TSArrayType) return typeNode;
+	if (typeNode.type === AST_NODE_TYPES.TSTupleType) return typeNode;
+	if (typeNode.type === AST_NODE_TYPES.TSTypeReference && typeNode.typeName.type === AST_NODE_TYPES.Identifier && typeNode.typeName.name === "Array") return typeNode;
+}
+function getFixableTypesForAnnotation(typeNode) {
+	if (typeNode.type === AST_NODE_TYPES.TSUnionType) return typeNode.types.flatMap(getFixableTypesForAnnotation);
+	const fixable = getFixableArrayOrTupleType(typeNode);
+	return fixable ? [fixable] : [];
+}
+function getAnnotatedParamNode(param) {
+	if (param.type === AST_NODE_TYPES.TSParameterProperty) return getAnnotatedParamNode(param.parameter);
+	if (param.type === AST_NODE_TYPES.AssignmentPattern) return param.left.type === AST_NODE_TYPES.Identifier ? param.left : void 0;
+	if (param.type === AST_NODE_TYPES.RestElement || param.type === AST_NODE_TYPES.Identifier) return param;
+}
+const FUNCTION_LIKE_SELECTOR = [
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"TSCallSignatureDeclaration",
+	"TSConstructSignatureDeclaration",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression",
+	"TSFunctionType",
+	"TSMethodSignature"
+].join(", ");
+const preferReadonlyArrayParam = createRule({
+	name: "prefer-readonly-array-param",
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Require array and tuple parameters to be typed readonly, regardless of whether the function body mutates them -- a narrower, safely-autofixable sibling of @typescript-eslint/prefer-readonly-parameter-types scoped to array/tuple shapes only." },
+		schema: [],
+		messages: { preferReadonly: "Array and tuple parameters should be typed readonly ({{ suggestion }}) so a caller can pass a readonly or shared array with confidence, and so any mutation inside the function becomes a deliberate, visible compile error instead of a silent side effect on the caller's data." }
+	},
+	defaultOptions: [],
+	create(context) {
+		function checkParam(param) {
+			const annotatedNode = getAnnotatedParamNode(param);
+			if (!annotatedNode?.typeAnnotation) return;
+			const fixableTypes = getFixableTypesForAnnotation(annotatedNode.typeAnnotation.typeAnnotation);
+			if (fixableTypes.length === 0) return;
+			const suggestion = fixableTypes.map((fixableType) => fixableType.type === AST_NODE_TYPES.TSTypeReference ? "ReadonlyArray<T>" : `readonly ${fixableType.type === AST_NODE_TYPES.TSTupleType ? "[T, U]" : "T[]"}`).join(" / ");
+			context.report({
+				node: param,
+				messageId: "preferReadonly",
+				data: { suggestion },
+				fix(fixer) {
+					return fixableTypes.map((fixableType) => fixableType.type === AST_NODE_TYPES.TSTypeReference ? fixer.replaceText(fixableType.typeName, "ReadonlyArray") : fixer.insertTextBefore(fixableType, "readonly "));
+				}
+			});
+		}
+		return { [FUNCTION_LIKE_SELECTOR](node) {
+			for (const param of node.params) checkParam(param);
+		} };
+	}
+});
 //#endregion
 //#region src/plugin.ts
 const plugin = {
@@ -537,83 +1090,20 @@ const plugin = {
 	rules: {
 		"barrel-direct-siblings-only": barrelDirectSiblingsOnly,
 		"barrel-policy": barrelPolicy,
+		"no-array-isarray-mutation": noArrayIsArrayMutation,
 		"no-enum-number-widening": noEnumNumberWidening,
+		"no-enum-reverse-lookup-widening": noEnumReverseLookupWidening,
 		"no-index-files": noIndexFiles,
+		"no-map-instanceof-mutation": noMapInstanceofMutation,
 		"no-mutable-union-array-param": noMutableUnionArrayParam,
 		"no-non-barrel-index": noNonBarrelIndex,
 		"no-non-barrel-reexport": noNonBarrelReexport,
 		"no-object-assign": noObjectAssign,
-		"no-pointless-reassignment": {
-			meta: {
-				type: "problem",
-				fixable: "code",
-				schema: [],
-				messages: { pointlessReassignment: "Pointless reassignment: '{{ name }}' is just an alias for '{{ value }}'. Use the original directly." }
-			},
-			create(context) {
-				return { VariableDeclarator(node) {
-					if (node.id.type !== "Identifier" || node.init?.type !== "Identifier" || node.id.name.startsWith("_")) return;
-					if (node.parent.type !== "VariableDeclaration" || node.parent.kind !== "const") return;
-					const scope = context.sourceCode.getScope(node);
-					const sourceVariable = scope.references.find((reference) => reference.identifier === node.init)?.resolved;
-					if (!sourceVariable || sourceVariable.references.some((reference) => reference.isWrite() && !reference.init)) return;
-					const aliasName = node.id.name;
-					const originalName = node.init.name;
-					const aliasIsAnnotated = hasTypeAnnotation(node.id);
-					context.report({
-						node,
-						messageId: "pointlessReassignment",
-						data: {
-							name: aliasName,
-							value: originalName
-						},
-						fix(fixer) {
-							const variable = scope.set.get(aliasName);
-							if (!variable) return null;
-							if (aliasIsAnnotated) return null;
-							if (variable.references.filter((reference) => reference.isWrite() && reference.identifier !== node.id).length > 0) return null;
-							const readRefs = variable.references.filter((reference) => reference.isRead() && isIdentifierReference(reference));
-							if (readRefs.some((reference) => {
-								const afterToken = context.sourceCode.getTokenAfter(reference.identifier);
-								if (afterToken?.value === ":") return false;
-								if (afterToken?.value !== "}" && afterToken?.value !== ",") return false;
-								let token = context.sourceCode.getTokenBefore(reference.identifier);
-								while (token) {
-									if (token.value === "{") return true;
-									if (token.value === "[" || token.value === "(") return false;
-									if (token.value === ":") return false;
-									token = context.sourceCode.getTokenBefore(token);
-								}
-								return false;
-							})) return null;
-							if (readRefs.some((reference) => resolveFrom(reference.from, originalName) !== sourceVariable)) return null;
-							const fixes = readRefs.map((reference) => fixer.replaceText(reference.identifier, originalName));
-							const declaration = node.parent;
-							if (declaration.type !== "VariableDeclaration" || declaration.declarations.length !== 1) return null;
-							fixes.push(fixer.remove(declaration.parent.type === "ExportNamedDeclaration" ? declaration.parent : declaration));
-							return fixes;
-						}
-					});
-				} };
-			}
-		},
-		"no-side-effects-in-index": {
-			meta: {
-				type: "problem",
-				schema: [],
-				messages: { notAPureReexport: "A barrel (index) file may contain only re-export statements ('export * from ...' / 'export { x } from ...' / 'export type { x } from ...') -- nothing else, so it can never have a side effect at import time by construction. Found: {{ description }}." }
-			},
-			create(context) {
-				if (!isIndexFile(context.filename)) return {};
-				return { Program(node) {
-					for (const statement of node.body) if (!isPureReexport(statement)) context.report({
-						node: statement,
-						messageId: "notAPureReexport",
-						data: { description: statement.type }
-					});
-				} };
-			}
-		}
+		"no-pointless-reassignment": noPointlessReassignment,
+		"no-set-instanceof-mutation": noSetInstanceofMutation,
+		"no-side-effects-in-index": noSideEffectsInIndex,
+		"prefer-numeric-sort-compare": preferNumericSortCompare,
+		"prefer-readonly-array-param": preferReadonlyArrayParam
 	},
 	configs: {
 		get recommended() {
@@ -624,7 +1114,8 @@ const plugin = {
 					"exadev/barrel-policy": ["error", { mode: "banned" }],
 					"exadev/no-mutable-union-array-param": "error",
 					"exadev/no-object-assign": "error",
-					"exadev/no-pointless-reassignment": "error"
+					"exadev/no-pointless-reassignment": "error",
+					"exadev/prefer-readonly-array-param": "error"
 				}
 			};
 		},
@@ -647,14 +1138,44 @@ const recommendedTypeChecked = [
 		linterOptions: { noInlineConfig: true },
 		rules: {
 			"exadev/barrel-policy": ["error", { mode: "banned" }],
+			"exadev/no-array-isarray-mutation": "error",
 			"exadev/no-enum-number-widening": "error",
+			"exadev/no-enum-reverse-lookup-widening": "error",
+			"exadev/no-map-instanceof-mutation": "error",
 			"exadev/no-mutable-union-array-param": "error",
 			"exadev/no-object-assign": "error",
 			"exadev/no-pointless-reassignment": "error",
-			"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "never" }],
+			"exadev/no-set-instanceof-mutation": "error",
+			"exadev/prefer-numeric-sort-compare": "error",
+			"exadev/prefer-readonly-array-param": "error",
 			"@typescript-eslint/ban-ts-comment": ["error", { "ts-expect-error": true }],
+			"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "never" }],
+			"@typescript-eslint/consistent-type-exports": "error",
+			"@typescript-eslint/consistent-type-imports": "error",
 			"@typescript-eslint/method-signature-style": ["error", "property"],
-			"@typescript-eslint/no-non-null-assertion": "error"
+			"@typescript-eslint/no-deprecated": "error",
+			"@typescript-eslint/no-magic-numbers": ["error", {
+				ignore: [
+					-1,
+					0,
+					1,
+					2
+				],
+				ignoreArrayIndexes: true,
+				ignoreEnums: true,
+				ignoreReadonlyClassProperties: true,
+				ignoreDefaultValues: true
+			}],
+			"@typescript-eslint/no-misused-spread": "error",
+			"@typescript-eslint/no-mixed-enums": "error",
+			"@typescript-eslint/no-non-null-assertion": "error",
+			"@typescript-eslint/no-unnecessary-condition": "error",
+			"@typescript-eslint/prefer-readonly": "error",
+			"@typescript-eslint/promise-function-async": "error",
+			"@typescript-eslint/require-array-sort-compare": "error",
+			"@typescript-eslint/strict-boolean-expressions": "error",
+			"@typescript-eslint/switch-exhaustiveness-check": "error",
+			"@typescript-eslint/use-unknown-in-catch-callback-variable": "error"
 		}
 	},
 	{