eslint-plugin-flawless 0.1.12 → 1.1.0

package/dist/{plugin-DYVtpuio.mjs → plugin-B-YWsemf.mjs}

@@ -1,19 +1,20 @@
+import { createRequire } from "node:module";
 import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { createSyncFn } from "synckit";
 import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
-import { DefinitionType, ImplicitLibVariable, PatternVisitor, ScopeType, Visitor } from "@typescript-eslint/scope-manager";
-import { requiresQuoting } from "@typescript-eslint/type-utils";
+import { findVariable, isArrowToken, isOpeningParenToken } from "@typescript-eslint/utils/ast-utils";
+import ts9, { ScriptTarget, TypeFlags, isIdentifierPart, isIdentifierStart } from "typescript";
+import { DefinitionType, ImplicitLibVariable, ScopeType, Visitor } from "@typescript-eslint/scope-manager";
 import assert from "node:assert";
+import { getStaticJSONValue, parseForESLint } from "jsonc-eslint-parser";
 import * as core from "@eslint-react/core";
-import { findVariable } from "@typescript-eslint/utils/ast-utils";
-import ts9 from "typescript";
 import { getStaticTOMLValue } from "toml-eslint-parser";
 //#region package.json
 var name = "eslint-plugin-flawless";
-var version = "0.1.12";
+var version = "1.1.0";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -83,11 +84,11 @@ function createFlawlessRule({ createOnce, ...meta }) {
 }
 //#endregion
 //#region src/rules/arrow-return-style/rule.ts
-const RULE_NAME$12 = "arrow-return-style";
+const RULE_NAME$15 = "arrow-return-style";
 const IMPLICIT = "useImplicitReturn";
 const EXPLICIT = "useExplicitReturn";
 const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
