exadev-eslint-config 2.4.0 → 2.5.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-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(...)`:
+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-map-instanceof-mutation`, `exadev/no-set-instanceof-mutation`, `exadev/prefer-readonly-array-param`, `exadev/prefer-numeric-sort-compare`, `exadev/no-pointless-reassignment`, `linterOptions.noInlineConfig`, `@typescript-eslint/consistent-type-assertions` banning all type assertions, `@typescript-eslint/consistent-type-imports`, `@typescript-eslint/consistent-type-exports`, `@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/promise-function-async`, `@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,9 +114,13 @@ 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. |
+| `prefer-readonly-array-param` | ✓ | A narrower, safely-autofixable sibling of `@typescript-eslint/prefer-readonly-parameter-types` scoped to array/tuple parameter shapes only: fires unconditionally on every non-readonly array or tuple parameter, regardless of whether the function body mutates it, in any parameter position (a plain identifier, a rest parameter, a default-valued parameter, or a constructor parameter property) and any function-like shape (a concrete function/arrow/method, or a declaration-only ambient function, interface method, function type alias, call/construct signature, or abstract/ambient class method). A union containing an array/tuple member is fixed on that member alone. Autofix prepends `readonly ` (or renames `Array<T>` to `ReadonlyArray<T>`), turning any resulting mutation into a real compile error to resolve deliberately. Requires no type information -- registered in both `plugin.configs.recommended` and the default (type-checked) export. |
 | `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-map-instanceof-mutation` | | `Map` is declared as extending `ReadonlyMap`, so `instanceof Map` narrows a parameter whose real type includes a `ReadonlyMap` -- bare, unioned, or reached through a type alias -- straight past the readonly guarantee to the full mutable interface; calling `set`/`delete`/`clear` there can mutate a caller's genuinely read-only map. Recognises the direct `if (input instanceof Map)` guard (braced or not), the early-return/early-throw idiom, `&&`, the ternary form, and the else-of-a-negated-test form. No autofix: 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`. |
+| `no-set-instanceof-mutation` | | `instanceof Set` narrows a parameter whose real type includes a `ReadonlySet` -- bare, unioned, or reached through a type alias -- straight to the fully mutable `Set` interface, with no way to preserve the read-only guarantee through the narrowing; calling `add`/`delete`/`clear` there can mutate a caller's genuinely read-only set. Recognises the same guard idioms as `no-map-instanceof-mutation` above. No autofix, for the same aliasing reason. Requires type information -- only in the default (type-checked) export, not `plugin.configs.recommended`. |
 | `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`. |
+| `prefer-numeric-sort-compare` | suggestion | A deliberately narrow addition alongside `@typescript-eslint/require-array-sort-compare` (which already flags any bare `.sort()`/`.toSorted()` except on a plain string array, with no fix): when the array's element type is definitively `number`, a suggestion offers an ascending compare function (`(a, b) => a - b`), since the default comparator sorts lexicographically (`[1, 2, 10].sort()` becomes `[1, 10, 2]`). Not a full autofix -- descending order is a real, if less common, alternative intent. Requires type information -- only in the default (type-checked) export, not `plugin.configs.recommended`, since it needs the checker to confirm the array's element type. |
 
 ## Barrel policy
 

package/dist/index.cjs

@@ -30,8 +30,9 @@ let node_path = require("node:path");
 let _typescript_eslint_utils = require("@typescript-eslint/utils");
 let typescript = require("typescript");
 typescript = __toESM(typescript, 1);
+let ts_api_utils = require("ts-api-utils");
 //#region package.json
-var version = "2.4.0";
+var version = "2.5.0";
 //#endregion
 //#region src/rules/barrel-helpers.ts
 const INDEX_BASENAME$1 = /^index\.[cm]?[tj]sx?$/;
@@ -275,19 +276,19 @@ const MUTATING_INSERT_METHODS$1 = /* @__PURE__ */ new Set([
 	"fill",
 	"copyWithin"
 ]);
-const createRule$2 = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const createRule$6 = _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) {
+function definitelyExits$2(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 last !== void 0 && definitelyExits$2(last);
 	}
 	return false;
 }
