eslint-plugin-flawless 1.1.0 → 1.2.0

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

@@ -1,5 +1,5 @@
 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";
@@ -14,7 +14,7 @@ import * as core from "@eslint-react/core";
 import { getStaticTOMLValue } from "toml-eslint-parser";
 //#region package.json
 var name = "eslint-plugin-flawless";
-var version = "1.1.0";
+var version = "1.2.0";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -84,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";
@@ -232,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;
@@ -598,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({
@@ -613,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: {
@@ -624,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."
 };
@@ -672,7 +672,7 @@ function jsxNameToString(node) {
 	}
 	return null;
 }
-function createOnce$8(context) {
+function createOnce$9(context) {
 	let mode;
 	let fragmentName;
 	let namedFragments;
@@ -719,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
@@ -737,7 +737,7 @@ const jsxShorthandFragment = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$13,
+		messages: messages$14,
 		schema: schema$3,
 		type: "suggestion"
 	}
@@ -877,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;
@@ -888,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: {
@@ -991,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;
@@ -1047,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],
@@ -1058,7 +1058,7 @@ const maxLinesPerFunction = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$12,
+		messages: messages$13,
 		schema: schema$2,
 		type: "suggestion"
 	}
@@ -1658,7 +1658,8 @@ const Modifier = {
 	"override": 8192,
 	"async": 16384,
 	"default": 32768,
-	"namespace": 65536
+	"namespace": 65536,
+	"constAsserted": 131072
 };
 const PredefinedFormat = {
 	camelCase: 1,
@@ -1670,15 +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 << 22;
-const TYPE_REFERENCE_STRICT_WEIGHT = 1 << 23;
+const TYPE_REFERENCE_LOOSE_WEIGHT = 1 << 23;
+const TYPE_REFERENCE_STRICT_WEIGHT = 1 << 24;
 const UnderscoreOption = {
 	forbid: 1,
 	allow: 2,
@@ -1773,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;
@@ -1783,6 +1784,7 @@ function createValidator(type, context, allConfigs) {
 			name = validateUnderscore({
 				name,
 				config,
+				isObjectStyleEnumName,
 				node,
 				originalName,
 				position: "leading"
@@ -1791,6 +1793,7 @@ function createValidator(type, context, allConfigs) {
 			name = validateUnderscore({
 				name,
 				config,
+				isObjectStyleEnumName,
 				node,
 				originalName,
 				position: "trailing"
@@ -1799,6 +1802,7 @@ function createValidator(type, context, allConfigs) {
 			name = validateAffix({
 				name,
 				config,
+				isObjectStyleEnumName,
 				node,
 				originalName,
 				position: "prefix"
@@ -1807,6 +1811,7 @@ function createValidator(type, context, allConfigs) {
 			name = validateAffix({
 				name,
 				config,
+				isObjectStyleEnumName,
 				node,
 				originalName,
 				position: "suffix"
@@ -1815,12 +1820,14 @@ function createValidator(type, context, allConfigs) {
 			if (!validateCustom({
 				name,
 				config,
+				isObjectStyleEnumName,
 				node,
 				originalName
 			})) return;
 			if (!validatePredefinedFormat({
 				name,
 				config,
+				isObjectStyleEnumName,
 				modifiers,
 				node,
 				originalName
@@ -1844,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("_");
@@ -1870,7 +1877,7 @@ function createValidator(type, context, allConfigs) {
 							originalName,
 							position
 						}),
-						messageId: "unexpectedUnderscore",
+						messageId: pickMessageId("unexpectedUnderscore", isObjectStyleEnumName),
 						node
 					});
 					return;
@@ -1884,7 +1891,7 @@ function createValidator(type, context, allConfigs) {
 							originalName,
 							position
 						}),
-						messageId: "missingUnderscore",
+						messageId: pickMessageId("missingUnderscore", isObjectStyleEnumName),
 						node
 					});
 					return;
@@ -1898,7 +1905,7 @@ function createValidator(type, context, allConfigs) {
 							originalName,
 							position
 						}),
-						messageId: "missingUnderscore",
+						messageId: pickMessageId("missingUnderscore", isObjectStyleEnumName),
 						node
 					});
 					return;
@@ -1906,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) {
@@ -1920,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);
@@ -1935,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) {
@@ -1953,12 +1960,26 @@ function createValidator(type, context, allConfigs) {
 				originalName,
 				processedName: name
 			}),
-			messageId: originalName === name ? "doesNotMatchFormat" : "doesNotMatchFormatTrimmed",
+			messageId: pickMessageId(originalName === name ? "doesNotMatchFormat" : "doesNotMatchFormatTrimmed", isObjectStyleEnumName),
 			node
 		});
 		return false;
 	}
 }
+/**
+* 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));
@@ -2295,6 +2316,7 @@ const SCHEMA = {
 		...selectorSchema("variableLike", false, ["unused", "async"]),
 		...selectorSchema("variable", true, [
 			"const",
+			"constAsserted",
 			"destructured",
 			"exported",
 			"global",
@@ -2437,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 = [
 	{
@@ -2525,12 +2554,19 @@ 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
@@ -2678,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);
@@ -2707,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);
@@ -2718,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);
 				}
 			},
@@ -2732,7 +2770,7 @@ function create$4(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$11,
+	name: RULE_NAME$12,
 	create: create$4,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
@@ -2743,7 +2781,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$11,
+		messages: messages$12,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -2827,23 +2865,145 @@ function isGlobal(scope) {
 	return scope.type === TSESLint.Scope.ScopeType.global || scope.type === TSESLint.Scope.ScopeType.module;
 }
 /**
-* Determines if a VariableDeclarator represents an object-style enum declaration.
+* 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`).
 *
-* Object-style enums are const assertions applied to object expressions, commonly
-* used as an alternative to TypeScript enums. Examples:
+* @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 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") 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;
+	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;
@@ -2862,9 +3022,9 @@ function requiresQuoting(node, target) {
 }
 //#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`).
@@ -2942,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;
@@ -2959,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: {
@@ -2970,7 +3130,7 @@ const noExportDefaultArrow = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$10,
+		messages: messages$11,
 		schema: [],
 		type: "suggestion"
 	}
@@ -3135,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
@@ -3171,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
@@ -3343,7 +3503,7 @@ function create$3(context) {
 	} };
 }
 const noRedundantTsconfigOptions = createEslintRule({
-	name: RULE_NAME$9,
+	name: RULE_NAME$10,
 	create: create$3,
 	defaultOptions: [],
 	meta: {
@@ -3354,7 +3514,7 @@ const noRedundantTsconfigOptions = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$9,
+		messages: messages$10,
 		schema: [],
 		type: "suggestion"
 	}
@@ -3597,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: {
@@ -3621,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: {
@@ -3652,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()`.
@@ -3736,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;
@@ -3761,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: {
@@ -3772,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
@@ -3943,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 = {
@@ -3969,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: {
@@ -3980,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.
@@ -4264,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;
@@ -4315,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 }],
@@ -4327,7 +4487,7 @@ const preferParameterDestructuring = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$4,
+		messages: messages$5,
 		schema: [{
 			additionalProperties: false,
 			properties: { allowSideEffectReordering: {
@@ -4609,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. */
@@ -4820,7 +4980,7 @@ function create$2(context) {
 	};
 }
 const preferReadOnlyProps = createEslintRule({
-	name: RULE_NAME$3,
+	name: RULE_NAME$4,
 	create: create$2,
 	defaultOptions: [{}],
 	meta: {
@@ -4832,7 +4992,7 @@ const preferReadOnlyProps = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$3,
+		messages: messages$4,
 		schema: [{
 			additionalProperties: false,
 			properties: {
@@ -4857,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
@@ -4890,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: {
@@ -4990,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) {
@@ -5023,8 +5183,8 @@ function createOnce(context) {
 	};
 }
 const purity = createFlawlessRule({
-	name: RULE_NAME$2,
-	createOnce,
+	name: RULE_NAME$3,
+	createOnce: createOnce$1,
 	defaultOptions: [{}],
 	meta: {
 		defaultOptions: [{}],
@@ -5034,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";
@@ -5352,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
 	}