exadev-eslint-config 2.2.0 → 2.4.0

package/README.md

@@ -16,7 +16,7 @@ Consumers need `eslint >=10.0.0` and `typescript-eslint >=8.0.0` as required pee
 pnpm add -D @exadev/eslint-config typescript-eslint eslint
 ```
 
-The default export is the full, type-checked ruleset: typescript-eslint's `recommendedTypeChecked` + `stylisticTypeChecked` presets, `exadev/barrel-policy` at `mode: 'banned'` (see [Barrel policy](#barrel-policy)), `exadev/no-object-assign`, `exadev/no-mutable-union-array-param`, `exadev/no-enum-number-widening`, `exadev/no-pointless-reassignment`, `linterOptions.noInlineConfig`, `@typescript-eslint/consistent-type-assertions` banning all type assertions, `@typescript-eslint/ban-ts-comment` banning `@ts-expect-error` outright, and `@typescript-eslint/method-signature-style` set to `'property'` (method-shorthand signatures are checked bivariantly under `strictFunctionTypes`, which is unsound) -- the type-assertion and ts-comment rules are relaxed in test files (see below). Spread it directly into `tseslint.config(...)`:
+The default export is the full, type-checked ruleset: typescript-eslint's `recommendedTypeChecked` + `stylisticTypeChecked` presets, `exadev/barrel-policy` at `mode: 'banned'` (see [Barrel policy](#barrel-policy)), `exadev/no-object-assign`, `exadev/no-mutable-union-array-param`, `exadev/no-array-isarray-mutation`, `exadev/no-enum-number-widening`, `exadev/no-enum-reverse-lookup-widening`, `exadev/no-pointless-reassignment`, `linterOptions.noInlineConfig`, `@typescript-eslint/consistent-type-assertions` banning all type assertions, `@typescript-eslint/no-non-null-assertion` banning the `!` operator (the same manual-override escape hatch as a type assertion, under a different spelling), `@typescript-eslint/ban-ts-comment` banning `@ts-expect-error` outright, `@typescript-eslint/method-signature-style` set to `'property'` (method-shorthand signatures are checked bivariantly under `strictFunctionTypes`, which is unsound), `@typescript-eslint/no-deprecated`, `@typescript-eslint/no-misused-spread`, `@typescript-eslint/no-mixed-enums`, `@typescript-eslint/no-unnecessary-condition`, `@typescript-eslint/prefer-readonly`, `@typescript-eslint/require-array-sort-compare`, `@typescript-eslint/switch-exhaustiveness-check`, `@typescript-eslint/use-unknown-in-catch-callback-variable`, `@typescript-eslint/strict-boolean-expressions` at the rule's own bare defaults (an unambiguous non-nullable truthy check stays allowed; an ambiguous nullable check does not), and `@typescript-eslint/no-magic-numbers` tuned to exempt array indexes, enum members, readonly class properties, default parameter values, and the handful of universally-idiomatic bare numbers (`-1`, `0`, `1`, `2`) -- the type-assertion and ts-comment rules are relaxed in test files, and `no-magic-numbers` is not (see below). Spread it directly into `tseslint.config(...)`:
 
 ```ts
 // eslint.config.ts