-const noArrayIsArrayMutation = createRule$2({
+const noArrayIsArrayMutation = createRule$6({
 	name: "no-array-isarray-mutation",
 	meta: {
 		type: "problem",
@@ -360,7 +361,7 @@ const noArrayIsArrayMutation = createRule$2({
 					}
 					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;
+						if (sibling?.type === _typescript_eslint_utils.AST_NODE_TYPES.IfStatement && !sibling.alternate && isNegatedArrayIsArrayCall(sibling.test, parameterVariable, ruleContext) && definitelyExits$2(sibling.consequent)) return true;
 					}
 				}
 				current = parent;
@@ -494,6 +495,107 @@ const noIndexFiles = {
 	}
 };
 //#endregion
+//#region src/rules/no-map-instanceof-mutation.ts
+const createRule$5 = _typescript_eslint_utils.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 === _typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof" && node.right.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.right.name === "Map";
+}
+function definitelyExits$1(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$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 = _typescript_eslint_utils.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 !== _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_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 === _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 (!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 !== _typescript_eslint_utils.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 === _typescript_eslint_utils.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 === _typescript_eslint_utils.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 === _typescript_eslint_utils.AST_NODE_TYPES.LogicalExpression && parent.operator === "&&" && parent.right === current && matchesInstanceofMapOn(parent.left, parameterVariable, ruleContext)) return true;
+				if (parent.type === _typescript_eslint_utils.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 === _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 && 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",
@@ -502,7 +604,7 @@ const MUTATING_INSERT_METHODS = /* @__PURE__ */ new Set([
 	"fill",
 	"copyWithin"
 ]);
-const createRule$1 = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const createRule$4 = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
 function isUnionArrayType(typeAnnotation) {
 	if (typeAnnotation.type === _typescript_eslint_utils.AST_NODE_TYPES.TSArrayType && typeAnnotation.elementType.type === _typescript_eslint_utils.AST_NODE_TYPES.TSUnionType) return typeAnnotation.elementType;
 	if (typeAnnotation.type === _typescript_eslint_utils.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "Array" && typeAnnotation.typeArguments?.params.length === 1) {
@@ -510,7 +612,7 @@ function isUnionArrayType(typeAnnotation) {
 		if (firstParam?.type === _typescript_eslint_utils.AST_NODE_TYPES.TSUnionType) return firstParam;
 	}
 }
-const noMutableUnionArrayParam = createRule$1({
+const noMutableUnionArrayParam = createRule$4({
 	name: "no-mutable-union-array-param",
 	meta: {
 		type: "problem",
@@ -636,14 +738,14 @@ const noNonBarrelReexport = {
 };
 //#endregion
 //#region src/rules/no-object-assign.ts
-const createRule = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const createRule$3 = _typescript_eslint_utils.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",
@@ -718,6 +820,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 = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+function isSetInstanceofExpression(node) {
+	return node.type === _typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof" && node.right.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.right.name === "Set";
+}
+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 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 = _typescript_eslint_utils.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 !== _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_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 === _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 (!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 !== _typescript_eslint_utils.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 === _typescript_eslint_utils.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 === _typescript_eslint_utils.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 === _typescript_eslint_utils.AST_NODE_TYPES.LogicalExpression && parent.operator === "&&" && parent.right === current && matchesSetInstanceofOn(parent.left, parameterVariable, ruleContext)) return true;
+				if (parent.type === _typescript_eslint_utils.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 === _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 && 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 = _typescript_eslint_utils.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 & typescript.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 = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return { CallExpression(node) {
+			if (node.arguments.length > 0) return;
+			const { callee } = node;
+			if (callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || callee.computed) return;
+			if (callee.property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || !SORT_METHOD_NAMES.has(callee.property.name)) return;
+			const receiverTsNode = services.esTreeNodeToTSNodeMap.get(callee.object);
+			if (!typescript.isExpression(receiverTsNode)) return;
+			const receiverType = checker.getTypeAtLocation(receiverTsNode);
+			if (!checker.isArrayType(receiverType)) return;
+			if (!(0, ts_api_utils.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 = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+function getFixableArrayOrTupleType(typeNode) {
+	if (typeNode.type === _typescript_eslint_utils.AST_NODE_TYPES.TSTypeOperator && typeNode.operator === "readonly") return void 0;
+	if (typeNode.type === _typescript_eslint_utils.AST_NODE_TYPES.TSArrayType) return typeNode;
+	if (typeNode.type === _typescript_eslint_utils.AST_NODE_TYPES.TSTupleType) return typeNode;
+	if (typeNode.type === _typescript_eslint_utils.AST_NODE_TYPES.TSTypeReference && typeNode.typeName.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && typeNode.typeName.name === "Array") return typeNode;
+}
+function getFixableTypesForAnnotation(typeNode) {
+	if (typeNode.type === _typescript_eslint_utils.AST_NODE_TYPES.TSUnionType) return typeNode.types.flatMap(getFixableTypesForAnnotation);
+	const fixable = getFixableArrayOrTupleType(typeNode);
+	return fixable ? [fixable] : [];
+}
+function getAnnotatedParamNode(param) {
+	if (param.type === _typescript_eslint_utils.AST_NODE_TYPES.TSParameterProperty) return getAnnotatedParamNode(param.parameter);
+	if (param.type === _typescript_eslint_utils.AST_NODE_TYPES.AssignmentPattern) return param.left.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier ? param.left : void 0;
+	if (param.type === _typescript_eslint_utils.AST_NODE_TYPES.RestElement || param.type === _typescript_eslint_utils.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 === _typescript_eslint_utils.AST_NODE_TYPES.TSTypeReference ? "ReadonlyArray<T>" : `readonly ${fixableType.type === _typescript_eslint_utils.AST_NODE_TYPES.TSTupleType ? "[T, U]" : "T[]"}`).join(" / ");
+			context.report({
+				node: param,
+				messageId: "preferReadonly",
+				data: { suggestion },
+				fix(fixer) {
+					return fixableTypes.map((fixableType) => fixableType.type === _typescript_eslint_utils.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 = {
@@ -733,81 +1122,16 @@ const plugin = {
 		"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 !== 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;
-						}
-					});
-				} };
-			}
-		},
-		"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() {
@@ -818,7 +1142,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"
 				}
 			};
 		},
@@ -844,11 +1169,17 @@ const recommendedTypeChecked = [
 			"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",
+			"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-deprecated": "error",
 			"@typescript-eslint/no-magic-numbers": ["error", {
@@ -868,6 +1199,7 @@ const recommendedTypeChecked = [
 			"@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",

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.4.0";
+var version = "2.5.0";
 //#endregion
 //#region src/rules/barrel-helpers.ts
 const INDEX_BASENAME$1 = /^index\.[cm]?[tj]sx?$/;
@@ -247,19 +248,19 @@ const MUTATING_INSERT_METHODS$1 = /* @__PURE__ */ new Set([
 	"fill",
 	"copyWithin"
 ]);
-const createRule$2 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+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(statement) {
+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(last);
+		return last !== void 0 && definitelyExits$2(last);
 	}
 	return false;
 }
-const noArrayIsArrayMutation = createRule$2({
+const noArrayIsArrayMutation = createRule$6({
 	name: "no-array-isarray-mutation",
 	meta: {
 		type: "problem",
@@ -332,7 +333,7 @@ const noArrayIsArrayMutation = createRule$2({
 					}
 					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;
+						if (sibling?.type === AST_NODE_TYPES.IfStatement && !sibling.alternate && isNegatedArrayIsArrayCall(sibling.test, parameterVariable, ruleContext) && definitelyExits$2(sibling.consequent)) return true;
 					}
 				}
 				current = parent;
@@ -466,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",
@@ -474,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) {
@@ -482,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",
@@ -608,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",
@@ -690,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 = {
@@ -705,81 +1094,16 @@ const plugin = {
 		"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 !== 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;
-						}
-					});
-				} };
-			}
-		},
-		"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() {
@@ -790,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"
 				}
 			};
 		},
@@ -816,11 +1141,17 @@ const recommendedTypeChecked = [
 			"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",
+			"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-deprecated": "error",
 			"@typescript-eslint/no-magic-numbers": ["error", {
@@ -840,6 +1171,7 @@ const recommendedTypeChecked = [
 			"@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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exadev-eslint-config",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Shared custom ESLint rules and plugin for ExaDev projects",
   "type": "module",
   "sideEffects": false,
@@ -63,7 +63,8 @@
     "vitest": "^4.1.10"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^8.67.0"
+    "@typescript-eslint/utils": "^8.67.0",
+    "ts-api-utils": "^2.5.0"
   },
   "scripts": {
     "build": "turbo run _build",