eslint-plugin-flawless 1.0.0 → 1.2.0

package/dist/{plugin-DFLOyhkl.mjs → plugin-K2GOCG3Z.mjs}

@@ -1,21 +1,20 @@
 import { createRequire } from "node:module";
-import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
+import { ASTUtils, AST_NODE_TYPES, AST_TOKEN_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
 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 { findVariable, isArrowToken, isOpeningParenToken } from "@typescript-eslint/utils/ast-utils";
-import { DefinitionType, ImplicitLibVariable, PatternVisitor, ScopeType, Visitor } from "@typescript-eslint/scope-manager";
-import { requiresQuoting } from "@typescript-eslint/type-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 ts9 from "typescript";
 import { getStaticTOMLValue } from "toml-eslint-parser";
 //#region package.json
 var name = "eslint-plugin-flawless";
-var version = "1.0.0";
+var version = "1.2.0";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -85,7 +84,7 @@ function createFlawlessRule({ createOnce, ...meta }) {
 }
 //#endregion
 //#region src/rules/arrow-return-style/rule.ts
-const RULE_NAME$15 = "arrow-return-style";
+const RULE_NAME$16 = "arrow-return-style";
 const IMPLICIT = "useImplicitReturn";
 const EXPLICIT = "useExplicitReturn";
 const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
@@ -233,7 +232,7 @@ function collectArrows(root) {
 	return arrows.sort((a, b) => a.range[0] - b.range[0]);
 }
 const arrowReturnStyle = createFlawlessRule({
-	name: RULE_NAME$15,
+	name: RULE_NAME$16,
 	createOnce(context) {
 		let config = DEFAULTS$1;
 		let sourceCode;
@@ -599,10 +598,10 @@ const arrowReturnStyle = createFlawlessRule({
 });
 //#endregion
 //#region src/rules/jsx-shorthand-boolean/rule.ts
-const RULE_NAME$14 = "jsx-shorthand-boolean";
+const RULE_NAME$15 = "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) {
+const messages$15 = { [MESSAGE_ID$7]: "Set an explicit value for boolean attribute '{{name}}'." };
+function createOnce$10(context) {
 	return { JSXAttribute(node) {
 		if (node.value !== null) return;
 		context.report({
@@ -614,8 +613,8 @@ function createOnce$9(context) {
 	} };
 }
 const jsxShorthandBoolean = createFlawlessRule({
-	name: RULE_NAME$14,
-	createOnce: createOnce$9,
+	name: RULE_NAME$15,
+	createOnce: createOnce$10,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -625,19 +624,19 @@ const jsxShorthandBoolean = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$14,
+		messages: messages$15,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$13 = "jsx-shorthand-fragment";
+const RULE_NAME$14 = "jsx-shorthand-fragment";
 const MESSAGE_ID_NAMED = "useNamedFragment";
 const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
 const DEFAULT_MODE = "syntax";
 const DEFAULT_FRAGMENT_NAME = "Fragment";
-const messages$13 = {
+const messages$14 = {
 	[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."
 };
@@ -673,7 +672,7 @@ function jsxNameToString(node) {
 	}
 	return null;
 }
-function createOnce$8(context) {
+function createOnce$9(context) {
 	let mode;
 	let fragmentName;
 	let namedFragments;
@@ -720,8 +719,8 @@ function createOnce$8(context) {
 	};
 }
 const jsxShorthandFragment = createFlawlessRule({
-	name: RULE_NAME$13,
-	createOnce: createOnce$8,
+	name: RULE_NAME$14,
+	createOnce: createOnce$9,
 	defaultOptions: [{
 		fragmentName: DEFAULT_FRAGMENT_NAME,
 		mode: DEFAULT_MODE
@@ -738,7 +737,7 @@ const jsxShorthandFragment = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$13,
+		messages: messages$14,
 		schema: schema$3,
 		type: "suggestion"
 	}
@@ -878,7 +877,7 @@ function getOpeningParenOfParameters(node, sourceCode) {
 }
 //#endregion
 //#region src/rules/max-lines-per-function/rule.ts
-const RULE_NAME$12 = "max-lines-per-function";
+const RULE_NAME$13 = "max-lines-per-function";
 const MESSAGE_ID_EXCEED = "exceed";
 /** A line that is empty or holds only whitespace. */
 const BLANK_LINE = /^\s*$/u;
@@ -889,7 +888,7 @@ const DEFAULTS = {
 	skipBlankLines: false,
 	skipComments: false
 };
-const messages$12 = { [MESSAGE_ID_EXCEED]: "{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}." };
+const messages$13 = { [MESSAGE_ID_EXCEED]: "{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}." };
 const schema$2 = [{
 	additionalProperties: false,
 	properties: {
@@ -992,7 +991,7 @@ function getCountedLoc(countFrom, funcNode, reportNode) {
 * @param context - The rule context.
 * @returns The visitors measuring each function.
 */
-function createOnce$7(context) {
+function createOnce$8(context) {
 	let commentLineNumbers;
 	let config;
 	let lines;
@@ -1048,8 +1047,8 @@ function createOnce$7(context) {
 	};
 }
 const maxLinesPerFunction = createFlawlessRule({
-	name: RULE_NAME$12,
-	createOnce: createOnce$7,
+	name: RULE_NAME$13,
+	createOnce: createOnce$8,
 	defaultOptions: [DEFAULTS],
 	meta: {
 		defaultOptions: [DEFAULTS],
@@ -1059,7 +1058,7 @@ const maxLinesPerFunction = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$12,
+		messages: messages$13,
 		schema: schema$2,
 		type: "suggestion"
 	}
@@ -1539,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,
@@ -1588,7 +1658,8 @@ const Modifier = {
 	"override": 8192,
 	"async": 16384,
 	"default": 32768,
-	"namespace": 65536
+	"namespace": 65536,
+	"constAsserted": 131072
 };
 const PredefinedFormat = {
 	camelCase: 1,
@@ -1600,13 +1671,15 @@ const PredefinedFormat = {
 };
 const PredefinedFormatValueToKey = Object.fromEntries(Object.entries(PredefinedFormat).map(([key, value]) => [value, key]));
 const TypeModifier = {
-	boolean: 131072,
-	string: 262144,
-	number: 524288,
-	function: 1048576,
-	array: 2097152
+	boolean: 262144,
+	string: 524288,
+	number: 1048576,
+	function: 2097152,
+	array: 4194304
 };
 const TypeModifierValueToKey = Object.fromEntries(Object.entries(TypeModifier).map(([key, value]) => [value, key]));
+const TYPE_REFERENCE_LOOSE_WEIGHT = 1 << 23;
+const TYPE_REFERENCE_STRICT_WEIGHT = 1 << 24;
 const UnderscoreOption = {
 	forbid: 1,
 	allow: 2,
@@ -1701,7 +1774,7 @@ function createValidator(type, context, allConfigs) {
 		if (!aIsMethodOrProperty && bIsMethodOrProperty) return 1;
 		return b.selector - a.selector;
 	});
-	return (node, modifiers = /* @__PURE__ */ new Set()) => {
+	return (node, modifiers = /* @__PURE__ */ new Set(), isObjectStyleEnumName = false) => {
 		const originalName = node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`;
 		for (const config of configs) {
 			if (config.filter?.regex.test(originalName) !== config.filter?.match) continue;
@@ -1711,6 +1784,7 @@ function createValidator(type, context, allConfigs) {
 			name = validateUnderscore({
 				name,
 				config,
+				isObjectStyleEnumName,
 				node,
 				originalName,
 				position: "leading"
@@ -1719,6 +1793,7 @@ function createValidator(type, context, allConfigs) {
 			name = validateUnderscore({
 				name,
 				config,
+				isObjectStyleEnumName,
 				node,
 				originalName,
 				position: "trailing"
@@ -1727,6 +1802,7 @@ function createValidator(type, context, allConfigs) {
 			name = validateAffix({
 				name,
 				config,
+				isObjectStyleEnumName,
 				node,
 				originalName,
 				position: "prefix"
@@ -1735,6 +1811,7 @@ function createValidator(type, context, allConfigs) {
 			name = validateAffix({
 				name,
 				config,
+				isObjectStyleEnumName,
 				node,
 				originalName,
 				position: "suffix"
@@ -1743,12 +1820,14 @@ function createValidator(type, context, allConfigs) {
 			if (!validateCustom({
 				name,
 				config,
+				isObjectStyleEnumName,
 				node,
 				originalName
 			})) return;
 			if (!validatePredefinedFormat({
 				name,
 				config,
+				isObjectStyleEnumName,
 				modifiers,
 				node,
 				originalName
@@ -1772,7 +1851,7 @@ function createValidator(type, context, allConfigs) {
 			type: selectorTypeToMessageString(type)
 		};
 	}
-	function validateUnderscore({ name, config, node, originalName, position }) {
+	function validateUnderscore({ name, config, isObjectStyleEnumName, node, originalName, position }) {
 		const option = position === "leading" ? config.leadingUnderscore : config.trailingUnderscore;
 		if (!option) return name;
 		const hasSingleUnderscore = position === "leading" ? () => name.startsWith("_") : () => name.endsWith("_");
@@ -1798,7 +1877,7 @@ function createValidator(type, context, allConfigs) {
 							originalName,
 							position
 						}),
-						messageId: "unexpectedUnderscore",
+						messageId: pickMessageId("unexpectedUnderscore", isObjectStyleEnumName),
 						node
 					});
 					return;
@@ -1812,7 +1891,7 @@ function createValidator(type, context, allConfigs) {
 							originalName,
 							position
 						}),
-						messageId: "missingUnderscore",
+						messageId: pickMessageId("missingUnderscore", isObjectStyleEnumName),
 						node
 					});
 					return;
@@ -1826,7 +1905,7 @@ function createValidator(type, context, allConfigs) {
 							originalName,
 							position
 						}),
-						messageId: "missingUnderscore",
+						messageId: pickMessageId("missingUnderscore", isObjectStyleEnumName),
 						node
 					});
 					return;
@@ -1834,7 +1913,7 @@ function createValidator(type, context, allConfigs) {
 				return trimDoubleUnderscore();
 		}
 	}
-	function validateAffix({ name, config, node, originalName, position }) {
+	function validateAffix({ name, config, isObjectStyleEnumName, node, originalName, position }) {
 		const affixes = config[position];
 		if (!affixes || affixes.length === 0) return name;
 		for (const affix of affixes) {
@@ -1848,11 +1927,11 @@ function createValidator(type, context, allConfigs) {
 				originalName,
 				position
 			}),
-			messageId: "missingAffix",
+			messageId: pickMessageId("missingAffix", isObjectStyleEnumName),
 			node
 		});
 	}
-	function validateCustom({ name, config, node, originalName }) {
+	function validateCustom({ name, config, isObjectStyleEnumName, node, originalName }) {
 		const { custom } = config;
 		if (!custom) return true;
 		const result = custom.regex.test(name);
@@ -1863,12 +1942,12 @@ function createValidator(type, context, allConfigs) {
 				custom,
 				originalName
 			}),
-			messageId: "satisfyCustom",
+			messageId: pickMessageId("satisfyCustom", isObjectStyleEnumName),
 			node
 		});
 		return false;
 	}
-	function validatePredefinedFormat({ name, config, modifiers, node, originalName }) {
+	function validatePredefinedFormat({ name, config, isObjectStyleEnumName, modifiers, node, originalName }) {
 		const formats = config.format;
 		if (!formats || formats.length === 0) return true;
 		if (!modifiers.has(Modifier.requiresQuotes)) for (const format of formats) {
@@ -1881,37 +1960,150 @@ function createValidator(type, context, allConfigs) {
 				originalName,
 				processedName: name
 			}),
-			messageId: originalName === name ? "doesNotMatchFormat" : "doesNotMatchFormatTrimmed",
+			messageId: pickMessageId(originalName === name ? "doesNotMatchFormat" : "doesNotMatchFormatTrimmed", isObjectStyleEnumName),
 			node
 		});
 		return false;
 	}
 }
-const SelectorsAllowedToHaveTypes = Selector.variable | Selector.parameter | Selector.classProperty | Selector.objectLiteralProperty | Selector.typeProperty | Selector.parameterProperty | Selector.classicAccessor;
+/**
+* Picks the `*ForeignContract` variant of a message id when the name belongs
+* to an `objectStyleEnum` - a plain object literal, not a real enum, so the
+* violation message should point at the `satisfies` escape instead of a
+* rename.
+*
+* @param baseMessageId - The base message id for the violation kind.
+* @param isObjectStyleEnumName - Whether the name is an objectStyleEnum
+*   container or key.
+* @returns The message id to report.
+*/
+function pickMessageId(baseMessageId, isObjectStyleEnumName) {
+	return isObjectStyleEnumName ? `${baseMessageId}ForeignContract` : baseMessageId;
+}
+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
@@ -1919,10 +2111,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 ? {
@@ -1943,7 +2147,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 {
@@ -1981,9 +2185,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),
@@ -2023,7 +2257,7 @@ function selectorSchema(selectorString, allowType, modifiers) {
 	};
 	if (allowType) selector["types"] = {
 		additionalItems: false,
-		items: { $ref: "#/$defs/typeModifiers" },
+		items: { $ref: "#/$defs/typeMatcher" },
 		type: "array"
 	};
 	return [{
@@ -2065,7 +2299,7 @@ function selectorsSchema() {
 			},
 			types: {
 				additionalItems: false,
-				items: { $ref: "#/$defs/typeModifiers" },
+				items: { $ref: "#/$defs/typeMatcher" },
 				type: "array"
 			}
 		},
@@ -2082,13 +2316,14 @@ const SCHEMA = {
 		...selectorSchema("variableLike", false, ["unused", "async"]),
 		...selectorSchema("variable", true, [
 			"const",
+			"constAsserted",
 			"destructured",
 			"exported",
 			"global",
 			"unused",
 			"async"
 		]),
-		...selectorSchema("function", false, [
+		...selectorSchema("function", true, [
 			"exported",
 			"global",
 			"unused",
@@ -2148,7 +2383,7 @@ const SCHEMA = {
 			"override",
 			"async"
 		]),
-		...selectorSchema("classMethod", false, [
+		...selectorSchema("classMethod", true, [
 			"abstract",
 			"private",
 			"#private",
@@ -2159,13 +2394,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",
@@ -2224,14 +2459,21 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$11 = "naming-convention";
-const messages$11 = {
+const RULE_NAME$12 = "naming-convention";
+const FOREIGN_CONTRACT_HINT = " If this is data conforming to an external shape, declare it with `satisfies` instead.";
+const messages$12 = {
 	doesNotMatchFormat: "{{type}} name `{{name}}` must match one of the following formats: {{formats}}",
+	doesNotMatchFormatForeignContract: `{{type}} name \`{{name}}\` must match one of the following formats: {{formats}}${FOREIGN_CONTRACT_HINT}`,
 	doesNotMatchFormatTrimmed: "{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}",
+	doesNotMatchFormatTrimmedForeignContract: `{{type}} name \`{{name}}\` trimmed as \`{{processedName}}\` must match one of the following formats: {{formats}}${FOREIGN_CONTRACT_HINT}`,
 	missingAffix: "{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}",
+	missingAffixForeignContract: `{{type}} name \`{{name}}\` must have one of the following {{position}}es: {{affixes}}${FOREIGN_CONTRACT_HINT}`,
 	missingUnderscore: "{{type}} name `{{name}}` must have {{count}} {{position}} underscore(s).",
+	missingUnderscoreForeignContract: `{{type}} name \`{{name}}\` must have {{count}} {{position}} underscore(s).${FOREIGN_CONTRACT_HINT}`,
 	satisfyCustom: "{{type}} name `{{name}}` must {{regexMatch}} the RegExp: {{regex}}",
-	unexpectedUnderscore: "{{type}} name `{{name}}` must not have a {{position}} underscore."
+	satisfyCustomForeignContract: `{{type}} name \`{{name}}\` must {{regexMatch}} the RegExp: {{regex}}${FOREIGN_CONTRACT_HINT}`,
+	unexpectedUnderscore: "{{type}} name `{{name}}` must not have a {{position}} underscore.",
+	unexpectedUnderscoreForeignContract: `{{type}} name \`{{name}}\` must not have a {{position}} underscore.${FOREIGN_CONTRACT_HINT}`
 };
 const camelCaseNamingConfig = [
 	{
@@ -2258,22 +2500,13 @@ const camelCaseNamingConfig = [
 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;
@@ -2286,52 +2519,6 @@ function create$4(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.
 	*
@@ -2339,7 +2526,6 @@ function create$4(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;
@@ -2367,12 +2553,20 @@ function create$4(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;
+				if (isObjectStyleEnumKey(node)) {
+					const enumModifiers = /* @__PURE__ */ new Set();
+					if (requiresQuoting(node.key, compilerOptions.target)) enumModifiers.add(Modifier.requiresQuotes);
+					validators.enumMember(node.key, enumModifiers, true);
+					return;
+				}
 				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
 			},
 			validator: validators.objectLiteralProperty
 		},
 		[["TSMethodSignature[computed = false]", "TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type = \"TSFunctionType\"]"].join(", ")]: {
 			handler: (node, validator) => {
+				if (isExternalMember(node, context.sourceCode)) return;
 				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
 			},
 			validator: validators.typeMethod
@@ -2403,6 +2597,7 @@ function create$4(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);
@@ -2494,7 +2689,7 @@ function create$4(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
@@ -2519,6 +2714,7 @@ function create$4(contextWithoutDefaults) {
 		},
 		"TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type != \"TSFunctionType\"]": {
 			handler: (node, validator) => {
+				if (isExternalMember(node, context.sourceCode)) return;
 				const modifiers = /* @__PURE__ */ new Set([Modifier.public]);
 				if (node.readonly) modifiers.add(Modifier.readonly);
 				handleMember(validator, node, modifiers);
@@ -2548,9 +2744,10 @@ function create$4(contextWithoutDefaults) {
 			handler: (node, validator) => {
 				const identifiers = getIdentifiersFromPattern(node.id);
 				const baseModifiers = /* @__PURE__ */ new Set();
-				const { parent } = node;
+				const { init, parent } = node;
 				if (parent.kind === "const") baseModifiers.add(Modifier.const);
 				if (isGlobal(context.sourceCode.getScope(node))) baseModifiers.add(Modifier.global);
+				if (isConstAssertedInitializer(init)) baseModifiers.add(Modifier.constAsserted);
 				const isObjectStyleEnum = isObjectStyleEnumDeclaration(node, parent);
 				for (const id of identifiers) {
 					const modifiers = new Set(baseModifiers);
@@ -2559,7 +2756,7 @@ function create$4(contextWithoutDefaults) {
 					if (isExported(parent, id.name, scope)) modifiers.add(Modifier.exported);
 					if (isUnused(id.name, scope)) modifiers.add(Modifier.unused);
 					if (isAsyncVariableIdentifier(id)) modifiers.add(Modifier.async);
-					if (isObjectStyleEnum) validators.objectStyleEnum(id, modifiers);
+					if (isObjectStyleEnum) validators.objectStyleEnum(id, modifiers, true);
 					else validator(id, modifiers);
 				}
 			},
@@ -2573,7 +2770,7 @@ function create$4(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$11,
+	name: RULE_NAME$12,
 	create: create$4,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
@@ -2584,18 +2781,75 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$11,
+		messages: messages$12,
 		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;
@@ -2610,14 +2864,167 @@ 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);
+/**
+* Checks whether a type annotation is the bare `const` type reference used by
+* const assertions (`as const`, `<const>`).
+*
+* @param typeAnnotation - The type node to check.
+* @returns True if the type node is the `const` reference.
+*/
+function isConstTypeReference(typeAnnotation) {
+	return typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "const";
+}
+/**
+* Unwraps a *bare* const-asserted object expression - `{...} as const` or
+* `<const>{...}` - directly, with no `satisfies` wrapper. A `satisfies`
+* wrapper is a distinct, intentional escape hatch (declaring conformance to
+* an externally-owned type) and must never be treated as the same thing by
+* this helper; callers that also want to recognize the `satisfies`-wrapped
+* form unwrap it themselves first (see `isConstAssertedInitializer`).
+*
+* @param expression - The expression to unwrap.
+* @returns The inner object expression, or undefined if `expression` isn't a
+*   bare const-asserted object literal.
+*/
+function getConstAssertedObject(expression) {
+	if ((expression.type === AST_NODE_TYPES.TSAsExpression || expression.type === AST_NODE_TYPES.TSTypeAssertion) && isConstTypeReference(expression.typeAnnotation) && expression.expression.type === AST_NODE_TYPES.ObjectExpression) return expression.expression;
+}
+/**
+* Determines if a VariableDeclarator represents an object-style enum
+* declaration.
+*
+* Object-style enums are *bare* 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 }`
+* - `const Config: Options = { RED: 'red' } as const` (a type annotation on
+*   the binding doesn't opt out - `satisfies` is the intended escape).
+*
+* A const assertion wrapped in `satisfies` (`{...} as const satisfies T`) is
+* explicitly excluded: it declares conformance to an externally-owned type,
+* which is the foreign-contract escape hatch this rule wants authors to
+* reach for instead of renaming keys to fit.
+*
+* @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" || !node.init) return false;
+	if (node.init.type === AST_NODE_TYPES.TSSatisfiesExpression) return false;
+	return getConstAssertedObject(node.init) !== void 0;
+}
+/**
+* True when `init` is a const-asserted object expression, bare (`{...} as
+* const`) or `satisfies`-wrapped (`{...} as const satisfies T`). Used for the
+* `constAsserted` variable modifier, which - unlike `isObjectStyleEnumDeclaration`
+* - deliberately covers both forms: it exists so consumers can pin a format on
+* const-asserted data objects regardless of whether they carry a `satisfies`
+* clause.
+*
+* @param init - The VariableDeclarator's initializer, if any.
+* @returns True if `init` is a const-asserted object expression.
+*/
+function isConstAssertedInitializer(init) {
+	if (!init) return false;
+	return getConstAssertedObject(init.type === AST_NODE_TYPES.TSSatisfiesExpression ? init.expression : init) !== void 0;
+}
+/**
+* Determines if an object literal property is a direct key of an
+* object-style-enum declaration's object literal - i.e. `RED` in `const
+* Colors = { RED: 'red' } as const`, but not a key of a nested object value.
+* Nested object values aren't reached because their enclosing ObjectExpression
+* is parented by a Property, not the const-assertion node this checks for.
+*
+* @param node - The non-computed object literal property node.
+* @returns True if this property is a top-level object-style-enum key.
+*/
+function isObjectStyleEnumKey(node) {
+	const objectExpression = node.parent;
+	if (objectExpression.type !== AST_NODE_TYPES.ObjectExpression) return false;
+	const assertion = objectExpression.parent;
+	if (assertion.type !== AST_NODE_TYPES.TSAsExpression && assertion.type !== AST_NODE_TYPES.TSTypeAssertion || getConstAssertedObject(assertion) !== objectExpression) return false;
+	const declarator = assertion.parent;
+	return declarator.type === AST_NODE_TYPES.VariableDeclarator && declarator.parent.kind === "const";
+}
+const EXTERNAL_JSDOC_TAG_PATTERN = /@external\b/u;
+/**
+* Resolves the node whose leading comments should be inspected for JSDoc -
+* for an exported declaration, the JSDoc block precedes the `export` keyword,
+* not the declaration itself.
+*
+* @param node - The declaration node.
+* @returns The export wrapper if present, otherwise `node` itself.
+*/
+function getJsDocumentTargetNode(node) {
+	const { parent } = node;
+	if (parent?.type === AST_NODE_TYPES.ExportDefaultDeclaration || parent?.type === AST_NODE_TYPES.ExportNamedDeclaration) return parent;
+	return node;
+}
+/**
+* Checks whether `node`'s immediately preceding JSDoc block comment carries
+* an `@external` tag, marking the name(s) it documents as coming from a
+* foreign wire format.
+*
+* @param node - The node to check.
+* @param sourceCode - Used to read the comments preceding `node`.
+* @returns True if the leading JSDoc comment contains `@external`.
+*/
+function hasExternalJsDocumentTag(node, sourceCode) {
+	const lastComment = sourceCode.getCommentsBefore(getJsDocumentTargetNode(node)).at(-1);
+	return lastComment?.type === AST_TOKEN_TYPES.Block && lastComment.value.startsWith("*") && EXTERNAL_JSDOC_TAG_PATTERN.test(lastComment.value);
+}
+/**
+* Walks up from a type member to the nearest enclosing interface or type
+* alias declaration, passing through any nested type literals along the way
+* - foreign formats nest, so an `@external` tag on the outer declaration
+* covers members at any depth.
+*
+* @param node - The member node to walk up from.
+* @returns The enclosing declaration, or undefined if none is found.
+*/
+function findEnclosingTypeDeclaration(node) {
+	let current = node.parent;
+	while (current) {
+		if (current.type === AST_NODE_TYPES.TSInterfaceDeclaration || current.type === AST_NODE_TYPES.TSTypeAliasDeclaration) return current;
+		current = current.parent;
+	}
+}
+/**
+* Determines if a typeProperty/typeMethod member should skip naming
+* validation because it (or its enclosing interface/type-alias declaration)
+* is marked `@external` - a foreign wire-format name, not the author's
+* choice. The type's own name (validated via `typeLike`) is unaffected.
+*
+* @param node - The typeProperty/typeMethod node to check.
+* @param sourceCode - Used to read leading comments for the JSDoc check.
+* @returns True if the member should be skipped.
+*/
+function isExternalMember(node, sourceCode) {
+	if (hasExternalJsDocumentTag(node, sourceCode)) return true;
+	const enclosing = findEnclosingTypeDeclaration(node);
+	return enclosing !== void 0 && hasExternalJsDocumentTag(enclosing, sourceCode);
+}
+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$10 = "no-export-default-arrow";
+const RULE_NAME$11 = "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." };
+const messages$11 = { [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`).
@@ -2695,7 +3102,7 @@ function createFixFunction({ arrowFunction, context, exportDeclaration, sourceCo
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$6(context) {
+function createOnce$7(context) {
 	return { ArrowFunctionExpression(node) {
 		const { parent } = node;
 		if (parent.type !== AST_NODE_TYPES.ExportDefaultDeclaration) return;
@@ -2712,8 +3119,8 @@ function createOnce$6(context) {
 	} };
 }
 const noExportDefaultArrow = createFlawlessRule({
-	name: RULE_NAME$10,
-	createOnce: createOnce$6,
+	name: RULE_NAME$11,
+	createOnce: createOnce$7,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -2723,7 +3130,7 @@ const noExportDefaultArrow = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$10,
+		messages: messages$11,
 		schema: [],
 		type: "suggestion"
 	}
@@ -2888,7 +3295,7 @@ function flatten(file, context) {
 }
 //#endregion
 //#region src/rules/no-redundant-tsconfig-options/rule.ts
-const RULE_NAME$9 = "no-redundant-tsconfig-options";
+const RULE_NAME$10 = "no-redundant-tsconfig-options";
 const MESSAGE_ID$5 = "redundant";
 /**
 * Compiler options TypeScript resolves case-insensitively; a child that re-sets
@@ -2924,7 +3331,7 @@ const PATH_KEYS = /* @__PURE__ */ new Set([
 	"tsBuildInfoFile",
 	"typeRoots"
 ]);
-const messages$9 = { [MESSAGE_ID$5]: "'{{option}}' is redundant: it is already set to this value by {{source}}. Remove it." };
+const messages$10 = { [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
@@ -3096,7 +3503,7 @@ function create$3(context) {
 	} };
 }
 const noRedundantTsconfigOptions = createEslintRule({
-	name: RULE_NAME$9,
+	name: RULE_NAME$10,
 	create: create$3,
 	defaultOptions: [],
 	meta: {
@@ -3107,7 +3514,7 @@ const noRedundantTsconfigOptions = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$9,
+		messages: messages$10,
 		schema: [],
 		type: "suggestion"
 	}
@@ -3350,15 +3757,15 @@ function resolveFactory(sourceCode, node) {
 }
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.ts
-const RULE_NAME$8 = "no-unnecessary-use-callback";
+const RULE_NAME$9 = "no-unnecessary-use-callback";
 const MESSAGE_ID_DEFAULT$1 = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
-const messages$8 = {
+const messages$9 = {
 	[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$8,
+	name: RULE_NAME$9,
 	createOnce: createUnnecessaryHookRule({
 		hook: "useCallback",
 		messageIds: {
@@ -3374,22 +3781,22 @@ const noUnnecessaryUseCallback = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$8,
+		messages: messages$9,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/no-unnecessary-use-memo/rule.ts
-const RULE_NAME$7 = "no-unnecessary-use-memo";
+const RULE_NAME$8 = "no-unnecessary-use-memo";
 const MESSAGE_ID_DEFAULT = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
-const messages$7 = {
+const messages$8 = {
 	[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$7,
+	name: RULE_NAME$8,
 	createOnce: createUnnecessaryHookRule({
 		hook: "useMemo",
 		messageIds: {
@@ -3405,16 +3812,16 @@ const noUnnecessaryUseMemo = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$7,
+		messages: messages$8,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/padding-after-expect-assertions/rule.ts
-const RULE_NAME$6 = "padding-after-expect-assertions";
+const RULE_NAME$7 = "padding-after-expect-assertions";
 const MESSAGE_ID$4 = "missingPadding";
-const messages$6 = { [MESSAGE_ID$4]: "Expected a blank line after '{{name}}'." };
+const messages$7 = { [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()`.
@@ -3489,7 +3896,7 @@ function findPaddingAnchor(sourceCode, node, nextNode) {
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$3(context) {
+function createOnce$4(context) {
 	return { ExpressionStatement(node) {
 		const name = getAssertionName(node);
 		if (name === void 0) return;
@@ -3514,8 +3921,8 @@ function createOnce$3(context) {
 	} };
 }
 const paddingAfterExpectAssertions = createFlawlessRule({
-	name: RULE_NAME$6,
-	createOnce: createOnce$3,
+	name: RULE_NAME$7,
+	createOnce: createOnce$4,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -3525,16 +3932,16 @@ const paddingAfterExpectAssertions = createFlawlessRule({
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
-		messages: messages$6,
+		messages: messages$7,
 		schema: [],
 		type: "layout"
 	}
 });
 //#endregion
 //#region src/rules/prefer-destructuring-assignment/rule.ts
-const RULE_NAME$5 = "prefer-destructuring-assignment";
+const RULE_NAME$6 = "prefer-destructuring-assignment";
 const MESSAGE_ID$3 = "default";
-const messages$5 = { [MESSAGE_ID$3]: "Use destructuring assignment for component props." };
+const messages$6 = { [MESSAGE_ID$3]: "Use destructuring assignment for component props." };
 /**
 * Identifiers that cannot be used as a binding name in strict-mode module code.
 * A property may be accessed with such a name (`props.default`), but a shorthand
@@ -3696,7 +4103,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$2(context) {
+function createOnce$3(context) {
 	let collector = core.getFunctionComponentCollector(context);
 	const selectorKeys = Object.keys(collector.visitor);
 	const listener = {
@@ -3722,8 +4129,8 @@ function createOnce$2(context) {
 	return listener;
 }
 const preferDestructuringAssignment = createFlawlessRule({
-	name: RULE_NAME$5,
-	createOnce: createOnce$2,
+	name: RULE_NAME$6,
+	createOnce: createOnce$3,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -3733,16 +4140,16 @@ const preferDestructuringAssignment = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$5,
+		messages: messages$6,
 		schema: [],
 		type: "problem"
 	}
 });
 //#endregion
 //#region src/rules/prefer-parameter-destructuring/rule.ts
-const RULE_NAME$4 = "prefer-parameter-destructuring";
+const RULE_NAME$5 = "prefer-parameter-destructuring";
 const MESSAGE_ID$2 = "default";
-const messages$4 = { [MESSAGE_ID$2]: "Destructure parameter '{{name}}' in the function signature instead of the body." };
+const messages$5 = { [MESSAGE_ID$2]: "Destructure parameter '{{name}}' in the function signature instead of the body." };
 /**
 * Collects the binding names introduced by a pattern (or parameter), including
 * names nested in object/array patterns, defaults, and rest elements.
@@ -4017,7 +4424,7 @@ function planFix(query) {
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$1(context) {
+function createOnce$2(context) {
 	let allowSideEffectReordering = true;
 	function checkFunction(node) {
 		const { body, params } = node;
@@ -4068,8 +4475,8 @@ function createOnce$1(context) {
 	};
 }
 const preferParameterDestructuring = createFlawlessRule({
-	name: RULE_NAME$4,
-	createOnce: createOnce$1,
+	name: RULE_NAME$5,
+	createOnce: createOnce$2,
 	defaultOptions: [{ allowSideEffectReordering: true }],
 	meta: {
 		defaultOptions: [{ allowSideEffectReordering: true }],
@@ -4080,7 +4487,7 @@ const preferParameterDestructuring = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$4,
+		messages: messages$5,
 		schema: [{
 			additionalProperties: false,
 			properties: { allowSideEffectReordering: {
@@ -4362,9 +4769,9 @@ function isReadonlyPropertiesProperty(checker, type, property) {
 }
 //#endregion
 //#region src/rules/prefer-read-only-props/rule.ts
-const RULE_NAME$3 = "prefer-read-only-props";
+const RULE_NAME$4 = "prefer-read-only-props";
 const DEFAULT_WRAPPER_TYPE = "Readonly";
-const messages$3 = { preferReadOnlyProps: "A function component's props should be read-only." };
+const messages$4 = { preferReadOnlyProps: "A function component's props should be read-only." };
 /** Names of the `React.forwardRef` wrapper whose props are its second type argument. */
 const FORWARD_REF_NAMES = /* @__PURE__ */ new Set(["forwardRef"]);
 /** Names of the `React.memo` wrapper whose props are its first type argument. */
@@ -4573,7 +4980,7 @@ function create$2(context) {
 	};
 }
 const preferReadOnlyProps = createEslintRule({
-	name: RULE_NAME$3,
+	name: RULE_NAME$4,
 	create: create$2,
 	defaultOptions: [{}],
 	meta: {
@@ -4585,7 +4992,7 @@ const preferReadOnlyProps = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$3,
+		messages: messages$4,
 		schema: [{
 			additionalProperties: false,
 			properties: {
@@ -4610,7 +5017,7 @@ const preferReadOnlyProps = createEslintRule({
 });
 //#endregion
 //#region src/rules/purity/rule.ts
-const RULE_NAME$2 = "purity";
+const RULE_NAME$3 = "purity";
 const MESSAGE_ID$1 = "impureCall";
 /**
 * Non-deterministic Luau / Roblox calls, written as dotted paths matching how
@@ -4643,7 +5050,7 @@ const GUARDED_GLOBALS = /* @__PURE__ */ new Set([
 	"tick",
 	"time"
 ]);
-const messages$2 = { [MESSAGE_ID$1]: "Do not call '{{name}}' during render. Components and hooks must be pure. Move this call into an event handler, effect, or state initializer." };
+const messages$3 = { [MESSAGE_ID$1]: "Do not call '{{name}}' during render. Components and hooks must be pure. Move this call into an event handler, effect, or state initializer." };
 const schema$1 = [{
 	additionalProperties: false,
 	properties: {
@@ -4743,7 +5150,7 @@ function isRenderContext(reactContext, func) {
 	const { parent } = func;
 	return parent.type === AST_NODE_TYPES.CallExpression && parent.arguments[0] === func && core.isUseMemoCall(reactContext, parent);
 }
-function createOnce(context) {
+function createOnce$1(context) {
 	const reactContext = context;
 	let signatures;
 	function handle(node, match, path) {
@@ -4776,8 +5183,8 @@ function createOnce(context) {
 	};
 }
 const purity = createFlawlessRule({
-	name: RULE_NAME$2,
-	createOnce,
+	name: RULE_NAME$3,
+	createOnce: createOnce$1,
 	defaultOptions: [{}],
 	meta: {
 		defaultOptions: [{}],
@@ -4787,12 +5194,314 @@ const purity = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$2,
+		messages: messages$3,
 		schema: schema$1,
 		type: "problem"
 	}
 });
 //#endregion
+//#region src/rules/react-namespace/imports.ts
+/**
+* Whether a module specifier refers to the configured React import source. Matches
+* the exact source or any subpath (`@rbxts/react` and `@rbxts/react/jsx-runtime`).
+*
+* @param value - The `source.value` of an import declaration.
+* @param importSource - The configured React import source.
+* @returns True when the specifier resolves to the React package.
+*/
+function matchesSource(value, importSource) {
+	return value === importSource || value.startsWith(`${importSource}/`);
+}
+/**
+* Collects the import declarations in a program that come from the React source.
+*
+* @param program - The program node whose top-level statements are scanned.
+* @param importSource - The configured React import source.
+* @returns The matching import declarations, in source order.
+*/
+function getReactImportDeclarations(program, importSource) {
+	return program.body.filter((statement) => {
+		return statement.type === AST_NODE_TYPES.ImportDeclaration && typeof statement.source.value === "string" && matchesSource(statement.source.value, importSource);
+	});
+}
+/**
+* Classifies an import specifier by the kind of React binding it introduces:
+* named for `ImportSpecifier`, namespace for default and namespace specifiers.
+*
+* @param specifier - The specifier to classify.
+* @returns `"named"` or `"namespace"`.
+*/
+function classifySpecifier(specifier) {
+	return specifier.type === AST_NODE_TYPES.ImportSpecifier ? "named" : "namespace";
+}
+/**
+* Finds the local name of a default or namespace React import, used to qualify a
+* bare type reference (`React.ReactNode`). Returns `null` when no such import
+* exists, in which case the caller ensures one under the name `React`.
+*
+* @param declarations - The React import declarations of the file.
+* @returns The local namespace name, or `null`.
+*/
+function findReactNamespaceLocal(declarations) {
+	for (const declaration of declarations) for (const specifier of declaration.specifiers) if (specifier.type === AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier) return specifier.local.name;
+	return null;
+}
+/**
+* Whether the file already imports React as a default or namespace binding (so a
+* namespace type qualification resolves without adding an import).
+*
+* @param declarations - The React import declarations of the file.
+* @returns True when a default or namespace React import is present.
+*/
+function hasReactNamespaceImport(declarations) {
+	return findReactNamespaceLocal(declarations) !== null;
+}
+/**
+* Inserts a fresh import statement above the first statement of the program.
+*
+* @param fixer - The fixer used to build the edit.
+* @param program - The program whose head receives the import.
+* @param text - The full import statement (including trailing newline).
+* @returns The insertion fix.
+*/
+function insertImportStatement(fixer, program, text) {
+	const first = program.body.at(0);
+	if (first === void 0) return fixer.insertTextAfterRange([0, 0], text);
+	return fixer.insertTextBefore(first, text);
+}
+/**
+* Builds the fix that ensures a named value import of `name` from the React
+* source, or `null` when it is already present. Prefers extending an existing
+* named import, then appending to a default import, and otherwise inserts a new
+* statement. Never touched for namespace-only imports, which cannot carry named
+* siblings and instead receive a fresh statement.
+*
+* @param fixer - The fixer used to build the edit.
+* @param parameters - The declarations, program, name, and source to import.
+* @returns The fix, or `null` when the import already exists.
+*/
+function ensureNamedValueImport(fixer, { name, declarations, importSource, program }) {
+	const valueDeclarations = declarations.filter((declaration) => declaration.importKind !== "type");
+	for (const declaration of valueDeclarations) for (const specifier of declaration.specifiers) if (isNamedSpecifier(specifier) && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === name) return null;
+	for (const declaration of valueDeclarations) {
+		const last = declaration.specifiers.filter(isNamedSpecifier).at(-1);
+		if (last !== void 0) return fixer.insertTextAfter(last, `, ${name}`);
+	}
+	for (const declaration of valueDeclarations) {
+		const defaultSpecifier = declaration.specifiers.find((specifier) => specifier.type === AST_NODE_TYPES.ImportDefaultSpecifier);
+		if (defaultSpecifier !== void 0) return fixer.insertTextAfter(defaultSpecifier, `, { ${name} }`);
+	}
+	return insertImportStatement(fixer, program, `import { ${name} } from "${importSource}";\n`);
+}
+/**
+* Removes a single named specifier from a React import, dropping the whole
+* declaration when it was the only binding. Handles the comma and braces that
+* surround the specifier so the remaining import stays well-formed.
+*
+* @param fixer - The fixer used to build the edit.
+* @param sourceCode - The source code, used to locate surrounding tokens.
+* @param declaration - The declaration owning the specifier.
+* @param specifier - The named specifier to remove.
+* @returns The removal fix.
+*/
+function removeNamedSpecifier(fixer, sourceCode, declaration, specifier) {
+	const named = declaration.specifiers.filter(isNamedSpecifier);
+	const others = declaration.specifiers.filter((entry) => !isNamedSpecifier(entry));
+	if (named.length === 1) {
+		const lastOther = others.at(-1);
+		if (lastOther === void 0) return removeWholeDeclaration(fixer, sourceCode, declaration);
+		const comma = sourceCode.getTokenAfter(lastOther, (token) => token.value === ",");
+		const closeBrace = sourceCode.getTokenAfter(specifier, (token) => token.value === "}");
+		if (comma !== null && closeBrace !== null) return fixer.removeRange([comma.range[0], closeBrace.range[1]]);
+		return fixer.remove(specifier);
+	}
+	if (named.indexOf(specifier) === named.length - 1) {
+		const comma = sourceCode.getTokenBefore(specifier, (token) => token.value === ",");
+		if (comma !== null) return fixer.removeRange([comma.range[0], specifier.range[1]]);
+		return fixer.remove(specifier);
+	}
+	const comma = sourceCode.getTokenAfter(specifier, (token) => token.value === ",");
+	if (comma !== null) return fixer.removeRange([specifier.range[0], comma.range[1]]);
+	return fixer.remove(specifier);
+}
+/**
+* Finds the named specifier that binds `name` across the React import
+* declarations, or `null` when none does.
+*
+* @param declarations - The React import declarations of the file.
+* @param name - The local name of the binding to find.
+* @returns A specifier together with its declaration, or `null`.
+*/
+function findNamedSpecifier(declarations, name) {
+	for (const declaration of declarations) for (const specifier of declaration.specifiers) if (isNamedSpecifier(specifier) && specifier.local.name === name) return {
+		declaration,
+		specifier
+	};
+	return null;
+}
+function isNamedSpecifier(specifier) {
+	return specifier.type === AST_NODE_TYPES.ImportSpecifier;
+}
+/**
+* Removes a whole import declaration together with the line break that follows
+* it, so dropping the sole specifier of an import leaves no blank line.
+*
+* @param fixer - The fixer used to build the edit.
+* @param sourceCode - The source code, used to inspect trailing characters.
+* @param declaration - The declaration to remove.
+* @returns The removal fix.
+*/
+function removeWholeDeclaration(fixer, { text }, declaration) {
+	const [start] = declaration.range;
+	let end = declaration.range[1];
+	if (text[end] === "\r") end += 1;
+	if (text[end] === "\n") end += 1;
+	return fixer.removeRange([start, end]);
+}
+//#endregion
+//#region src/rules/react-namespace/rule.ts
+const RULE_NAME$2 = "react-namespace";
+const MESSAGE_ID_RUNTIME = "runtimeNamespace";
+const MESSAGE_ID_TYPE = "typeNamedImport";
+const DEFAULT_IMPORT_SOURCE = "react";
+const messages$2 = {
+	[MESSAGE_ID_RUNTIME]: "Use a named import of '{{name}}' instead of accessing it through the React namespace.",
+	[MESSAGE_ID_TYPE]: "Access the '{{name}}' type through the React namespace instead of importing it by name."
+};
+/**
+* Whether a member access is the target of an assignment (`React.x = …`), which
+* must be left alone — rewriting it to a bare name would create an assignment to
+* an import binding.
+*
+* @param node - The member expression under consideration.
+* @returns True when the member is an assignment target.
+*/
+function isAssignmentTarget(node) {
+	return node.parent.type === AST_NODE_TYPES.AssignmentExpression && node.parent.left === node;
+}
+/**
+* Scans a binding's references once, recording whether all of them are bare
+* type references (`typeName` is the identifier itself) and where the first one
+* starts. The named import can be removed only when every reference is
+* convertible, and only the *first* reference carries the import edits.
+*
+* The import edits (adding the namespace import, removing the redundant
+* specifier) sit at the top of the file. ESLint merges a report's fix array into
+* one edit spanning `[min, max]`, so anchoring those edits to the first
+* reference keeps that span from the file head to the first usage — later
+* references stay disjoint and their own qualify edits survive a single pass.
+*
+* @param references - The references recorded for the binding.
+* @returns The convertibility and first-reference facts for the binding.
+*/
+function computeRemovableInfo(references) {
+	let allConvertible = true;
+	let firstStart = Number.POSITIVE_INFINITY;
+	for (const { identifier } of references) {
+		firstStart = Math.min(firstStart, identifier.range[0]);
+		if (identifier.parent.type !== AST_NODE_TYPES.TSTypeReference || identifier.parent.typeName !== identifier) allConvertible = false;
+	}
+	return {
+		allConvertible,
+		firstStart
+	};
+}
+function createOnce(context) {
+	let importSource;
+	let program;
+	let declarations;
+	let sourceCode;
+	let resolutions;
+	let removableInfoByVariable;
+	function getRemovableInfo(variable) {
+		let info = removableInfoByVariable.get(variable);
+		if (info === void 0) {
+			info = computeRemovableInfo(variable.references);
+			removableInfoByVariable.set(variable, info);
+		}
+		return info;
+	}
+	return {
+		before() {
+			({sourceCode} = context);
+			importSource = context.settings["react-x"]?.importSource ?? DEFAULT_IMPORT_SOURCE;
+			program = sourceCode.ast;
+			declarations = getReactImportDeclarations(program, importSource);
+			resolutions = /* @__PURE__ */ new Map();
+			removableInfoByVariable = /* @__PURE__ */ new Map();
+			for (const declaration of declarations) for (const specifier of declaration.specifiers) {
+				const kind = classifySpecifier(specifier);
+				const [variable] = sourceCode.getDeclaredVariables(specifier);
+				if (variable === void 0) continue;
+				for (const reference of variable.references) resolutions.set(reference.identifier, {
+					kind,
+					variable
+				});
+			}
+		},
+		MemberExpression(node) {
+			if (node.computed || node.object.type !== AST_NODE_TYPES.Identifier || node.property.type !== AST_NODE_TYPES.Identifier || isAssignmentTarget(node)) return;
+			const { object, property } = node;
+			if (resolutions.get(object)?.kind !== "namespace") return;
+			context.report({
+				data: { name: property.name },
+				fix: (fixer) => {
+					const fixes = [fixer.removeRange([object.range[0], property.range[0]])];
+					const ensure = ensureNamedValueImport(fixer, {
+						name: property.name,
+						declarations,
+						importSource,
+						program
+					});
+					if (ensure !== null) fixes.push(ensure);
+					return fixes;
+				},
+				messageId: MESSAGE_ID_RUNTIME,
+				node
+			});
+		},
+		TSTypeReference(node) {
+			if (node.typeName.type !== AST_NODE_TYPES.Identifier) return;
+			const { typeName } = node;
+			const resolution = resolutions.get(typeName);
+			if (resolution?.kind !== "named") return;
+			context.report({
+				data: { name: typeName.name },
+				fix: (fixer) => {
+					const reactLocal = findReactNamespaceLocal(declarations) ?? "React";
+					const fixes = [fixer.insertTextBefore(typeName, `${reactLocal}.`)];
+					const info = getRemovableInfo(resolution.variable);
+					if (info.allConvertible && typeName.range[0] === info.firstStart) {
+						if (!hasReactNamespaceImport(declarations)) fixes.push(insertImportStatement(fixer, program, `import ${reactLocal} from "${importSource}";\n`));
+						const found = findNamedSpecifier(declarations, typeName.name);
+						if (found !== null) fixes.push(removeNamedSpecifier(fixer, sourceCode, found.declaration, found.specifier));
+					}
+					return fixes;
+				},
+				messageId: MESSAGE_ID_TYPE,
+				node
+			});
+		}
+	};
+}
+const reactNamespace = createFlawlessRule({
+	name: RULE_NAME$2,
+	createOnce,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Prefer named imports for React runtime values and the React namespace for React types",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$2,
+		schema: [],
+		type: "problem"
+	}
+});
+//#endregion
 //#region src/rules/toml-sort-keys/rule.ts
 const RULE_NAME$1 = "toml-sort-keys";
 const MESSAGE_ID = "unsorted";
@@ -5105,6 +5814,7 @@ const plugin = {
 		"prefer-parameter-destructuring": preferParameterDestructuring,
 		"prefer-read-only-props": preferReadOnlyProps,
 		"purity": purity,
+		"react-namespace": reactNamespace,
 		"toml-sort-keys": tomlSortKeys,
 		"yaml-block-key-blank-lines": yamlBlockKeyBlankLines
 	}