@@ -114,7 +114,9 @@ export default tseslint.config(
 | `no-pointless-reassignment` | ✓ | `const foo = bar` where both sides are plain identifiers and the alias adds no transformation. Autofix rewrites every read to the original name and deletes the declaration (including its `export` keyword, when exported). Still reported but deliberately not auto-fixable where collapsing the alias would change meaning: an explicit type annotation (`const exhaustive: never = item` -- the annotation is the point), a read where the original name is shadowed, a read as a shorthand object property, more than one declarator in the statement, or a source that is written to anywhere. |
 | `no-object-assign` | ✓/suggestion | `Object.assign` does not check a source object's properties against the target's declared types, unlike object spread. A fresh object-literal target autofixes to `{ ...target, ...source }`; mutating an existing reassignable binding offers a suggestion only (changes the object's identity); a `const` binding or a non-statement call site gets a plain report with no fix. |
 | `no-mutable-union-array-param` | ✓ | A function parameter typed as an array of a union (`(string \| number)[]`) accepts a narrower caller array (`number[]`) by covariance; calling `push`/`unshift`/`splice`/`fill`/`copyWithin` on it can then insert a value the caller's own array was never declared to hold. Autofix marks the parameter `readonly`, turning the mutating call into a real compile error to resolve deliberately. Requires no type information. |
+| `no-array-isarray-mutation` | | `Array.isArray`'s own type declaration narrows to plain `any[]`, discarding the `readonly` guarantee of any array type in the narrowed parameter's real type -- a bare `readonly T[]`, a `ReadonlyArray<T>`, one behind a type alias, or one alongside other union members -- inside the guarded branch; calling `push`/`unshift`/`splice`/`fill`/`copyWithin` there can mutate a caller's genuinely readonly array. Recognises the direct `if (Array.isArray(x))` guard (braced or not), the early-return/early-throw idiom, `&&`, the ternary form, and the else-of-a-negated-test form. No autofix: re-adding `readonly` is a no-op (the guard already discarded it) and rewriting the mutating call into a copy-first pattern is not safely mechanical in the presence of aliasing. Requires type information -- only in the default (type-checked) export, not `plugin.configs.recommended` -- specifically to see through a type alias and to catch a bare, non-union readonly array parameter, neither visible from the parameter's own syntax alone. |
 | `no-enum-number-widening` | | A bare (non-literal) `number` is accepted anywhere a numeric enum is expected, without checking it is actually one of the enum's members -- only a numeric *literal* gets range-checked by `tsc`. No autofix: the only provably safe fix is a genuine runtime membership check against the enum's own values, which is a behavioural choice a mechanical fix cannot responsibly make. Requires type information -- only in the default (type-checked) export, not `plugin.configs.recommended`. |
+| `no-enum-reverse-lookup-widening` | suggestion | Indexing a numeric enum's reverse mapping (`Direction[n]`) with a bare (non-literal) `number`, or with a different enum's member, types as plain `string` for any index, including one outside the enum's actual members, where it genuinely returns `undefined` at runtime -- `tsc` does not range-check even a numeric literal index here. When the indexed expression is the init of a variable with an explicit `: string` annotation, a suggestion widens it to `: string \| undefined`, forcing later uses as a bare `string` to surface as real compile errors; every other syntactic position gets a plain report with no fix, and no case gets a full `--fix` autofix. Requires type information -- only in the default (type-checked) export, not `plugin.configs.recommended`. |
 
 ## Barrel policy
 

package/dist/index.cjs

@@ -31,7 +31,7 @@ let _typescript_eslint_utils = require("@typescript-eslint/utils");
 let typescript = require("typescript");
 typescript = __toESM(typescript, 1);
 //#region package.json
-var version = "2.2.0";
+var version = "2.4.0";
 //#endregion
 //#region src/rules/barrel-helpers.ts
 const INDEX_BASENAME$1 = /^index\.[cm]?[tj]sx?$/;
@@ -267,6 +267,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$2 = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+function isArrayIsArrayCall(node) {
+	return node.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.callee.object.name === "Array" && node.callee.property.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.callee.property.name === "isArray";
+}
+function definitelyExits(statement) {
+	if (statement.type === _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement || statement.type === _typescript_eslint_utils.AST_NODE_TYPES.ThrowStatement || statement.type === _typescript_eslint_utils.AST_NODE_TYPES.ContinueStatement || statement.type === _typescript_eslint_utils.AST_NODE_TYPES.BreakStatement) return true;
+	if (statement.type === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) {
+		const last = statement.body.at(-1);
+		return last !== void 0 && definitelyExits(last);
+	}
+	return false;
+}
+const noArrayIsArrayMutation = createRule$2({
+	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 = _typescript_eslint_utils.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 !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || callee.property.type !== _typescript_eslint_utils.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 === _typescript_eslint_utils.TSESLint.Scope.DefinitionType.Parameter);
+			if (!parameterDefinition) return;
+			const parameterNode = parameterDefinition.name;
+			if (parameterNode.type !== _typescript_eslint_utils.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 !== _typescript_eslint_utils.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 === _typescript_eslint_utils.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 === _typescript_eslint_utils.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 === _typescript_eslint_utils.AST_NODE_TYPES.LogicalExpression && parent.operator === "&&" && parent.right === current && matchesArrayIsArrayOn(parent.left, parameterVariable, ruleContext)) return true;
+				if (parent.type === _typescript_eslint_utils.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 === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement || parent.type === _typescript_eslint_utils.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 === _typescript_eslint_utils.AST_NODE_TYPES.IfStatement && !sibling.alternate && isNegatedArrayIsArrayCall(sibling.test, parameterVariable, ruleContext) && definitelyExits(sibling.consequent)) return true;
+					}
+				}
+				current = parent;
+			}
+			return false;
+		}
+	}
+});
+//#endregion
 //#region src/rules/no-enum-number-widening.ts
 const noEnumNumberWidening = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`)({
 	name: "no-enum-number-widening",
@@ -312,6 +415,67 @@ const noEnumNumberWidening = _typescript_eslint_utils.ESLintUtils.RuleCreator((n
 	}
 });
 //#endregion
+//#region src/rules/no-enum-reverse-lookup-widening.ts
+const noEnumReverseLookupWidening = _typescript_eslint_utils.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 = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return { MemberExpression(node) {
+			if (!node.computed) return;
+			const objectTsNode = services.esTreeNodeToTSNodeMap.get(node.object);
+			if (!typescript.isExpression(objectTsNode)) return;
+			const objectType = checker.getTypeAtLocation(objectTsNode);
+			const objectSymbol = objectType.getSymbol();
+			if (!objectSymbol || !(objectSymbol.flags & typescript.SymbolFlags.Enum)) return;
+			if (!checker.getIndexInfoOfType(objectType, typescript.IndexKind.Number)) return;
+			const propertyTsNode = services.esTreeNodeToTSNodeMap.get(node.property);
+			if (!typescript.isExpression(propertyTsNode)) return;
+			const rawPropertyType = checker.getTypeAtLocation(propertyTsNode);
+			const propertyType = checker.getBaseConstraintOfType(rawPropertyType) ?? rawPropertyType;
+			if (propertyType.flags & typescript.TypeFlags.EnumLike) {
+				if (checker.isTypeAssignableTo(propertyType, checker.getDeclaredTypeOfSymbol(objectSymbol))) return;
+			} else {
+				if (propertyType.isLiteral()) return;
+				if (!(propertyType.flags & typescript.TypeFlags.NumberLike)) return;
+			}
+			const enumName = checker.typeToString(checker.getDeclaredTypeOfSymbol(objectSymbol));
+			const parent = node.parent;
+			if (parent.type === _typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && parent.id.typeAnnotation?.typeAnnotation.type === _typescript_eslint_utils.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: {
@@ -565,7 +729,9 @@ 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-mutable-union-array-param": noMutableUnionArrayParam,
 		"no-non-barrel-index": noNonBarrelIndex,
@@ -584,7 +750,7 @@ const plugin = {
 					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;
+					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);
@@ -675,13 +841,37 @@ 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-mutable-union-array-param": "error",
 			"exadev/no-object-assign": "error",
 			"exadev/no-pointless-reassignment": "error",
-			"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "never" }],
 			"@typescript-eslint/ban-ts-comment": ["error", { "ts-expect-error": true }],
-			"@typescript-eslint/method-signature-style": ["error", "property"]
+			"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "never" }],
+			"@typescript-eslint/method-signature-style": ["error", "property"],
+			"@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/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"
 		}
 	},
 	{

package/dist/index.js

@@ -3,7 +3,7 @@ import { posix } from "node:path";
 import { AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
 import * as ts from "typescript";
 //#region package.json
-var version = "2.2.0";
+var version = "2.4.0";
 //#endregion
 //#region src/rules/barrel-helpers.ts
 const INDEX_BASENAME$1 = /^index\.[cm]?[tj]sx?$/;
@@ -239,6 +239,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$2 = 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(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 noArrayIsArrayMutation = createRule$2({
+	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(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 +387,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: {
@@ -537,7 +701,9 @@ 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-mutable-union-array-param": noMutableUnionArrayParam,
 		"no-non-barrel-index": noNonBarrelIndex,
@@ -556,7 +722,7 @@ const plugin = {
 					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;
+					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);
@@ -647,13 +813,37 @@ 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-mutable-union-array-param": "error",
 			"exadev/no-object-assign": "error",
 			"exadev/no-pointless-reassignment": "error",
-			"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "never" }],
 			"@typescript-eslint/ban-ts-comment": ["error", { "ts-expect-error": true }],
-			"@typescript-eslint/method-signature-style": ["error", "property"]
+			"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "never" }],
+			"@typescript-eslint/method-signature-style": ["error", "property"],
+			"@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/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"
 		}
 	},
 	{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exadev-eslint-config",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Shared custom ESLint rules and plugin for ExaDev projects",
   "type": "module",
   "sideEffects": false,