-const DEFAULTS = {
+const DEFAULTS$1 = {
 	jsxAlwaysUseExplicitReturn: false,
 	maxLen: 80,
 	maxObjectProperties: 4,
@@ -231,9 +232,9 @@ function collectArrows(root) {
 	return arrows.sort((a, b) => a.range[0] - b.range[0]);
 }
 const arrowReturnStyle = createFlawlessRule({
-	name: RULE_NAME$12,
+	name: RULE_NAME$15,
 	createOnce(context) {
-		let config = DEFAULTS;
+		let config = DEFAULTS$1;
 		let sourceCode;
 		let lines;
 		let pendingConsults;
@@ -288,38 +289,50 @@ const arrowReturnStyle = createFlawlessRule({
 			};
 		}
 		/**
+		* Prepares the oxfmt question for `node`: how would the formatter render
+		* the enclosing statement once the candidate fix is applied? `collapse`
+		* supplies the implicit-direction candidate (the block body textually
+		* replaced by its collapsed expression); omitting it asks about the
+		* statement as written.
+		*
+		* @param node - The arrow function in question.
+		* @param collapse - The implicit-direction candidate, if any.
+		* @returns The consult, or `null` when the arrow cannot be located.
+		*/
+		function buildConsult(node, collapse) {
+			const statement = statementOf(node);
+			const arrowIndex = collectArrows(statement).findIndex((arrow) => arrow.range[0] === node.range[0]);
+			if (arrowIndex === -1) return null;
+			const offset = statement.range[0];
+			const source = sourceCode.getText(statement);
+			const snippet = collapse === void 0 ? source : source.slice(0, collapse.block.range[0] - offset) + collapse.replacement + source.slice(collapse.block.range[1] - offset);
+			const request = {
+				arrowIndex,
+				code: `${snippet}\n`,
+				printWidth: printWidth(),
+				tabWidth: config.tabWidth
+			};
+			return {
+				baseIndent: leadingWhitespace(lineOf(statement.loc.start.line)),
+				cacheKey: `${arrowIndex}${request.printWidth}${request.tabWidth}${snippet}`,
+				node,
+				request
+			};
+		}
+		/**
 		* Resolves every deferred oxfmt consult with a single worker round-trip:
-		* would the formatter render each arrow (params through body) on a single
-		* line that fits `maxLen`? Arrows the formatter cannot keep on one fitting
-		* line are reported. Fails open (no report) when the worker or oxfmt is
-		* unavailable so that an unavailable formatter can never introduce reports
-		* it would have to fight over.
+		* would the formatter render each candidate arrow (params through body) on
+		* a single line that fits `maxLen`? Explicit consults report when it
+		* cannot, implicit consults report when it can. Fails open (no report)
+		* when the worker or oxfmt is unavailable so that an unavailable formatter
+		* can never introduce reports it would have to fight over.
 		*/
 		function resolvePendingConsults() {
 			if (pendingConsults.length === 0) return;
-			const nodes = pendingConsults;
+			const consults = pendingConsults;
 			pendingConsults = [];
 			const worker = getFormatSync();
 			if (worker === null) return;
-			const consults = nodes.flatMap((node) => {
-				const statement = statementOf(node);
-				const snippet = sourceCode.getText(statement);
-				const baseIndent = leadingWhitespace(lineOf(statement.loc.start.line));
-				const arrowIndex = collectArrows(statement).findIndex((arrow) => arrow.range[0] === node.range[0]);
-				if (arrowIndex === -1) return [];
-				const request = {
-					arrowIndex,
-					code: `${snippet}\n`,
-					printWidth: printWidth(),
-					tabWidth: config.tabWidth
-				};
-				return [{
-					baseIndent,
-					cacheKey: `${arrowIndex}${request.printWidth}${request.tabWidth}${snippet}`,
-					node,
-					request
-				}];
-			});
 			const misses = /* @__PURE__ */ new Map();
 			for (const consult of consults) if (formatCacheGet(consult.cacheKey) === void 0) misses.set(consult.cacheKey, consult.request);
 			if (misses.size > 0) {
@@ -338,7 +351,10 @@ const arrowReturnStyle = createFlawlessRule({
 				const response = formatCacheGet(consult.cacheKey);
 				if (response === void 0) continue;
 				if (response.lineText === null) continue;
-				if (!(response.singleLine && width(consult.baseIndent) + width(response.lineText) <= config.maxLen)) reportExplicit(consult.node, EXPLICIT);
+				const fits = response.singleLine && width(consult.baseIndent) + width(response.lineText) <= config.maxLen;
+				if (consult.kind === "implicit") {
+					if (fits) reportImplicit(consult.node, consult.block, consult.replacement);
+				} else if (!fits) reportExplicit(consult.node, EXPLICIT);
 			}
 		}
 		/**
@@ -365,6 +381,28 @@ const arrowReturnStyle = createFlawlessRule({
 			return arrowIndent.length > 0 ? "  " : "	";
 		}
 		/**
+		* The `)` of a wrapped sole-argument call whose trailing comma the fix
+		* should absorb. `foo(() =>\n\tbody,\n)` only carries that comma because
+		* the argument was wrapped; once the block body hugs the call again the
+		* comma is debris (`},\n)` where the formatter writes `})`).
+		*
+		* @param node - The arrow function being converted.
+		* @param bodyEnd - The body's last token or node (including parens).
+		* @returns The closing paren to absorb up to, or `null`.
+		*/
+		function danglingCloser(node, bodyEnd) {
+			const { loc, parent } = node;
+			if (!(parent.type === AST_NODE_TYPES.CallExpression || parent.type === AST_NODE_TYPES.NewExpression) || parent.arguments.length !== 1 || parent.arguments[0] !== node) return null;
+			const opener = sourceCode.getTokenBefore(node);
+			if (opener?.value !== "(" || opener.loc.end.line !== loc.start.line) return null;
+			const comma = sourceCode.getTokenAfter(bodyEnd);
+			if (comma?.value !== ",") return null;
+			const closer = sourceCode.getTokenAfter(comma);
+			if (closer?.value !== ")" || closer.range[1] !== parent.range[1]) return null;
+			if (sourceCode.getCommentsBefore(closer).length > 0) return null;
+			return closer;
+		}
+		/**
 		* Reports and fixes an implicit arrow into an explicit block body.
 		*
 		* @param node - The arrow function to convert.
@@ -396,8 +434,9 @@ const arrowReturnStyle = createFlawlessRule({
 			const commentLines = comments.map((comment) => targetIndent + sourceCode.getText(comment));
 			const returnLine = `${targetIndent}return ${[firstLine, ...shifted].join("\n")};`;
 			const replacement = ` {\n${[...commentLines, returnLine].join("\n")}\n${arrowIndent}}`;
+			const end = danglingCloser(node, bodyEnd)?.range[0] ?? bodyEnd.range[1];
 			context.report({
-				fix: (fixer) => fixer.replaceTextRange([arrowToken.range[1], bodyEnd.range[1]], replacement),
+				fix: (fixer) => fixer.replaceTextRange([arrowToken.range[1], end], replacement),
 				messageId,
 				node
 			});
@@ -432,7 +471,20 @@ const arrowReturnStyle = createFlawlessRule({
 			const prefix = lineOf(block.loc.start.line).slice(0, block.loc.start.column);
 			const suffix = lineOf(block.loc.end.line).slice(block.loc.end.column);
 			if (width(prefix + collapsed + suffix) > limit()) return;
-			reportImplicit(node, block, collapsed);
+			if (statementOf(node).loc.end.line === block.loc.end.line || config.useOxfmt === false) {
+				reportImplicit(node, block, collapsed);
+				return;
+			}
+			const consult = buildConsult(node, {
+				block,
+				replacement: collapsed
+			});
+			if (consult !== null) pendingConsults.push({
+				...consult,
+				block,
+				kind: "implicit",
+				replacement: collapsed
+			});
 		}
 		function checkExpressionBody(node) {
 			const body = node.body;
@@ -461,8 +513,15 @@ const arrowReturnStyle = createFlawlessRule({
 				return;
 			}
 			if (width(lineOf(bodyStart.loc.start.line)) > limit()) {
-				if (config.useOxfmt !== false) pendingConsults.push(node);
-				else reportExplicit(node, EXPLICIT);
+				if (config.useOxfmt === false) {
+					reportExplicit(node, EXPLICIT);
+					return;
+				}
+				const consult = buildConsult(node);
+				if (consult !== null) pendingConsults.push({
+					...consult,
+					kind: "explicit"
+				});
 				return;
 			}
 			if (objectStyleWantsExplicit(body)) reportExplicit(node, COMPLEX_EXPLICIT);
@@ -474,7 +533,7 @@ const arrowReturnStyle = createFlawlessRule({
 			},
 			"before": function() {
 				config = {
-					...DEFAULTS,
+					...DEFAULTS$1,
 					...context.options[0]
 				};
 				({sourceCode} = context);
@@ -486,7 +545,7 @@ const arrowReturnStyle = createFlawlessRule({
 			}
 		};
 	},
-	defaultOptions: [DEFAULTS],
+	defaultOptions: [DEFAULTS$1],
 	meta: {
 		docs: {
 			description: "Enforce arrow function return style based on line length",
@@ -539,23 +598,23 @@ const arrowReturnStyle = createFlawlessRule({
 });
 //#endregion
 //#region src/rules/jsx-shorthand-boolean/rule.ts
-const RULE_NAME$11 = "jsx-shorthand-boolean";
-const MESSAGE_ID$5 = "setAttributeValue";
-const messages$11 = { [MESSAGE_ID$5]: "Set an explicit value for boolean attribute '{{name}}'." };
-function createOnce$7(context) {
+const RULE_NAME$14 = "jsx-shorthand-boolean";
+const MESSAGE_ID$7 = "setAttributeValue";
+const messages$14 = { [MESSAGE_ID$7]: "Set an explicit value for boolean attribute '{{name}}'." };
+function createOnce$9(context) {
 	return { JSXAttribute(node) {
 		if (node.value !== null) return;
 		context.report({
 			data: { name: context.sourceCode.getText(node.name) },
 			fix: (fixer) => fixer.insertTextAfter(node.name, "={true}"),
-			messageId: MESSAGE_ID$5,
+			messageId: MESSAGE_ID$7,
 			node
 		});
 	} };
 }
 const jsxShorthandBoolean = createFlawlessRule({
-	name: RULE_NAME$11,
-	createOnce: createOnce$7,
+	name: RULE_NAME$14,
+	createOnce: createOnce$9,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -565,23 +624,23 @@ const jsxShorthandBoolean = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$11,
+		messages: messages$14,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$10 = "jsx-shorthand-fragment";
+const RULE_NAME$13 = "jsx-shorthand-fragment";
 const MESSAGE_ID_NAMED = "useNamedFragment";
 const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
 const DEFAULT_MODE = "syntax";
 const DEFAULT_FRAGMENT_NAME = "Fragment";
-const messages$10 = {
+const messages$13 = {
 	[MESSAGE_ID_NAMED]: "Use the '{{name}}' component instead of fragment shorthand syntax.",
 	[MESSAGE_ID_SHORTHAND]: "Use the fragment shorthand syntax '<>...</>' instead of the '{{name}}' component."
 };
-const schema$2 = [{
+const schema$3 = [{
 	additionalProperties: false,
 	properties: {
 		fragmentName: {
@@ -613,7 +672,7 @@ function jsxNameToString(node) {
 	}
 	return null;
 }
-function createOnce$6(context) {
+function createOnce$8(context) {
 	let mode;
 	let fragmentName;
 	let namedFragments;
@@ -660,8 +719,8 @@ function createOnce$6(context) {
 	};
 }
 const jsxShorthandFragment = createFlawlessRule({
-	name: RULE_NAME$10,
-	createOnce: createOnce$6,
+	name: RULE_NAME$13,
+	createOnce: createOnce$8,
 	defaultOptions: [{
 		fragmentName: DEFAULT_FRAGMENT_NAME,
 		mode: DEFAULT_MODE
@@ -678,7 +737,328 @@ const jsxShorthandFragment = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$10,
+		messages: messages$13,
+		schema: schema$3,
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/max-lines-per-function/core-ast-utils.ts
+/**
+* @file Helpers ported from ESLint core's `lib/rules/utils/ast-utils.js` and
+* `lib/shared/string-utils.js`, so this rule's diagnostics read and point
+* identically to core's `max-lines-per-function`. `@typescript-eslint/utils`
+* re-exports `@eslint-community/eslint-utils` equivalents
+* (`getFunctionNameWithKind`, `getFunctionHeadLocation`), but those diverge from
+* core — they name variable-bound functions (`const f = () => {}` →
+* `arrow function 'f'`) and bracket computed keys — so the port is what keeps
+* parity with core, not availability. ESLint is MIT licensed — Copyright OpenJS
+* Foundation and other contributors.
+*/
+/**
+* Describes a function by name and kind, as core does, so diagnostics read the
+* same. Examples: `function 'foo'`, `arrow function`, `constructor`,
+* `static async generator method 'foo'`, `private method #foo`.
+*
+* Core's `TSPropertySignature` / `TSMethodSignature` branches are omitted: this
+* rule only visits the three function node types, so a signature node can never
+* reach here.
+*
+* @param node - The function to describe.
+* @returns The space-joined description.
+*/
+function getFunctionNameWithKind({ id, async, generator, parent, type }) {
+	const tokens = [];
+	if (parent.type === AST_NODE_TYPES.MethodDefinition || parent.type === AST_NODE_TYPES.PropertyDefinition) {
+		if (parent.static) tokens.push("static");
+		if (!parent.computed && parent.key.type === AST_NODE_TYPES.PrivateIdentifier) tokens.push("private");
+	}
+	if (async) tokens.push("async");
+	if (generator) tokens.push("generator");
+	if (parent.type === AST_NODE_TYPES.Property || parent.type === AST_NODE_TYPES.MethodDefinition) {
+		if (parent.kind === "constructor") return "constructor";
+		if (parent.kind === "get") tokens.push("getter");
+		else if (parent.kind === "set") tokens.push("setter");
+		else tokens.push("method");
+	} else if (parent.type === AST_NODE_TYPES.PropertyDefinition) tokens.push("method");
+	else {
+		if (type === AST_NODE_TYPES.ArrowFunctionExpression) tokens.push("arrow");
+		tokens.push("function");
+	}
+	if (parent.type === AST_NODE_TYPES.Property || parent.type === AST_NODE_TYPES.MethodDefinition || parent.type === AST_NODE_TYPES.PropertyDefinition) if (!parent.computed && parent.key.type === AST_NODE_TYPES.PrivateIdentifier) tokens.push(`#${parent.key.name}`);
+	else {
+		const name = getStaticPropertyName(parent);
+		if (name !== null) tokens.push(`'${name}'`);
+		else if (id !== null) tokens.push(`'${id.name}'`);
+	}
+	else if (id !== null) tokens.push(`'${id.name}'`);
+	return tokens.join(" ");
+}
+/**
+* Locates the head of a function — the part worth underlining in a diagnostic,
+* rather than the function's whole multi-line body. For example the
+* `function foo` of a declaration, or the `=>` of an arrow function.
+*
+* Core's `TSPropertySignature` / `TSMethodSignature` branches are omitted for
+* the same reason as in {@link getFunctionNameWithKind}: those nodes never
+* reach here.
+*
+* @param node - The function to locate.
+* @param sourceCode - The source code being linted.
+* @returns The location of the function's head.
+*/
+function getFunctionHeadLoc(node, sourceCode) {
+	const { body, loc, parent, type } = node;
+	if (parent.type === AST_NODE_TYPES.Property || parent.type === AST_NODE_TYPES.MethodDefinition || parent.type === AST_NODE_TYPES.PropertyDefinition) return {
+		end: getOpeningParenOfParameters(node, sourceCode)?.loc.start ?? loc.end,
+		start: parent.loc.start
+	};
+	if (type === AST_NODE_TYPES.ArrowFunctionExpression) {
+		const arrowToken = sourceCode.getTokenBefore(body, isArrowToken);
+		if (arrowToken !== null) return {
+			end: arrowToken.loc.end,
+			start: arrowToken.loc.start
+		};
+	}
+	return {
+		end: getOpeningParenOfParameters(node, sourceCode)?.loc.start ?? loc.end,
+		start: loc.start
+	};
+}
+/**
+* Upper-cases the first character of a string.
+*
+* @param value - The string to convert.
+* @returns The converted string.
+*/
+function upperCaseFirst(value) {
+	return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+/**
+* Reads the statically known string value of a property key.
+*
+* @param node - The key node.
+* @returns The value as a string, or `null` when it is not statically known.
+*/
+function getStaticStringValue(node) {
+	if (node.type === AST_NODE_TYPES.Literal) return node.value === null ? node.raw : String(node.value);
+	if (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0 && node.quasis.length === 1) return node.quasis[0]?.value.cooked ?? null;
+	return null;
+}
+/**
+* Reads the property name of a member definition.
+*
+* @param node - The member whose key to read.
+* @returns The property name, or `null` when the key is computed from a
+*   dynamic expression.
+*/
+function getStaticPropertyName(node) {
+	if (!node.computed && node.key.type === AST_NODE_TYPES.Identifier) return node.key.name;
+	return getStaticStringValue(node.key);
+}
+/**
+* Finds the token opening a function's parameter list.
+*
+* @param node - The function whose parameters to locate.
+* @param sourceCode - The source code being linted.
+* @returns The opening paren, or — for an arrow function with a single
+*   parameter written without parentheses — that parameter's first token.
+*   `null` when neither can be found.
+*/
+function getOpeningParenOfParameters(node, sourceCode) {
+	const [firstParameter] = node.params;
+	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression && node.params.length === 1 && firstParameter !== void 0) {
+		const argumentToken = sourceCode.getFirstToken(firstParameter);
+		if (argumentToken === null) return null;
+		const maybeParenToken = sourceCode.getTokenBefore(argumentToken);
+		return maybeParenToken !== null && isOpeningParenToken(maybeParenToken) ? maybeParenToken : argumentToken;
+	}
+	return node.id === null ? sourceCode.getFirstToken(node, isOpeningParenToken) : sourceCode.getTokenAfter(node.id, isOpeningParenToken);
+}
+//#endregion
+//#region src/rules/max-lines-per-function/rule.ts
+const RULE_NAME$12 = "max-lines-per-function";
+const MESSAGE_ID_EXCEED = "exceed";
+/** A line that is empty or holds only whitespace. */
+const BLANK_LINE = /^\s*$/u;
+const DEFAULTS = {
+	countFrom: "body",
+	IIFEs: false,
+	max: 50,
+	skipBlankLines: false,
+	skipComments: false
+};
+const messages$12 = { [MESSAGE_ID_EXCEED]: "{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}." };
+const schema$2 = [{
+	additionalProperties: false,
+	properties: {
+		countFrom: {
+			description: "Where the counted range begins: \"body\" (default) excludes the signature, \"function\" counts the whole node like ESLint core.",
+			enum: ["body", "function"],
+			type: "string"
+		},
+		IIFEs: {
+			description: "Whether immediately-invoked function expressions are measured.",
+			type: "boolean"
+		},
+		max: {
+			description: "The maximum number of lines a function may span.",
+			minimum: 0,
+			type: "integer"
+		},
+		skipBlankLines: {
+			description: "Whether lines containing only whitespace are excluded from the count.",
+			type: "boolean"
+		},
+		skipComments: {
+			description: "Whether lines consisting solely of a comment are excluded from the count.",
+			type: "boolean"
+		}
+	},
+	type: "object"
+}];
+/**
+* Indexes comments by every source line they occupy, so a line can be tested
+* for comment-only status in constant time.
+*
+* @param comments - Every comment in the file.
+* @returns A map from one-indexed line number to the comment on that line.
+*/
+function getCommentLineNumbers(comments) {
+	const map = /* @__PURE__ */ new Map();
+	for (const comment of comments) for (let { line } = comment.loc.start; line <= comment.loc.end.line; line += 1) map.set(line, comment);
+	return map;
+}
+/**
+* Determines whether a comment occupies a whole line, leaving no code beside
+* it.
+*
+* @param line - The source text of the line.
+* @param lineNumber - The one-indexed number of that line.
+* @param comment - The comment occupying part of the line.
+* @returns `true` when nothing but the comment appears on the line.
+*/
+function isFullLineComment(line, lineNumber, comment) {
+	const { end, start } = comment.loc;
+	const isFirstTokenOnLine = start.line === lineNumber && line.slice(0, start.column).trim() === "";
+	const isLastTokenOnLine = end.line === lineNumber && line.slice(end.column).trim() === "";
+	return (start.line < lineNumber || isFirstTokenOnLine) && (end.line > lineNumber || isLastTokenOnLine);
+}
+/**
+* Determines whether a function is the callee of its own call expression.
+*
+* @param node - The node to test.
+* @returns `true` when the node is immediately invoked.
+*/
+function isIIFE(node) {
+	if (node.type !== AST_NODE_TYPES.ArrowFunctionExpression && node.type !== AST_NODE_TYPES.FunctionExpression) return false;
+	const { parent } = node;
+	return parent.type === AST_NODE_TYPES.CallExpression && parent.callee === node;
+}
+/**
+* Determines whether a function is the value of a class method or of an object
+* shorthand method or accessor. In that case the enclosing member — not the
+* bare function expression — is the unit measured and reported.
+*
+* @param node - The function to test.
+* @returns `true` when the function is embedded in a member definition.
+*/
+function isEmbedded(node) {
+	const { parent } = node;
+	if (parent.type === AST_NODE_TYPES.MethodDefinition) return parent.value === node;
+	if (parent.type === AST_NODE_TYPES.Property) return parent.value === node && (parent.method || parent.kind === "get" || parent.kind === "set");
+	return false;
+}
+/**
+* Selects the source range whose lines are counted for a function.
+*
+* Under `"body"` this is the function's body — the braces themselves for a
+* block body, or the expression for a concise arrow body — so the signature is
+* excluded. Under `"function"` it is the reported node, matching ESLint core.
+*
+* @param countFrom - Which range to measure.
+* @param funcNode - The function being measured.
+* @param reportNode - The node the diagnostic attaches to: the enclosing member
+*   for an embedded method, otherwise `funcNode` itself.
+* @returns The location whose line span is counted.
+*/
+function getCountedLoc(countFrom, funcNode, reportNode) {
+	return countFrom === "function" ? reportNode.loc : funcNode.body.loc;
+}
+/**
+* Builds the rule's per-file listener.
+*
+* @param context - The rule context.
+* @returns The visitors measuring each function.
+*/
+function createOnce$7(context) {
+	let commentLineNumbers;
+	let config;
+	let lines;
+	let sourceCode;
+	/**
+	* Counts a function's lines and reports it when it exceeds the maximum.
+	*
+	* @param funcNode - The function to measure.
+	*/
+	function processFunction(funcNode) {
+		const node = isEmbedded(funcNode) ? funcNode.parent : funcNode;
+		if (!config.IIFEs && isIIFE(node)) return;
+		const { end, start } = getCountedLoc(config.countFrom, funcNode, node);
+		let lineCount = 0;
+		for (let index = start.line - 1; index < end.line; index += 1) {
+			const line = lines[index] ?? "";
+			const lineNumber = index + 1;
+			if (config.skipComments) {
+				const comment = commentLineNumbers.get(lineNumber);
+				if (comment !== void 0 && isFullLineComment(line, lineNumber, comment)) continue;
+			}
+			if (config.skipBlankLines && BLANK_LINE.test(line)) continue;
+			lineCount += 1;
+		}
+		if (lineCount > config.max) context.report({
+			data: {
+				name: upperCaseFirst(getFunctionNameWithKind(funcNode)),
+				lineCount,
+				maxLines: config.max
+			},
+			loc: getFunctionHeadLoc(funcNode, sourceCode),
+			messageId: MESSAGE_ID_EXCEED,
+			node
+		});
+	}
+	return {
+		ArrowFunctionExpression: processFunction,
+		before() {
+			const options = context.options[0];
+			config = {
+				countFrom: options?.countFrom ?? DEFAULTS.countFrom,
+				IIFEs: options?.IIFEs ?? DEFAULTS.IIFEs,
+				max: options?.max ?? DEFAULTS.max,
+				skipBlankLines: options?.skipBlankLines ?? DEFAULTS.skipBlankLines,
+				skipComments: options?.skipComments ?? DEFAULTS.skipComments
+			};
+			({sourceCode} = context);
+			lines = [...sourceCode.lines];
+			commentLineNumbers = config.skipComments ? getCommentLineNumbers(sourceCode.getAllComments()) : /* @__PURE__ */ new Map();
+		},
+		FunctionDeclaration: processFunction,
+		FunctionExpression: processFunction
+	};
+}
+const maxLinesPerFunction = createFlawlessRule({
+	name: RULE_NAME$12,
+	createOnce: createOnce$7,
+	defaultOptions: [DEFAULTS],
+	meta: {
+		defaultOptions: [DEFAULTS],
+		docs: {
+			description: "Enforce a maximum number of lines of code in a function",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		hasSuggestions: false,
+		messages: messages$12,
 		schema: schema$2,
 		type: "suggestion"
 	}
@@ -1158,6 +1538,77 @@ function isUsedVariable(variable) {
 	});
 }
 //#endregion
+//#region src/rules/naming-convention/utils/contextual-type.ts
+/**
+* Determines if an object literal member's name is dictated by the contextual
+* type of the enclosing object literal (e.g. `{ ... } satisfies
+* Partial<Service>`). In that case the name is not the author's choice - it is
+* required by the declared type, which is itself validated at its declaration
+* site - so naming validation should be skipped.
+*
+* @param node - The non-computed object literal property or method node.
+* @param services - Parser services (may lack type information).
+* @param cache - Per-file cache of contextual types keyed by object literal.
+* @returns True if the member name is required by a contextual type.
+*/
+function isDictatedByContextualType(node, services, cache) {
+	if (!services.program || node.parent.type !== AST_NODE_TYPES.ObjectExpression) return false;
+	const checker = services.program.getTypeChecker();
+	const tsObject = services.esTreeNodeToTSNodeMap.get(node.parent);
+	const candidates = getCandidateTypes(node.parent, tsObject, checker, cache);
+	if (candidates === null) return false;
+	const name = node.key.type === AST_NODE_TYPES.Identifier ? node.key.name : String(node.key.value);
+	return candidates.some((candidate) => {
+		const property = checker.getPropertyOfType(candidate, name);
+		return property !== void 0 && !isDeclaredWithinLiteral(property, tsObject);
+	});
+}
+/**
+* Resolves the contextual type of an object literal into its candidate
+* constituent types, cached per object literal.
+*
+* Union arms are checked individually because `getPropertyOfType` on a union
+* only finds properties present in every arm, while a name dictated by a
+* single arm still isn't the author's choice.
+*
+* @param objectNode - The enclosing object literal (ESTree).
+* @param tsObject - The corresponding TypeScript node.
+* @param checker - The type checker.
+* @param cache - Per-file cache of contextual types keyed by object literal.
+* @returns The candidate types, or null if there is no contextual type.
+*/
+function getCandidateTypes(objectNode, tsObject, checker, cache) {
+	const cached = cache.get(objectNode);
+	if (cached !== void 0) return cached;
+	const contextualType = checker.getContextualType(tsObject);
+	let candidates = null;
+	if (contextualType !== void 0) {
+		const nonNullable = contextualType.getNonNullableType();
+		candidates = (nonNullable.isUnion() ? nonNullable.types : [nonNullable]).map((arm) => checker.getApparentType(arm));
+	}
+	cache.set(objectNode, candidates);
+	return candidates;
+}
+/**
+* Guards against self-inference: in generic calls like `identity({ Name: 1 })`
+* the contextual type is inferred from the literal itself, so the property
+* symbol's declarations all live inside the literal - the name is still the
+* author's choice. Transient symbols without declarations (such as those from
+* mapped types like `Partial<T>`) originate from the contextual type and count
+* as dictated.
+*
+* @param symbol - The property symbol found on a candidate contextual type.
+* @param literal - The object literal being checked.
+* @returns True if every declaration of the symbol lies inside the literal.
+*/
+function isDeclaredWithinLiteral(symbol, literal) {
+	const declarations = symbol.declarations ?? [];
+	if (declarations.length === 0) return false;
+	return declarations.every((declaration) => {
+		return declaration.getSourceFile() === literal.getSourceFile() && declaration.pos >= literal.pos && declaration.end <= literal.end;
+	});
+}
+//#endregion
 //#region src/rules/naming-convention/utils/enums.ts
 const Selector = {
 	variable: 1,
@@ -1226,6 +1677,8 @@ const TypeModifier = {
 	array: 2097152
 };
 const TypeModifierValueToKey = Object.fromEntries(Object.entries(TypeModifier).map(([key, value]) => [value, key]));
+const TYPE_REFERENCE_LOOSE_WEIGHT = 1 << 22;
+const TYPE_REFERENCE_STRICT_WEIGHT = 1 << 23;
 const UnderscoreOption = {
 	forbid: 1,
 	allow: 2,
@@ -1506,31 +1959,130 @@ function createValidator(type, context, allConfigs) {
 		return false;
 	}
 }
-const SelectorsAllowedToHaveTypes = Selector.variable | Selector.parameter | Selector.classProperty | Selector.objectLiteralProperty | Selector.typeProperty | Selector.parameterProperty | Selector.classicAccessor;
+const SelectorsAllowedToHaveTypes = Selector.variable | Selector.function | Selector.parameter | Selector.classProperty | Selector.objectLiteralProperty | Selector.typeProperty | Selector.parameterProperty | Selector.classicAccessor | Selector.classMethod | Selector.objectLiteralMethod | Selector.typeMethod;
 function isAllTypesMatch(type, callback) {
 	if (type.isUnion()) return type.types.every((inner) => callback(inner));
 	return callback(type);
 }
+function isAnyType(type) {
+	return (type.flags & TypeFlags.Any) !== 0;
+}
+function symbolMatchesTypeReference(symbol, reference) {
+	if (symbol === void 0 || reference.name === void 0 || symbol.name !== reference.name) return false;
+	if (reference.from === void 0) return true;
+	const { declarations } = symbol;
+	if (!declarations || declarations.length === 0) return false;
+	for (const declaration of declarations) {
+		const { fileName } = declaration.getSourceFile();
+		if (moduleSpecifierMatches(fileName, reference.from)) return true;
+	}
+	return false;
+}
+function matchesNamedTypeReference(type, reference) {
+	if (isAnyType(type)) return false;
+	if (symbolMatchesTypeReference(type.aliasSymbol, reference)) return true;
+	if (symbolMatchesTypeReference(type.symbol, reference)) return true;
+	if (type.isIntersection() || type.isUnion()) {
+		for (const inner of type.types) if (matchesNamedTypeReference(inner, reference)) return true;
+	}
+	return false;
+}
+function matchesReturnTypeReference(type, reference) {
+	if (isAnyType(type)) return false;
+	for (const signature of type.getCallSignatures()) if (matchesTypeReference(signature.getReturnType(), reference)) return true;
+	if (type.isIntersection() || type.isUnion()) {
+		for (const inner of type.types) if (matchesReturnTypeReference(inner, reference)) return true;
+	}
+	return false;
+}
+function matchesTypeReference(type, reference) {
+	if (isAnyType(type)) return false;
+	if (reference.name === void 0 && reference.returns === void 0) return false;
+	if (reference.name !== void 0 && !matchesNamedTypeReference(type, reference)) return false;
+	if (reference.returns !== void 0 && !matchesReturnTypeReference(type, reference.returns)) return false;
+	return true;
+}
 function isCorrectType(node, config, context, selector) {
 	if (config.types === void 0) return true;
 	if ((SelectorsAllowedToHaveTypes & selector) === 0) return true;
 	const services = getParserServices(context);
 	const checker = services.program.getTypeChecker();
 	const type = services.getTypeAtLocation(node).getNonNullableType();
-	for (const allowedType of config.types) switch (allowedType) {
-		case TypeModifier.array:
-			if (isAllTypesMatch(type, (inner) => checker.isArrayType(inner) || checker.isTupleType(inner))) return true;
-			break;
-		case TypeModifier.boolean:
-		case TypeModifier.number:
-		case TypeModifier.string:
-			if (checker.typeToString(checker.getWidenedType(checker.getBaseTypeOfLiteralType(type))) === TypeModifierValueToKey[allowedType]) return true;
-			break;
-		case TypeModifier.function:
-			if (isAllTypesMatch(type, (inner) => inner.getCallSignatures().length > 0)) return true;
-			break;
+	const predicates = [];
+	for (const allowedType of config.types) {
+		if (typeof allowedType === "object") {
+			predicates.push((inner) => matchesTypeReference(inner, allowedType));
+			continue;
+		}
+		switch (allowedType) {
+			case TypeModifier.array:
+				predicates.push((inner) => checker.isArrayType(inner) || checker.isTupleType(inner));
+				break;
+			case TypeModifier.boolean:
+			case TypeModifier.number:
+			case TypeModifier.string:
+				predicates.push((inner) => {
+					return checker.typeToString(checker.getWidenedType(checker.getBaseTypeOfLiteralType(inner))) === TypeModifierValueToKey[allowedType];
+				});
+				break;
+			case TypeModifier.function:
+				predicates.push((inner) => inner.getCallSignatures().length > 0);
+				break;
+		}
 	}
-	return false;
+	return isAllTypesMatch(type, (inner) => predicates.some((predicate) => predicate(inner)));
+}
+const BACKSLASH_PATTERN = /\\/gu;
+const TYPESCRIPT_EXTENSION_PATTERN = /\.d\.ts$|\.tsx?$/u;
+const WINDOWS_DRIVE_PATTERN = /^[A-Za-z]:\//u;
+const LEADING_DOT_OR_SLASH_PATTERN = /^(\.\/|\/)/u;
+/**
+* Path-form specifiers start with `.`, `/`, or a Windows drive letter (e.g.
+* `C:/`).
+*
+* @param specifier - The module specifier to classify.
+* @returns True if the specifier should be treated as a filesystem path rather
+*   than a package name.
+*/
+function looksLikePath(specifier) {
+	if (specifier.startsWith(".")) return true;
+	if (specifier.startsWith("/")) return true;
+	return WINDOWS_DRIVE_PATTERN.test(specifier);
+}
+/**
+* Checks whether a declaration's source file matches a module specifier.
+*
+* Two specifier shapes are supported:
+*
+* 1. **Bare package specifier** (e.g. `"@rbxts/jecs"`, `"lodash"`) — matches
+*    when the declaration's file path contains `/node_modules/<specifier>/` as
+*    a substring. Handles flat and pnpm-style layouts (pnpm paths still contain
+*    a final `/node_modules/<specifier>/` segment after the virtual store
+*    directory). **Not** supported: Yarn Plug'n'Play (no `node_modules` on
+*    disk), vendored packages outside `node_modules`, or types provided by
+*    separate `@types/*` packages.
+* 2. **Path specifier** (starts with `.`, `/`, or a Windows drive letter) —
+*    matches against the normalized declaration path with `.d.ts` / `.tsx?`
+*    stripped. Windows absolute paths require exact equality. POSIX-style
+*    absolute or relative paths are normalized to a bare tail and matched as a
+*    suffix; this means `"./shared/network"` matches a declaration at
+*    `<root>/shared/network.ts`.
+*
+* @param declarationFile - Path of the file declaring the matched symbol.
+* @param specifier - The `from` module specifier from the rule config.
+* @returns True if the declaration file matches the specifier.
+*/
+function moduleSpecifierMatches(declarationFile, specifier) {
+	const normalizedFile = declarationFile.replace(BACKSLASH_PATTERN, "/");
+	const normalizedSpecifier = specifier.replace(BACKSLASH_PATTERN, "/");
+	if (looksLikePath(normalizedSpecifier)) {
+		const stripped = normalizedFile.replace(TYPESCRIPT_EXTENSION_PATTERN, "");
+		if (WINDOWS_DRIVE_PATTERN.test(normalizedSpecifier)) return stripped === normalizedSpecifier;
+		const tail = normalizedSpecifier.replace(LEADING_DOT_OR_SLASH_PATTERN, "");
+		if (stripped === tail) return true;
+		return stripped.endsWith(`/${tail}`);
+	}
+	return normalizedFile.includes(`/node_modules/${normalizedSpecifier}/`);
 }
 //#endregion
 //#region src/rules/naming-convention/utils/parse-options.ts
@@ -1538,10 +2090,22 @@ function parseOptions(context) {
 	const normalizedOptions = context.options.flatMap(normalizeOption);
 	return Object.fromEntries(Object.keys(Selector).map((key) => [key, createValidator(key, context, normalizedOptions)]));
 }
+/**
+* A type-reference matcher counts as "strict" for sorting when any level of it
+* (including nested `returns` matchers) constrains the declaring module.
+*
+* @param reference - The matcher to inspect.
+* @returns True if the matcher carries a `from` constraint at any depth.
+*/
+function hasFromConstraint(reference) {
+	if (reference.from !== void 0) return true;
+	return reference.returns !== void 0 && hasFromConstraint(reference.returns);
+}
 function normalizeOption(option) {
 	let weight = 0;
 	if (option.modifiers) for (const modifier of option.modifiers) weight |= Modifier[modifier];
-	if (option.types) for (const type of option.types) weight |= TypeModifier[type];
+	if (option.types) for (const type of option.types) if (typeof type === "string") weight |= TypeModifier[type];
+	else weight |= hasFromConstraint(type) ? TYPE_REFERENCE_STRICT_WEIGHT : TYPE_REFERENCE_LOOSE_WEIGHT;
 	if (option.filter !== void 0) weight |= 1 << 30;
 	const normalizedOption = {
 		custom: option.custom ? {
@@ -1562,7 +2126,7 @@ function normalizeOption(option) {
 		prefix: option.prefix && option.prefix.length > 0 ? option.prefix : void 0,
 		suffix: option.suffix && option.suffix.length > 0 ? option.suffix : void 0,
 		trailingUnderscore: option.trailingUnderscore !== void 0 ? UnderscoreOption[option.trailingUnderscore] : void 0,
-		types: option.types?.map((type) => TypeModifier[type]) ?? void 0
+		types: option.types?.map((type) => typeof type === "string" ? TypeModifier[type] : type) ?? void 0
 	};
 	return (Array.isArray(option.selector) ? option.selector : [option.selector]).map((selector) => {
 		return {
@@ -1600,9 +2164,39 @@ const $DEFS = {
 		},
 		type: "array"
 	},
-	typeModifiers: {
+	typeMatcher: { oneOf: [{
+		description: "Built-in type modifier matching by widened TS type.",
 		enum: Object.keys(TypeModifier),
 		type: "string"
+	}, { $ref: "#/$defs/typeReferenceMatcher" }] },
+	typeReferenceMatcher: {
+		additionalProperties: false,
+		anyOf: [{
+			required: ["name"],
+			type: "object"
+		}, {
+			required: ["returns"],
+			type: "object"
+		}],
+		dependencies: { from: ["name"] },
+		description: "Type-reference matcher. Matches when the variable's type resolves to a symbol with the given `name`; if `from` is supplied, the symbol's declaration must also live in a file the specifier resolves to. `returns` instead (or additionally) matches callable types by the return type of their call signatures.",
+		properties: {
+			name: {
+				description: "Symbol name to match (compared against the type's `aliasSymbol` then `symbol`).",
+				minLength: 1,
+				type: "string"
+			},
+			from: {
+				description: "Module specifier the type must originate from. Bare package name (e.g. `@rbxts/jecs`) matches `/node_modules/<from>/` in the declaration path. Path-form (starts with `.`, `/`, or a Windows drive letter) matches the declaration path with extension stripped. Omit to match any source.",
+				minLength: 1,
+				type: "string"
+			},
+			returns: {
+				$ref: "#/$defs/typeReferenceMatcher",
+				description: "Nested matcher applied to call-signature return types. The type matches when at least one call signature's return type satisfies it. Lets anonymous function types (which have no symbol name) be matched, e.g. React components typed `(props: P) => ReactNode`."
+			}
+		},
+		type: "object"
 	},
 	underscoreOptions: {
 		enum: Object.keys(UnderscoreOption),
@@ -1642,7 +2236,7 @@ function selectorSchema(selectorString, allowType, modifiers) {
 	};
 	if (allowType) selector["types"] = {
 		additionalItems: false,
-		items: { $ref: "#/$defs/typeModifiers" },
+		items: { $ref: "#/$defs/typeMatcher" },
 		type: "array"
 	};
 	return [{
@@ -1684,7 +2278,7 @@ function selectorsSchema() {
 			},
 			types: {
 				additionalItems: false,
-				items: { $ref: "#/$defs/typeModifiers" },
+				items: { $ref: "#/$defs/typeMatcher" },
 				type: "array"
 			}
 		},
@@ -1707,7 +2301,7 @@ const SCHEMA = {
 			"unused",
 			"async"
 		]),
-		...selectorSchema("function", false, [
+		...selectorSchema("function", true, [
 			"exported",
 			"global",
 			"unused",
@@ -1767,7 +2361,7 @@ const SCHEMA = {
 			"override",
 			"async"
 		]),
-		...selectorSchema("classMethod", false, [
+		...selectorSchema("classMethod", true, [
 			"abstract",
 			"private",
 			"#private",
@@ -1778,13 +2372,13 @@ const SCHEMA = {
 			"override",
 			"async"
 		]),
-		...selectorSchema("objectLiteralMethod", false, [
+		...selectorSchema("objectLiteralMethod", true, [
 			"public",
 			"requiresQuotes",
 			"async"
 		]),
-		...selectorSchema("typeMethod", false, ["public", "requiresQuotes"]),
-		...selectorSchema("method", false, [
+		...selectorSchema("typeMethod", true, ["public", "requiresQuotes"]),
+		...selectorSchema("method", true, [
 			"abstract",
 			"private",
 			"#private",
@@ -1843,8 +2437,8 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$9 = "naming-convention";
-const messages$9 = {
+const RULE_NAME$11 = "naming-convention";
+const messages$11 = {
 	doesNotMatchFormat: "{{type}} name `{{name}}` must match one of the following formats: {{formats}}",
 	doesNotMatchFormatTrimmed: "{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}",
 	missingAffix: "{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}",
@@ -1874,25 +2468,16 @@ const camelCaseNamingConfig = [
 		selector: "typeLike"
 	}
 ];
-function create$3(contextWithoutDefaults) {
+function create$4(contextWithoutDefaults) {
 	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
 	const validators = parseOptions(context);
-	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
+	const services = getParserServices(context, true);
+	const compilerOptions = services.program?.getCompilerOptions() ?? {};
+	const contextualTypeCache = /* @__PURE__ */ new WeakMap();
 	function handleMember(validator, { key }, modifiers) {
-		if (requiresQuoting$1(key, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
+		if (requiresQuoting(key, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
 		validator(key, modifiers);
 	}
-	function getMemberModifiers(node) {
-		const modifiers = /* @__PURE__ */ new Set();
-		if ("key" in node && node.key.type === AST_NODE_TYPES.PrivateIdentifier) modifiers.add(Modifier["#private"]);
-		else if (node.accessibility) modifiers.add(Modifier[node.accessibility]);
-		else modifiers.add(Modifier.public);
-		if (node.static) modifiers.add(Modifier.static);
-		if ("readonly" in node && node.readonly) modifiers.add(Modifier.readonly);
-		if ("override" in node && node.override) modifiers.add(Modifier.override);
-		if (node.type === AST_NODE_TYPES.TSAbstractPropertyDefinition || node.type === AST_NODE_TYPES.TSAbstractMethodDefinition || node.type === AST_NODE_TYPES.TSAbstractAccessorProperty) modifiers.add(Modifier.abstract);
-		return modifiers;
-	}
 	const { unusedVariables } = collectVariables(context);
 	function isUnused(name, initialScope) {
 		let variable = null;
@@ -1905,52 +2490,6 @@ function create$3(contextWithoutDefaults) {
 		if (!variable) return false;
 		return unusedVariables.has(variable);
 	}
-	function isDestructured(id) {
-		return id.parent.type === AST_NODE_TYPES.Property && id.parent.shorthand || id.parent.type === AST_NODE_TYPES.AssignmentPattern && id.parent.parent.type === AST_NODE_TYPES.Property && id.parent.parent.shorthand;
-	}
-	function isAsyncMemberOrProperty(propertyOrMemberNode) {
-		return Boolean("value" in propertyOrMemberNode && propertyOrMemberNode.value && "async" in propertyOrMemberNode.value && propertyOrMemberNode.value.async);
-	}
-	function isAsyncVariableIdentifier(id) {
-		return Boolean("async" in id.parent && id.parent.async || "init" in id.parent && id.parent.init && "async" in id.parent.init && id.parent.init.async);
-	}
-	/**
-	* Determines if a VariableDeclarator represents an object-style enum declaration.
-	*
-	* Object-style enums are const assertions applied to object expressions, commonly
-	* used as an alternative to TypeScript enums. Examples:
-	* - `const Colors = { RED: 'red', BLUE: 'blue' } as const`
-	* - `const Status = <const>{ OK: 200, ERROR: 500 }`.
-	*
-	* @param node - The VariableDeclarator AST node to check.
-	* @param parent - The parent VariableDeclaration node.
-	* @returns True if this represents an object-style enum declaration.
-	*/
-	function isObjectStyleEnumDeclaration(node, parent) {
-		if (parent.kind !== "const") return false;
-		if (!node.init) return false;
-		if (node.init.type === AST_NODE_TYPES.TSAsExpression && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
-		if (node.init.type === AST_NODE_TYPES.TSTypeAssertion && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
-		return false;
-	}
-	/**
-	* Checks if a method name exists in any of the implemented interfaces.
-	*
-	* @param implementsList - List of implemented interfaces.
-	* @param methodName - Name of the method to check.
-	* @param checker - TypeScript type checker.
-	* @param services - Parser services.
-	* @returns True if the method name is found in any interface.
-	*/
-	function checkInterfacesForMethod(implementsList, methodName, checker, services) {
-		for (const implementsClause of implementsList) {
-			const interfaceType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(implementsClause));
-			if (!interfaceType.getSymbol()) continue;
-			const interfaceMembers = checker.getPropertiesOfType(interfaceType);
-			for (const member of interfaceMembers) if (member.name === methodName) return true;
-		}
-		return false;
-	}
 	/**
 	* Determines if a class method is implementing an interface method.
 	*
@@ -1958,7 +2497,6 @@ function create$3(contextWithoutDefaults) {
 	* @returns True if the method is implementing an interface method.
 	*/
 	function isImplementingInterfaceMethod(node) {
-		const services = getParserServices(context, true);
 		if (!services.program) return false;
 		const checker = services.program.getTypeChecker();
 		let parentClass = null;
@@ -1986,6 +2524,7 @@ function create$3(contextWithoutDefaults) {
 		},
 		":not(ObjectPattern) > Property[computed = false][kind = \"init\"][value.type != \"ArrowFunctionExpression\"][value.type != \"FunctionExpression\"][value.type != \"TSEmptyBodyFunctionExpression\"]": {
 			handler: (node, validator) => {
+				if (isDictatedByContextualType(node, services, contextualTypeCache)) return;
 				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
 			},
 			validator: validators.objectLiteralProperty
@@ -2022,6 +2561,7 @@ function create$3(contextWithoutDefaults) {
 			"Property[computed = false][kind = \"init\"][value.type = \"TSEmptyBodyFunctionExpression\"]"
 		].join(", ")]: {
 			handler: (node, validator) => {
+				if (node.type === AST_NODE_TYPES.Property && isDictatedByContextualType(node, services, contextualTypeCache)) return;
 				const modifiers = /* @__PURE__ */ new Set([Modifier.public]);
 				if (isAsyncMemberOrProperty(node)) modifiers.add(Modifier.async);
 				handleMember(validator, node, modifiers);
@@ -2113,7 +2653,7 @@ function create$3(contextWithoutDefaults) {
 		"TSEnumMember": {
 			handler: ({ id }, validator) => {
 				const modifiers = /* @__PURE__ */ new Set();
-				if (requiresQuoting$1(id, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
+				if (requiresQuoting(id, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
 				validator(id, modifiers);
 			},
 			validator: validators.enumMember
@@ -2192,8 +2732,8 @@ function create$3(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$9,
-	create: create$3,
+	name: RULE_NAME$11,
+	create: create$4,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
 		docs: {
@@ -2203,18 +2743,75 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$9,
+		messages: messages$11,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
 });
+/**
+* Checks if a method name exists in any of the implemented interfaces.
+*
+* @param implementsList - List of implemented interfaces.
+* @param methodName - Name of the method to check.
+* @param checker - TypeScript type checker.
+* @param services - Parser services.
+* @returns True if the method name is found in any interface.
+*/
+function checkInterfacesForMethod(implementsList, methodName, checker, services) {
+	for (const implementsClause of implementsList) {
+		const interfaceType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(implementsClause));
+		if (!interfaceType.getSymbol()) continue;
+		const interfaceMembers = checker.getPropertiesOfType(interfaceType);
+		for (const member of interfaceMembers) if (member.name === methodName) return true;
+	}
+	return false;
+}
 function getIdentifiersFromPattern(pattern) {
 	const identifiers = [];
-	new PatternVisitor({}, pattern, (id) => {
-		identifiers.push(id);
-	}).visit(pattern);
+	const stack = [pattern];
+	for (const node of stack) switch (node.type) {
+		case AST_NODE_TYPES.ArrayPattern:
+			for (const element of node.elements) if (element !== null) stack.push(element);
+			break;
+		case AST_NODE_TYPES.AssignmentPattern:
+			stack.push(node.left);
+			break;
+		case AST_NODE_TYPES.Identifier:
+			identifiers.push(node);
+			break;
+		case AST_NODE_TYPES.ObjectPattern:
+			for (const property of node.properties) stack.push(property);
+			break;
+		case AST_NODE_TYPES.Property:
+			stack.push(node.value);
+			break;
+		case AST_NODE_TYPES.RestElement:
+			stack.push(node.argument);
+			break;
+		default: break;
+	}
 	return identifiers;
 }
+function getMemberModifiers(node) {
+	const modifiers = /* @__PURE__ */ new Set();
+	if ("key" in node && node.key.type === AST_NODE_TYPES.PrivateIdentifier) modifiers.add(Modifier["#private"]);
+	else if (node.accessibility) modifiers.add(Modifier[node.accessibility]);
+	else modifiers.add(Modifier.public);
+	if (node.static) modifiers.add(Modifier.static);
+	if ("readonly" in node && node.readonly) modifiers.add(Modifier.readonly);
+	if ("override" in node && node.override) modifiers.add(Modifier.override);
+	if (node.type === AST_NODE_TYPES.TSAbstractPropertyDefinition || node.type === AST_NODE_TYPES.TSAbstractMethodDefinition || node.type === AST_NODE_TYPES.TSAbstractAccessorProperty) modifiers.add(Modifier.abstract);
+	return modifiers;
+}
+function isAsyncMemberOrProperty(propertyOrMemberNode) {
+	return Boolean("value" in propertyOrMemberNode && propertyOrMemberNode.value && "async" in propertyOrMemberNode.value && propertyOrMemberNode.value.async);
+}
+function isAsyncVariableIdentifier(id) {
+	return Boolean("async" in id.parent && id.parent.async || "init" in id.parent && id.parent.init && "async" in id.parent.init && id.parent.init.async);
+}
+function isDestructured(id) {
+	return id.parent.type === AST_NODE_TYPES.Property && id.parent.shorthand || id.parent.type === AST_NODE_TYPES.AssignmentPattern && id.parent.parent.type === AST_NODE_TYPES.Property && id.parent.parent.shorthand;
+}
 function isExported(node, name, scope) {
 	if (node?.parent?.type === AST_NODE_TYPES.ExportDefaultDeclaration || node?.parent?.type === AST_NODE_TYPES.ExportNamedDeclaration) return true;
 	if (scope === null) return false;
@@ -2229,14 +2826,45 @@ function isGlobal(scope) {
 	if (scope === null) return false;
 	return scope.type === TSESLint.Scope.ScopeType.global || scope.type === TSESLint.Scope.ScopeType.module;
 }
-function requiresQuoting$1(node, target) {
-	return requiresQuoting(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`, target);
+/**
+* Determines if a VariableDeclarator represents an object-style enum declaration.
+*
+* Object-style enums are const assertions applied to object expressions, commonly
+* used as an alternative to TypeScript enums. Examples:
+* - `const Colors = { RED: 'red', BLUE: 'blue' } as const`
+* - `const Status = <const>{ OK: 200, ERROR: 500 }`.
+*
+* @param node - The VariableDeclarator AST node to check.
+* @param parent - The parent VariableDeclaration node.
+* @returns True if this represents an object-style enum declaration.
+*/
+function isObjectStyleEnumDeclaration(node, parent) {
+	if (parent.kind !== "const") return false;
+	if (!node.init) return false;
+	if (node.init.type === AST_NODE_TYPES.TSAsExpression && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
+	if (node.init.type === AST_NODE_TYPES.TSTypeAssertion && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
+	return false;
+}
+function isValidIdentifierText(name, languageVersion) {
+	if (name.length === 0) return false;
+	const firstCodePoint = name.codePointAt(0);
+	if (firstCodePoint === void 0 || !isIdentifierStart(firstCodePoint, languageVersion)) return false;
+	let index = firstCodePoint > 65535 ? 2 : 1;
+	while (index < name.length) {
+		const codePoint = name.codePointAt(index);
+		if (codePoint === void 0 || !isIdentifierPart(codePoint, languageVersion)) return false;
+		index += codePoint > 65535 ? 2 : 1;
+	}
+	return true;
+}
+function requiresQuoting(node, target) {
+	return !isValidIdentifierText(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`, target ?? ScriptTarget.Latest);
 }
 //#endregion
 //#region src/rules/no-export-default-arrow/rule.ts
-const RULE_NAME$8 = "no-export-default-arrow";
-const MESSAGE_ID$4 = "disallowExportDefaultArrow";
-const messages$8 = { [MESSAGE_ID$4]: "Assign the arrow function to a named constant instead of exporting it anonymously." };
+const RULE_NAME$10 = "no-export-default-arrow";
+const MESSAGE_ID$6 = "disallowExportDefaultArrow";
+const messages$10 = { [MESSAGE_ID$6]: "Assign the arrow function to a named constant instead of exporting it anonymously." };
 /**
 * Converts a filename stem to camelCase, treating `-`, `_`, and whitespace as
 * word separators (`use-mouse` -> `useMouse`).
@@ -2314,7 +2942,7 @@ function createFixFunction({ arrowFunction, context, exportDeclaration, sourceCo
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$5(context) {
+function createOnce$6(context) {
 	return { ArrowFunctionExpression(node) {
 		const { parent } = node;
 		if (parent.type !== AST_NODE_TYPES.ExportDefaultDeclaration) return;
@@ -2325,14 +2953,14 @@ function createOnce$5(context) {
 				exportDeclaration: parent,
 				sourceCode: context.sourceCode
 			}),
-			messageId: MESSAGE_ID$4,
+			messageId: MESSAGE_ID$6,
 			node
 		});
 	} };
 }
 const noExportDefaultArrow = createFlawlessRule({
-	name: RULE_NAME$8,
-	createOnce: createOnce$5,
+	name: RULE_NAME$10,
+	createOnce: createOnce$6,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -2342,7 +2970,391 @@ const noExportDefaultArrow = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$8,
+		messages: messages$10,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/no-redundant-tsconfig-options/resolve-extends.ts
+const TOP_LEVEL_KEYS = [
+	"include",
+	"exclude",
+	"files"
+];
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Resolves one `extends` specifier to an absolute config path, or `undefined`
+* when it cannot be found. Path specifiers resolve against the extending file's
+* directory (appending `.json` or `/tsconfig.json` as TypeScript does); package
+* specifiers go through `require.resolve`, which honours the package `exports`
+* map (so `@scope/pkg/subpath` maps correctly).
+*
+* @param spec - The raw `extends` specifier.
+* @param fromFile - The absolute path of the config doing the extending.
+* @returns The resolved absolute path, or `undefined`.
+*/
+function resolveExtendsTarget(spec, fromFile) {
+	if (isPathSpecifier(spec)) {
+		const base = path.resolve(path.dirname(fromFile), spec);
+		return (base.endsWith(".json") ? [base] : [`${base}.json`, path.join(base, "tsconfig.json")]).find((candidate) => fileExists(candidate));
+	}
+	const require = createRequire(fromFile);
+	for (const candidate of [
+		spec,
+		`${spec}.json`,
+		`${spec}/tsconfig.json`
+	]) try {
+		return require.resolve(candidate);
+	} catch {}
+}
+/**
+* Builds the config a child inherits from its `extends` targets alone (the child
+* itself excluded). Later targets in an `extends` array override earlier ones,
+* matching TypeScript's precedence.
+*
+* @param childFile - The absolute path of the config being linted.
+* @param extendsField - The child's raw `extends` value (string or array).
+* @returns The inherited config, or `undefined` when nothing resolves.
+*/
+function buildInheritedConfig(childFile, extendsField) {
+	const context = {
+		cache: /* @__PURE__ */ new Map(),
+		stack: /* @__PURE__ */ new Set([childFile])
+	};
+	const result = emptyConfig();
+	let resolvedAny = false;
+	for (const spec of normalizeExtends(extendsField)) {
+		const target = resolveExtendsTarget(spec, childFile);
+		if (target === void 0) continue;
+		resolvedAny = true;
+		mergeParent(result, flatten(target, context));
+	}
+	return resolvedAny ? result : void 0;
+}
+/**
+* Whether an `extends` specifier is a filesystem path (relative or absolute)
+* rather than a package specifier. Matches TypeScript: a leading `.` or a rooted
+* path is a path; anything else resolves through node module resolution.
+*
+* @param spec - The raw `extends` specifier.
+* @returns True when the specifier should resolve against the filesystem.
+*/
+function isPathSpecifier(spec) {
+	return spec.startsWith(".") || path.isAbsolute(spec);
+}
+function fileExists(candidate) {
+	try {
+		return statSync(candidate).isFile();
+	} catch {
+		return false;
+	}
+}
+function normalizeExtends(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.filter((entry) => typeof entry === "string");
+	return [];
+}
+function emptyConfig() {
+	return {
+		compilerOptions: /* @__PURE__ */ new Map(),
+		topLevel: /* @__PURE__ */ new Map()
+	};
+}
+function mergeInto(target, source) {
+	for (const [key, entry] of source) target.set(key, entry);
+}
+function mergeParent(into, parent) {
+	mergeInto(into.compilerOptions, parent.compilerOptions);
+	mergeInto(into.topLevel, parent.topLevel);
+}
+function parseTsconfig(file) {
+	try {
+		const { ast } = parseForESLint(readFileSync(file, "utf8"), {});
+		const statement = ast.body.at(0);
+		if (statement?.expression.type !== "JSONObjectExpression") return;
+		const value = getStaticJSONValue(statement.expression);
+		return isRecord(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Reads and parses a parent tsconfig from disk. Returns `undefined` for any
+* failure — missing file, unreadable, invalid JSONC, or a top level that is not
+* an object — so a broken ancestor never crashes the lint.
+*
+* @param file - The absolute path of the config to read.
+* @param cache - Per-resolution parse cache, keyed by absolute path.
+* @returns The parsed config subset, or `undefined`.
+*/
+function readTsconfig(file, cache) {
+	if (cache.has(file)) return cache.get(file);
+	const parsed = parseTsconfig(file);
+	cache.set(file, parsed);
+	return parsed;
+}
+function overlay(target, options, source) {
+	if (!isRecord(options)) return;
+	for (const [key, value] of Object.entries(options)) target.set(key, {
+		source,
+		value
+	});
+}
+/**
+* Flattens the effective config a file resolves to — its own extends chain,
+* overlaid by its own values (a file's own options win over what it extends).
+* The `visited` set guards against circular `extends`.
+*
+* @param file - The absolute path of the config to flatten.
+* @param context - The shared cycle stack and parse cache.
+* @returns The flattened config, with each entry's `source` naming its definer.
+*/
+function flatten(file, context) {
+	const result = emptyConfig();
+	if (context.stack.has(file)) return result;
+	context.stack.add(file);
+	try {
+		const config = readTsconfig(file, context.cache);
+		if (config === void 0) return result;
+		for (const spec of normalizeExtends(config.extends)) {
+			const target = resolveExtendsTarget(spec, file);
+			if (target !== void 0) mergeParent(result, flatten(target, context));
+		}
+		overlay(result.compilerOptions, config.compilerOptions, file);
+		for (const key of TOP_LEVEL_KEYS) if (config[key] !== void 0) result.topLevel.set(key, {
+			source: file,
+			value: config[key]
+		});
+		return result;
+	} finally {
+		context.stack.delete(file);
+	}
+}
+//#endregion
+//#region src/rules/no-redundant-tsconfig-options/rule.ts
+const RULE_NAME$9 = "no-redundant-tsconfig-options";
+const MESSAGE_ID$5 = "redundant";
+/**
+* Compiler options TypeScript resolves case-insensitively; a child that re-sets
+* one differing only in case is still redundant.
+*/
+const ENUM_SCALAR_KEYS = /* @__PURE__ */ new Set([
+	"jsx",
+	"module",
+	"moduleDetection",
+	"moduleResolution",
+	"newLine",
+	"target"
+]);
+/**
+* Array-valued options TypeScript treats as unordered sets, so a reordered but
+* otherwise identical value is still redundant.
+*/
+const SET_KEYS = /* @__PURE__ */ new Set(["lib", "types"]);
+/**
+* `compilerOptions` keys whose values are resolved as paths relative to the
+* config that declares them. An identical value repeated in a child in a
+* different directory means a different path, so these are only redundant when
+* the value is location-independent (see {@link isLocationIndependent}).
+*/
+const PATH_KEYS = /* @__PURE__ */ new Set([
+	"baseUrl",
+	"declarationDir",
+	"outDir",
+	"outFile",
+	"paths",
+	"rootDir",
+	"rootDirs",
+	"tsBuildInfoFile",
+	"typeRoots"
+]);
+const messages$9 = { [MESSAGE_ID$5]: "'{{option}}' is redundant: it is already set to this value by {{source}}. Remove it." };
+/**
+* Structural equality between two static JSON values. Strings compare
+* case-insensitively when `caseInsensitive` is set (used for enum-valued
+* options and `lib` entries, which TypeScript itself folds).
+*
+* @param a - The child's value.
+* @param b - The inherited value.
+* @param caseInsensitive - Whether string scalars compare case-insensitively.
+* @returns Whether the two values are equal.
+*/
+function equalValues(a, b, caseInsensitive) {
+	if (typeof a === "string" && typeof b === "string") return caseInsensitive ? a.toLowerCase() === b.toLowerCase() : a === b;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, index) => equalValues(item, b[index], caseInsensitive));
+	if (isRecord(a) && isRecord(b)) {
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		return aKeys.length === bKeys.length && aKeys.every((key) => key in b && equalValues(a[key], b[key], caseInsensitive));
+	}
+	return a === b;
+}
+/**
+* Set equality for two arrays: same length and every element of one has a
+* distinct equal counterpart in the other, ignoring order.
+*
+* @param a - The child's array.
+* @param b - The inherited array.
+* @param caseInsensitive - Whether string elements compare case-insensitively.
+* @returns Whether the arrays hold the same elements regardless of order.
+*/
+function equalUnordered(a, b, caseInsensitive) {
+	if (a.length !== b.length) return false;
+	const remaining = [...b];
+	for (const item of a) {
+		const index = remaining.findIndex((other) => equalValues(item, other, caseInsensitive));
+		if (index === -1) return false;
+		remaining.splice(index, 1);
+	}
+	return true;
+}
+/**
+* Whether a path-valued option is location-independent — every path string it
+* contains is either `${configDir}`-anchored (re-anchored to the extending
+* config, so an identical value resolves to the same files) or absolute. Only
+* then is repeating a path option genuinely redundant.
+*
+* @param value - The option value.
+* @returns Whether the value resolves the same regardless of config location.
+*/
+function isLocationIndependent(value) {
+	if (typeof value === "string") return value.includes("${configDir}") || path.isAbsolute(value);
+	if (Array.isArray(value)) return value.every((item) => isLocationIndependent(item));
+	if (isRecord(value)) return Object.values(value).every((item) => isLocationIndependent(item));
+	return true;
+}
+/**
+* Whether a child option re-setting `inherited` to `childValue` is redundant:
+* the values are equal and, for path-valued options, location-independent.
+*
+* @param key - The option name.
+* @param childValue - The value the child sets.
+* @param inherited - The inherited value.
+* @param isPathKey - Whether the key is path-valued.
+* @returns Whether the child option is redundant.
+*/
+function isRedundant(key, childValue, inherited, isPathKey) {
+	const caseInsensitive = key === "lib" || ENUM_SCALAR_KEYS.has(key);
+	if (!(SET_KEYS.has(key) && Array.isArray(childValue) && Array.isArray(inherited) ? equalUnordered(childValue, inherited, caseInsensitive) : equalValues(childValue, inherited, caseInsensitive))) return false;
+	return !isPathKey || isLocationIndependent(childValue);
+}
+function keyName({ key }) {
+	return key.type === "JSONIdentifier" ? key.name : String(getStaticJSONValue(key));
+}
+function findProperty(object, name) {
+	return object.properties.find((property) => keyName(property) === name);
+}
+/**
+* Reads a node's static value, returning `undefined` when it cannot be evaluated
+* (such as an exotic non-JSON node), so an odd value never crashes the rule. The
+* result is boxed so a genuine `undefined` value stays distinguishable.
+*
+* @param node - The value node to evaluate.
+* @returns A box holding the value, or `undefined` on failure.
+*/
+function safeStaticValue(node) {
+	try {
+		return { value: getStaticJSONValue(node) };
+	} catch {
+		return;
+	}
+}
+function create$3(context) {
+	const { sourceCode } = context;
+	if (sourceCode.parserServices.isJSON !== true) return {};
+	const { filename } = context;
+	if (!path.isAbsolute(filename)) return {};
+	/**
+	* Reports a redundant property, removing it (with its delimiter comma) unless
+	* a comment is attached, in which case it reports without a fix to avoid
+	* stranding the comment.
+	*
+	* @param property - The redundant property node.
+	* @param name - The property's key name (already computed by the caller).
+	* @param entry - The inherited value and the config that defined it.
+	*/
+	function report(property, name, entry) {
+		const relative = path.relative(path.dirname(filename), entry.source) || entry.source;
+		context.report({
+			data: {
+				option: name,
+				source: relative.split(path.sep).join("/")
+			},
+			fix: buildFix(property),
+			loc: property.key.loc,
+			messageId: MESSAGE_ID$5
+		});
+	}
+	function buildFix(property) {
+		const node = property;
+		const before = sourceCode.getTokenBefore(node);
+		const after = sourceCode.getTokenAfter(node);
+		const leading = sourceCode.getCommentsBefore(node);
+		const between = sourceCode.getCommentsAfter(node);
+		const trailing = after?.value === "," ? sourceCode.getCommentsAfter(after).filter((comment) => comment.loc.start.line === after.loc.end.line) : [];
+		if (leading.length > 0 || between.length > 0 || trailing.length > 0) return;
+		let start;
+		let end;
+		if (after?.value === ",") {
+			start = before?.range[1] ?? property.range[0];
+			end = after.range[1];
+		} else if (before?.value === ",") {
+			start = before.range[0];
+			end = property.range[1];
+		} else {
+			start = before?.range[1] ?? property.range[0];
+			end = property.range[1];
+		}
+		return (fixer) => fixer.removeRange([start, end]);
+	}
+	function checkObject(object, lookup, isPathKey) {
+		for (const property of object.properties) {
+			const name = keyName(property);
+			const entry = lookup(name);
+			if (entry === void 0) continue;
+			const childValue = safeStaticValue(property.value);
+			if (childValue !== void 0 && isRedundant(name, childValue.value, entry.value, isPathKey(name))) report(property, name, entry);
+		}
+	}
+	return { Program() {
+		const statement = sourceCode.ast.body.at(0);
+		if (statement?.expression.type !== "JSONObjectExpression") return;
+		const root = statement.expression;
+		const extendsProperty = findProperty(root, "extends");
+		if (extendsProperty === void 0) return;
+		const extendsValue = safeStaticValue(extendsProperty.value);
+		if (extendsValue === void 0) return;
+		const inherited = buildInheritedConfig(filename, extendsValue.value);
+		if (inherited === void 0) return;
+		const compilerOptions = findProperty(root, "compilerOptions");
+		if (compilerOptions?.value.type === "JSONObjectExpression") checkObject(compilerOptions.value, (name) => {
+			return inherited.compilerOptions.get(name);
+		}, (name) => {
+			return PATH_KEYS.has(name);
+		});
+		checkObject(root, (name) => {
+			return inherited.topLevel.get(name);
+		}, () => {
+			return true;
+		});
+	} };
+}
+const noRedundantTsconfigOptions = createEslintRule({
+	name: RULE_NAME$9,
+	create: create$3,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow tsconfig options that redundantly re-set a value already provided by an extended config",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$9,
 		schema: [],
 		type: "suggestion"
 	}
@@ -2585,15 +3597,15 @@ function resolveFactory(sourceCode, node) {
 }
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.ts
-const RULE_NAME$7 = "no-unnecessary-use-callback";
+const RULE_NAME$8 = "no-unnecessary-use-callback";
 const MESSAGE_ID_DEFAULT$1 = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
-const messages$7 = {
+const messages$8 = {
 	[MESSAGE_ID_DEFAULT$1]: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary.",
 	[MESSAGE_ID_INSIDE_USE_EFFECT$1]: "'{{name}}' is only used inside 1 useEffect, which may be unnecessary. You can move the computation into useEffect directly and merge the dependency arrays."
 };
 const noUnnecessaryUseCallback = createFlawlessRule({
-	name: RULE_NAME$7,
+	name: RULE_NAME$8,
 	createOnce: createUnnecessaryHookRule({
 		hook: "useCallback",
 		messageIds: {
@@ -2609,22 +3621,22 @@ const noUnnecessaryUseCallback = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$7,
+		messages: messages$8,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/no-unnecessary-use-memo/rule.ts
-const RULE_NAME$6 = "no-unnecessary-use-memo";
+const RULE_NAME$7 = "no-unnecessary-use-memo";
 const MESSAGE_ID_DEFAULT = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
-const messages$6 = {
+const messages$7 = {
 	[MESSAGE_ID_DEFAULT]: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary.",
 	[MESSAGE_ID_INSIDE_USE_EFFECT]: "'{{name}}' is only used inside 1 useEffect, which may be unnecessary. You can move the computation into useEffect directly and merge the dependency arrays."
 };
 const noUnnecessaryUseMemo = createFlawlessRule({
-	name: RULE_NAME$6,
+	name: RULE_NAME$7,
 	createOnce: createUnnecessaryHookRule({
 		hook: "useMemo",
 		messageIds: {
@@ -2640,12 +3652,132 @@ const noUnnecessaryUseMemo = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$6,
+		messages: messages$7,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
+//#region src/rules/padding-after-expect-assertions/rule.ts
+const RULE_NAME$6 = "padding-after-expect-assertions";
+const MESSAGE_ID$4 = "missingPadding";
+const messages$6 = { [MESSAGE_ID$4]: "Expected a blank line after '{{name}}'." };
+/**
+* Matches a statement that declares the expected assertion count at the top of
+* a test: `expect.assertions(n)` or `expect.hasAssertions()`.
+*
+* Detection is purely syntactic (a non-computed `expect.assertions` /
+* `expect.hasAssertions` call) with no scope analysis, mirroring the deliberate
+* looseness of `@vitest/eslint-plugin`'s own padding rules. A shadowed local
+* `expect` is vanishingly rare, and the only consequence is a harmless blank
+* line.
+*
+* @param node - The expression statement to inspect.
+* @returns The matched member name (`expect.assertions` / `expect.hasAssertions`)
+*   for the message, or `undefined` when the statement is not an assertion count.
+*/
+function getAssertionName({ expression }) {
+	if (expression.type !== AST_NODE_TYPES.CallExpression) return;
+	const { callee } = expression;
+	if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES.Identifier || callee.object.name !== "expect" || callee.property.type !== AST_NODE_TYPES.Identifier) return;
+	const { name } = callee.property;
+	if (name !== "assertions" && name !== "hasAssertions") return;
+	return `expect.${name}`;
+}
+/**
+* Returns the statement list that directly contains a node, so its following
+* sibling can be found. The assertion count opens an `it`/`test` callback body
+* (a `BlockStatement`) or, at worst, sits at the top level (`Program`).
+*
+* @param node - The node whose containing list is wanted.
+* @returns The sibling statements, or `undefined` when the parent holds no list.
+*/
+function getContainingList({ parent }) {
+	if (parent.type === AST_NODE_TYPES.BlockStatement || parent.type === AST_NODE_TYPES.Program) return parent.body;
+}
+/**
+* Locates the two tokens the padding is measured and inserted between: the last
+* token of the assertion statement (advanced past any trailing comment on the
+* same line) and the first token of the following statement (a leading comment
+* included). This mirrors ESLint core's `padding-line-between-statements`, so a
+* trailing `// note` does not defeat the rule and the fix lands in the right
+* place. Note that `yaml-block-key-blank-lines` deliberately takes the opposite
+* stance and bails on comments, since rewriting there would re-attach them.
+*
+* @param sourceCode - The source code, for token lookups.
+* @param node - The assertion statement.
+* @param nextNode - The statement that follows it.
+* @returns The anchor tokens, or `undefined` when either cannot be resolved.
+*/
+function findPaddingAnchor(sourceCode, node, nextNode) {
+	const lastToken = sourceCode.getLastToken(node);
+	if (lastToken === null) return;
+	let previousToken = lastToken;
+	const nextToken = sourceCode.getFirstTokenBetween(previousToken, nextNode, {
+		filter(token) {
+			if (ASTUtils.isTokenOnSameLine(previousToken, token)) {
+				previousToken = token;
+				return false;
+			}
+			return true;
+		},
+		includeComments: true
+	}) ?? sourceCode.getFirstToken(nextNode);
+	if (nextToken === null) return;
+	return {
+		nextToken,
+		previousToken
+	};
+}
+/**
+* Requires a blank line after the assertion count that opens a test, keeping the
+* bookkeeping visually separate from the expectations that follow.
+*
+* @param context - The rule context.
+* @returns The rule listener.
+*/
+function createOnce$3(context) {
+	return { ExpressionStatement(node) {
+		const name = getAssertionName(node);
+		if (name === void 0) return;
+		const list = getContainingList(node);
+		if (list === void 0) return;
+		const nextNode = list[list.indexOf(node) + 1];
+		if (nextNode === void 0) return;
+		const { sourceCode } = context;
+		const anchor = findPaddingAnchor(sourceCode, node, nextNode);
+		if (anchor === void 0) return;
+		const { nextToken, previousToken } = anchor;
+		const gap = nextToken.loc.start.line - previousToken.loc.end.line;
+		if (gap > 1) return;
+		context.report({
+			data: { name },
+			fix(fixer) {
+				return fixer.insertTextAfter(previousToken, gap === 0 ? "\n\n" : "\n");
+			},
+			loc: node.loc,
+			messageId: MESSAGE_ID$4
+		});
+	} };
+}
+const paddingAfterExpectAssertions = createFlawlessRule({
+	name: RULE_NAME$6,
+	createOnce: createOnce$3,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Enforce a blank line after `expect.assertions` and `expect.hasAssertions`",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		messages: messages$6,
+		schema: [],
+		type: "layout"
+	}
+});
+//#endregion
 //#region src/rules/prefer-destructuring-assignment/rule.ts
 const RULE_NAME$5 = "prefer-destructuring-assignment";
 const MESSAGE_ID$3 = "default";
@@ -4209,10 +5341,13 @@ const plugin = {
 		"arrow-return-style": arrowReturnStyle,
 		"jsx-shorthand-boolean": jsxShorthandBoolean,
 		"jsx-shorthand-fragment": jsxShorthandFragment,
+		"max-lines-per-function": maxLinesPerFunction,
 		"naming-convention": namingConvention,
 		"no-export-default-arrow": noExportDefaultArrow,
+		"no-redundant-tsconfig-options": noRedundantTsconfigOptions,
 		"no-unnecessary-use-callback": noUnnecessaryUseCallback,
 		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
+		"padding-after-expect-assertions": paddingAfterExpectAssertions,
 		"prefer-destructuring-assignment": preferDestructuringAssignment,
 		"prefer-parameter-destructuring": preferParameterDestructuring,
 		"prefer-read-only-props": preferReadOnlyProps,