oxlint-plugin-react-doctor 0.9.1-dev.49c5c1e → 0.9.1-dev.4ebd0a0

package/dist/index.js

@@ -15542,6 +15542,8 @@ const COMMON_UI_FONT_FAMILIES = new Set([
 	"roboto",
 	"space grotesk"
 ]);
+const DECORATIVE_RADIAL_SPOTLIGHT_TRANSPARENT_ALPHA_MAX = .05;
+const RADIAL_HALO_TRANSPARENT_ALPHA_MAX = .05;
 const EXCESSIVE_MOTION_STAGGER_SECONDS = .08;
 const TAILWIND_TEXT_SIZE_PX = new Map([
 	["text-xs", 12],
@@ -15559,12 +15561,31 @@ const TAILWIND_TEXT_SIZE_PX = new Map([
 	["text-9xl", 128]
 ]);
 const GENERIC_MARKETING_PHRASES = new Set([
+	"best of breed",
+	"best-in-class",
+	"built for the modern",
 	"cutting-edge",
+	"drive engagement",
+	"drive growth",
+	"drive results",
+	"empower your",
+	"enterprise-grade",
 	"future-proof",
+	"game changing",
+	"game-changer",
+	"harness the power",
+	"industry-leading",
+	"leverage the power",
 	"next-generation",
 	"seamless experience",
-	"supercharge your workflow",
+	"seamlessly integrate",
+	"streamline your",
+	"supercharge your",
 	"transform your business",
+	"trusted by leading",
+	"trusted by the world",
+	"unleash the power",
+	"unleash your",
 	"unlock your potential",
 	"world-class"
 ]);
@@ -15645,6 +15666,367 @@ const TAILWIND_DISPLAY_TOKENS = new Set([
 const SPACE_AXIS_PATTERN = /(?:^|\s)(?:-)?space-(x|y)-(\d+(?:\.\d+)?|\[[^\]]+\])(?=$|[\s:])/;
 const TRAILING_THREE_PERIOD_ELLIPSIS_PATTERN = /[\p{L}\p{N}]\.\.\./u;
 //#endregion
+//#region src/plugin/rules/design/utils/get-style-property-key.ts
+const getStylePropertyKey = (property) => getStaticPropertyKeyName(property, { allowComputedString: true });
+//#endregion
+//#region src/plugin/rules/design/utils/get-effective-style-property.ts
+const getEffectiveStyleProperty = (properties, propertyName) => {
+	for (const property of [...properties ?? []].reverse()) {
+		const currentPropertyName = getStylePropertyKey(property);
+		if (!currentPropertyName) return null;
+		if (currentPropertyName === propertyName && isNodeOfType(property, "Property")) return property;
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/rules/design/utils/get-inline-style-expression.ts
+const isConstObjectBindingMutated = (symbol) => symbol.references.some((reference) => {
+	if (reference.flag !== "read") return true;
+	let referenceExpression = reference.identifier;
+	while (referenceExpression.parent && isNodeOfType(referenceExpression.parent, "MemberExpression") && referenceExpression.parent.object === referenceExpression) referenceExpression = referenceExpression.parent;
+	const parent = referenceExpression.parent;
+	return Boolean(isNodeOfType(parent, "AssignmentExpression") && parent.left === referenceExpression || isNodeOfType(parent, "UpdateExpression") && parent.argument === referenceExpression || isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === referenceExpression || isNodeOfType(parent, "CallExpression") && parent.arguments?.some((argument) => argument === referenceExpression));
+});
+const resolveInlineStyleObjectExpression = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "ObjectExpression")) return candidate;
+	if (!scopes || !isNodeOfType(candidate, "Identifier")) return null;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || isConstObjectBindingMutated(symbol)) return null;
+	const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+	nextVisitedSymbolIds.add(symbol.id);
+	return resolveInlineStyleObjectExpression(symbol.initializer, scopes, nextVisitedSymbolIds);
+};
+const getInlineStyleExpression = (node, scopes) => {
+	if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "style") return null;
+	if (!isNodeOfType(node.value, "JSXExpressionContainer")) return null;
+	return resolveInlineStyleObjectExpression(node.value.expression, scopes);
+};
+//#endregion
+//#region src/plugin/rules/design/utils/get-string-from-class-name-attr.ts
+const getStringFromClassNameAttr = (node) => {
+	if (!isNodeOfType(node, "JSXOpeningElement")) return null;
+	const classAttr = getAuthoritativeJsxAttribute(node.attributes ?? [], "className");
+	if (!classAttr?.value) return null;
+	if (isNodeOfType(classAttr.value, "Literal") && typeof classAttr.value.value === "string") return classAttr.value.value;
+	if (isNodeOfType(classAttr.value, "JSXExpressionContainer") && isNodeOfType(classAttr.value.expression, "Literal") && typeof classAttr.value.expression.value === "string") return classAttr.value.expression.value;
+	if (isNodeOfType(classAttr.value, "JSXExpressionContainer") && isNodeOfType(classAttr.value.expression, "TemplateLiteral") && classAttr.value.expression.quasis?.length === 1) return classAttr.value.expression.quasis[0].value?.raw ?? null;
+	return null;
+};
+//#endregion
+//#region src/plugin/rules/design/utils/get-style-property-string-value.ts
+const getStylePropertyStringValue = (property) => {
+	if (!isNodeOfType(property, "Property")) return null;
+	if (isNodeOfType(property.value, "Literal") && typeof property.value.value === "string") return property.value.value;
+	return null;
+};
+//#endregion
+//#region src/plugin/constants/tailwind.ts
+const TAILWIND_NAMED_BREAKPOINTS = [
+	"sm",
+	"md",
+	"lg",
+	"xl",
+	"2xl"
+];
+const TAILWIND_BREAKPOINT_NAMES = ["", ...TAILWIND_NAMED_BREAKPOINTS];
+const TAILWIND_BREAKPOINT_RANKS = new Map(TAILWIND_NAMED_BREAKPOINTS.map((breakpointName, breakpointIndex) => [breakpointName, breakpointIndex]));
+//#endregion
+//#region src/plugin/utils/normalize-tailwind-arbitrary-utility-value.ts
+const normalizeTailwindArbitraryUtilityValue = (value) => value.replace(/(?<!\\)_/g, " ");
+//#endregion
+//#region src/plugin/utils/get-tailwind-visibility-effect.ts
+const DISPLAY_VISIBILITY_EFFECTS = new Map([
+	["hidden", {
+		isVisible: false,
+		propertyName: "display"
+	}],
+	["block", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["contents", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["flex", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["flow-root", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["grid", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["inline", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["inline-block", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["inline-flex", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["inline-grid", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["inline-table", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["list-item", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["table", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["table-caption", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["table-cell", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["table-column", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["table-column-group", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["table-footer-group", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["table-header-group", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["table-row", {
+		isVisible: true,
+		propertyName: "display"
+	}],
+	["table-row-group", {
+		isVisible: true,
+		propertyName: "display"
+	}]
+]);
+const VISIBILITY_VISIBILITY_EFFECTS = new Map([
+	["collapse", {
+		isVisible: false,
+		propertyName: "visibility"
+	}],
+	["invisible", {
+		isVisible: false,
+		propertyName: "visibility"
+	}],
+	["visible", {
+		isVisible: true,
+		propertyName: "visibility"
+	}]
+]);
+const VISIBLE_ARBITRARY_DISPLAY_VALUES = new Set([
+	"block",
+	"contents",
+	"flex",
+	"flow-root",
+	"grid",
+	"inline",
+	"inline block",
+	"inline flex",
+	"inline flow-root",
+	"inline grid",
+	"inline table",
+	"list-item",
+	"table",
+	"table-caption",
+	"table-cell",
+	"table-column",
+	"table-column-group",
+	"table-footer-group",
+	"table-header-group",
+	"table-row",
+	"table-row-group"
+]);
+const getArbitraryCssPropertyValue = (utility, propertyName) => {
+	const propertyPrefix = `[${propertyName}:`;
+	return utility.toLowerCase().startsWith(propertyPrefix) && utility.endsWith("]") ? utility.slice(propertyPrefix.length, -1) : null;
+};
+const getTailwindVisibilityEffect = (utility) => {
+	const knownEffect = DISPLAY_VISIBILITY_EFFECTS.get(utility) ?? VISIBILITY_VISIBILITY_EFFECTS.get(utility);
+	if (knownEffect) return {
+		...knownEffect,
+		status: "known"
+	};
+	const arbitraryDisplayValue = getArbitraryCssPropertyValue(utility, "display");
+	if (arbitraryDisplayValue !== null) {
+		const displayValue = normalizeTailwindArbitraryUtilityValue(arbitraryDisplayValue).trim().toLowerCase();
+		if (displayValue === "none") return {
+			isVisible: false,
+			propertyName: "display",
+			status: "known"
+		};
+		return VISIBLE_ARBITRARY_DISPLAY_VALUES.has(displayValue) ? {
+			isVisible: true,
+			propertyName: "display",
+			status: "known"
+		} : {
+			isVisible: null,
+			propertyName: "display",
+			status: "unknown"
+		};
+	}
+	const arbitraryVisibilityValue = getArbitraryCssPropertyValue(utility, "visibility");
+	if (arbitraryVisibilityValue === null) return {
+		isVisible: null,
+		propertyName: null,
+		status: "not-relevant"
+	};
+	const visibilityValue = normalizeTailwindArbitraryUtilityValue(arbitraryVisibilityValue).trim().toLowerCase();
+	if (visibilityValue === "visible") return {
+		isVisible: true,
+		propertyName: "visibility",
+		status: "known"
+	};
+	return visibilityValue === "hidden" || visibilityValue === "collapse" ? {
+		isVisible: false,
+		propertyName: "visibility",
+		status: "known"
+	} : {
+		isVisible: null,
+		propertyName: "visibility",
+		status: "unknown"
+	};
+};
+//#endregion
+//#region src/plugin/utils/parse-tailwind-class-name-token.ts
+const isCharacterEscaped = (value, characterIndex) => {
+	let backslashCount = 0;
+	for (let precedingIndex = characterIndex - 1; precedingIndex >= 0 && value[precedingIndex] === "\\"; precedingIndex -= 1) backslashCount += 1;
+	return backslashCount % 2 === 1;
+};
+const parseTailwindClassNameToken = (rawToken) => {
+	const variants = [];
+	let segmentStartIndex = 0;
+	for (const characterIndex of getTailwindTopLevelCharacterIndices(rawToken, (character) => character === ":")) {
+		variants.push(rawToken.slice(segmentStartIndex, characterIndex));
+		segmentStartIndex = characterIndex + 1;
+	}
+	let utility = rawToken.slice(segmentStartIndex);
+	const hasTrailingImportantModifier = utility.endsWith("!") && !isCharacterEscaped(utility, utility.length - 1);
+	const isImportant = utility.startsWith("!") || hasTrailingImportantModifier;
+	if (utility.startsWith("!")) utility = utility.slice(1);
+	if (hasTrailingImportantModifier) utility = utility.slice(0, -1);
+	return {
+		isImportant,
+		utility,
+		variants
+	};
+};
+//#endregion
+//#region src/plugin/utils/get-tailwind-visibility-at-breakpoints.ts
+const getResponsiveVariantScope = (variants) => {
+	let minimumBreakpointIndex = 0;
+	let maximumBreakpointIndex = TAILWIND_BREAKPOINT_NAMES.length;
+	for (const variant of variants) {
+		const minimumVariantIndex = TAILWIND_BREAKPOINT_NAMES.indexOf(variant);
+		if (minimumVariantIndex > 0) {
+			minimumBreakpointIndex = Math.max(minimumBreakpointIndex, minimumVariantIndex);
+			continue;
+		}
+		if (variant.startsWith("max-")) {
+			const maximumVariantIndex = TAILWIND_BREAKPOINT_NAMES.indexOf(variant.slice(4));
+			if (maximumVariantIndex > 0) {
+				maximumBreakpointIndex = Math.min(maximumBreakpointIndex, maximumVariantIndex);
+				continue;
+			}
+		}
+		return null;
+	}
+	return {
+		maximumBreakpointIndex,
+		minimumBreakpointIndex,
+		specificity: variants.length
+	};
+};
+const resolveVisibilityProperty = (scopedEffects, breakpointIndex, propertyName) => {
+	const applicableEffects = scopedEffects.filter(({ effect, scope }) => effect.propertyName === propertyName && breakpointIndex >= scope.minimumBreakpointIndex && breakpointIndex < scope.maximumBreakpointIndex);
+	if (applicableEffects.length === 0) return true;
+	const highestImportanceEffects = applicableEffects.some(({ token }) => token.isImportant) ? applicableEffects.filter(({ token }) => token.isImportant) : applicableEffects;
+	const maximumSpecificity = Math.max(...highestImportanceEffects.map(({ scope }) => scope.specificity));
+	const highestSpecificityEffects = highestImportanceEffects.filter(({ scope }) => scope.specificity === maximumSpecificity);
+	const maximumMinimumBreakpoint = Math.max(...highestSpecificityEffects.map(({ scope }) => scope.minimumBreakpointIndex));
+	const latestMinimumEffects = highestSpecificityEffects.filter(({ scope }) => scope.minimumBreakpointIndex === maximumMinimumBreakpoint);
+	const minimumMaximumBreakpoint = Math.min(...latestMinimumEffects.map(({ scope }) => scope.maximumBreakpointIndex));
+	const highestPriorityStates = new Set(latestMinimumEffects.filter(({ scope }) => scope.maximumBreakpointIndex === minimumMaximumBreakpoint).map(({ effect }) => effect.isVisible));
+	return highestPriorityStates.size === 1 ? highestPriorityStates.values().next().value ?? null : null;
+};
+const getTailwindVisibilityAtBreakpoints = (className) => {
+	const scopedEffects = [];
+	for (const token of splitTailwindClassName(className).map(parseTailwindClassNameToken)) {
+		const resolution = getTailwindVisibilityEffect(token.utility);
+		if (resolution.status === "not-relevant") continue;
+		const scope = getResponsiveVariantScope(token.variants);
+		if (scope === null) return null;
+		if (!scope || scope.minimumBreakpointIndex >= scope.maximumBreakpointIndex) continue;
+		if (resolution.status === "unknown" || resolution.propertyName === null || resolution.isVisible === null) return null;
+		const effect = {
+			isVisible: resolution.isVisible,
+			propertyName: resolution.propertyName
+		};
+		scopedEffects.push({
+			effect,
+			scope,
+			token
+		});
+	}
+	const visibilityAtBreakpoints = [];
+	for (let breakpointIndex = 0; breakpointIndex < TAILWIND_BREAKPOINT_NAMES.length; breakpointIndex += 1) {
+		const displayVisibility = resolveVisibilityProperty(scopedEffects, breakpointIndex, "display");
+		const visibilityVisibility = resolveVisibilityProperty(scopedEffects, breakpointIndex, "visibility");
+		if (displayVisibility === null || visibilityVisibility === null) return null;
+		visibilityAtBreakpoints.push(displayVisibility && visibilityVisibility);
+	}
+	return visibilityAtBreakpoints;
+};
+//#endregion
+//#region src/plugin/utils/is-inside-statically-hidden-jsx-subtree.ts
+const isStaticallyHiddenOpeningElement = (openingElement, context) => {
+	if (isHiddenFromScreenReader(openingElement, context.settings)) return true;
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	const styleExpression = styleAttribute ? getInlineStyleExpression(styleAttribute, context.scopes) : null;
+	if (styleExpression) {
+		const displayProperty = getEffectiveStyleProperty(styleExpression.properties, "display");
+		if (displayProperty && getStylePropertyStringValue(displayProperty)?.toLowerCase() === "none") return true;
+		const visibilityProperty = getEffectiveStyleProperty(styleExpression.properties, "visibility");
+		const visibilityValue = visibilityProperty ? getStylePropertyStringValue(visibilityProperty)?.toLowerCase() : null;
+		if (visibilityValue === "hidden" || visibilityValue === "collapse") return true;
+	}
+	const className = getStringFromClassNameAttr(openingElement);
+	if (!className) return false;
+	const visibilityAtBreakpoints = getTailwindVisibilityAtBreakpoints(className);
+	return Boolean(visibilityAtBreakpoints && visibilityAtBreakpoints.every((isVisible) => !isVisible));
+};
+const isInsideStaticallyHiddenJsxSubtree$1 = (node, context) => {
+	let currentNode = node;
+	while (currentNode) {
+		if (isNodeOfType(currentNode, "JSXElement") && isStaticallyHiddenOpeningElement(currentNode.openingElement, context)) return true;
+		currentNode = currentNode.parent;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/react-ui/utils/get-opening-element-tag-name.ts
 const getOpeningElementTagName = (openingElement) => {
 	if (!openingElement) return null;
@@ -15675,8 +16057,20 @@ const isInsideExcludedTypographyAncestor = (jsxTextNode) => {
 //#endregion
 //#region src/plugin/rules/react-ui/no-em-dash-in-jsx-text.ts
 const EM_DASH = "—";
-const LONG_FORM_CONTENT_PATH_PATTERN = /(?:^|[/\\])(?:articles?|blog|changelog|content|docs?|posts?)(?:[/\\]|$)/i;
+const EM_DASH_ENTITY_PATTERN = /&(?:mdash|#0*8212|#x0*2014);/gi;
+const LONG_FORM_CONTENT_PATH_PATTERN$1 = /(?:^|[/\\])(?:articles?|blog|changelog|content|docs?|posts?)(?:[/\\]|$)/i;
 const PROSE_EM_DASH_PATTERN = /\p{L}[^—\n]*—[^—\n]*\p{L}/u;
+const LETTER_WORD_PATTERN = /\p{L}+/gu;
+const LINE_BREAK_PATTERN = /[\r\n]/u;
+const hasProseEmDash = (text) => text.includes(EM_DASH) && text.split(LINE_BREAK_PATTERN).some((line) => PROSE_EM_DASH_PATTERN.test(line) && (line.match(LETTER_WORD_PATTERN)?.length ?? 0) >= 5);
+const hasProseEmDashInStaticExpression = (rawExpression) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isNodeOfType(expression, "Literal")) return typeof expression.value === "string" && hasProseEmDash(expression.value);
+	if (isNodeOfType(expression, "TemplateLiteral")) return expression.quasis.some((quasi) => hasProseEmDash(quasi.value.cooked ?? quasi.value.raw ?? ""));
+	if (isNodeOfType(expression, "ConditionalExpression")) return hasProseEmDashInStaticExpression(expression.consequent) || hasProseEmDashInStaticExpression(expression.alternate);
+	if (isNodeOfType(expression, "LogicalExpression")) return hasProseEmDashInStaticExpression(expression.right);
+	return false;
+};
 const noEmDashInJsxText = defineRule({
 	id: "design-no-em-dash-in-jsx-text",
 	title: "Em dash in JSX text",
@@ -15685,17 +16079,30 @@ const noEmDashInJsxText = defineRule({
 	defaultEnabled: false,
 	category: "Architecture",
 	recommendation: "Replace em dashes in UI text with commas, colons, semicolons, or parentheses so the copy reads less like AI output.",
-	create: (context) => ({ JSXText(jsxTextNode) {
-		if (context.filename && LONG_FORM_CONTENT_PATH_PATTERN.test(context.filename)) return;
-		const textValue = typeof jsxTextNode.value === "string" ? jsxTextNode.value : "";
-		if (!textValue.includes(EM_DASH)) return;
-		if (!PROSE_EM_DASH_PATTERN.test(textValue)) return;
-		if (isInsideExcludedTypographyAncestor(jsxTextNode)) return;
-		context.report({
-			node: jsxTextNode,
-			message: "Em dash (—) in UI text reads like AI output to your users."
-		});
-	} })
+	create: (context) => {
+		if (context.filename && LONG_FORM_CONTENT_PATH_PATTERN$1.test(context.filename)) return {};
+		return {
+			JSXExpressionContainer(node) {
+				if (node.parent && isNodeOfType(node.parent, "JSXAttribute")) return;
+				if (isInsideExcludedTypographyAncestor(node)) return;
+				if (isInsideStaticallyHiddenJsxSubtree$1(node, context)) return;
+				if (!hasProseEmDashInStaticExpression(node.expression)) return;
+				context.report({
+					node,
+					message: "Em dash (—) in UI text reads like AI output to your users."
+				});
+			},
+			JSXText(node) {
+				if (!hasProseEmDash((typeof node.value === "string" ? node.value : "").replace(EM_DASH_ENTITY_PATTERN, EM_DASH))) return;
+				if (isInsideExcludedTypographyAncestor(node)) return;
+				if (isInsideStaticallyHiddenJsxSubtree$1(node, context)) return;
+				context.report({
+					node,
+					message: "Em dash (—) in UI text reads like AI output to your users."
+				});
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/rules/react-ui/utils/collect-axis-shorthand-pairs.ts
@@ -37454,19 +37861,6 @@ const getStaticMotionPropObject = (openingElement, propertyName, scopes) => {
 	return attribute.value.expression;
 };
 //#endregion
-//#region src/plugin/rules/design/utils/get-style-property-key.ts
-const getStylePropertyKey = (property) => getStaticPropertyKeyName(property, { allowComputedString: true });
-//#endregion
-//#region src/plugin/rules/design/utils/get-effective-style-property.ts
-const getEffectiveStyleProperty = (properties, propertyName) => {
-	for (const property of [...properties ?? []].reverse()) {
-		const currentPropertyName = getStylePropertyKey(property);
-		if (!currentPropertyName) return null;
-		if (currentPropertyName === propertyName && isNodeOfType(property, "Property")) return property;
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/correctness/motion-keyframe-times-mismatch.ts
 const getKeyframeLengths = (animationObject) => {
 	const keyframeLengths = [];
@@ -37510,76 +37904,9 @@ const motionKeyframeTimesMismatch = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/parse-tailwind-class-name-token.ts
-const isCharacterEscaped = (value, characterIndex) => {
-	let backslashCount = 0;
-	for (let precedingIndex = characterIndex - 1; precedingIndex >= 0 && value[precedingIndex] === "\\"; precedingIndex -= 1) backslashCount += 1;
-	return backslashCount % 2 === 1;
-};
-const parseTailwindClassNameToken = (rawToken) => {
-	const variants = [];
-	let segmentStartIndex = 0;
-	for (const characterIndex of getTailwindTopLevelCharacterIndices(rawToken, (character) => character === ":")) {
-		variants.push(rawToken.slice(segmentStartIndex, characterIndex));
-		segmentStartIndex = characterIndex + 1;
-	}
-	let utility = rawToken.slice(segmentStartIndex);
-	const hasTrailingImportantModifier = utility.endsWith("!") && !isCharacterEscaped(utility, utility.length - 1);
-	const isImportant = utility.startsWith("!") || hasTrailingImportantModifier;
-	if (utility.startsWith("!")) utility = utility.slice(1);
-	if (hasTrailingImportantModifier) utility = utility.slice(0, -1);
-	return {
-		isImportant,
-		utility,
-		variants
-	};
-};
-//#endregion
 //#region src/plugin/utils/get-unvariant-class-name-tokens.ts
 const getUnvariantClassNameTokens = (classNameValue) => splitTailwindClassName(classNameValue).map(parseTailwindClassNameToken).filter((token) => token.variants.length === 0).map((token) => token.utility);
 //#endregion
-//#region src/plugin/rules/design/utils/get-inline-style-expression.ts
-const isConstObjectBindingMutated = (symbol) => symbol.references.some((reference) => {
-	if (reference.flag !== "read") return true;
-	let referenceExpression = reference.identifier;
-	while (referenceExpression.parent && isNodeOfType(referenceExpression.parent, "MemberExpression") && referenceExpression.parent.object === referenceExpression) referenceExpression = referenceExpression.parent;
-	const parent = referenceExpression.parent;
-	return Boolean(isNodeOfType(parent, "AssignmentExpression") && parent.left === referenceExpression || isNodeOfType(parent, "UpdateExpression") && parent.argument === referenceExpression || isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === referenceExpression || isNodeOfType(parent, "CallExpression") && parent.arguments?.some((argument) => argument === referenceExpression));
-});
-const resolveInlineStyleObjectExpression = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const candidate = stripParenExpression(expression);
-	if (isNodeOfType(candidate, "ObjectExpression")) return candidate;
-	if (!scopes || !isNodeOfType(candidate, "Identifier")) return null;
-	const symbol = scopes.symbolFor(candidate);
-	if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || isConstObjectBindingMutated(symbol)) return null;
-	const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-	nextVisitedSymbolIds.add(symbol.id);
-	return resolveInlineStyleObjectExpression(symbol.initializer, scopes, nextVisitedSymbolIds);
-};
-const getInlineStyleExpression = (node, scopes) => {
-	if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "style") return null;
-	if (!isNodeOfType(node.value, "JSXExpressionContainer")) return null;
-	return resolveInlineStyleObjectExpression(node.value.expression, scopes);
-};
-//#endregion
-//#region src/plugin/rules/design/utils/get-string-from-class-name-attr.ts
-const getStringFromClassNameAttr = (node) => {
-	if (!isNodeOfType(node, "JSXOpeningElement")) return null;
-	const classAttr = getAuthoritativeJsxAttribute(node.attributes ?? [], "className");
-	if (!classAttr?.value) return null;
-	if (isNodeOfType(classAttr.value, "Literal") && typeof classAttr.value.value === "string") return classAttr.value.value;
-	if (isNodeOfType(classAttr.value, "JSXExpressionContainer") && isNodeOfType(classAttr.value.expression, "Literal") && typeof classAttr.value.expression.value === "string") return classAttr.value.expression.value;
-	if (isNodeOfType(classAttr.value, "JSXExpressionContainer") && isNodeOfType(classAttr.value.expression, "TemplateLiteral") && classAttr.value.expression.quasis?.length === 1) return classAttr.value.expression.quasis[0].value?.raw ?? null;
-	return null;
-};
-//#endregion
-//#region src/plugin/rules/design/utils/get-style-property-string-value.ts
-const getStylePropertyStringValue = (property) => {
-	if (!isNodeOfType(property, "Property")) return null;
-	if (isNodeOfType(property.value, "Literal") && typeof property.value.value === "string") return property.value.value;
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/correctness/motion-layout-on-inline-element.ts
 const ENABLED_LAYOUT_VALUES = new Set([
 	"position",
@@ -47575,6 +47902,155 @@ const noAsyncEventHandlerWithoutReentryGuard = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/design/no-auto-scrolling-content.ts
+const MOVEMENT_CONTROL_ACTION_PATTERN = /\b(?:next|pause|play|prev|previous|resume|stop)\b/i;
+const MOVEMENT_CONTROL_CONTEXT_PATTERN = /\b(?:carousel|marquee|slide|slider|ticker)\b/i;
+const LIVE_REGION_ROLES$1 = new Set([
+	"alert",
+	"log",
+	"progressbar",
+	"status",
+	"timer"
+]);
+const HORIZONTAL_MOTION_PROPERTY_NAMES = ["x", "translateX"];
+const getPercentageValue = (node) => {
+	if (!isNodeOfType(node, "Literal") || typeof node.value !== "string") return null;
+	const match = /^(-?(?:\d+(?:\.\d+)?|\.\d+))%$/.exec(node.value.trim());
+	return match ? Number.parseFloat(match[1]) : null;
+};
+const getPercentageValues = (node) => {
+	if (!isNodeOfType(node, "ArrayExpression")) {
+		const percentageValue = getPercentageValue(node);
+		return percentageValue === null ? null : [percentageValue];
+	}
+	const percentageValues = [];
+	for (const element of node.elements) {
+		if (!element || isNodeOfType(element, "SpreadElement")) return null;
+		const percentageValue = getPercentageValue(element);
+		if (percentageValue === null) return null;
+		percentageValues.push(percentageValue);
+	}
+	return percentageValues.length > 0 ? percentageValues : null;
+};
+const isInfiniteRepeatProperty = (property, context) => isNodeOfType(property, "Property") && (isNodeOfType(property.value, "Identifier") && property.value.name === "Infinity" && context.scopes.isGlobalReference(property.value) || isNodeOfType(property.value, "Literal") && property.value.value === Infinity);
+const hasInfiniteMotionRepeat = (openingElement, animateObject, context) => {
+	const transitionObjects = [];
+	const transitionObject = getStaticMotionPropObject(openingElement, "transition", context.scopes);
+	if (transitionObject) transitionObjects.push(transitionObject);
+	const nestedTransitionProperty = getEffectiveStyleProperty(animateObject.properties, "transition");
+	if (nestedTransitionProperty && isNodeOfType(nestedTransitionProperty.value, "ObjectExpression")) transitionObjects.push(nestedTransitionProperty.value);
+	return transitionObjects.some((candidate) => {
+		const repeatProperty = getEffectiveStyleProperty(candidate.properties, "repeat");
+		return Boolean(repeatProperty && isInfiniteRepeatProperty(repeatProperty, context));
+	});
+};
+const getHorizontalTravel = (openingElement, animateObject, context) => {
+	const initialObject = getStaticMotionPropObject(openingElement, "initial", context.scopes);
+	for (const propertyName of HORIZONTAL_MOTION_PROPERTY_NAMES) {
+		const animateProperty = getEffectiveStyleProperty(animateObject.properties, propertyName);
+		if (!animateProperty) continue;
+		const animateValues = getPercentageValues(animateProperty.value);
+		if (!animateValues) continue;
+		const percentageValues = [...animateValues];
+		if (percentageValues.length === 1 && initialObject) {
+			const initialProperty = getEffectiveStyleProperty(initialObject.properties, propertyName);
+			if (!initialProperty) continue;
+			const initialValues = getPercentageValues(initialProperty.value);
+			if (!initialValues || initialValues.length !== 1) continue;
+			percentageValues.push(initialValues[0]);
+		}
+		if (percentageValues.length < 2) continue;
+		return Math.max(...percentageValues) - Math.min(...percentageValues);
+	}
+	return null;
+};
+const hasDynamicJsxAttributeValue = (attribute) => {
+	if (!attribute.value || isNodeOfType(attribute.value, "Literal")) return false;
+	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return true;
+	const expression = attribute.value.expression;
+	return !(isNodeOfType(expression, "Literal") || isNodeOfType(expression, "TemplateLiteral") && expression.expressions.length === 0);
+};
+const hasUnresolvedTextTrackContent = (node) => {
+	if (isNodeOfType(node, "JSXExpressionContainer")) {
+		const expression = node.expression;
+		if (isNodeOfType(expression, "Literal") || isNodeOfType(expression, "TemplateLiteral") && expression.expressions.length === 0 || isNodeOfType(expression, "JSXEmptyExpression")) return false;
+		if (isNodeOfType(expression, "JSXElement") || isNodeOfType(expression, "JSXFragment")) return hasUnresolvedTextTrackContent(expression);
+		return true;
+	}
+	if (isNodeOfType(node, "JSXElement")) {
+		if (node.openingElement.selfClosing || !isNodeOfType(node.openingElement.name, "JSXIdentifier") || !/^[a-z]/.test(node.openingElement.name.name) || hasJsxSpreadAttribute(node.openingElement.attributes) || node.openingElement.attributes.some((attribute) => isNodeOfType(attribute, "JSXAttribute") && hasDynamicJsxAttributeValue(attribute))) return true;
+		return node.children.some(hasUnresolvedTextTrackContent);
+	}
+	if (isNodeOfType(node, "JSXFragment")) return node.children.some(hasUnresolvedTextTrackContent);
+	return isNodeOfType(node, "JSXSpreadChild");
+};
+const hasUnresolvedOrLiveSemantics = (openingElement, context) => {
+	if (hasJsxSpreadAttribute(openingElement.attributes)) return true;
+	const roleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "role");
+	const roleValues = roleAttribute ? getJsxPropStaticStringValues(roleAttribute, context.scopes) : [];
+	if (!roleValues) return true;
+	if (roleValues.some((role) => role.toLowerCase().split(/\s+/).some((roleToken) => LIVE_REGION_ROLES$1.has(roleToken)))) return true;
+	const ariaLiveAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "aria-live");
+	if (!ariaLiveAttribute) return false;
+	const ariaLiveValues = getJsxPropStaticStringValues(ariaLiveAttribute, context.scopes);
+	return !ariaLiveValues || ariaLiveValues.some((value) => value.toLowerCase() !== "off");
+};
+const isInsideUnresolvedOrLiveRegion = (element, context) => {
+	let currentNode = element;
+	while (currentNode) {
+		if (isNodeOfType(currentNode, "JSXElement") && hasUnresolvedOrLiveSemantics(currentNode.openingElement, context)) return true;
+		currentNode = currentNode.parent;
+	}
+	return false;
+};
+const findNearestJsxContainer = (element) => {
+	let ancestor = element.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement")) return ancestor;
+		ancestor = ancestor.parent;
+	}
+	return null;
+};
+const hasPauseOrCarouselControl = (containers, movingElement, context) => {
+	const movingIdAttribute = getAuthoritativeJsxAttribute(movingElement.openingElement.attributes, "id");
+	const movingIds = movingIdAttribute ? getJsxPropStaticStringValues(movingIdAttribute, context.scopes) : [];
+	return containers.flatMap((container) => getStaticJsxDescendantOpeningElements(container)).some((openingElement) => {
+		if (getElementType(openingElement, context.settings) !== "button") return false;
+		const ariaLabelAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "aria-label");
+		const ariaLabelValues = ariaLabelAttribute ? getJsxPropStaticStringValues(ariaLabelAttribute, context.scopes) : [];
+		const buttonElement = openingElement.parent;
+		const visibleLabel = isNodeOfType(buttonElement, "JSXElement") ? getStaticJsxText(buttonElement).trim() : "";
+		const controlLabels = [...ariaLabelValues ?? [], visibleLabel].filter(Boolean);
+		if (!controlLabels.some((label) => MOVEMENT_CONTROL_ACTION_PATTERN.test(label))) return false;
+		if (controlLabels.some((label) => MOVEMENT_CONTROL_CONTEXT_PATTERN.test(label))) return true;
+		const ariaControlsAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "aria-controls");
+		const controlledIds = ariaControlsAttribute ? getJsxPropStaticStringValues(ariaControlsAttribute, context.scopes) : [];
+		return Boolean(movingIds && controlledIds && controlledIds.some((controlledId) => movingIds.includes(controlledId)));
+	});
+};
+const noAutoScrollingContent = defineRule({
+	id: "no-auto-scrolling-content",
+	title: "Content auto-scrolls forever",
+	severity: "warn",
+	defaultEnabled: false,
+	tags: ["design", "test-noise"],
+	recommendation: "Keep content still so readers control the pace, or provide an accessible pause control for essential live movement.",
+	create: (context) => ({ JSXElement(node) {
+		if (isInsideUnresolvedOrLiveRegion(node, context)) return;
+		if (node.children.some(hasUnresolvedTextTrackContent) || !getStaticJsxText(node).trim()) return;
+		const animateObject = getStaticMotionPropObject(node.openingElement, "animate", context.scopes);
+		if (!animateObject || !hasInfiniteMotionRepeat(node.openingElement, animateObject, context)) return;
+		const horizontalTravel = getHorizontalTravel(node.openingElement, animateObject, context);
+		if (horizontalTravel === null || horizontalTravel < 20) return;
+		const container = findNearestJsxContainer(node);
+		if (hasPauseOrCarouselControl([container, container ? findNearestJsxContainer(container) : null].filter((candidate) => candidate !== null), node, context)) return;
+		context.report({
+			node: node.openingElement,
+			message: "This content moves horizontally on an endless loop, so readers cannot control its pace. Keep it still or provide an accessible pause control."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/a11y/no-autofocus.ts
 const MESSAGE$56 = "`autoFocus` moves focus on load, which can disrupt screen reader and keyboard users. Remove it and let users choose where to focus.";
 const resolveSettings$21 = (settings) => {
@@ -50907,9 +51383,9 @@ const PADDING_SIDES_BY_PREFIX$1 = new Map([
 ]);
 const TAILWIND_PADDING_PATTERN = /^(p[trblesxy]?)-(px|[\d.]+)$/;
 const ARBITRARY_PADDING_PATTERN = /^(p[trblesxy]?)-\[([\d.]+)(px|rem)\]$/;
-const TAILWIND_BACKGROUND_COLOR_PATTERN = /^bg-(?!opacity-|auto$|center$|clip-|contain$|cover$|fixed$|left$|local$|none$|origin-|repeat|right$|scroll$|top$|\[(?:length|position|size):).+/;
+const TAILWIND_BACKGROUND_COLOR_PATTERN$2 = /^bg-(?!opacity-|auto$|center$|clip-|contain$|cover$|fixed$|left$|local$|none$|origin-|repeat|right$|scroll$|top$|\[(?:length|position|size):).+/;
 const TAILWIND_BORDER_GEOMETRY_PATTERN = /^border(?:-[trblxy])?(?:(?:-(?:px|\d+(?:\.\d+)?|\[\d+(?:\.\d+)?px\]))|-(?:hidden|none|solid|dashed|dotted|double))?$/;
-const TAILWIND_SHADOW_GEOMETRY_PATTERN = /^(?:ring(?:-(?:px|\d+(?:\.\d+)?|\[\d+(?:\.\d+)?px\]))?|shadow(?:-none|-(?:2xl|inner|lg|md|sm|xl|xs))?)$/;
+const TAILWIND_SHADOW_GEOMETRY_PATTERN$1 = /^(?:ring(?:-(?:px|\d+(?:\.\d+)?|\[\d+(?:\.\d+)?px\]))?|shadow(?:-none|-(?:2xl|inner|lg|md|sm|xl|xs))?)$/;
 const BOUNDED_CONTAINER_TAG_NAMES = new Set([
 	"article",
 	"aside",
@@ -51067,9 +51543,9 @@ const noCrampedContainerPadding = defineRule({
 		if (classNameValue && hasCapabilityOrUnspecified(context.settings, "tailwind")) {
 			const tokens = getUnvariantClassNameTokensWithImportantModifiers(classNameValue);
 			const paddingResolution = getTailwindPaddingResolution(tokens);
-			const backgroundResolution = getTailwindUtilityResolution(tokens, (utility) => TAILWIND_BACKGROUND_COLOR_PATTERN.test(utility));
+			const backgroundResolution = getTailwindUtilityResolution(tokens, (utility) => TAILWIND_BACKGROUND_COLOR_PATTERN$2.test(utility));
 			const borderResolution = getTailwindUtilityResolution(tokens, (utility) => TAILWIND_BORDER_GEOMETRY_PATTERN.test(utility));
-			const shadowResolution = getTailwindUtilityResolution(tokens, (utility) => TAILWIND_SHADOW_GEOMETRY_PATTERN.test(utility));
+			const shadowResolution = getTailwindUtilityResolution(tokens, (utility) => TAILWIND_SHADOW_GEOMETRY_PATTERN$1.test(utility));
 			const isBackgroundProtected = backgroundResolution.isImportant || backgroundResolution.isAmbiguous;
 			const isBorderProtected = borderResolution.isImportant || borderResolution.isAmbiguous;
 			const isShadowProtected = shadowResolution.isImportant || shadowResolution.isAmbiguous;
@@ -53286,7 +53762,7 @@ const splitShadowLayers = (shadowValue) => {
 };
 const RGB_COLOR_PATTERN = /rgba?\([^)]*\)/i;
 const HEX_COLOR_PATTERN = /#(?:[0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{4}|[0-9a-f]{3})\b/i;
-const ZERO_ALPHA_PATTERN = /^[+-]?(?:0+(?:\.0*)?|\.0+)%?$/;
+const ZERO_ALPHA_PATTERN$1 = /^[+-]?(?:0+(?:\.0*)?|\.0+)%?$/;
 const isAtTopLevel = (value, index) => {
 	let parenthesisDepth = 0;
 	for (let characterIndex = 0; characterIndex < index; characterIndex += 1) {
@@ -53307,9 +53783,9 @@ const isShadowLayerFullyTransparent = (layer) => {
 	if (rgbMatch?.index === void 0 || !isAtTopLevel(layer, rgbMatch.index)) return false;
 	const colorArguments = rgbMatch[0].slice(rgbMatch[0].indexOf("(") + 1, -1);
 	const slashIndex = colorArguments.lastIndexOf("/");
-	if (slashIndex !== -1) return ZERO_ALPHA_PATTERN.test(colorArguments.slice(slashIndex + 1).trim());
+	if (slashIndex !== -1) return ZERO_ALPHA_PATTERN$1.test(colorArguments.slice(slashIndex + 1).trim());
 	const legacyArguments = colorArguments.split(",");
-	return legacyArguments.length === 4 && ZERO_ALPHA_PATTERN.test(legacyArguments[3].trim());
+	return legacyArguments.length === 4 && ZERO_ALPHA_PATTERN$1.test(legacyArguments[3].trim());
 };
 const extractColorFromShadowLayer = (layer) => {
 	const colorMatch = layer.match(RGB_COLOR_PATTERN) ?? layer.match(HEX_COLOR_PATTERN);
@@ -53385,7 +53861,7 @@ const hasStrongBlur = (tokens) => tokens.some((token) => {
 	const match = token.match(ARBITRARY_BLUR_PATTERN);
 	return Boolean(match && parseFloat(match[1]) >= 24);
 });
-const hasOnlyWhitespaceChildren = (node) => node.children.every((child) => isNodeOfType(child, "JSXText") && (child.value ?? "").trim().length === 0);
+const hasOnlyWhitespaceChildren$1 = (node) => node.children.every((child) => isNodeOfType(child, "JSXText") && (child.value ?? "").trim().length === 0);
 const noDecorativeBlurOrb = defineRule({
 	id: "no-decorative-blur-orb",
 	title: "Empty blurred color orb decorates the layout",
@@ -53394,7 +53870,7 @@ const noDecorativeBlurOrb = defineRule({
 	tags: ["design", "test-noise"],
 	recommendation: "Use structure, imagery, or a restrained surface treatment instead of an oversized blurred color blob.",
 	create: (context) => ({ JSXElement(node) {
-		if (!isNodeOfType(node.openingElement.name, "JSXIdentifier") || !DECORATIVE_ORB_ELEMENT_NAMES.has(node.openingElement.name.name) || !hasOnlyWhitespaceChildren(node)) return;
+		if (!isNodeOfType(node.openingElement.name, "JSXIdentifier") || !DECORATIVE_ORB_ELEMENT_NAMES.has(node.openingElement.name.name) || !hasOnlyWhitespaceChildren$1(node)) return;
 		const classNameValue = getStringFromClassNameAttr(node.openingElement);
 		if (!classNameValue) return;
 		const tokens = getUnvariantClassNameTokens(classNameValue);
@@ -53424,9 +53900,115 @@ const isDataVisualizationContext = (node, filename) => {
 	return false;
 };
 //#endregion
+//#region src/plugin/rules/design/utils/split-css-top-level.ts
+const splitCssTopLevel = (value, separator) => {
+	const parts = [];
+	let depth = 0;
+	let partStartIndex = 0;
+	for (let characterIndex = 0; characterIndex < value.length; characterIndex += 1) {
+		const character = value[characterIndex];
+		if (character === "(") depth += 1;
+		if (character === ")") {
+			depth -= 1;
+			if (depth < 0) return null;
+		}
+		if (character === separator && depth === 0) {
+			parts.push(value.slice(partStartIndex, characterIndex).trim());
+			partStartIndex = characterIndex + 1;
+		}
+	}
+	if (depth !== 0) return null;
+	parts.push(value.slice(partStartIndex).trim());
+	return parts;
+};
+//#endregion
 //#region src/plugin/rules/design/no-decorative-grid-background.ts
-const isDecorativeGridValue = (value) => {
-	return [...value.replace(/repeating-linear-gradient/gi, "").matchAll(/linear-gradient\(/gi)].length >= 2 && /(?:^|[^\d.])1px(?:[^\d.]|$)/i.test(value) && /transparent/i.test(value);
+const TAILWIND_BACKGROUND_SHORTHAND_PROPERTY_PATTERN = /^\[background:[\s\S]+\]$/i;
+const TAILWIND_BACKGROUND_PROPERTY_PATTERN = /^\[(?:background|background-image):[\s\S]+\]$/i;
+const TAILWIND_BACKGROUND_SIZE_PROPERTY_PATTERN = /^\[background-size:[\s\S]+\]$/i;
+const TAILWIND_BACKGROUND_IMAGE_PATTERN = /^(?:bg-none|bg-(?:conic|linear|radial)(?:-|$)|bg-\[(?!length:)[\s\S]+\])$/i;
+const TAILWIND_BACKGROUND_SIZE_PATTERN = /^(?:bg-(?:auto|contain|cover)|bg-\[length:[\s\S]+\])$/i;
+const getLinearGradientBodies = (value) => {
+	const gradientBodies = [];
+	for (const match of value.matchAll(/(?:-(?:moz|ms|o|webkit)-)?linear-gradient\(/gi)) {
+		if (match.index === void 0) continue;
+		const prefix = value.slice(0, match.index).toLowerCase();
+		if (prefix.endsWith("repeating-") || /[\w-]$/.test(prefix)) continue;
+		const bodyStartIndex = match.index + match[0].length;
+		let parenthesisDepth = 1;
+		for (let characterIndex = bodyStartIndex; characterIndex < value.length; characterIndex += 1) {
+			const character = value[characterIndex];
+			if (character === "(") parenthesisDepth += 1;
+			if (character !== ")") continue;
+			parenthesisDepth -= 1;
+			if (parenthesisDepth !== 0) continue;
+			gradientBodies.push(value.slice(bodyStartIndex, characterIndex));
+			break;
+		}
+	}
+	return gradientBodies;
+};
+const getHairlineGradientAxis = (gradientBody) => {
+	const normalizedBody = gradientBody.trim().toLowerCase();
+	const hasLeadingHairline = /\b1(?:\.0+)?px\s*,\s*transparent\s+1(?:\.0+)?px\b/i.test(normalizedBody);
+	const hasInvertedHairline = /transparent\s+calc\(\s*100%\s*-\s*1(?:\.0+)?px\s*\)\s*,[\s\S]*\b1(?:\.0+)?px\b/i.test(normalizedBody);
+	if (!hasLeadingHairline && !hasInvertedHairline) return null;
+	if (/^(?:to\s+(?:left|right)|(?:90|270)(?:\.0+)?deg)\s*,/i.test(normalizedBody)) return "vertical";
+	if (/^(?:to\s+(?:top|bottom)|(?:0|180|360)(?:\.0+)?deg)\s*,/i.test(normalizedBody)) return "horizontal";
+	if (/^(?:to\b|[-+.\d]+(?:deg|grad|rad|turn)\b|in\s)/i.test(normalizedBody)) return null;
+	return "horizontal";
+};
+const getFixedPixelTileDimensionCount = (value, isShorthand) => {
+	const layers = splitCssTopLevel(value, ",");
+	if (!layers) return 0;
+	let maximumDimensionCount = 0;
+	for (const layer of layers) {
+		let sizeValue = layer.trim();
+		if (isShorthand) {
+			const shorthandParts = splitCssTopLevel(layer, "/");
+			if (!shorthandParts || shorthandParts.length !== 2 || !shorthandParts[1]) continue;
+			sizeValue = shorthandParts[1];
+		}
+		const sizeMatch = sizeValue.match(/^(\d+(?:\.\d+)?)px(?:\s+(\d+(?:\.\d+)?)px)?(?:\s+(?:no-repeat|repeat|round|space)){0,2}$/i);
+		if (!sizeMatch || Number.parseFloat(sizeMatch[1]) <= 0) continue;
+		if (sizeMatch[2] && Number.parseFloat(sizeMatch[2]) <= 0) continue;
+		maximumDimensionCount = Math.max(maximumDimensionCount, sizeMatch[2] ? 2 : 1);
+	}
+	return maximumDimensionCount;
+};
+const isDecorativeGridValue = (backgroundValue, backgroundSizeValue, shouldUseBackgroundShorthandSize, isBackgroundSizeShorthand) => {
+	const hairlineAxes = getLinearGradientBodies(backgroundValue).map(getHairlineGradientAxis).filter((axis) => axis !== null);
+	if (hairlineAxes.length === 0) return false;
+	const tileDimensionCount = Math.max(shouldUseBackgroundShorthandSize ? getFixedPixelTileDimensionCount(backgroundValue, true) : 0, backgroundSizeValue ? getFixedPixelTileDimensionCount(backgroundSizeValue, isBackgroundSizeShorthand) : 0);
+	if (hairlineAxes.length >= 2) return new Set(hairlineAxes).size >= 2 && tileDimensionCount >= 1;
+	return tileDimensionCount >= 2;
+};
+const getTailwindBackgroundValue = (utility) => {
+	const propertyMatch = utility.match(/^\[([^:\]]+):([\s\S]+)\]$/);
+	if (propertyMatch?.[1] && propertyMatch[2] && ["background", "background-image"].includes(propertyMatch[1].toLowerCase())) return normalizeTailwindArbitraryUtilityValue(propertyMatch[2]);
+	const backgroundMatch = utility.match(/^bg-\[(?:image:)?([\s\S]+)\]$/);
+	if (backgroundMatch?.[1]) return normalizeTailwindArbitraryUtilityValue(backgroundMatch[1]);
+	return null;
+};
+const getTailwindBackgroundSizeValue = (utility) => {
+	const propertyMatch = utility.match(/^\[background-size:([\s\S]+)\]$/i);
+	if (propertyMatch?.[1]) return normalizeTailwindArbitraryUtilityValue(propertyMatch[1]);
+	const sizeMatch = utility.match(/^bg-\[length:([\s\S]+)\]$/i);
+	if (sizeMatch?.[1]) return normalizeTailwindArbitraryUtilityValue(sizeMatch[1]);
+	return /^(?:bg-auto|bg-contain|bg-cover)$/i.test(utility) ? utility.slice(3) : null;
+};
+const isDecorativeTailwindGrid = (classNameValue, backgroundSizeOverride) => {
+	const tokens = splitTailwindClassName(classNameValue);
+	const backgroundResolution = resolveEffectiveTailwindClassNameToken(tokens, (utility) => Boolean(TAILWIND_BACKGROUND_PROPERTY_PATTERN.test(utility) || TAILWIND_BACKGROUND_IMAGE_PATTERN.test(utility)));
+	const backgroundSizeResolution = resolveEffectiveTailwindClassNameToken(tokens, (utility) => Boolean(TAILWIND_BACKGROUND_SHORTHAND_PROPERTY_PATTERN.test(utility) || TAILWIND_BACKGROUND_SIZE_PROPERTY_PATTERN.test(utility) || TAILWIND_BACKGROUND_SIZE_PATTERN.test(utility)));
+	if (backgroundResolution.isAmbiguous || backgroundSizeResolution.isAmbiguous) return false;
+	const backgroundUtility = backgroundResolution.utility;
+	if (!backgroundUtility) return false;
+	const backgroundValue = getTailwindBackgroundValue(backgroundUtility);
+	if (!backgroundValue) return false;
+	const backgroundSizeUtility = backgroundSizeResolution.utility;
+	const hasExplicitBackgroundSize = backgroundSizeOverride !== void 0 || Boolean(backgroundSizeUtility && !TAILWIND_BACKGROUND_SHORTHAND_PROPERTY_PATTERN.test(backgroundSizeUtility));
+	return isDecorativeGridValue(backgroundValue, backgroundSizeOverride ?? (backgroundSizeUtility ? getTailwindBackgroundSizeValue(backgroundSizeUtility) : null), !hasExplicitBackgroundSize, false);
 };
 const noDecorativeGridBackground = defineRule({
 	id: "no-decorative-grid-background",
@@ -53437,34 +54019,70 @@ const noDecorativeGridBackground = defineRule({
 	recommendation: "Reserve coordinate grids for data or spatial interfaces; use a quieter surface for decoration.",
 	create: (context) => ({ JSXOpeningElement(node) {
 		if (isDataVisualizationContext(node, context.filename)) return;
-		const classNameValue = getStringFromClassNameAttr(node);
-		if (classNameValue && isDecorativeGridValue(classNameValue)) {
-			context.report({
-				node,
-				message: "This layered one-pixel grid is decorative rather than functional. Simplify the surface or tie the grid to spatial content."
-			});
-			return;
-		}
-		for (const attribute of node.attributes ?? []) {
-			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
-			const styleExpression = getInlineStyleExpression(attribute);
-			if (!styleExpression) continue;
-			for (const propertyName of ["background", "backgroundImage"]) {
-				const property = getEffectiveStyleProperty(styleExpression.properties, propertyName);
-				if (!property) continue;
-				const propertyValue = getStylePropertyStringValue(property);
-				if (!propertyValue || !isDecorativeGridValue(propertyValue)) continue;
-				context.report({
-					node: property,
-					message: "This background draws a decorative coordinate grid. Use it only when the grid conveys spatial information."
-				});
+		let inlineBackgroundSizeValue;
+		const styleAttribute = getAuthoritativeJsxAttribute(node.attributes ?? [], "style");
+		if (!styleAttribute && hasJsxSpreadThatMayProvideAttribute(node.attributes ?? [], "style")) return;
+		if (styleAttribute) {
+			const styleExpression = getInlineStyleExpression(styleAttribute, context.scopes);
+			if (!styleExpression) return;
+			if (styleExpression.properties.some((property) => getStylePropertyKey(property) === null)) return;
+			let backgroundProperty = null;
+			let backgroundSizeProperty = null;
+			for (const property of styleExpression.properties) {
+				if (!isNodeOfType(property, "Property")) return;
+				const propertyName = getStylePropertyKey(property);
+				if (propertyName === "background") {
+					backgroundProperty = property;
+					backgroundSizeProperty = property;
+				}
+				if (propertyName === "backgroundImage") backgroundProperty = property;
+				if (propertyName === "backgroundSize") backgroundSizeProperty = property;
+			}
+			if (backgroundProperty || backgroundSizeProperty) {
+				const backgroundValue = backgroundProperty ? getStylePropertyStringValue(backgroundProperty) : null;
+				const backgroundSizeValue = backgroundSizeProperty ? getStylePropertyStringValue(backgroundSizeProperty) : null;
+				if (backgroundSizeProperty && backgroundSizeProperty !== backgroundProperty && backgroundSizeValue === null) return;
+				if (backgroundSizeProperty !== backgroundProperty && backgroundSizeValue) inlineBackgroundSizeValue = backgroundSizeValue;
+				if (backgroundValue && isDecorativeGridValue(backgroundValue, backgroundSizeValue, backgroundSizeProperty === backgroundProperty, Boolean(backgroundSizeProperty && getStylePropertyKey(backgroundSizeProperty) === "background"))) {
+					context.report({
+						node: backgroundProperty ?? styleAttribute,
+						message: "This fixed-pixel background draws a decorative coordinate grid. Use it only when the grid conveys spatial information."
+					});
+					return;
+				}
+				if (backgroundProperty) return;
 			}
 		}
+		const classNameValue = getStringFromClassNameAttr(node);
+		if (classNameValue && isDecorativeTailwindGrid(classNameValue, inlineBackgroundSizeValue)) context.report({
+			node,
+			message: "This fixed-pixel grid is decorative rather than functional. Simplify the surface or tie the grid to spatial content."
+		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/design/no-decorative-pulse.ts
 const BUSY_TEXT_PATTERN = /\b(?:loading|processing|saving|syncing|uploading)\b/i;
+const CURSOR_GLYPH_PATTERN = /^[_|▀-▟■▮❙❚｜]$/u;
+const CURSOR_ANIMATION_NAME_PATTERN = /(?:^|[-_\s])(?:blink|caret|cursor|pulse)(?:$|[-_\s])/i;
+const INFINITE_ANIMATION_TOKEN_PATTERN = /(?:^|\s)infinite(?:$|\s)/i;
+const HERO_CONTEXT_NAME_PATTERN = /(?:Hero|Landing|Marketing|Masthead)/;
+const HERO_CONTEXT_CLASS_PATTERN = /(?:^|[-_:])(?:hero|landing|marketing|masthead)(?:$|[-_:])/i;
+const PREFORMATTED_CONTEXT_NAME_PATTERN = /(?:Code|Console|Diff|Editor|Syntax|Terminal)/;
+const PREFORMATTED_CONTEXT_CLASS_PATTERN = /(?:^|[-_:])(?:code|console|diff|editor|syntax|terminal)(?:$|[-_:])/i;
+const EXCLUDED_CONTENT_PATH_PATTERN$1 = /(?:^|[/\\])(?:docs?|documentation)(?:[/\\]|$)/i;
+const CURSOR_EXEMPT_ROLES = new Set([
+	"progressbar",
+	"status",
+	"textbox"
+]);
+const CURSOR_EXEMPT_ELEMENT_NAMES = new Set([
+	"code",
+	"input",
+	"pre",
+	"textarea"
+]);
+const TAILWIND_ANIMATION_UTILITY_PATTERN = /^(?:animate-|\[animation:)/;
 const getStaticAttributeValue = (attribute) => {
 	const value = attribute.value;
 	if (!value) return true;
@@ -53479,17 +54097,141 @@ const isBusyStatus = (openingElement) => {
 	const roleValue = roleAttribute && getStaticAttributeValue(roleAttribute);
 	return roleValue === "status" || roleValue === "progressbar";
 };
+const getStaticCursorText = (node) => {
+	if (isNodeOfType(node, "JSXText")) return node.value;
+	if (isNodeOfType(node, "Literal")) return typeof node.value === "string" ? node.value : null;
+	if (isNodeOfType(node, "TemplateLiteral")) {
+		if (node.expressions.length > 0) return null;
+		return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join("");
+	}
+	if (isNodeOfType(node, "JSXExpressionContainer")) return getStaticCursorText(node.expression);
+	if (isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment")) {
+		let text = "";
+		for (const child of node.children) {
+			const childText = getStaticCursorText(child);
+			if (childText === null) return null;
+			text += childText;
+		}
+		return text;
+	}
+	return null;
+};
+const getStaticCursorGlyph = (element) => {
+	const glyph = getStaticCursorText(element)?.trim() ?? "";
+	return CURSOR_GLYPH_PATTERN.test(glyph) ? glyph : null;
+};
+const hasCursorAnimationName = (value) => CURSOR_ANIMATION_NAME_PATTERN.test(value.replaceAll("\\_", "_"));
+const isInfiniteCursorAnimation = (value) => {
+	const animationSegments = splitCssTopLevel(value, ",");
+	return Boolean(animationSegments?.length === 1 && INFINITE_ANIMATION_TOKEN_PATTERN.test(value) && hasCursorAnimationName(value));
+};
+const getInlineCursorAnimationState = (openingElement, context) => {
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	if (!styleAttribute) return null;
+	const styleExpression = getInlineStyleExpression(styleAttribute, context.scopes);
+	if (!styleExpression || styleExpression.properties.some((property) => getStylePropertyKey(property) === null)) return null;
+	const animationProperty = getEffectiveStyleProperty(styleExpression.properties, "animation");
+	if (animationProperty) {
+		const animationValue = getStylePropertyStringValue(animationProperty);
+		return animationValue === null ? null : isInfiniteCursorAnimation(animationValue);
+	}
+	const animationNameProperty = getEffectiveStyleProperty(styleExpression.properties, "animationName");
+	const animationIterationCountProperty = getEffectiveStyleProperty(styleExpression.properties, "animationIterationCount");
+	if (!animationNameProperty && !animationIterationCountProperty) return null;
+	if (!animationNameProperty || !animationIterationCountProperty) return null;
+	const animationName = getStylePropertyStringValue(animationNameProperty);
+	const animationIterationCount = getStylePropertyStringValue(animationIterationCountProperty);
+	if (animationName === null || animationIterationCount === null) return null;
+	return animationIterationCount.toLowerCase() === "infinite" && hasCursorAnimationName(animationName);
+};
+const hasStaticTailwindCursorAnimation = (openingElement) => {
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	if (!classNameValue) return false;
+	const animationResolution = resolveEffectiveTailwindClassNameToken(splitTailwindClassName(classNameValue), (utility) => TAILWIND_ANIMATION_UTILITY_PATTERN.test(utility));
+	if (animationResolution.isAmbiguous || !animationResolution.utility) return false;
+	if (animationResolution.utility === "animate-pulse") return true;
+	const arbitraryAnimation = animationResolution.utility.match(/^animate-\[(.+)\]$/)?.[1] ?? animationResolution.utility.match(/^\[animation:(.+)\]$/)?.[1];
+	return Boolean(arbitraryAnimation && isInfiniteCursorAnimation(arbitraryAnimation.replaceAll("_", " ")));
+};
+const hasProvenCursorAnimation = (openingElement, context) => {
+	return getInlineCursorAnimationState(openingElement, context) ?? hasStaticTailwindCursorAnimation(openingElement);
+};
+const getAncestorOpeningElements$2 = (element) => {
+	const openingElements = [];
+	let ancestor = element;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement")) openingElements.push(ancestor.openingElement);
+		ancestor = ancestor.parent;
+	}
+	return openingElements;
+};
+const hasUnresolvedOrEnabledAttribute = (openingElement, attributeName) => {
+	const attribute = getAuthoritativeJsxAttribute(openingElement.attributes, attributeName, false);
+	if (!attribute) return false;
+	const value = getStaticAttributeValue(attribute);
+	return value !== false && value !== "false";
+};
+const hasCursorSemanticExemption = (openingElements) => openingElements.some((openingElement) => {
+	if (hasJsxSpreadAttribute(openingElement.attributes)) return true;
+	const elementName = resolveJsxElementType(openingElement);
+	if (CURSOR_EXEMPT_ELEMENT_NAMES.has(elementName.toLowerCase()) || PREFORMATTED_CONTEXT_NAME_PATTERN.test(elementName) || hasUnresolvedOrEnabledAttribute(openingElement, "contentEditable") || hasUnresolvedOrEnabledAttribute(openingElement, "aria-busy")) return true;
+	const roleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "role", false);
+	if (roleAttribute) {
+		const role = getStringLiteralAttributeValue(roleAttribute);
+		if (!role || CURSOR_EXEMPT_ROLES.has(role.trim().toLowerCase().split(/\s+/)[0])) return true;
+	}
+	const ariaLiveAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "aria-live", false);
+	if (ariaLiveAttribute) {
+		const ariaLive = getStringLiteralAttributeValue(ariaLiveAttribute);
+		if (!ariaLive || ariaLive.toLowerCase() !== "off") return true;
+	}
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	return Boolean(classNameValue && splitTailwindClassName(classNameValue).map(parseTailwindClassNameToken).some((token) => PREFORMATTED_CONTEXT_CLASS_PATTERN.test(token.utility)));
+});
+const isHeroDisplayContext = (element) => {
+	let ancestor = element.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement")) {
+			const openingElement = ancestor.openingElement;
+			const elementName = resolveJsxElementType(openingElement);
+			if (elementName === "h1" || HERO_CONTEXT_NAME_PATTERN.test(elementName)) return true;
+			const classNameValue = getStringFromClassNameAttr(openingElement);
+			if (classNameValue && splitTailwindClassName(classNameValue).map(parseTailwindClassNameToken).some((token) => HERO_CONTEXT_CLASS_PATTERN.test(token.utility))) return true;
+			if ((elementName === "header" || elementName === "section") && getStaticJsxDescendantOpeningElements(ancestor).some((descendant) => resolveJsxElementType(descendant) === "h1")) return true;
+		}
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const isExcludedContentPath$1 = (context) => {
+	const rootDirectory = getReactDoctorStringSetting(context.settings, "rootDirectory") ?? "";
+	return EXCLUDED_CONTENT_PATH_PATTERN$1.test(`${rootDirectory}/${context.filename ?? ""}`);
+};
 const noDecorativePulse = defineRule({
 	id: "no-decorative-pulse",
 	title: "Stable copy pulses for attention",
 	severity: "warn",
 	defaultEnabled: false,
 	tags: ["design", "test-noise"],
-	recommendation: "Reserve pulsing motion for real in-progress feedback. Use hierarchy and static contrast for announcements and feature labels.",
+	recommendation: "Reserve pulsing motion for real in-progress feedback. Remove fake blinking cursors and use static hierarchy for decorative emphasis.",
 	create: (context) => ({ JSXElement(node) {
 		const openingElement = node.openingElement;
+		const cursorGlyph = getStaticCursorGlyph(node);
+		const possibleCursorGlyph = getStaticJsxText(node).trim();
+		if (cursorGlyph || CURSOR_GLYPH_PATTERN.test(possibleCursorGlyph)) {
+			if (!cursorGlyph) return;
+			const openingElements = getAncestorOpeningElements$2(node);
+			if (isExcludedContentPath$1(context) || hasCursorSemanticExemption(openingElements) || !isHeroDisplayContext(node) || !hasProvenCursorAnimation(openingElement, context)) return;
+			context.report({
+				node: openingElement,
+				message: "This fake cursor blinks continuously in display copy without an editable surface. Remove the simulated typing effect and let the composition hold attention."
+			});
+			return;
+		}
 		const classNameValue = getStringFromClassNameAttr(openingElement);
-		if (!classNameValue || !getUnvariantClassNameTokens(classNameValue).includes("animate-pulse")) return;
+		if (!classNameValue) return;
+		const animationResolution = resolveEffectiveTailwindClassNameToken(splitTailwindClassName(classNameValue), (utility) => TAILWIND_ANIMATION_UTILITY_PATTERN.test(utility));
+		if (animationResolution.isAmbiguous || animationResolution.utility !== "animate-pulse") return;
 		const text = getStaticJsxText(node).replace(/\s+/g, " ").trim();
 		if (!text || BUSY_TEXT_PATTERN.test(text)) return;
 		if (isBusyStatus(openingElement)) return;
@@ -53500,6 +54242,287 @@ const noDecorativePulse = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/design/utils/get-static-tailwind-background-image.ts
+const TAILWIND_BACKGROUND_IMAGE_UTILITY_PATTERN = /^(?:bg-none|bg-\[(?:image:[\s\S]+|(?:radial-gradient|repeating-radial-gradient|linear-gradient|repeating-linear-gradient|conic-gradient|repeating-conic-gradient|url)\([\s\S]+\))\]|\[(?:background|background-image):[\s\S]+\])$/i;
+const getStaticTailwindBackgroundImage = (tokens) => {
+	const resolution = resolveEffectiveTailwindClassNameToken(tokens, (utility) => TAILWIND_BACKGROUND_IMAGE_UTILITY_PATTERN.test(utility), []);
+	const utility = resolution.utility;
+	if (!utility || utility === "bg-none") return {
+		isAmbiguous: resolution.isAmbiguous,
+		isImportant: resolution.isImportant,
+		value: null
+	};
+	let arbitraryValue = null;
+	if (utility.startsWith("bg-[") && utility.endsWith("]")) arbitraryValue = utility.slice(4, -1).replace(/^image:/i, "");
+	else arbitraryValue = utility.match(/^\[(?:background|background-image):([\s\S]+)\]$/i)?.[1] ?? null;
+	return {
+		isAmbiguous: resolution.isAmbiguous,
+		isImportant: resolution.isImportant,
+		value: arbitraryValue ? normalizeTailwindArbitraryUtilityValue(arbitraryValue) : null
+	};
+};
+//#endregion
+//#region src/plugin/rules/design/utils/get-css-function-contents.ts
+const getCssFunctionContents = (value) => {
+	const openingParenthesisIndex = value.indexOf("(");
+	if (openingParenthesisIndex < 0 || !value.endsWith(")")) return null;
+	let depth = 0;
+	for (let characterIndex = openingParenthesisIndex; characterIndex < value.length; characterIndex += 1) {
+		const character = value[characterIndex];
+		if (character === "(") depth += 1;
+		if (character === ")") depth -= 1;
+		if (depth < 0 || depth === 0 && characterIndex !== value.length - 1) return null;
+	}
+	return depth === 0 ? value.slice(openingParenthesisIndex + 1, -1) : null;
+};
+//#endregion
+//#region src/plugin/rules/design/utils/parse-static-css-color-with-alpha.ts
+const CSS_ALPHA_VALUE_PATTERN = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?%?$/i;
+const parseAlpha$1 = (value) => {
+	const trimmedValue = value.trim();
+	if (!CSS_ALPHA_VALUE_PATTERN.test(trimmedValue)) return null;
+	const numericValue = Number.parseFloat(trimmedValue);
+	if (!Number.isFinite(numericValue)) return null;
+	const alpha = trimmedValue.endsWith("%") ? numericValue / 100 : numericValue;
+	return alpha >= 0 && alpha <= 1 ? alpha : null;
+};
+const parseFunctionalColorAlpha = (colorValue) => {
+	const contents = getCssFunctionContents(colorValue);
+	if (contents === null) return null;
+	const slashParts = splitCssTopLevel(contents, "/");
+	if (!slashParts || slashParts.length > 2) return null;
+	if (slashParts.length === 2) return parseAlpha$1(slashParts[1]);
+	const commaParts = splitCssTopLevel(contents, ",");
+	if (!commaParts) return null;
+	return commaParts.length === 4 ? parseAlpha$1(commaParts[3]) : 1;
+};
+const parseStaticCssColorWithAlpha = (colorValue) => {
+	const normalizedColor = colorValue.trim().toLowerCase();
+	if (normalizedColor === "transparent") return {
+		alpha: 0,
+		blue: 0,
+		green: 0,
+		red: 0
+	};
+	const parsedRgb = parseColorToRgb(normalizedColor);
+	if (!parsedRgb) return null;
+	let alpha = 1;
+	if (/^#[\da-f]{4}$/i.test(normalizedColor)) alpha = Number.parseInt(normalizedColor.slice(4), 16) / 15;
+	else if (/^#[\da-f]{8}$/i.test(normalizedColor)) alpha = Number.parseInt(normalizedColor.slice(7), 16) / 255;
+	else if (/^(?:rgb|hsl)a?\(/i.test(normalizedColor)) {
+		const functionalAlpha = parseFunctionalColorAlpha(normalizedColor);
+		if (functionalAlpha === null) return null;
+		alpha = functionalAlpha;
+	}
+	return {
+		...parsedRgb,
+		alpha
+	};
+};
+//#endregion
+//#region src/plugin/rules/design/utils/parse-static-css-gradient-stop.ts
+const CSS_STOP_POSITION_PATTERN = /^(?:0|[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:%|px|rem))(?:\s+(?:0|[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:%|px|rem)))?$/i;
+const parseStaticCssGradientStop = (stop) => {
+	const trimmedStop = stop.trim();
+	const functionalColorMatch = trimmedStop.match(/^(?:rgb|hsl)a?\(/i);
+	if (functionalColorMatch) {
+		let depth = 0;
+		for (let characterIndex = functionalColorMatch[0].length - 1; characterIndex < trimmedStop.length; characterIndex += 1) {
+			const character = trimmedStop[characterIndex];
+			if (character === "(") depth += 1;
+			if (character === ")") depth -= 1;
+			if (depth !== 0) continue;
+			const colorValue = trimmedStop.slice(0, characterIndex + 1);
+			const positionValue = trimmedStop.slice(characterIndex + 1).trim();
+			if (positionValue && !CSS_STOP_POSITION_PATTERN.test(positionValue)) return null;
+			const color = parseStaticCssColorWithAlpha(colorValue);
+			return color ? {
+				color,
+				positions: positionValue ? positionValue.split(/\s+/) : []
+			} : null;
+		}
+		return null;
+	}
+	const colorMatch = trimmedStop.match(/^(?:transparent|#[\da-f]{3,8})(?:\s+|$)/i);
+	if (!colorMatch) return null;
+	const colorValue = colorMatch[0].trim();
+	const positionValue = trimmedStop.slice(colorMatch[0].length).trim();
+	if (positionValue && !CSS_STOP_POSITION_PATTERN.test(positionValue)) return null;
+	const color = parseStaticCssColorWithAlpha(colorValue);
+	return color ? {
+		color,
+		positions: positionValue ? positionValue.split(/\s+/) : []
+	} : null;
+};
+//#endregion
+//#region src/plugin/rules/design/utils/parse-static-radial-gradient.ts
+const RADIAL_GRADIENT_PRELUDE_PATTERN = /\b(?:at|circle|closest-corner|closest-side|ellipse|farthest-corner|farthest-side)\b/i;
+const parseStaticRadialGradient = (backgroundValue) => {
+	const normalizedValue = backgroundValue.trim();
+	if (!/^radial-gradient\(/i.test(normalizedValue)) return null;
+	const gradientContents = getCssFunctionContents(normalizedValue);
+	if (gradientContents === null) return null;
+	const gradientParts = splitCssTopLevel(gradientContents, ",");
+	if (!gradientParts || gradientParts.length < 2) return null;
+	const firstStop = parseStaticCssGradientStop(gradientParts[0]);
+	if (!firstStop && !RADIAL_GRADIENT_PRELUDE_PATTERN.test(gradientParts[0])) return null;
+	const stopParts = firstStop ? gradientParts : gradientParts.slice(1);
+	if (stopParts.length < 2) return null;
+	const parsedStops = stopParts.map(parseStaticCssGradientStop);
+	return parsedStops.every((stop) => stop !== null) ? parsedStops : null;
+};
+//#endregion
+//#region src/plugin/rules/design/utils/parse-static-tailwind-length-px.ts
+const parseStaticTailwindLengthPx = (utility, prefix) => {
+	if (utility === `${prefix}-px`) return 1;
+	const arbitraryMatch = utility.match(new RegExp(`^${prefix}-\\[(?:length:)?(\\d+(?:\\.\\d*)?|\\.\\d+)(px|rem)\\]$`, "i"));
+	if (arbitraryMatch) {
+		const numericValue = Number.parseFloat(arbitraryMatch[1]);
+		return arbitraryMatch[2].toLowerCase() === "rem" ? numericValue * 16 : numericValue;
+	}
+	const scaleMatch = utility.match(new RegExp(`^${prefix}-(\\d+(?:\\.\\d*)?|\\.\\d+)$`));
+	return scaleMatch ? Number.parseFloat(scaleMatch[1]) * 4 : null;
+};
+//#endregion
+//#region src/plugin/rules/design/no-decorative-radial-spotlight.ts
+const SPOTLIGHT_SURFACE_ELEMENT_NAMES = new Set([
+	"article",
+	"aside",
+	"div",
+	"header",
+	"main",
+	"section"
+]);
+const CSS_STATIC_LENGTH_PATTERN = /^(\d+(?:\.\d*)?|\.\d+)(px|rem)$/i;
+const TAILWIND_WIDTH_UTILITY_PATTERN = /^(?:size|w)-/;
+const TAILWIND_HEIGHT_UTILITY_PATTERN = /^(?:h|size)-/;
+const BACKGROUND_STYLE_PROPERTY_NAMES$1 = new Set(["background", "backgroundImage"]);
+const INLINE_BOTTOM_PROPERTY_NAMES = new Set(["bottom", "inset"]);
+const INLINE_LEFT_PROPERTY_NAMES = new Set(["inset", "left"]);
+const INLINE_RIGHT_PROPERTY_NAMES = new Set(["inset", "right"]);
+const INLINE_TOP_PROPERTY_NAMES = new Set(["inset", "top"]);
+const hasDecorativeRadialSpotlightGradient = (backgroundValue) => {
+	const parsedStops = parseStaticRadialGradient(backgroundValue);
+	if (!parsedStops) return false;
+	const finalStop = parsedStops.at(-1)?.color;
+	if (!finalStop || finalStop.alpha > .05) return false;
+	const visibleStops = parsedStops.slice(0, -1).map((stop) => stop.color).filter((stop) => stop.alpha > DECORATIVE_RADIAL_SPOTLIGHT_TRANSPARENT_ALPHA_MAX);
+	if (visibleStops.length === 0 || visibleStops.length > 2 || visibleStops.some((stop) => stop.alpha >= .45 || !hasColorChroma(stop))) return false;
+	const firstVisibleStop = visibleStops[0];
+	return visibleStops.every((stop) => stop.red === firstVisibleStop.red && stop.green === firstVisibleStop.green && stop.blue === firstVisibleStop.blue);
+};
+const parseStaticLengthPx = (value) => {
+	if (typeof value === "number") return Number.isFinite(value) && value >= 0 ? value : null;
+	if (typeof value !== "string") return null;
+	const match = value.trim().match(CSS_STATIC_LENGTH_PATTERN);
+	if (!match) return null;
+	const numericValue = Number.parseFloat(match[1]);
+	return match[2].toLowerCase() === "rem" ? numericValue * 16 : numericValue;
+};
+const parseStaticZero = (value) => {
+	if (typeof value === "number") return Number.isFinite(value) ? value === 0 : null;
+	if (typeof value !== "string") return null;
+	return /^[+-]?(?:0+(?:\.0*)?|\.0+)(?:px|rem)?$/i.test(value.trim());
+};
+const getTailwindInsetEdgeEvidence = (tokens, edge) => {
+	const axis = edge === "top" || edge === "bottom" ? "y" : "x";
+	const resolution = resolveEffectiveTailwindClassNameToken(tokens, (utility) => {
+		const unsignedUtility = utility.startsWith("-") ? utility.slice(1) : utility;
+		return /^inset-(?![xy]-)/.test(unsignedUtility) || unsignedUtility.startsWith(`inset-${axis}-`) || unsignedUtility.startsWith(`${edge}-`) || (edge === "left" || edge === "right") && (unsignedUtility.startsWith("start-") || unsignedUtility.startsWith("end-"));
+	}, []);
+	const utility = resolution.utility;
+	const utilityPrefix = utility?.slice(0, utility.lastIndexOf("-")) ?? null;
+	const unsignedUtility = utility?.startsWith("-") ? utility.slice(1) : utility;
+	const isLogicalInset = unsignedUtility?.startsWith("start-") || unsignedUtility?.startsWith("end-");
+	return {
+		isAmbiguous: resolution.isAmbiguous,
+		isImportant: resolution.isImportant,
+		isZero: utility && utilityPrefix && !isLogicalInset ? parseStaticTailwindLengthPx(utility, utilityPrefix) === 0 : utility === null ? null : false
+	};
+};
+const getTailwindSurfaceEvidence = (tokens) => {
+	const widthResolution = resolveEffectiveTailwindClassNameToken(tokens, (utility) => TAILWIND_WIDTH_UTILITY_PATTERN.test(utility), []);
+	const heightResolution = resolveEffectiveTailwindClassNameToken(tokens, (utility) => TAILWIND_HEIGHT_UTILITY_PATTERN.test(utility), []);
+	const positionResolution = resolveEffectiveTailwindClassNameToken(tokens, (utility) => utility === "absolute" || utility === "fixed" || utility === "relative" || utility === "static" || utility === "sticky", []);
+	const widthPx = widthResolution.utility ? parseStaticTailwindLengthPx(widthResolution.utility, "size") ?? parseStaticTailwindLengthPx(widthResolution.utility, "w") : null;
+	return {
+		heightPx: heightResolution.utility ? parseStaticTailwindLengthPx(heightResolution.utility, "size") ?? parseStaticTailwindLengthPx(heightResolution.utility, "h") : null,
+		heightIsAmbiguous: heightResolution.isAmbiguous,
+		heightIsImportant: heightResolution.isImportant,
+		hasHeight: heightResolution.utility !== null || heightResolution.isAmbiguous,
+		hasWidth: widthResolution.utility !== null || widthResolution.isAmbiguous,
+		insetBottom: getTailwindInsetEdgeEvidence(tokens, "bottom"),
+		insetLeft: getTailwindInsetEdgeEvidence(tokens, "left"),
+		insetRight: getTailwindInsetEdgeEvidence(tokens, "right"),
+		insetTop: getTailwindInsetEdgeEvidence(tokens, "top"),
+		positionIsAmbiguous: positionResolution.isAmbiguous,
+		positionIsFixed: positionResolution.isAmbiguous ? null : positionResolution.utility === null ? null : positionResolution.utility === "fixed",
+		positionIsImportant: positionResolution.isImportant,
+		widthPx,
+		widthIsAmbiguous: widthResolution.isAmbiguous,
+		widthIsImportant: widthResolution.isImportant
+	};
+};
+const getEffectiveInsetEdgeIsZero = (styleProperties, propertyNames, tailwindEvidence) => {
+	if (tailwindEvidence.isAmbiguous) return null;
+	const inlineProperty = getEffectiveStylePropertyAmong(styleProperties, propertyNames);
+	if (tailwindEvidence.isImportant) return tailwindEvidence.isZero;
+	if (!inlineProperty) return tailwindEvidence.isZero;
+	return parseStaticZero(getStylePropertyNumberValue(inlineProperty) ?? getStylePropertyStringValue(inlineProperty));
+};
+const noDecorativeRadialSpotlight = defineRule({
+	id: "no-decorative-radial-spotlight",
+	title: "Large decorative radial spotlight",
+	severity: "warn",
+	defaultEnabled: false,
+	tags: [
+		"design",
+		"test-noise",
+		"react-jsx-only"
+	],
+	recommendation: "Use product-specific imagery, structure, or a restrained solid surface instead of a large translucent radial glow.",
+	create: (context) => ({ JSXOpeningElement(node) {
+		if (!isProvenIntrinsicJsxElement(node, context.scopes) || !isNodeOfType(node.name, "JSXIdentifier") || !SPOTLIGHT_SURFACE_ELEMENT_NAMES.has(node.name.name) || isDataVisualizationContext(node, context.filename)) return;
+		const classNameAttribute = getAuthoritativeJsxAttribute(node.attributes, "className");
+		const styleAttribute = getAuthoritativeJsxAttribute(node.attributes, "style");
+		if (!classNameAttribute && hasJsxSpreadThatMayProvideAttribute(node.attributes, "className") || !styleAttribute && hasJsxSpreadThatMayProvideAttribute(node.attributes, "style")) return;
+		const className = classNameAttribute ? getStringFromClassNameAttr(node) : "";
+		if (classNameAttribute && className === null) return;
+		const styleExpression = styleAttribute ? getInlineStyleExpression(styleAttribute, context.scopes) : null;
+		if (styleAttribute && !styleExpression || styleExpression?.properties.some((property) => getStylePropertyKey(property) === null)) return;
+		const tokens = className && hasCapabilityOrUnspecified(context.settings, "tailwind") ? splitTailwindClassName(className) : [];
+		const tailwindBackground = getStaticTailwindBackgroundImage(tokens);
+		if (tailwindBackground.isAmbiguous) return;
+		const inlineBackgroundProperty = getEffectiveStylePropertyAmong(styleExpression?.properties, BACKGROUND_STYLE_PROPERTY_NAMES$1);
+		const inlineBackgroundValue = inlineBackgroundProperty ? getStylePropertyStringValue(inlineBackgroundProperty) : null;
+		const backgroundValue = inlineBackgroundProperty && !tailwindBackground.isImportant ? inlineBackgroundValue : tailwindBackground.value;
+		if (!backgroundValue || !hasDecorativeRadialSpotlightGradient(backgroundValue)) return;
+		const tailwindSurface = getTailwindSurfaceEvidence(tokens);
+		if (tailwindSurface.widthIsAmbiguous || tailwindSurface.heightIsAmbiguous) return;
+		const inlineWidthProperty = getEffectiveStyleProperty(styleExpression?.properties, "width");
+		const inlineHeightProperty = getEffectiveStyleProperty(styleExpression?.properties, "height");
+		const inlineWidthPx = inlineWidthProperty ? parseStaticLengthPx(getStylePropertyNumberValue(inlineWidthProperty) ?? getStylePropertyStringValue(inlineWidthProperty)) : null;
+		const inlineHeightPx = inlineHeightProperty ? parseStaticLengthPx(getStylePropertyNumberValue(inlineHeightProperty) ?? getStylePropertyStringValue(inlineHeightProperty)) : null;
+		const widthPx = tailwindSurface.widthIsImportant ? tailwindSurface.widthPx : inlineWidthProperty ? inlineWidthPx : tailwindSurface.widthPx;
+		const heightPx = tailwindSurface.heightIsImportant ? tailwindSurface.heightPx : inlineHeightProperty ? inlineHeightPx : tailwindSurface.heightPx;
+		const hasWidth = tailwindSurface.widthIsImportant ? tailwindSurface.hasWidth : inlineWidthProperty !== null || tailwindSurface.hasWidth;
+		const hasHeight = tailwindSurface.heightIsImportant ? tailwindSurface.hasHeight : inlineHeightProperty !== null || tailwindSurface.hasHeight;
+		const positionProperty = getEffectiveStyleProperty(styleExpression?.properties, "position");
+		const positionIsFixed = tailwindSurface.positionIsAmbiguous ? null : tailwindSurface.positionIsImportant ? tailwindSurface.positionIsFixed : positionProperty ? getStylePropertyStringValue(positionProperty)?.toLowerCase() === "fixed" : tailwindSurface.positionIsFixed;
+		const insetEdgesAreZero = [
+			getEffectiveInsetEdgeIsZero(styleExpression?.properties, INLINE_TOP_PROPERTY_NAMES, tailwindSurface.insetTop),
+			getEffectiveInsetEdgeIsZero(styleExpression?.properties, INLINE_RIGHT_PROPERTY_NAMES, tailwindSurface.insetRight),
+			getEffectiveInsetEdgeIsZero(styleExpression?.properties, INLINE_BOTTOM_PROPERTY_NAMES, tailwindSurface.insetBottom),
+			getEffectiveInsetEdgeIsZero(styleExpression?.properties, INLINE_LEFT_PROPERTY_NAMES, tailwindSurface.insetLeft)
+		].every((isZero) => isZero === true);
+		if (!(!hasWidth && !hasHeight && positionIsFixed === true && insetEdgesAreZero || widthPx !== null && widthPx >= 240 && heightPx !== null && heightPx >= 160)) return;
+		context.report({
+			node: inlineBackgroundProperty ?? node,
+			message: "This large translucent radial glow is generic decorative scaffolding. Replace it with a visual treatment tied to the product or simplify the surface."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/architecture/no-default-props.ts
 const hasReachingWriteOnAliasPath = (receiver, context) => {
 	const visitedSymbolIds = /* @__PURE__ */ new Set();
@@ -59978,7 +61001,7 @@ const noExcessiveMotionStagger = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/design/no-excessive-pill-treatment.ts
-const HORIZONTAL_PADDING_PATTERN$1 = /^px-(?:px|[\d.]+|\[[^\]]+\])$/;
+const HORIZONTAL_PADDING_PATTERN$2 = /^px-(?:px|[\d.]+|\[[^\]]+\])$/;
 const isPillTreatment = (openingElement) => {
 	const element = openingElement.parent;
 	if (!isNodeOfType(element, "JSXElement")) return false;
@@ -59987,7 +61010,7 @@ const isPillTreatment = (openingElement) => {
 	const classNameValue = getStringFromClassNameAttr(openingElement);
 	if (!classNameValue) return false;
 	const tokens = getUnvariantClassNameTokens(classNameValue);
-	return tokens.includes("rounded-full") && tokens.some((token) => HORIZONTAL_PADDING_PATTERN$1.test(token)) && hasVisibleTailwindFillOrEdge(tokens);
+	return tokens.includes("rounded-full") && tokens.some((token) => HORIZONTAL_PADDING_PATTERN$2.test(token)) && hasVisibleTailwindFillOrEdge(tokens);
 };
 const noExcessivePillTreatment = defineRule({
 	id: "no-excessive-pill-treatment",
@@ -60998,13 +62021,13 @@ const getFontSizePx = (property) => {
 	const value = Number.parseFloat(match[1]);
 	return match[2] === "rem" ? value * 16 : value;
 };
-const getStaticEffectiveFontSize = (openingElement, hasTailwind) => {
+const getStaticEffectiveFontSize = (openingElement, hasTailwind, scopes) => {
 	const classNameValue = getStringFromClassNameAttr(openingElement);
 	const tailwindFontSize = hasTailwind ? getStaticTailwindFontSize(classNameValue) : null;
 	if (classNameValue && hasTailwind && hasImportantTailwindFontSize(classNameValue)) return tailwindFontSize;
 	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes ?? [], "style");
 	if (!styleAttribute) return hasJsxSpreadAttribute(openingElement.attributes) ? null : tailwindFontSize;
-	const styleExpression = getInlineStyleExpression(styleAttribute);
+	const styleExpression = getInlineStyleExpression(styleAttribute, scopes);
 	if (!styleExpression) return null;
 	const fontSizeProperty = getEffectiveStyleProperty(styleExpression.properties, "fontSize");
 	if (fontSizeProperty) return getFontSizePx(fontSizeProperty);
@@ -61368,7 +62391,7 @@ const getProvenRenderLocation = (openingElement) => {
 	}
 	return null;
 };
-const getStaticBooleanAttributeState = (openingElement, attributeName) => {
+const getStaticBooleanAttributeState$1 = (openingElement, attributeName) => {
 	const attribute = hasJsxPropIgnoreCase(openingElement.attributes, attributeName);
 	if (!attribute) return false;
 	if (!attribute.value) return true;
@@ -61401,11 +62424,11 @@ const hasStaticallyHidingStyle = (openingElement) => {
 const isStaticallyExcludedOpeningElement = (openingElement, isTarget) => {
 	const tagName = isNodeOfType(openingElement.name, "JSXIdentifier") ? openingElement.name.name : null;
 	if (!tagName || !/^[a-z]/.test(tagName)) return true;
-	const hiddenState = getStaticBooleanAttributeState(openingElement, "hidden");
-	const inertState = getStaticBooleanAttributeState(openingElement, "inert");
+	const hiddenState = getStaticBooleanAttributeState$1(openingElement, "hidden");
+	const inertState = getStaticBooleanAttributeState$1(openingElement, "inert");
 	if (hiddenState !== false || inertState !== false || hasStaticallyHidingClassName(openingElement) || hasStaticallyHidingStyle(openingElement) || tagName === "template") return true;
-	if (tagName === "fieldset" && getStaticBooleanAttributeState(openingElement, "disabled") !== false) return true;
-	if ((tagName === "dialog" || tagName === "details") && getStaticBooleanAttributeState(openingElement, "open") !== true) return true;
+	if (tagName === "fieldset" && getStaticBooleanAttributeState$1(openingElement, "disabled") !== false) return true;
+	if ((tagName === "dialog" || tagName === "details") && getStaticBooleanAttributeState$1(openingElement, "open") !== true) return true;
 	if (isTarget && tagName === "input") {
 		const typeAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "type");
 		if (typeAttribute && (!typeAttribute.value || getJsxPropStringValue(typeAttribute) === null)) return true;
@@ -61912,6 +62935,89 @@ const noGenericHandlerNames = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/design/no-generic-marketing-copy.ts
+const MARKETING_COPY_EXCLUDED_ELEMENT_NAMES = new Set([
+	"code",
+	"codeblock",
+	"codesnippet",
+	"demo",
+	"example",
+	"fixture",
+	"kbd",
+	"markdown",
+	"markdownblock",
+	"markdowncontent",
+	"markdownrenderer",
+	"markdowntext",
+	"markdownview",
+	"mdx",
+	"mdxcontent",
+	"mdxremote",
+	"playground",
+	"pre",
+	"preview",
+	"reactmarkdown",
+	"renderproxy",
+	"samp",
+	"script",
+	"story",
+	"style",
+	"syntaxhighlighter",
+	"template"
+]);
+const STATIC_COPY_BOUNDARY$1 = "\0";
+const LEXICAL_CHARACTER_PATTERN = /[\p{L}\p{N}]/u;
+const isExcludedCopyElement$1 = (openingElement) => {
+	const elementName = resolveJsxElementType(openingElement).split(".").at(-1);
+	return Boolean(elementName && MARKETING_COPY_EXCLUDED_ELEMENT_NAMES.has(elementName.toLowerCase()));
+};
+const getStaticRenderedCopy = (node, context) => {
+	if (!node) return "";
+	if (isNodeOfType(node, "JSXText")) return node.value ?? "";
+	if (isNodeOfType(node, "JSXEmptyExpression")) return "";
+	if (isNodeOfType(node, "Literal")) return typeof node.value === "string" ? node.value : "";
+	if (isNodeOfType(node, "TemplateLiteral")) {
+		const staticSegments = (node.quasis ?? []).map((quasi) => quasi.value?.raw ?? "");
+		if (node.expressions.length === 0) return staticSegments.join("");
+		return `${STATIC_COPY_BOUNDARY$1}${staticSegments.join(STATIC_COPY_BOUNDARY$1)}${STATIC_COPY_BOUNDARY$1}`;
+	}
+	if (isNodeOfType(node, "JSXExpressionContainer")) return getStaticRenderedCopy(node.expression, context);
+	if (isNodeOfType(node, "JSXElement")) {
+		if (isExcludedCopyElement$1(node.openingElement) || isInsideStaticallyHiddenJsxSubtree$1(node, context)) return "";
+		return (node.children ?? []).map((child) => getStaticRenderedCopy(child, context)).join(" ");
+	}
+	if (isNodeOfType(node, "JSXFragment")) return (node.children ?? []).map((child) => getStaticRenderedCopy(child, context)).join(" ");
+	if (isNodeOfType(node, "ConditionalExpression")) return `${STATIC_COPY_BOUNDARY$1}${getStaticRenderedCopy(node.consequent, context)}${STATIC_COPY_BOUNDARY$1}${getStaticRenderedCopy(node.alternate, context)}${STATIC_COPY_BOUNDARY$1}`;
+	if (isNodeOfType(node, "LogicalExpression")) return `${STATIC_COPY_BOUNDARY$1}${getStaticRenderedCopy(node.right, context)}${STATIC_COPY_BOUNDARY$1}`;
+	return STATIC_COPY_BOUNDARY$1;
+};
+const isInsideExcludedCopyElement = (node) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement") && isExcludedCopyElement$1(ancestor.openingElement)) return true;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const findFirstMarketingPhrase = (pageText) => {
+	let firstPhrase = null;
+	let firstPhraseIndex = pageText.length;
+	for (const phrase of GENERIC_MARKETING_PHRASES) {
+		let searchStartIndex = 0;
+		while (searchStartIndex < pageText.length) {
+			const phraseIndex = pageText.indexOf(phrase, searchStartIndex);
+			if (phraseIndex < 0 || phraseIndex >= firstPhraseIndex) break;
+			const precedingCharacter = pageText[phraseIndex - 1];
+			const followingCharacter = pageText[phraseIndex + phrase.length];
+			if ((!precedingCharacter || !LEXICAL_CHARACTER_PATTERN.test(precedingCharacter)) && (!followingCharacter || !LEXICAL_CHARACTER_PATTERN.test(followingCharacter))) {
+				firstPhrase = phrase;
+				firstPhraseIndex = phraseIndex;
+				break;
+			}
+			searchStartIndex = phraseIndex + phrase.length;
+		}
+	}
+	return firstPhrase;
+};
 const noGenericMarketingCopy = defineRule({
 	id: "no-generic-marketing-copy",
 	title: "Page uses generic marketing language",
@@ -61920,9 +63026,8 @@ const noGenericMarketingCopy = defineRule({
 	tags: ["design", "test-noise"],
 	recommendation: "Replace broad promotional phrases with concrete capabilities, outcomes, or evidence.",
 	create: (context) => ({ JSXElement(node) {
-		if (!isTopLevelPageCopyRoot(node)) return;
-		const pageText = getStaticJsxText(node).replace(/\s+/g, " ").toLowerCase();
-		const matchedPhrase = [...GENERIC_MARKETING_PHRASES].find((phrase) => pageText.includes(phrase));
+		if (!isTopLevelPageCopyRoot(node) || isInsideExcludedCopyElement(node)) return;
+		const matchedPhrase = findFirstMarketingPhrase(getStaticRenderedCopy(node, context).replace(/\s+/g, " ").toLowerCase());
 		if (!matchedPhrase) return;
 		context.report({
 			node: node.openingElement,
@@ -62333,12 +63438,69 @@ const HERO_HEADING_SIZE_CLASSES = new Set([
 	"text-8xl",
 	"text-9xl"
 ]);
+const PSEUDO_ELEMENT_NAMES$1 = ["before", "after"];
+const PSEUDO_DISPLAY_UTILITIES = new Set(["block", "inline-block"]);
+const PSEUDO_CONTENT_PATTERN = /^(?:content-\[(?:""|'')\]|\[content:(?:""|'')\])$/;
+const TAILWIND_BACKGROUND_COLOR_PATTERN$1 = /^bg-(?:transparent|black|white|current|inherit|(?:slate|gray|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d+|\[(?!url\(|(?:image|length|position|size):).+\])(?:\/.+)?$/;
+const CHROMATIC_TAILWIND_BACKGROUND_PATTERN$1 = /^bg-(?:red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d+$/;
+const TEXT_TRANSFORM_UTILITIES = new Set([
+	"capitalize",
+	"lowercase",
+	"normal-case",
+	"uppercase"
+]);
+const BASE_ROUNDING_PATTERN = /^rounded(?:$|-(?!(?:b|bl|br|e|ee|es|l|r|s|se|ss|t|tl|tr)-))/;
+const HORIZONTAL_PADDING_PATTERN$1 = /^p(?:x)?-/;
+const STATIC_ARBITRARY_TRACKING_PATTERN = /^tracking-\[(?:length:)?(-?(?:\d+(?:\.\d*)?|\.\d+))(?:em|px|rem)\]$/i;
 const hasPositivePillPadding = (token) => {
 	const spacingMatch = token.match(/^p(?:x)?-(px|[\d.]+)$/);
 	if (spacingMatch) return spacingMatch[1] === "px" || parseFloat(spacingMatch[1]) > 0;
 	const arbitraryMatch = token.match(/^p(?:x)?-\[([\d.]+)(?:px|rem)\]$/);
 	return Boolean(arbitraryMatch && parseFloat(arbitraryMatch[1]) > 0);
 };
+const isNonNormalTrackingUtility = (utility) => {
+	if (utility === "tracking-normal") return false;
+	if (/^tracking-(?:tight|tighter|wide|wider|widest)$/.test(utility)) return true;
+	const arbitraryTracking = utility.match(STATIC_ARBITRARY_TRACKING_PATTERN);
+	return Boolean(arbitraryTracking && Number.parseFloat(arbitraryTracking[1]) !== 0);
+};
+const hasChromaticTailwindBackground$1 = (utility) => {
+	if (CHROMATIC_TAILWIND_BACKGROUND_PATTERN$1.test(utility)) return true;
+	const arbitraryColor = utility.match(/^bg-\[(?:color:)?(.+)\]$/)?.[1];
+	if (!arbitraryColor || /^(?:rgba|hsla)\(/i.test(arbitraryColor)) return false;
+	if (/^#[\da-f]{4}(?:[\da-f]{4})?$/i.test(arbitraryColor)) return false;
+	const parsedColor = parseColorToRgb(arbitraryColor);
+	return parsedColor ? hasColorChroma(parsedColor) : false;
+};
+const hasStaticDashPseudoElement = (classNameValue) => {
+	const utilitiesByPseudoElement = new Map(PSEUDO_ELEMENT_NAMES$1.map((pseudoElementName) => [pseudoElementName, []]));
+	for (const rawToken of splitTailwindClassName(classNameValue)) {
+		const parsedToken = parseTailwindClassNameToken(rawToken);
+		if (parsedToken.variants.length !== 1 || !PSEUDO_ELEMENT_NAMES$1.includes(parsedToken.variants[0])) continue;
+		utilitiesByPseudoElement.get(parsedToken.variants[0])?.push(parsedToken.isImportant ? `!${parsedToken.utility}` : parsedToken.utility);
+	}
+	for (const utilities of utilitiesByPseudoElement.values()) {
+		const contentResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => utility.startsWith("content-") || utility.startsWith("[content:"), []);
+		const displayResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => PSEUDO_DISPLAY_UTILITIES.has(utility) || [
+			"hidden",
+			"contents",
+			"flex",
+			"grid",
+			"inline",
+			"inline-flex",
+			"inline-grid"
+		].includes(utility), []);
+		const widthResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => utility.startsWith("w-"), []);
+		const heightResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => utility.startsWith("h-"), []);
+		const backgroundResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => TAILWIND_BACKGROUND_COLOR_PATTERN$1.test(utility), []);
+		const backgroundOpacityResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => utility.startsWith("bg-opacity-"), []);
+		if (contentResolution.isAmbiguous || displayResolution.isAmbiguous || widthResolution.isAmbiguous || heightResolution.isAmbiguous || backgroundResolution.isAmbiguous || backgroundOpacityResolution.isAmbiguous || !contentResolution.utility || !PSEUDO_CONTENT_PATTERN.test(contentResolution.utility) || !displayResolution.utility || !PSEUDO_DISPLAY_UTILITIES.has(displayResolution.utility) || !widthResolution.utility || !heightResolution.utility || !backgroundResolution.utility || !hasChromaticTailwindBackground$1(backgroundResolution.utility) || backgroundOpacityResolution.utility && backgroundOpacityResolution.utility !== "bg-opacity-100") continue;
+		const widthPx = parseStaticTailwindLengthPx(widthResolution.utility, "w");
+		const heightPx = parseStaticTailwindLengthPx(heightResolution.utility, "h");
+		if (widthPx !== null && widthPx >= 8 && widthPx <= 80 && heightPx !== null && heightPx >= 1 && heightPx <= 6) return true;
+	}
+	return false;
+};
 const noHeroEyebrowChip = defineRule({
 	id: "no-hero-eyebrow-chip",
 	title: "Hero uses a decorative eyebrow label",
@@ -62351,14 +63513,21 @@ const noHeroEyebrowChip = defineRule({
 		if (!labelText || labelText.length > 32) return;
 		const classNameValue = getStringFromClassNameAttr(node.openingElement);
 		if (!classNameValue) return;
-		const labelTokens = new Set(getUnvariantClassNameTokens(classNameValue));
-		const isTrackedLabel = labelTokens.has("uppercase") && [...labelTokens].some((token) => token.startsWith("tracking-"));
-		const isPillLabel = labelTokens.has("rounded-full") && hasVisibleTailwindFillOrEdge([...labelTokens]) && [...labelTokens].some(hasPositivePillPadding);
-		if (!isTrackedLabel && !isPillLabel) return;
+		const labelTokens = getUnvariantClassNameTokensWithImportantModifiers(classNameValue);
+		const effectiveTextTransform = getEffectiveTailwindClassNameToken(labelTokens, (utility) => TEXT_TRANSFORM_UTILITIES.has(utility));
+		const effectiveTracking = getEffectiveTailwindClassNameToken(labelTokens, (utility) => utility.startsWith("tracking-"));
+		const isTrackedLabel = effectiveTextTransform === "uppercase" && effectiveTracking !== null && isNonNormalTrackingUtility(effectiveTracking);
+		const effectiveRounding = getEffectiveTailwindClassNameToken(labelTokens, (utility) => BASE_ROUNDING_PATTERN.test(utility));
+		const effectiveHorizontalPadding = getEffectiveTailwindClassNameToken(labelTokens, (utility) => HORIZONTAL_PADDING_PATTERN$1.test(utility));
+		const isPillLabel = effectiveRounding === "rounded-full" && hasVisibleTailwindFillOrEdge(labelTokens) && effectiveHorizontalPadding !== null && hasPositivePillPadding(effectiveHorizontalPadding);
+		const labelFontSizePx = getStaticTailwindFontSize(classNameValue);
+		const hasDashPseudoElement = labelFontSizePx !== null && labelFontSizePx <= 14 && hasStaticDashPseudoElement(classNameValue);
+		if (!isTrackedLabel && !isPillLabel && !hasDashPseudoElement) return;
 		const heading = getNextStaticJsxElementSibling(node);
 		if (!heading || !isNodeOfType(heading.openingElement.name, "JSXIdentifier") || heading.openingElement.name.name !== "h1") return;
 		const headingClassName = getStringFromClassNameAttr(heading.openingElement);
-		if (!headingClassName || !getUnvariantClassNameTokens(headingClassName).some((token) => HERO_HEADING_SIZE_CLASSES.has(token))) return;
+		const effectiveHeadingSize = getEffectiveTailwindClassNameToken(headingClassName ? getUnvariantClassNameTokensWithImportantModifiers(headingClassName) : [], (utility) => parseStaticTailwindFontSize(utility) !== null);
+		if (!effectiveHeadingSize || !HERO_HEADING_SIZE_CLASSES.has(effectiveHeadingSize)) return;
 		context.report({
 			node: node.openingElement,
 			message: "This small decorative label immediately above a display headline creates a generic hero scaffold. Fold the context into stronger content structure."
@@ -63154,11 +64323,53 @@ const noIconTileHeadingStack = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/tokenize-identifier-words.ts
+const IDENTIFIER_WORD_PATTERN = /[A-Z]+(?=[A-Z][a-z]|\b)|[A-Z]?[a-z]+|\d+/g;
+const tokenizeIdentifierWords = (identifierName) => {
+	const words = identifierName.match(IDENTIFIER_WORD_PATTERN);
+	if (!words) return [];
+	return words.map((word) => word.toLowerCase());
+};
+//#endregion
 //#region src/plugin/rules/design/no-image-hover-transform.ts
 const HOVER_VARIANT_PATTERN = /^(?:(?:group|peer)-)?hover(?:\/[^:]+)?$/;
 const IMAGE_TRANSFORM_PATTERN = /^-?(?:scale|rotate)-/;
-const NEUTRAL_SCALE_PATTERN = /^scale(?:-[xyz])?-(?:100|none)$/;
-const NEUTRAL_ROTATE_PATTERN = /^rotate(?:-[xyz])?-(?:0|none)$/;
+const NEUTRAL_SCALE_PATTERN = /^scale(?:-[xyz])?-(?:100|none|\[(?:1(?:\.0+)?|100(?:\.0+)?%)\])$/;
+const NEUTRAL_ROTATE_PATTERN = /^rotate(?:-[xyz])?-(?:0|none|\[0(?:\.0+)?(?:deg|grad|rad|turn)?\])$/;
+const MOTION_IMAGE_SCALE_PROPERTY_NAMES = [
+	"scale",
+	"scaleX",
+	"scaleY"
+];
+const MOTION_IMAGE_ROTATION_PROPERTY_NAMES = [
+	"rotate",
+	"rotateX",
+	"rotateY",
+	"rotateZ"
+];
+const FUNCTIONAL_IMAGE_CONTEXT_PATTERN = /(?:^|[-_\s])(?:crop(?:per)?|gallery|image[-_\s]?viewer|lightbox|product[-_\s]?zoom|zoom)(?:$|[-_\s])/i;
+const FUNCTIONAL_IMAGE_CONTEXT_IDENTIFIER_WORDS = new Set([
+	"crop",
+	"cropper",
+	"gallery",
+	"lightbox",
+	"zoom"
+]);
+const FUNCTIONAL_IMAGE_CONTEXT_VALUE_ATTRIBUTE_NAMES = new Set([
+	"aria-label",
+	"aria-roledescription",
+	"className",
+	"data-testid",
+	"id",
+	"title"
+]);
+const INACTIVE_CONTEXT_ATTRIBUTE_STRING_VALUES = new Set([
+	"",
+	"0",
+	"false",
+	"none",
+	"off"
+]);
 const removeNegativeModifier = (utility) => utility.startsWith("-") ? utility.slice(1) : utility;
 const getHoverImageTransform = (classNameValue) => {
 	const rawTokens = splitTailwindClassName(classNameValue);
@@ -63176,6 +64387,87 @@ const getHoverImageTransform = (classNameValue) => {
 	}
 	return null;
 };
+const getStaticIntrinsicFactoryTarget = (node) => {
+	const candidate = stripParenExpression(node);
+	if (isNodeOfType(candidate, "MemberExpression")) return getStaticPropertyName(candidate);
+	if (!isNodeOfType(candidate, "CallExpression")) return null;
+	const target = candidate.arguments[0];
+	return target && !isNodeOfType(target, "SpreadElement") && isNodeOfType(target, "Literal") && typeof target.value === "string" ? target.value : null;
+};
+const isProvenMotionImage = (node, context) => {
+	if (!isProvenFramerMotionJsxElement(node, context.scopes)) return false;
+	if (isNodeOfType(node.name, "JSXMemberExpression")) return node.name.property.name === "img";
+	if (!isNodeOfType(node.name, "JSXIdentifier")) return false;
+	const symbol = resolveConstIdentifierAlias(node.name, context.scopes);
+	if (symbol?.kind === "import") return getImportedName(symbol.declarationNode) === "img";
+	return Boolean(symbol?.kind === "const" && symbol.initializer && getStaticIntrinsicFactoryTarget(symbol.initializer) === "img");
+};
+const isKnownInactiveContextExpression = (node, context) => {
+	const expression = stripParenExpression(node);
+	if (isLiteralVoidExpression(expression)) return true;
+	if (isNodeOfType(expression, "Identifier") && expression.name === "undefined" && context.scopes.isGlobalReference(expression)) return true;
+	if (!isNodeOfType(expression, "Literal")) return false;
+	if (expression.value === false || expression.value === null || expression.value === 0) return true;
+	return typeof expression.value === "string" && INACTIVE_CONTEXT_ATTRIBUTE_STRING_VALUES.has(expression.value.trim().toLowerCase());
+};
+const isPotentiallyActiveContextAttribute = (attribute, context) => {
+	if (!attribute.value) return true;
+	if (isNodeOfType(attribute.value, "Literal")) return !isKnownInactiveContextExpression(attribute.value, context);
+	return isNodeOfType(attribute.value, "JSXExpressionContainer") && !isKnownInactiveContextExpression(attribute.value.expression, context);
+};
+const isPotentiallyActiveEventHandler = (attribute, context) => {
+	if (!attribute.value || !isNodeOfType(attribute.value, "JSXExpressionContainer") || isKnownInactiveContextExpression(attribute.value.expression, context)) return false;
+	return !isNodeOfType(stripParenExpression(attribute.value.expression), "Literal");
+};
+const hasActiveDragAttribute = (node, context) => {
+	for (const attributeName of ["drag", "draggable"]) {
+		const attribute = getAuthoritativeJsxAttribute(node.attributes, attributeName);
+		if (!attribute) continue;
+		if (isPotentiallyActiveContextAttribute(attribute, context)) return true;
+	}
+	return false;
+};
+const hasFunctionalImageContextEvidence = (node, context) => {
+	let currentNode = node;
+	while (currentNode) {
+		const openingElement = isNodeOfType(currentNode, "JSXOpeningElement") ? currentNode : isNodeOfType(currentNode, "JSXElement") ? currentNode.openingElement : null;
+		if (openingElement) {
+			if (hasActiveDragAttribute(openingElement, context)) return true;
+			const elementName = resolveJsxElementName(openingElement);
+			if (elementName && tokenizeIdentifierWords(elementName).some((word) => FUNCTIONAL_IMAGE_CONTEXT_IDENTIFIER_WORDS.has(word))) return true;
+			for (const attribute of openingElement.attributes) {
+				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+				const attributeName = getJsxAttributeName(attribute.name);
+				if (!attributeName) continue;
+				if (getAuthoritativeJsxAttribute(openingElement.attributes, attributeName) !== attribute) continue;
+				if (FUNCTIONAL_IMAGE_CONTEXT_PATTERN.test(attributeName) && isPotentiallyActiveContextAttribute(attribute, context)) return true;
+				if (/^onDrag/i.test(attributeName) && isPotentiallyActiveEventHandler(attribute, context)) return true;
+				if (!FUNCTIONAL_IMAGE_CONTEXT_VALUE_ATTRIBUTE_NAMES.has(attributeName)) continue;
+				if (getJsxPropStaticStringValues(attribute, context.scopes)?.some((value) => FUNCTIONAL_IMAGE_CONTEXT_PATTERN.test(value))) return true;
+			}
+		}
+		currentNode = currentNode.parent;
+	}
+	return false;
+};
+const getMotionHoverTransformProperty = (node, context) => {
+	if (!isProvenMotionImage(node, context) || hasFunctionalImageContextEvidence(node, context)) return null;
+	const whileHoverObject = getStaticMotionPropObject(node, "whileHover", context.scopes);
+	if (!whileHoverObject) return null;
+	for (const propertyName of MOTION_IMAGE_SCALE_PROPERTY_NAMES) {
+		const property = getEffectiveStyleProperty(whileHoverObject.properties, propertyName);
+		if (!property) continue;
+		const value = getStylePropertyNumberValue(property);
+		if (value !== null && value !== 1) return propertyName;
+	}
+	for (const propertyName of MOTION_IMAGE_ROTATION_PROPERTY_NAMES) {
+		const property = getEffectiveStyleProperty(whileHoverObject.properties, propertyName);
+		if (!property) continue;
+		const value = getStylePropertyNumberValue(property);
+		if (value !== null && value !== 0) return propertyName;
+	}
+	return null;
+};
 const noImageHoverTransform = defineRule({
 	id: "no-image-hover-transform",
 	title: "Image scales or rotates on hover",
@@ -63184,14 +64476,23 @@ const noImageHoverTransform = defineRule({
 	tags: ["design", "test-noise"],
 	recommendation: "Keep the image stable, or use a subtler hover response tied to an actual interaction affordance.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "img") return;
-		const classNameValue = getStringFromClassNameAttr(node);
-		if (!classNameValue) return;
-		const hoverTransform = getHoverImageTransform(classNameValue);
-		if (!hoverTransform) return;
+		if (isNodeOfType(node.name, "JSXIdentifier") && node.name.name === "img") {
+			const classNameValue = getStringFromClassNameAttr(node);
+			if (!classNameValue) return;
+			const hoverTransform = getHoverImageTransform(classNameValue);
+			if (!hoverTransform) return;
+			if (hasFunctionalImageContextEvidence(node, context)) return;
+			context.report({
+				node,
+				message: `The ${hoverTransform} treatment makes the image itself shift under the pointer. Use a steadier hover affordance.`
+			});
+			return;
+		}
+		const motionTransformProperty = getMotionHoverTransformProperty(node, context);
+		if (!motionTransformProperty) return;
 		context.report({
 			node,
-			message: `The ${hoverTransform} treatment makes the image itself shift under the pointer. Use a steadier hover affordance.`
+			message: `The whileHover ${motionTransformProperty} treatment makes the image itself shift under the pointer. Use a steadier hover affordance.`
 		});
 	} })
 });
@@ -67307,6 +68608,9 @@ const UNRESOLVABLE = new Set([
 	"revert",
 	"none"
 ]);
+const GRADIENT_FUNCTION_PATTERN = /^(?:linear|radial|conic)-gradient\(/i;
+const GRADIENT_PRELUDE_PATTERN = /^(?:to\b|[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:deg|grad|rad|turn)\b|circle\b|ellipse\b|closest-|farthest-|\bat\b|from\b|in\b)/i;
+const GRADIENT_STOP_POSITION_PATTERN = /^(?:[+-]?0|[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:%|px|rem|em|deg|grad|rad|turn))(?:\s+(?:[+-]?0|[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:%|px|rem|em|deg|grad|rad|turn)))?$/i;
 const resolveOpaqueColor = (raw) => {
 	const value = raw.trim().toLowerCase();
 	if (UNRESOLVABLE.has(value)) return null;
@@ -67330,6 +68634,49 @@ const resolveOpaqueColor = (raw) => {
 	}
 	return parseColorToRgb(value);
 };
+const getFunctionalColorEndIndex = (value) => {
+	const openingParenthesisIndex = value.indexOf("(");
+	if (openingParenthesisIndex < 0) return null;
+	let depth = 0;
+	for (let characterIndex = openingParenthesisIndex; characterIndex < value.length; characterIndex += 1) {
+		const character = value[characterIndex];
+		if (character === "(") depth += 1;
+		if (character === ")") depth -= 1;
+		if (depth < 0) return null;
+		if (depth === 0) return characterIndex + 1;
+	}
+	return null;
+};
+const parseOpaqueGradientStop = (stop) => {
+	const trimmedStop = stop.trim();
+	let colorEndIndex = 0;
+	if (/^(?:rgb|hsl)a?\(/i.test(trimmedStop)) {
+		const functionalColorEndIndex = getFunctionalColorEndIndex(trimmedStop);
+		if (functionalColorEndIndex === null) return null;
+		colorEndIndex = functionalColorEndIndex;
+	} else {
+		const colorMatch = trimmedStop.match(/^(?:#[\da-f]+|white|black)(?=\s|$)/i);
+		if (!colorMatch) return null;
+		colorEndIndex = colorMatch[0].length;
+	}
+	const color = resolveOpaqueColor(trimmedStop.slice(0, colorEndIndex));
+	if (!color) return null;
+	const position = trimmedStop.slice(colorEndIndex).trim();
+	return !position || GRADIENT_STOP_POSITION_PATTERN.test(position) ? color : null;
+};
+const parseOpaqueGradientStops = (raw) => {
+	const value = raw.trim();
+	if (/var\(/i.test(value)) return null;
+	if (!GRADIENT_FUNCTION_PATTERN.test(value)) return null;
+	const contents = getCssFunctionContents(value);
+	if (contents === null) return null;
+	const parts = splitCssTopLevel(contents, ",");
+	if (!parts || parts.length < 2) return null;
+	const stopParts = parseOpaqueGradientStop(parts[0]) === null && GRADIENT_PRELUDE_PATTERN.test(parts[0]) ? parts.slice(1) : parts;
+	if (stopParts.length < 2) return null;
+	const stops = stopParts.map(parseOpaqueGradientStop);
+	return stops.every((stop) => stop !== null) ? stops : null;
+};
 const toPx = (property) => {
 	const numberValue = getStylePropertyNumberValue(property);
 	if (numberValue !== null) return numberValue;
@@ -67366,17 +68713,32 @@ const noLowContrastInlineStyle = defineRule({
 		let foreground = null;
 		let backgroundColorRaw = null;
 		let backgroundShorthandRaw = null;
+		let backgroundImageRaw = null;
 		let backgroundColorIsUnknown = false;
 		let backgroundShorthandIsUnknown = false;
-		let backgroundImagePreventsEvaluation = false;
+		let backgroundImageIsUnknown = false;
+		let backgroundClipRaw = null;
+		let webkitBackgroundClipRaw = null;
+		let backgroundClipIsUnknown = false;
+		let webkitBackgroundClipIsUnknown = false;
 		let fontSizePx = null;
 		let isBold = null;
 		for (const property of properties) {
 			const key = getStylePropertyKey(property);
 			if (!key) continue;
 			if (key === "backgroundImage") {
-				const backgroundImageValue = getStylePropertyStringValue(property);
-				backgroundImagePreventsEvaluation = backgroundImageValue === null || backgroundImageValue.trim().toLowerCase() !== "none";
+				backgroundImageRaw = getStylePropertyStringValue(property);
+				backgroundImageIsUnknown = backgroundImageRaw === null;
+				continue;
+			}
+			if (key === "backgroundClip") {
+				backgroundClipRaw = getStylePropertyStringValue(property);
+				backgroundClipIsUnknown = backgroundClipRaw === null;
+				continue;
+			}
+			if (key === "WebkitBackgroundClip") {
+				webkitBackgroundClipRaw = getStylePropertyStringValue(property);
+				webkitBackgroundClipIsUnknown = webkitBackgroundClipRaw === null;
 				continue;
 			}
 			if (key === "fontSize" && property.type === "Property") {
@@ -67397,13 +68759,29 @@ const noLowContrastInlineStyle = defineRule({
 				backgroundShorthandIsUnknown = stringValue === null;
 			}
 		}
-		if (backgroundColorIsUnknown || backgroundShorthandIsUnknown || backgroundImagePreventsEvaluation) return;
+		if (backgroundColorIsUnknown || backgroundShorthandIsUnknown || backgroundImageIsUnknown) return;
 		if (backgroundColorRaw !== null && backgroundShorthandRaw !== null) return;
-		const backgroundRaw = backgroundColorRaw ?? backgroundShorthandRaw;
-		const background = backgroundRaw === null ? null : resolveOpaqueColor(backgroundRaw);
-		if (!foreground || !background) return;
+		if (!foreground) return;
+		let backgrounds = null;
+		const hasPaintedBackgroundImage = backgroundImageRaw !== null && backgroundImageRaw.trim().toLowerCase() !== "none";
+		if (hasPaintedBackgroundImage && backgroundShorthandRaw !== null) return;
+		if (hasPaintedBackgroundImage || backgroundShorthandRaw !== null && backgroundImageRaw === null) {
+			const gradientRaw = hasPaintedBackgroundImage ? backgroundImageRaw : backgroundShorthandRaw;
+			backgrounds = gradientRaw === null ? null : parseOpaqueGradientStops(gradientRaw);
+			if (hasPaintedBackgroundImage && !backgrounds) return;
+			if (backgrounds) {
+				const clipsBackgroundToText = [backgroundClipRaw, webkitBackgroundClipRaw].some((value) => value?.split(",").some((clipValue) => clipValue.trim().toLowerCase() === "text") === true);
+				if (backgroundClipIsUnknown || webkitBackgroundClipIsUnknown || clipsBackgroundToText) return;
+			}
+		}
+		if (!backgrounds) {
+			const backgroundRaw = backgroundColorRaw ?? backgroundShorthandRaw;
+			const background = backgroundRaw === null ? null : resolveOpaqueColor(backgroundRaw);
+			if (!background) return;
+			backgrounds = [background];
+		}
 		const threshold = fontSizePx === null || fontSizePx >= 24 || isBold !== false && fontSizePx >= 18.66 ? 3 : WCAG_CONTRAST_NORMAL_MIN;
-		const ratio = getWcagContrastRatio(foreground, background);
+		const ratio = Math.min(...backgrounds.map((background) => getWcagContrastRatio(foreground, background)));
 		if (ratio < threshold) context.report({
 			node,
 			message: `Your users struggle to read this text: its contrast against the background is ${ratio.toFixed(2)}:1, below the ${threshold}:1 WCAG minimum, so darken or lighten one of the colors.`
@@ -67414,7 +68792,76 @@ const noLowContrastInlineStyle = defineRule({
 //#region src/plugin/rules/design/no-manufactured-contrast-copy.ts
 const NOT_THEN_ASSERTION_PATTERN = /\bnot\s+(?:just\s+)?[^.!?]{3,60}[.!?]\s+(?:it(?:'s| is)|we|you|a|an|the)\b/gi;
 const NO_JUST_PATTERN = /\bno\s+[^.!?]{2,50}[.!?]\s+just\s+[^.!?]{2,60}(?:[.!?]|$)/gi;
-const countMatches = (text, pattern) => [...text.matchAll(pattern)].length;
+const ASSERTION_THEN_RESTRICTION_PATTERN = /\b[^.!?]{3,60}\.\s+(?:no|just)\s+[^.!?]{2,60}(?:[.!?]|$)/gi;
+const LONG_FORM_CONTENT_PATH_PATTERN = /(?:^|[/\\])(?:blog|changelog|content|docs?|documentation|posts?)(?:[/\\]|$)/i;
+const EXCLUDED_INTRINSIC_COPY_ELEMENT_NAMES = new Set([
+	"code",
+	"kbd",
+	"pre",
+	"samp"
+]);
+const EXCLUDED_COPY_COMPONENT_NAME_PATTERN = /(?:Code|Console|Markdown|MDX|Mdx|Terminal)/;
+const STATIC_COPY_BOUNDARY = "?!";
+const CONTRAST_COPY_PATTERNS = [
+	NOT_THEN_ASSERTION_PATTERN,
+	NO_JUST_PATTERN,
+	ASSERTION_THEN_RESTRICTION_PATTERN
+];
+const isExcludedCopyElement = (node) => {
+	const elementName = resolveJsxElementName(node.openingElement);
+	if (!elementName) return false;
+	return EXCLUDED_INTRINSIC_COPY_ELEMENT_NAMES.has(elementName.toLowerCase()) || EXCLUDED_COPY_COMPONENT_NAME_PATTERN.test(elementName);
+};
+const getStaticCopyText = (node, context) => {
+	if (!node) return null;
+	if (isNodeOfType(node, "JSXText")) return node.value ?? "";
+	if (isNodeOfType(node, "JSXEmptyExpression")) return "";
+	if (isNodeOfType(node, "Literal")) {
+		if (typeof node.value === "string") return node.value;
+		if (node.value === null || typeof node.value === "boolean") return "";
+		return STATIC_COPY_BOUNDARY;
+	}
+	if (isNodeOfType(node, "TemplateLiteral")) return node.expressions.length === 0 ? (node.quasis ?? []).map((quasi) => quasi.value?.raw ?? "").join("") : null;
+	if (isNodeOfType(node, "JSXExpressionContainer")) return getStaticCopyText(node.expression, context);
+	if (isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment")) {
+		if (isNodeOfType(node, "JSXElement") && (isExcludedCopyElement(node) || isInsideStaticallyHiddenJsxSubtree$1(node, context))) return STATIC_COPY_BOUNDARY;
+		const childTexts = [];
+		for (const child of node.children ?? []) {
+			const childText = getStaticCopyText(child, context);
+			if (childText === null) return null;
+			childTexts.push(childText);
+		}
+		return childTexts.join(" ");
+	}
+	return null;
+};
+const isInsideExcludedCopyContext = (node, context) => {
+	if (isInsideStaticallyHiddenJsxSubtree$1(node, context)) return true;
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement") && isExcludedCopyElement(ancestor)) return true;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const countNonOverlappingPatternRanges = (text) => {
+	const ranges = CONTRAST_COPY_PATTERNS.flatMap((pattern) => [...text.matchAll(pattern)].flatMap((match) => match.index === void 0 ? [] : [{
+		start: match.index,
+		end: match.index + match[0].length
+	}])).sort((leftRange, rightRange) => leftRange.start - rightRange.start);
+	let patternCount = 0;
+	let previousRangeEnd = null;
+	for (const range of ranges) {
+		if (previousRangeEnd !== null && range.start < previousRangeEnd) continue;
+		patternCount += 1;
+		previousRangeEnd = range.end;
+	}
+	return patternCount;
+};
+const isLongFormContentPath = (context) => {
+	const rootDirectory = getReactDoctorStringSetting(context.settings, "rootDirectory") ?? "";
+	return LONG_FORM_CONTENT_PATH_PATTERN.test(`${rootDirectory}/${context.filename ?? ""}`);
+};
 const noManufacturedContrastCopy = defineRule({
 	id: "no-manufactured-contrast-copy",
 	title: "Page repeatedly uses manufactured contrast copy",
@@ -67423,9 +68870,10 @@ const noManufacturedContrastCopy = defineRule({
 	tags: ["design", "test-noise"],
 	recommendation: "State the value directly instead of repeatedly contrasting it with a vague alternative.",
 	create: (context) => ({ JSXElement(node) {
-		if (!isTopLevelPageCopyRoot(node)) return;
-		const pageText = getStaticJsxText(node).replace(/\s+/g, " ").trim();
-		const patternCount = countMatches(pageText, NOT_THEN_ASSERTION_PATTERN) + countMatches(pageText, NO_JUST_PATTERN);
+		if (isLongFormContentPath(context) || !isTopLevelPageCopyRoot(node) || isInsideExcludedCopyContext(node, context)) return;
+		const staticCopyText = getStaticCopyText(node, context);
+		if (staticCopyText === null) return;
+		const patternCount = countNonOverlappingPatternRanges(staticCopyText.replace(/\s+/g, " ").trim());
 		if (patternCount < 3) return;
 		context.report({
 			node: node.openingElement,
@@ -67662,17 +69110,6 @@ const noMirrorPropEffect = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/constants/tailwind.ts
-const TAILWIND_NAMED_BREAKPOINTS = [
-	"sm",
-	"md",
-	"lg",
-	"xl",
-	"2xl"
-];
-const TAILWIND_BREAKPOINT_NAMES = ["", ...TAILWIND_NAMED_BREAKPOINTS];
-const TAILWIND_BREAKPOINT_RANKS = new Map(TAILWIND_NAMED_BREAKPOINTS.map((breakpointName, breakpointIndex) => [breakpointName, breakpointIndex]));
-//#endregion
 //#region src/plugin/rules/design/utils/get-css-transition-shorthand-evidence.ts
 const CSS_TIME_PATTERN$3 = /^(-?\d*\.?\d+)(ms|s)$/i;
 const CSS_TIMING_KEYWORDS = new Set([
@@ -67779,9 +69216,6 @@ const getCssTransitionShorthandEvidence = (value) => {
 //#region src/plugin/utils/get-tailwind-arbitrary-utility-value.ts
 const getTailwindArbitraryUtilityValue = (utility, prefix) => utility.startsWith(prefix) && utility.endsWith("]") ? utility.slice(prefix.length, -1) : null;
 //#endregion
-//#region src/plugin/utils/normalize-tailwind-arbitrary-utility-value.ts
-const normalizeTailwindArbitraryUtilityValue = (value) => value.replace(/(?<!\\)_/g, " ");
-//#endregion
 //#region src/plugin/utils/get-tailwind-transition-property-effect.ts
 const KNOWN_TRANSITION_PROPERTY_EFFECTS = new Map([
 	["transition-none", {
@@ -69532,247 +70966,6 @@ const noMultipleMainLandmarks = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/get-tailwind-visibility-effect.ts
-const DISPLAY_VISIBILITY_EFFECTS = new Map([
-	["hidden", {
-		isVisible: false,
-		propertyName: "display"
-	}],
-	["block", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["contents", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["flex", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["flow-root", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["grid", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["inline", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["inline-block", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["inline-flex", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["inline-grid", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["inline-table", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["list-item", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["table", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["table-caption", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["table-cell", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["table-column", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["table-column-group", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["table-footer-group", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["table-header-group", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["table-row", {
-		isVisible: true,
-		propertyName: "display"
-	}],
-	["table-row-group", {
-		isVisible: true,
-		propertyName: "display"
-	}]
-]);
-const VISIBILITY_VISIBILITY_EFFECTS = new Map([
-	["collapse", {
-		isVisible: false,
-		propertyName: "visibility"
-	}],
-	["invisible", {
-		isVisible: false,
-		propertyName: "visibility"
-	}],
-	["visible", {
-		isVisible: true,
-		propertyName: "visibility"
-	}]
-]);
-const VISIBLE_ARBITRARY_DISPLAY_VALUES = new Set([
-	"block",
-	"contents",
-	"flex",
-	"flow-root",
-	"grid",
-	"inline",
-	"inline block",
-	"inline flex",
-	"inline flow-root",
-	"inline grid",
-	"inline table",
-	"list-item",
-	"table",
-	"table-caption",
-	"table-cell",
-	"table-column",
-	"table-column-group",
-	"table-footer-group",
-	"table-header-group",
-	"table-row",
-	"table-row-group"
-]);
-const getArbitraryCssPropertyValue = (utility, propertyName) => {
-	const propertyPrefix = `[${propertyName}:`;
-	return utility.toLowerCase().startsWith(propertyPrefix) && utility.endsWith("]") ? utility.slice(propertyPrefix.length, -1) : null;
-};
-const getTailwindVisibilityEffect = (utility) => {
-	const knownEffect = DISPLAY_VISIBILITY_EFFECTS.get(utility) ?? VISIBILITY_VISIBILITY_EFFECTS.get(utility);
-	if (knownEffect) return {
-		...knownEffect,
-		status: "known"
-	};
-	const arbitraryDisplayValue = getArbitraryCssPropertyValue(utility, "display");
-	if (arbitraryDisplayValue !== null) {
-		const displayValue = normalizeTailwindArbitraryUtilityValue(arbitraryDisplayValue).trim().toLowerCase();
-		if (displayValue === "none") return {
-			isVisible: false,
-			propertyName: "display",
-			status: "known"
-		};
-		return VISIBLE_ARBITRARY_DISPLAY_VALUES.has(displayValue) ? {
-			isVisible: true,
-			propertyName: "display",
-			status: "known"
-		} : {
-			isVisible: null,
-			propertyName: "display",
-			status: "unknown"
-		};
-	}
-	const arbitraryVisibilityValue = getArbitraryCssPropertyValue(utility, "visibility");
-	if (arbitraryVisibilityValue === null) return {
-		isVisible: null,
-		propertyName: null,
-		status: "not-relevant"
-	};
-	const visibilityValue = normalizeTailwindArbitraryUtilityValue(arbitraryVisibilityValue).trim().toLowerCase();
-	if (visibilityValue === "visible") return {
-		isVisible: true,
-		propertyName: "visibility",
-		status: "known"
-	};
-	return visibilityValue === "hidden" || visibilityValue === "collapse" ? {
-		isVisible: false,
-		propertyName: "visibility",
-		status: "known"
-	} : {
-		isVisible: null,
-		propertyName: "visibility",
-		status: "unknown"
-	};
-};
-//#endregion
-//#region src/plugin/utils/get-tailwind-visibility-at-breakpoints.ts
-const getResponsiveVariantScope = (variants) => {
-	let minimumBreakpointIndex = 0;
-	let maximumBreakpointIndex = TAILWIND_BREAKPOINT_NAMES.length;
-	for (const variant of variants) {
-		const minimumVariantIndex = TAILWIND_BREAKPOINT_NAMES.indexOf(variant);
-		if (minimumVariantIndex > 0) {
-			minimumBreakpointIndex = Math.max(minimumBreakpointIndex, minimumVariantIndex);
-			continue;
-		}
-		if (variant.startsWith("max-")) {
-			const maximumVariantIndex = TAILWIND_BREAKPOINT_NAMES.indexOf(variant.slice(4));
-			if (maximumVariantIndex > 0) {
-				maximumBreakpointIndex = Math.min(maximumBreakpointIndex, maximumVariantIndex);
-				continue;
-			}
-		}
-		return null;
-	}
-	return {
-		maximumBreakpointIndex,
-		minimumBreakpointIndex,
-		specificity: variants.length
-	};
-};
-const resolveVisibilityProperty = (scopedEffects, breakpointIndex, propertyName) => {
-	const applicableEffects = scopedEffects.filter(({ effect, scope }) => effect.propertyName === propertyName && breakpointIndex >= scope.minimumBreakpointIndex && breakpointIndex < scope.maximumBreakpointIndex);
-	if (applicableEffects.length === 0) return true;
-	const highestImportanceEffects = applicableEffects.some(({ token }) => token.isImportant) ? applicableEffects.filter(({ token }) => token.isImportant) : applicableEffects;
-	const maximumSpecificity = Math.max(...highestImportanceEffects.map(({ scope }) => scope.specificity));
-	const highestSpecificityEffects = highestImportanceEffects.filter(({ scope }) => scope.specificity === maximumSpecificity);
-	const maximumMinimumBreakpoint = Math.max(...highestSpecificityEffects.map(({ scope }) => scope.minimumBreakpointIndex));
-	const latestMinimumEffects = highestSpecificityEffects.filter(({ scope }) => scope.minimumBreakpointIndex === maximumMinimumBreakpoint);
-	const minimumMaximumBreakpoint = Math.min(...latestMinimumEffects.map(({ scope }) => scope.maximumBreakpointIndex));
-	const highestPriorityStates = new Set(latestMinimumEffects.filter(({ scope }) => scope.maximumBreakpointIndex === minimumMaximumBreakpoint).map(({ effect }) => effect.isVisible));
-	return highestPriorityStates.size === 1 ? highestPriorityStates.values().next().value ?? null : null;
-};
-const getTailwindVisibilityAtBreakpoints = (className) => {
-	const scopedEffects = [];
-	for (const token of splitTailwindClassName(className).map(parseTailwindClassNameToken)) {
-		const resolution = getTailwindVisibilityEffect(token.utility);
-		if (resolution.status === "not-relevant") continue;
-		const scope = getResponsiveVariantScope(token.variants);
-		if (scope === null) return null;
-		if (!scope || scope.minimumBreakpointIndex >= scope.maximumBreakpointIndex) continue;
-		if (resolution.status === "unknown" || resolution.propertyName === null || resolution.isVisible === null) return null;
-		const effect = {
-			isVisible: resolution.isVisible,
-			propertyName: resolution.propertyName
-		};
-		scopedEffects.push({
-			effect,
-			scope,
-			token
-		});
-	}
-	const visibilityAtBreakpoints = [];
-	for (let breakpointIndex = 0; breakpointIndex < TAILWIND_BREAKPOINT_NAMES.length; breakpointIndex += 1) {
-		const displayVisibility = resolveVisibilityProperty(scopedEffects, breakpointIndex, "display");
-		const visibilityVisibility = resolveVisibilityProperty(scopedEffects, breakpointIndex, "visibility");
-		if (displayVisibility === null || visibilityVisibility === null) return null;
-		visibilityAtBreakpoints.push(displayVisibility && visibilityVisibility);
-	}
-	return visibilityAtBreakpoints;
-};
-//#endregion
 //#region src/plugin/rules/a11y/no-multiple-unlabeled-navigation-landmarks.ts
 const getLandmarkName = (node) => {
 	for (const attributeName of ["aria-label", "aria-labelledby"]) {
@@ -73651,44 +74844,267 @@ const noNullishCoalescingArithmeticPrecedence = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/design/no-numbered-section-markers.ts
-const NUMBERED_MARKER_PATTERN = /^(0[1-9]|1[0-2])$/;
+const NUMBERED_LABEL_ELEMENT_NAMES = new Set([
+	"b",
+	"div",
+	"em",
+	"p",
+	"small",
+	"span",
+	"strong"
+]);
+const WRAPPED_HEADING_ELEMENT_NAMES = new Set(["div", "header"]);
+const ORDERED_CONTEXT_ELEMENT_NAMES = new Set([
+	"article",
+	"li",
+	"menu",
+	"nav",
+	"ol",
+	"table",
+	"tbody",
+	"td",
+	"tfoot",
+	"th",
+	"thead",
+	"time",
+	"tr",
+	"ul"
+]);
+const ORDERED_CONTEXT_ROLES = new Set([
+	"list",
+	"listitem",
+	"navigation",
+	"progressbar",
+	"status"
+]);
 const HEADING_ELEMENT_PATTERN$3 = /^h[1-6]$/;
-const getSectionMarker = (node) => {
-	const match = getStaticJsxText(node).trim().match(NUMBERED_MARKER_PATTERN);
+const ORDERED_CONTEXT_CLASS_SEGMENT_PATTERN = /(?:^|[-_:])(?:calendar|card|card-item|date|day|milestone|month|progress|step|stepper|steps|timeline|year)(?:$|[-_:])/i;
+const ORDERED_CONTEXT_COMPONENT_NAME_PATTERN = /(?:Calendar|Date|Day|Milestone|Month|Progress|Step|Stepper|Timeline|Year)/;
+const ORDERED_CONTEXT_LABEL_PATTERN = /\b(?:progress|step|steps)\b/i;
+const ORDERED_HEADING_PATTERN = /^(?:phase|stage|step)\b/i;
+const DATE_HEADING_PATTERN = /^(?:fri(?:day)?|mon(?:day)?|sat(?:urday)?|sun(?:day)?|thu(?:rsday)?|tue(?:sday)?|wed(?:nesday)?|jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\b/i;
+const DATE_LIKE_LABEL_PATTERN = /\b(?:19|20)\d{2}\b|\b(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\b|\d{1,2}[./:-]\d{1,2}/i;
+const BARE_NUMBERED_LABEL_PATTERN = /^(\d{2})$/;
+const COMPOUND_NUMBERED_LABEL_PATTERN = /^(\d{1,2})\s*[/|·•—–]\s*\p{L}/u;
+const ACCENT_TEXT_CLASS_PATTERN = /^text-(?:amber|blue|cyan|emerald|fuchsia|green|indigo|lime|orange|pink|purple|red|rose|sky|teal|violet|yellow)-\d{2,3}$/;
+const ACCENT_ARBITRARY_TEXT_CLASS_PATTERN = /^text-\[(?:#|color:|hsl|oklch|rgb)/i;
+const BOLD_FONT_CLASS_NAMES = new Set([
+	"font-black",
+	"font-bold",
+	"font-extrabold",
+	"font-semibold"
+]);
+const getFullyStaticJsxText = (node) => {
+	if (!node) return "";
+	if (isNodeOfType(node, "JSXText")) return node.value ?? "";
+	if (isNodeOfType(node, "Literal")) return typeof node.value === "string" || typeof node.value === "number" ? String(node.value) : null;
+	if (isNodeOfType(node, "TemplateLiteral")) return node.expressions.length === 0 ? node.quasis[0]?.value.raw ?? "" : null;
+	if (isNodeOfType(node, "JSXExpressionContainer")) return isNodeOfType(node.expression, "JSXEmptyExpression") ? "" : getFullyStaticJsxText(node.expression);
+	if (isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment")) {
+		let text = "";
+		for (const child of node.children ?? []) {
+			const childText = getFullyStaticJsxText(child);
+			if (childText === null) return null;
+			text += childText;
+		}
+		return text;
+	}
+	return null;
+};
+const getOutermostJsxRoot = (node) => {
+	let outermostJsxRoot = node;
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement") || isNodeOfType(ancestor, "JSXFragment")) outermostJsxRoot = ancestor;
+		ancestor = ancestor.parent;
+	}
+	return outermostJsxRoot;
+};
+const hasConditionalOrLogicalAncestor = (node) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "ConditionalExpression") || isNodeOfType(ancestor, "LogicalExpression")) return true;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const getAncestorOpeningElements$1 = (node) => {
+	const openingElements = [];
+	let ancestor = node;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement")) openingElements.push(ancestor.openingElement);
+		ancestor = ancestor.parent;
+	}
+	return openingElements;
+};
+const hasUnresolvedJsxAttribute = (openingElement, attributeName) => {
+	const attribute = getAuthoritativeJsxAttribute(openingElement.attributes, attributeName, false);
+	if (!attribute?.value) return false;
+	if (getStringLiteralAttributeValue(attribute) !== null) return false;
+	return !(isNodeOfType(attribute.value, "JSXExpressionContainer") && isNodeOfType(attribute.value.expression, "Literal"));
+};
+const hasUnresolvedInlineRenderingStyle = (openingElement, scopes) => {
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	if (!styleAttribute) return false;
+	const styleExpression = getInlineStyleExpression(styleAttribute, scopes);
+	if (!styleExpression) return true;
+	if (styleExpression.properties.some((property) => getStylePropertyKey(property) === null)) return true;
+	for (const propertyName of ["display", "visibility"]) {
+		const property = getEffectiveStyleProperty(styleExpression.properties, propertyName);
+		if (property && getStylePropertyStringValue(property) === null) return true;
+	}
+	return false;
+};
+const isHiddenOrRenderingUnknown = (openingElement, hasTailwind, scopes, settings) => {
+	if (hasJsxSpreadAttribute(openingElement.attributes) || hasUnresolvedJsxAttribute(openingElement, "hidden") || hasUnresolvedJsxAttribute(openingElement, "aria-hidden") || hasUnresolvedInlineRenderingStyle(openingElement, scopes)) return true;
+	const classNameAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "className");
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	if (classNameAttribute && classNameValue === null) return true;
+	if (isHiddenFromScreenReader(openingElement, settings)) return true;
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	const styleExpression = styleAttribute ? getInlineStyleExpression(styleAttribute, scopes) : null;
+	if (styleExpression) {
+		const displayProperty = getEffectiveStyleProperty(styleExpression.properties, "display");
+		if (displayProperty && getStylePropertyStringValue(displayProperty)?.toLowerCase() === "none") return true;
+		const visibilityProperty = getEffectiveStyleProperty(styleExpression.properties, "visibility");
+		const visibilityValue = visibilityProperty ? getStylePropertyStringValue(visibilityProperty)?.toLowerCase() : null;
+		if (visibilityValue === "hidden" || visibilityValue === "collapse") return true;
+	}
+	if (!hasTailwind || !classNameValue) return false;
+	const visibilityAtBreakpoints = getTailwindVisibilityAtBreakpoints(classNameValue);
+	return visibilityAtBreakpoints === null || visibilityAtBreakpoints.every((isVisible) => !isVisible);
+};
+const hasHiddenOrUnknownAncestor = (node, hasTailwind, scopes, settings) => getAncestorOpeningElements$1(node).some((openingElement) => isHiddenOrRenderingUnknown(openingElement, hasTailwind, scopes, settings));
+const parseNumberedSectionLabel = (text) => {
+	const normalizedText = text.replace(/\s+/g, " ").trim();
+	if (!normalizedText || normalizedText.length > 40 || DATE_LIKE_LABEL_PATTERN.test(normalizedText)) return null;
+	const match = normalizedText.match(BARE_NUMBERED_LABEL_PATTERN) ?? normalizedText.match(COMPOUND_NUMBERED_LABEL_PATTERN);
 	if (!match) return null;
+	const index = Number.parseInt(match[1], 10);
+	return index > 0 && index <= 40 ? index : null;
+};
+const getHeadingFromElement = (element) => {
+	if (!isNodeOfType(element.openingElement.name, "JSXIdentifier")) return null;
+	if (HEADING_ELEMENT_PATTERN$3.test(element.openingElement.name.name)) return element;
+	if (!WRAPPED_HEADING_ELEMENT_NAMES.has(element.openingElement.name.name)) return null;
+	for (const child of element.children ?? []) {
+		if (isNodeOfType(child, "JSXText") && child.value.trim() === "") continue;
+		if (isNodeOfType(child, "JSXExpressionContainer") && isNodeOfType(child.expression, "JSXEmptyExpression")) continue;
+		return isNodeOfType(child, "JSXElement") ? getHeadingFromElement(child) : null;
+	}
+	return null;
+};
+const getFollowingStaticHeading = (node) => {
 	const sibling = getNextStaticJsxElementSibling(node);
-	if (!sibling || !isNodeOfType(sibling.openingElement.name, "JSXIdentifier") || !HEADING_ELEMENT_PATTERN$3.test(sibling.openingElement.name.name)) return null;
-	return parseInt(match[1], 10);
+	if (!sibling) return null;
+	const heading = getHeadingFromElement(sibling);
+	const headingText = getFullyStaticJsxText(heading);
+	if (!heading || !headingText) return null;
+	const normalizedHeadingText = headingText.replace(/\s+/g, " ").trim();
+	if (!normalizedHeadingText || ORDERED_HEADING_PATTERN.test(normalizedHeadingText) || DATE_HEADING_PATTERN.test(normalizedHeadingText)) return null;
+	return heading;
+};
+const hasOrderedOrUnresolvedContext = (node) => {
+	let ancestor = node;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement")) {
+			const openingElement = ancestor.openingElement;
+			if (hasJsxSpreadAttribute(openingElement.attributes)) return true;
+			if (isNodeOfType(openingElement.name, "JSXIdentifier")) {
+				const elementName = openingElement.name.name;
+				if (ORDERED_CONTEXT_ELEMENT_NAMES.has(elementName)) return true;
+				if (ORDERED_CONTEXT_COMPONENT_NAME_PATTERN.test(elementName)) return true;
+			}
+			const roleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "role", false);
+			const roleValue = roleAttribute ? getStringLiteralAttributeValue(roleAttribute) : null;
+			if (roleAttribute && roleValue === null) return true;
+			const role = roleValue?.toLowerCase();
+			if (role && ORDERED_CONTEXT_ROLES.has(role)) return true;
+			if (getAuthoritativeJsxAttribute(openingElement.attributes, "dateTime", false)) return true;
+			const ariaLabelAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "aria-label", false);
+			const ariaLabelValue = ariaLabelAttribute ? getStringLiteralAttributeValue(ariaLabelAttribute) : null;
+			if (ariaLabelAttribute && ariaLabelValue === null) return true;
+			const ariaLabel = ariaLabelValue ?? "";
+			if (ariaLabel && ORDERED_CONTEXT_LABEL_PATTERN.test(ariaLabel)) return true;
+			const classNameAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "className");
+			const classNameValue = getStringFromClassNameAttr(openingElement);
+			if (classNameAttribute && classNameValue === null) return true;
+			if (classNameValue && ORDERED_CONTEXT_CLASS_SEGMENT_PATTERN.test(classNameValue)) return true;
+		}
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const hasInlineMicroLabelTreatment = (openingElement, scopes) => {
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	if (!styleAttribute) return false;
+	const styleExpression = getInlineStyleExpression(styleAttribute, scopes);
+	if (!styleExpression) return false;
+	const fontFamily = getEffectiveStyleProperty(styleExpression.properties, "fontFamily");
+	if (fontFamily && /mono/i.test(getStylePropertyStringValue(fontFamily) ?? "")) return true;
+	const fontWeight = getEffectiveStyleProperty(styleExpression.properties, "fontWeight");
+	if (fontWeight) {
+		if ((getStylePropertyNumberValue(fontWeight) ?? Number.parseInt(getStylePropertyStringValue(fontWeight) ?? "", 10)) >= 600) return true;
+		if (/^(?:bold|bolder)$/i.test(getStylePropertyStringValue(fontWeight) ?? "")) return true;
+	}
+	const letterSpacing = getEffectiveStyleProperty(styleExpression.properties, "letterSpacing");
+	if (letterSpacing) {
+		if ((getStylePropertyNumberValue(letterSpacing) ?? Number.parseFloat(getStylePropertyStringValue(letterSpacing) ?? "")) > 0) return true;
+	}
+	const textTransform = getEffectiveStyleProperty(styleExpression.properties, "textTransform");
+	return Boolean(textTransform && getStylePropertyStringValue(textTransform)?.toLowerCase() === "uppercase");
+};
+const hasTailwindMicroLabelTreatment = (openingElement) => {
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	if (!classNameValue) return false;
+	return getUnvariantClassNameTokens(classNameValue).some((classNameToken) => classNameToken === "font-mono" || classNameToken === "uppercase" || BOLD_FONT_CLASS_NAMES.has(classNameToken) || classNameToken.startsWith("tracking-") && classNameToken !== "tracking-normal" || ACCENT_TEXT_CLASS_PATTERN.test(classNameToken) || ACCENT_ARBITRARY_TEXT_CLASS_PATTERN.test(classNameToken));
+};
+const getSectionMarker = (node, hasTailwind, scopes, settings) => {
+	const heading = getFollowingStaticHeading(node);
+	if (!isNodeOfType(node.openingElement.name, "JSXIdentifier") || !NUMBERED_LABEL_ELEMENT_NAMES.has(node.openingElement.name.name) || !heading || hasConditionalOrLogicalAncestor(node) || hasOrderedOrUnresolvedContext(node) || hasOrderedOrUnresolvedContext(heading) || hasHiddenOrUnknownAncestor(node, hasTailwind, scopes, settings) || hasHiddenOrUnknownAncestor(heading, hasTailwind, scopes, settings)) return null;
+	const text = getFullyStaticJsxText(node);
+	if (text === null) return null;
+	const index = parseNumberedSectionLabel(text);
+	if (index === null) return null;
+	const fontSize = getStaticEffectiveFontSize(node.openingElement, hasTailwind, scopes);
+	if (fontSize === null || fontSize <= 0 || fontSize > 13) return null;
+	if (!hasInlineMicroLabelTreatment(node.openingElement, scopes) && !(hasTailwind && hasTailwindMicroLabelTreatment(node.openingElement))) return null;
+	return {
+		index,
+		openingElement: node.openingElement
+	};
 };
 const noNumberedSectionMarkers = defineRule({
 	id: "no-numbered-section-markers",
-	title: "Sequential numbers are used as section decoration",
+	title: "Styled numbers are used as section decoration",
 	severity: "warn",
 	defaultEnabled: false,
 	tags: ["design", "test-noise"],
 	recommendation: "Remove decorative section numbering unless the sequence communicates real progress or ordered steps.",
 	create: (context) => {
-		const markers = /* @__PURE__ */ new Map();
+		const hasTailwind = hasCapabilityOrUnspecified(context.settings, "tailwind");
+		const markerBuckets = /* @__PURE__ */ new Map();
 		return {
 			JSXElement(node) {
-				const marker = getSectionMarker(node);
-				if (marker === null) return;
-				markers.set(marker, node.openingElement);
+				const marker = getSectionMarker(node, hasTailwind, context.scopes, context.settings);
+				if (!marker) return;
+				const outermostJsxRoot = getOutermostJsxRoot(node);
+				const existingBucket = markerBuckets.get(outermostJsxRoot);
+				if (existingBucket) {
+					existingBucket.set(marker.index, marker.openingElement);
+					return;
+				}
+				markerBuckets.set(outermostJsxRoot, new Map([[marker.index, marker.openingElement]]));
 			},
 			"Program:exit"() {
-				const sortedMarkers = [...markers.keys()].sort((left, right) => left - right);
-				let runStartIndex = 0;
-				for (let markerIndex = 1; markerIndex <= sortedMarkers.length; markerIndex += 1) {
-					if (markerIndex < sortedMarkers.length && sortedMarkers[markerIndex] === sortedMarkers[markerIndex - 1] + 1) continue;
-					if (markerIndex - runStartIndex >= 3) {
-						const firstNode = markers.get(sortedMarkers[runStartIndex]);
-						if (firstNode) context.report({
-							node: firstNode,
-							message: "Several headings are prefixed with decorative sequence numbers. Keep numbering for genuinely ordered steps, not visual scaffolding."
-						});
-						return;
-					}
-					runStartIndex = markerIndex;
+				for (const markers of markerBuckets.values()) {
+					if (markers.size < 2) continue;
+					const firstNode = markers.values().next().value;
+					if (!firstNode) continue;
+					context.report({
+						node: firstNode,
+						message: "Several headings are prefixed with styled numeric labels. Keep numbering for genuinely ordered steps, not visual scaffolding."
+					});
 				}
 			}
 		};
@@ -74263,7 +75679,7 @@ const noOversizedLongHeading = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/design/no-overwide-text-measure.ts
-const TEXT_ELEMENT_NAMES = new Set([
+const TEXT_ELEMENT_NAMES$1 = new Set([
 	"blockquote",
 	"dd",
 	"figcaption",
@@ -74279,7 +75695,7 @@ const noOverwideTextMeasure = defineRule({
 	category: "Accessibility",
 	recommendation: "Constrain long-form text to a readable line length, usually between 60ch and 75ch.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || !TEXT_ELEMENT_NAMES.has(node.name.name)) return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || !TEXT_ELEMENT_NAMES$1.has(node.name.name)) return;
 		const classNameValue = getStringFromClassNameAttr(node);
 		if (classNameValue) {
 			const overwideToken = getClassNameTokens(classNameValue).find((token) => {
@@ -77298,6 +78714,118 @@ const noPropTypes = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/rules/design/no-pulsing-status-dot.ts
+const ANIMATION_UTILITY_PATTERN = /^animate-/;
+const ROUNDING_UTILITY_PATTERN = /^rounded(?:-|$)/;
+const WIDTH_UTILITY_PATTERN$1 = /^(?:size|w)-/;
+const HEIGHT_UTILITY_PATTERN$1 = /^(?:h|size)-/;
+const PULSING_ANIMATION_UTILITIES = new Set(["animate-ping", "animate-pulse"]);
+const LIVE_STATUS_ROLES = new Set([
+	"alert",
+	"progressbar",
+	"status"
+]);
+const hasTinySquareSize = (tokens) => {
+	const widthUtility = getEffectiveTailwindClassNameToken(tokens, (utility) => WIDTH_UTILITY_PATTERN$1.test(utility));
+	const heightUtility = getEffectiveTailwindClassNameToken(tokens, (utility) => HEIGHT_UTILITY_PATTERN$1.test(utility));
+	const widthPx = widthUtility ? parseStaticTailwindLengthPx(widthUtility, "size") ?? parseStaticTailwindLengthPx(widthUtility, "w") : null;
+	const heightPx = heightUtility ? parseStaticTailwindLengthPx(heightUtility, "size") ?? parseStaticTailwindLengthPx(heightUtility, "h") : null;
+	return Boolean(widthPx !== null && heightPx !== null && widthPx === heightPx && widthPx >= 2 && widthPx <= 16);
+};
+const readStaticBooleanValue = (value) => {
+	if (typeof value !== "boolean" && typeof value !== "string") return null;
+	const normalizedValue = value.toString().toLowerCase();
+	if (normalizedValue === "true") return true;
+	if (normalizedValue === "false") return false;
+	return null;
+};
+const getStaticBooleanAttributeValue = (attribute) => {
+	if (!attribute.value) return true;
+	if (isNodeOfType(attribute.value, "Literal")) return readStaticBooleanValue(attribute.value.value);
+	if (isNodeOfType(attribute.value, "JSXExpressionContainer") && isNodeOfType(attribute.value.expression, "Literal")) return readStaticBooleanValue(attribute.value.expression.value);
+	return null;
+};
+const hasOnlyWhitespaceChildren = (element) => element.children.every((child) => isNodeOfType(child, "JSXText") && child.value.trim().length === 0);
+const hasLiveStatusSemanticExemption = (element) => {
+	let ancestor = element;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement")) {
+			const openingElement = ancestor.openingElement;
+			if (hasJsxSpreadAttribute(openingElement.attributes)) return true;
+			const ariaBusyAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "aria-busy", false);
+			if (ariaBusyAttribute && getStaticBooleanAttributeValue(ariaBusyAttribute) !== false) return true;
+			const ariaLiveAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "aria-live", false);
+			if (ariaLiveAttribute) {
+				const ariaLiveValue = getStringLiteralAttributeValue(ariaLiveAttribute);
+				if (!ariaLiveValue || ariaLiveValue.trim().toLowerCase() !== "off") return true;
+			}
+			const roleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "role", false);
+			if (roleAttribute) {
+				const roleValue = getStringLiteralAttributeValue(roleAttribute);
+				if (!roleValue || roleValue.trim().toLowerCase().split(/\s+/).some((role) => LIVE_STATUS_ROLES.has(role))) return true;
+			}
+		}
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const isHeaderContext = (node) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement") && isNodeOfType(ancestor.openingElement.name, "JSXIdentifier") && ancestor.openingElement.name.name === "header") return true;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const isStrictNavigationContext = (node) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement")) {
+			const openingElement = ancestor.openingElement;
+			if (isNodeOfType(openingElement.name, "JSXIdentifier") && openingElement.name.name === "nav") return true;
+			const roleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "role", false);
+			if ((roleAttribute ? getStringLiteralAttributeValue(roleAttribute) : null)?.trim().toLowerCase().split(/\s+/).some((role) => role === "navigation")) return true;
+		}
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const isHeroContext = (node) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement") && isNodeOfType(ancestor.openingElement.name, "JSXIdentifier") && ancestor.openingElement.name.name === "section") return getStaticJsxDescendantOpeningElements(ancestor).some((openingElement) => isNodeOfType(openingElement.name, "JSXIdentifier") && openingElement.name.name === "h1");
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const noPulsingStatusDot = defineRule({
+	id: "no-pulsing-status-dot",
+	title: "Decorative status dot pulses continuously",
+	severity: "warn",
+	defaultEnabled: false,
+	tags: [
+		"design",
+		"test-noise",
+		"react-jsx-only"
+	],
+	requires: ["tailwind"],
+	recommendation: "Use a static status indicator unless the element communicates real work in progress.",
+	create: (context) => ({ JSXElement(node) {
+		const openingElement = node.openingElement;
+		if (!isProvenIntrinsicJsxElement(openingElement, context.scopes) || getAuthoritativeJsxAttribute(openingElement.attributes, "style") !== null || !hasOnlyWhitespaceChildren(node) || hasLiveStatusSemanticExemption(node) || isInsideStaticallyHiddenJsxSubtree$1(node, context) || !isStrictNavigationContext(node) && !isHeaderContext(node) && !isHeroContext(node)) return;
+		const classNameValue = getStringFromClassNameAttr(openingElement);
+		if (!classNameValue) return;
+		const tokens = splitTailwindClassName(classNameValue);
+		const animationUtility = getEffectiveTailwindClassNameToken(tokens, (utility) => ANIMATION_UTILITY_PATTERN.test(utility));
+		if (!animationUtility || !PULSING_ANIMATION_UTILITIES.has(animationUtility)) return;
+		if (getEffectiveTailwindClassNameToken(tokens, (utility) => ROUNDING_UTILITY_PATTERN.test(utility)) !== "rounded-full" || !hasTinySquareSize(tokens)) return;
+		context.report({
+			node: openingElement,
+			message: "This tiny status dot pulses continuously without representing work in progress. Use a static indicator for passive availability or decoration."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/design/no-pure-black-background.ts
 const noPureBlackBackground = defineRule({
 	id: "no-pure-black-background",
@@ -77383,6 +78911,130 @@ const noPureBlackShadow = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/rules/design/no-radial-halo.ts
+const HALO_SURFACE_ELEMENT_NAMES = new Set([
+	"article",
+	"aside",
+	"div",
+	"header",
+	"main",
+	"section"
+]);
+const BACKGROUND_IMAGE_STYLE_PROPERTY_NAMES = new Set(["background", "backgroundImage"]);
+const BACKGROUND_COLOR_STYLE_PROPERTY_NAMES = new Set(["background", "backgroundColor"]);
+const TAILWIND_ARBITRARY_IMAGE_VALUE_PATTERN = /^(?:image:|(?:radial-gradient|repeating-radial-gradient|linear-gradient|repeating-linear-gradient|conic-gradient|repeating-conic-gradient|url)\()/i;
+const TAILWIND_NON_COLOR_BACKGROUND_UTILITY_PATTERN = /^bg-(?:auto|bottom|center|clip-|contain|cover|fixed|left|local|no-repeat|none|origin-|repeat|right|scroll|top)/;
+const isTailwindBackgroundColorUtility = (utility) => {
+	if (/^\[(?:background|background-color):[\s\S]+\]$/i.test(utility)) return true;
+	if (utility.startsWith("bg-[") && utility.endsWith("]")) {
+		const arbitraryValue = utility.slice(4, -1);
+		return !TAILWIND_ARBITRARY_IMAGE_VALUE_PATTERN.test(arbitraryValue);
+	}
+	return utility.startsWith("bg-") && !TAILWIND_NON_COLOR_BACKGROUND_UTILITY_PATTERN.test(utility);
+};
+const getStaticTailwindBackgroundColor = (tokens) => {
+	const resolution = resolveEffectiveTailwindClassNameToken(tokens, isTailwindBackgroundColorUtility, []);
+	const utility = resolution.utility;
+	if (!utility) return {
+		isAmbiguous: resolution.isAmbiguous,
+		isImportant: resolution.isImportant,
+		value: null
+	};
+	let arbitraryValue = null;
+	if (utility.startsWith("bg-[") && utility.endsWith("]")) arbitraryValue = utility.slice(4, -1).replace(/^color:/i, "");
+	else arbitraryValue = utility.match(/^\[(?:background|background-color):([\s\S]+)\]$/i)?.[1] ?? null;
+	return {
+		isAmbiguous: resolution.isAmbiguous,
+		isImportant: resolution.isImportant,
+		value: arbitraryValue ? normalizeTailwindArbitraryUtilityValue(arbitraryValue) : null
+	};
+};
+const getStaticHaloElementEvidence = (node, context) => {
+	if (!isProvenIntrinsicJsxElement(node, context.scopes)) return null;
+	const classNameAttribute = getAuthoritativeJsxAttribute(node.attributes, "className");
+	const styleAttribute = getAuthoritativeJsxAttribute(node.attributes, "style");
+	if (!classNameAttribute && hasJsxSpreadThatMayProvideAttribute(node.attributes, "className") || !styleAttribute && hasJsxSpreadThatMayProvideAttribute(node.attributes, "style")) return null;
+	const className = classNameAttribute ? getStringFromClassNameAttr(node) : "";
+	if (classNameAttribute && className === null) return null;
+	const styleExpression = styleAttribute ? getInlineStyleExpression(styleAttribute, context.scopes) : null;
+	if (styleAttribute && !styleExpression || styleExpression?.properties.some((property) => getStylePropertyKey(property) === null)) return null;
+	return {
+		styleExpression,
+		tokens: className && hasCapabilityOrUnspecified(context.settings, "tailwind") ? splitTailwindClassName(className) : []
+	};
+};
+const hasDarkBackground = (evidence) => {
+	const tailwindBackground = getStaticTailwindBackgroundColor(evidence.tokens);
+	if (tailwindBackground.isAmbiguous) return false;
+	const inlineBackgroundProperty = getEffectiveStylePropertyAmong(evidence.styleExpression?.properties, BACKGROUND_COLOR_STYLE_PROPERTY_NAMES);
+	const inlineBackgroundValue = inlineBackgroundProperty ? getStylePropertyStringValue(inlineBackgroundProperty) : null;
+	const backgroundValue = inlineBackgroundProperty && !tailwindBackground.isImportant ? inlineBackgroundValue : tailwindBackground.value;
+	if (!backgroundValue) return false;
+	const color = parseStaticCssColorWithAlpha(backgroundValue);
+	return Boolean(color && color.alpha >= .95 && color.red <= 35 && color.green <= 35 && color.blue <= 35);
+};
+const getStaticBackgroundImage = (evidence) => {
+	const tailwindBackground = getStaticTailwindBackgroundImage(evidence.tokens);
+	if (tailwindBackground.isAmbiguous) return null;
+	const inlineBackgroundProperty = getEffectiveStylePropertyAmong(evidence.styleExpression?.properties, BACKGROUND_IMAGE_STYLE_PROPERTY_NAMES);
+	const inlineBackgroundValue = inlineBackgroundProperty ? getStylePropertyStringValue(inlineBackgroundProperty) : null;
+	return {
+		property: inlineBackgroundProperty,
+		value: inlineBackgroundProperty && !tailwindBackground.isImportant ? inlineBackgroundValue : tailwindBackground.value
+	};
+};
+const isSmallPixelHalo = (stops) => {
+	const positions = stops.flatMap((stop) => stop.positions);
+	if (positions.length === 0) return false;
+	let maximumPixelExtent = 0;
+	for (const position of positions) {
+		const numericValue = Number.parseFloat(position);
+		if (!Number.isFinite(numericValue)) return false;
+		if (numericValue === 0) continue;
+		if (!position.toLowerCase().endsWith("px")) return false;
+		maximumPixelExtent = Math.max(maximumPixelExtent, Math.abs(numericValue));
+	}
+	return maximumPixelExtent <= 24;
+};
+const hasSaturatedRadialHalo = (backgroundValue) => {
+	const stops = parseStaticRadialGradient(backgroundValue);
+	if (!stops || isSmallPixelHalo(stops)) return false;
+	const finalStop = stops.at(-1);
+	if (!finalStop || finalStop.color.alpha > .05) return false;
+	const firstVisibleStop = stops.slice(0, -1).find((stop) => stop.color.alpha > RADIAL_HALO_TRANSPARENT_ALPHA_MAX);
+	return Boolean(firstVisibleStop && firstVisibleStop.color.alpha >= .7 && hasColorChroma(firstVisibleStop.color));
+};
+const getStaticRootOpeningElement = (node) => {
+	const root = getStaticJsxTreeRoot(node);
+	return isNodeOfType(root, "JSXElement") ? root.openingElement : null;
+};
+const noRadialHalo = defineRule({
+	id: "no-radial-halo",
+	title: "Saturated radial halo on a dark surface",
+	severity: "warn",
+	defaultEnabled: false,
+	tags: [
+		"design",
+		"test-noise",
+		"react-jsx-only"
+	],
+	recommendation: "Use restrained surface contrast, product-specific imagery, or a subtler accent instead of a saturated radial halo on a dark page.",
+	create: (context) => ({ JSXOpeningElement(node) {
+		if (!isNodeOfType(node.name, "JSXIdentifier") || !HALO_SURFACE_ELEMENT_NAMES.has(node.name.name) || isDataVisualizationContext(node, context.filename)) return;
+		const evidence = getStaticHaloElementEvidence(node, context);
+		if (!evidence) return;
+		const backgroundImage = getStaticBackgroundImage(evidence);
+		if (!backgroundImage?.value || !hasSaturatedRadialHalo(backgroundImage.value)) return;
+		const rootOpeningElement = getStaticRootOpeningElement(node);
+		const rootEvidence = rootOpeningElement && rootOpeningElement !== node ? getStaticHaloElementEvidence(rootOpeningElement, context) : null;
+		if (!hasDarkBackground(evidence) && (!rootEvidence || !hasDarkBackground(rootEvidence))) return;
+		context.report({
+			node: backgroundImage.property ?? node,
+			message: "This saturated radial halo adds a generic glow to a dark surface. Replace it with a more specific visual treatment or simplify the background."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/correctness/no-random-key.ts
 const ALWAYS_FRESH_DIRECT_CALLEES = new Set([
 	"nanoid",
@@ -79235,6 +80887,238 @@ const noRenderReturnValue = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/design/no-repeated-container-text.ts
+const REPEATED_TEXT_CONTAINER_NAMES = new Set([
+	"article",
+	"aside",
+	"div",
+	"section"
+]);
+const REPEATED_TEXT_SKIPPED_NAMES = new Set([
+	"a",
+	"button",
+	"canvas",
+	"code",
+	"datalist",
+	"dd",
+	"dl",
+	"dt",
+	"figure",
+	"input",
+	"kbd",
+	"label",
+	"menu",
+	"nav",
+	"ol",
+	"option",
+	"optgroup",
+	"pre",
+	"samp",
+	"select",
+	"summary",
+	"svg",
+	"table",
+	"tbody",
+	"td",
+	"textarea",
+	"tfoot",
+	"th",
+	"thead",
+	"tr",
+	"ul"
+]);
+const REPEATED_TEXT_SKIPPED_ROLES = new Set([
+	"button",
+	"cell",
+	"grid",
+	"gridcell",
+	"graphics-document",
+	"graphics-symbol",
+	"img",
+	"link",
+	"list",
+	"listbox",
+	"listitem",
+	"menu",
+	"menubar",
+	"navigation",
+	"progressbar",
+	"radiogroup",
+	"row",
+	"rowgroup",
+	"table",
+	"tablist",
+	"tree",
+	"treeitem",
+	"diagram"
+]);
+const CONTENT_ATTRIBUTE_NAMES = new Set(["children", "dangerouslySetInnerHTML"]);
+const DATA_VISUALIZATION_CLASS_PATTERN = /(?:^|[-_\s])(?:chart|graph|heatmap|plot|visualization)(?:$|[-_\s])/i;
+const VISUALLY_HIDDEN_CLASS_NAMES$1 = new Set([
+	"screen-reader-only",
+	"sr-only",
+	"visually-hidden"
+]);
+const VISUALLY_HIDDEN_UTILITY_NAMES = new Set(["not-sr-only", "sr-only"]);
+const TAILWIND_NAMED_BREAKPOINT_SET = new Set(TAILWIND_NAMED_BREAKPOINTS);
+const getNativeElementName = (openingElement) => {
+	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return null;
+	const elementName = openingElement.name.name;
+	return elementName === elementName.toLowerCase() ? elementName : null;
+};
+const hasContentAttribute = (openingElement) => openingElement.attributes.some((attribute) => isNodeOfType(attribute, "JSXAttribute") && CONTENT_ATTRIBUTE_NAMES.has(getJsxAttributeName(attribute.name) ?? ""));
+const isStaticallyHidden = (openingElement, classNameValue, context) => {
+	const hiddenAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "hidden");
+	if (hiddenAttribute) {
+		if (!hiddenAttribute.value) return true;
+		const hiddenValue = getStringLiteralAttributeValue(hiddenAttribute);
+		if (hiddenValue === null || hiddenValue.toLowerCase() !== "false") return true;
+	}
+	const ariaHiddenAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "aria-hidden");
+	if (ariaHiddenAttribute) {
+		const ariaHiddenValue = getStringLiteralAttributeValue(ariaHiddenAttribute);
+		if (ariaHiddenValue === null || ariaHiddenValue.toLowerCase() === "true") return true;
+	}
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	if (styleAttribute) {
+		const styleExpression = getInlineStyleExpression(styleAttribute, context.scopes);
+		if (!styleExpression) return false;
+		const displayProperty = getEffectiveStyleProperty(styleExpression.properties, "display");
+		const visibilityProperty = getEffectiveStyleProperty(styleExpression.properties, "visibility");
+		if (displayProperty && getStylePropertyStringValue(displayProperty)?.trim().toLowerCase() === "none" || visibilityProperty && ["collapse", "hidden"].includes(getStylePropertyStringValue(visibilityProperty)?.trim().toLowerCase() ?? "")) return true;
+		if (displayProperty && getStylePropertyStringValue(displayProperty) === null || visibilityProperty && getStylePropertyStringValue(visibilityProperty) === null) return true;
+	}
+	if (!classNameValue) return false;
+	const classNameTokens = splitTailwindClassName(classNameValue);
+	if (classNameTokens.some((classNameToken) => VISUALLY_HIDDEN_CLASS_NAMES$1.has(classNameToken))) return true;
+	if (getEffectiveTailwindClassNameToken(classNameTokens, (utility) => VISUALLY_HIDDEN_UTILITY_NAMES.has(utility)) === "sr-only") return true;
+	return getTailwindVisibilityAtBreakpoints(classNameValue)?.every((isVisible) => !isVisible) ?? false;
+};
+const hasResponsiveVisibility = (openingElement) => {
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	if (!classNameValue) return false;
+	return splitTailwindClassName(classNameValue).map(parseTailwindClassNameToken).some(({ utility, variants }) => {
+		if (!(getTailwindVisibilityEffect(utility).status !== "not-relevant" || VISUALLY_HIDDEN_UTILITY_NAMES.has(utility))) return false;
+		return variants.some((variant) => TAILWIND_NAMED_BREAKPOINT_SET.has(variant) || variant.startsWith("max-") && TAILWIND_NAMED_BREAKPOINT_SET.has(variant.slice(4)) || /^(?:min|max)-\[.+\]$/.test(variant));
+	});
+};
+const shouldSkipElement = (openingElement, isRoot, context) => {
+	const elementName = getNativeElementName(openingElement);
+	if (!elementName || REPEATED_TEXT_SKIPPED_NAMES.has(elementName)) return true;
+	if (hasJsxSpreadAttribute(openingElement.attributes) || hasContentAttribute(openingElement)) return true;
+	const classNameAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "className");
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	if (classNameAttribute && classNameValue === null) return true;
+	if (classNameValue && DATA_VISUALIZATION_CLASS_PATTERN.test(classNameValue) || isStaticallyHidden(openingElement, classNameValue, context)) return true;
+	const roleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "role");
+	if (roleAttribute) {
+		const role = getStringLiteralAttributeValue(roleAttribute)?.toLowerCase();
+		if (!role || REPEATED_TEXT_SKIPPED_ROLES.has(role)) return true;
+	}
+	return !isRoot && isTailwindCardSurface(openingElement);
+};
+const getStructuralPathSegment = (openingElement) => {
+	const elementName = getNativeElementName(openingElement);
+	if (!elementName) return null;
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	if (!classNameValue) return elementName;
+	const normalizedClasses = splitTailwindClassName(classNameValue).sort().join(".");
+	return normalizedClasses ? `${elementName}.${normalizedClasses}` : elementName;
+};
+const normalizeRepeatedText = (value) => {
+	const text = value.replace(/\s+/g, " ").trim();
+	if (text.length < 4 || text.length > 48 || !/\p{L}/u.test(text)) return null;
+	return text;
+};
+const appendTextOccurrence = (collection, value, node, structuralPath) => {
+	const text = normalizeRepeatedText(value);
+	if (!text) return;
+	const occurrences = collection.occurrencesByText.get(text) ?? [];
+	occurrences.push({
+		node,
+		signature: structuralPath.join(">")
+	});
+	collection.occurrencesByText.set(text, occurrences);
+};
+const collectStaticChild = (node, structuralPath, collection, context) => {
+	if (!collection.isStatic) return;
+	if (isNodeOfType(node, "JSXText")) {
+		appendTextOccurrence(collection, node.value ?? "", node, structuralPath);
+		return;
+	}
+	if (isNodeOfType(node, "JSXElement")) {
+		if (shouldSkipElement(node.openingElement, false, context)) return;
+		collection.descendantCount += 1;
+		if (collection.descendantCount > 250) {
+			collection.isStatic = false;
+			return;
+		}
+		if (hasResponsiveVisibility(node.openingElement)) {
+			collection.isStatic = false;
+			return;
+		}
+		const pathSegment = getStructuralPathSegment(node.openingElement);
+		if (!pathSegment) return;
+		const nextStructuralPath = [...structuralPath, pathSegment];
+		for (const child of node.children) collectStaticChild(child, nextStructuralPath, collection, context);
+		return;
+	}
+	if (isNodeOfType(node, "JSXFragment")) {
+		for (const child of node.children) collectStaticChild(child, structuralPath, collection, context);
+		return;
+	}
+	if (!isNodeOfType(node, "JSXExpressionContainer")) {
+		collection.isStatic = false;
+		return;
+	}
+	const expression = node.expression;
+	if (isNodeOfType(expression, "Literal")) {
+		if (typeof expression.value === "string") appendTextOccurrence(collection, expression.value, expression, structuralPath);
+		return;
+	}
+	if (isNodeOfType(expression, "TemplateLiteral") && expression.expressions.length === 0 && expression.quasis.length === 1) {
+		appendTextOccurrence(collection, expression.quasis[0].value.cooked ?? expression.quasis[0].value.raw, expression, structuralPath);
+		return;
+	}
+	if (!isNodeOfType(expression, "JSXEmptyExpression")) collection.isStatic = false;
+};
+const collectRepeatedText = (container, context) => {
+	if (hasResponsiveVisibility(container.openingElement) || shouldSkipElement(container.openingElement, true, context)) return null;
+	const collection = {
+		descendantCount: 0,
+		isStatic: true,
+		occurrencesByText: /* @__PURE__ */ new Map()
+	};
+	for (const child of container.children) collectStaticChild(child, [], collection, context);
+	return collection.isStatic ? collection : null;
+};
+const noRepeatedContainerText = defineRule({
+	id: "no-repeated-container-text",
+	title: "A card repeats the same text in distinct slots",
+	severity: "warn",
+	defaultEnabled: false,
+	tags: [
+		"design",
+		"test-noise",
+		"react-jsx-only"
+	],
+	category: "Design",
+	recommendation: "Keep repeated status or label copy in the one card slot where it carries the clearest meaning.",
+	create: (context) => ({ JSXElement(node) {
+		if (!hasCapabilityOrUnspecified(context.settings, "tailwind") || !isNodeOfType(node.openingElement.name, "JSXIdentifier") || !REPEATED_TEXT_CONTAINER_NAMES.has(node.openingElement.name.name) || !isTailwindCardSurface(node.openingElement)) return;
+		const collection = collectRepeatedText(node, context);
+		if (!collection) return;
+		for (const [text, occurrences] of collection.occurrencesByText) {
+			const distinctSignatures = new Set(occurrences.map((occurrence) => occurrence.signature));
+			if (occurrences.length < 3 || distinctSignatures.size < 3) continue;
+			context.report({
+				node: occurrences[0].node,
+				message: `The literal "${text}" appears in ${distinctSignatures.size} structurally different spots inside this card. Keep it in the one slot where it matters most.`
+			});
+		}
+	} })
+});
+//#endregion
 //#region src/plugin/rules/design/no-repeated-emoji-tiles.ts
 const EMOJI_PATTERN = /\p{Extended_Pictographic}/u;
 const EMOJI_SEQUENCE_PART_PATTERN = /\p{Extended_Pictographic}|\p{Emoji_Modifier}|\u200d|\ufe0f|\s/gu;
@@ -80733,14 +82617,6 @@ const classifySecretFileExposure = (filename, options = {}) => {
 	return "unknown";
 };
 //#endregion
-//#region src/plugin/utils/tokenize-identifier-words.ts
-const IDENTIFIER_WORD_PATTERN = /[A-Z]+(?=[A-Z][a-z]|\b)|[A-Z]?[a-z]+|\d+/g;
-const tokenizeIdentifierWords = (identifierName) => {
-	const words = identifierName.match(IDENTIFIER_WORD_PATTERN);
-	if (!words) return [];
-	return words.map((word) => word.toLowerCase());
-};
-//#endregion
 //#region src/plugin/utils/get-identifier-trailing-word.ts
 const getIdentifierTrailingWord = (identifierName) => tokenizeIdentifierWords(identifierName).at(-1) ?? identifierName.toLowerCase();
 //#endregion
@@ -81894,6 +83770,271 @@ const noSetStateInRender = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/constants/svg-tags.ts
+const SVG_TAGS = new Set([
+	"a",
+	"altGlyph",
+	"altGlyphDef",
+	"altGlyphItem",
+	"animate",
+	"animateColor",
+	"animateMotion",
+	"animateTransform",
+	"circle",
+	"clipPath",
+	"cursor",
+	"defs",
+	"desc",
+	"ellipse",
+	"feBlend",
+	"feColorMatrix",
+	"feComponentTransfer",
+	"feComposite",
+	"feConvolveMatrix",
+	"feDiffuseLighting",
+	"feDisplacementMap",
+	"feDistantLight",
+	"feDropShadow",
+	"feFlood",
+	"feFuncA",
+	"feFuncB",
+	"feFuncG",
+	"feFuncR",
+	"feGaussianBlur",
+	"feImage",
+	"feMerge",
+	"feMergeNode",
+	"feMorphology",
+	"feOffset",
+	"fePointLight",
+	"feSpecularLighting",
+	"feSpotLight",
+	"feTile",
+	"feTurbulence",
+	"filter",
+	"foreignObject",
+	"g",
+	"glyph",
+	"glyphRef",
+	"image",
+	"line",
+	"linearGradient",
+	"marker",
+	"mask",
+	"metadata",
+	"mpath",
+	"path",
+	"pattern",
+	"polygon",
+	"polyline",
+	"radialGradient",
+	"rect",
+	"set",
+	"stop",
+	"svg",
+	"switch",
+	"symbol",
+	"text",
+	"textPath",
+	"title",
+	"tref",
+	"tspan",
+	"use",
+	"view"
+]);
+//#endregion
+//#region src/plugin/rules/design/no-shape-assembled-illustration.ts
+const PRIMITIVE_ELEMENT_NAMES = new Set([
+	"rect",
+	"circle",
+	"ellipse",
+	"polygon"
+]);
+const TEXT_ELEMENT_NAMES = new Set(["text", "tspan"]);
+const EXCLUDED_SUBTREE_ELEMENT_NAMES = new Set([
+	"defs",
+	"symbol",
+	"mask",
+	"clipPath"
+]);
+const TAILWIND_DIMENSION_UTILITY_PATTERN = /^(?:(?:size|w|h|max-w|max-h)-|\[(?:width|height|max-width|max-height):)/;
+const getIntrinsicElementName = (openingElement) => isNodeOfType(openingElement.name, "JSXIdentifier") ? openingElement.name.name : null;
+const getStrictStaticNumericValue = (value) => {
+	if (!value) return null;
+	let candidate = value;
+	if (isNodeOfType(candidate, "JSXExpressionContainer")) candidate = stripParenExpression(candidate.expression);
+	if (!isNodeOfType(candidate, "Literal")) return null;
+	if (typeof candidate.value === "number") return Number.isFinite(candidate.value) ? candidate.value : null;
+	if (typeof candidate.value !== "string") return null;
+	const normalizedValue = candidate.value.trim().toLowerCase();
+	if (!/^(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?(?:px)?$/.test(normalizedValue)) return null;
+	const parsedValue = Number(normalizedValue.replace(/px$/, ""));
+	return Number.isFinite(parsedValue) ? parsedValue : null;
+};
+const getStrictStaticStringAttributeValue = (attribute) => {
+	const directValue = getStringLiteralAttributeValue(attribute);
+	if (directValue !== null) return directValue;
+	return isNodeOfType(attribute.value, "JSXExpressionContainer") ? getStaticStringExpression$1(attribute.value.expression) : null;
+};
+const getStaticSvgDimensions = (openingElement, context) => {
+	if (openingElement.attributes.some((attribute) => isNodeOfType(attribute, "JSXSpreadAttribute"))) return null;
+	const widthAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "width");
+	const heightAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "height");
+	if (!widthAttribute || !heightAttribute) return null;
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	if (styleAttribute) {
+		const styleExpression = getInlineStyleExpression(styleAttribute, context.scopes);
+		if (!styleExpression || getEffectiveStyleProperty(styleExpression.properties, "width") || getEffectiveStyleProperty(styleExpression.properties, "height") || getEffectiveStyleProperty(styleExpression.properties, "maxWidth") || getEffectiveStyleProperty(styleExpression.properties, "maxHeight")) return null;
+	}
+	if (getAuthoritativeJsxAttribute(openingElement.attributes, "className")) {
+		const classNameValue = getStringFromClassNameAttr(openingElement);
+		if (classNameValue === null || splitTailwindClassName(classNameValue).map(parseTailwindClassNameToken).some(({ utility }) => TAILWIND_DIMENSION_UTILITY_PATTERN.test(utility))) return null;
+	}
+	const width = getStrictStaticNumericValue(widthAttribute.value);
+	const height = getStrictStaticNumericValue(heightAttribute.value);
+	return width !== null && height !== null && width > 0 && height > 0 ? [width, height] : null;
+};
+const getCanonicalStaticPaintKey = (paint) => {
+	if (paint === null) return null;
+	const normalizedPaint = paint.trim().toLowerCase();
+	const parseablePaint = normalizedPaint === "white" ? "#fff" : normalizedPaint === "black" ? "#000" : normalizedPaint;
+	const parsedColor = parseColorToRgb(parseablePaint);
+	const parsedColorWithAlpha = parseStaticCssColorWithAlpha(parseablePaint);
+	if (!parsedColor || !parsedColorWithAlpha || parsedColorWithAlpha.alpha <= 0 || Object.values(parsedColor).some((channel) => !Number.isInteger(channel) || channel < 0 || channel > 255)) return null;
+	return `${parsedColor.red},${parsedColor.green},${parsedColor.blue}`;
+};
+const getStaticOwnFill = (openingElement, context) => {
+	if (openingElement.attributes.some((attribute) => isNodeOfType(attribute, "JSXSpreadAttribute"))) return null;
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	if (styleAttribute) {
+		const styleExpression = getInlineStyleExpression(styleAttribute, context.scopes);
+		if (!styleExpression) return null;
+		const fillProperty = getEffectiveStyleProperty(styleExpression.properties, "fill");
+		if (fillProperty) return getCanonicalStaticPaintKey(getStylePropertyStringValue(fillProperty));
+		if (styleExpression.properties.some((property) => !isNodeOfType(property, "Property") || getStylePropertyKey(property) === null)) return null;
+	}
+	const fillAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "fill");
+	return fillAttribute ? getCanonicalStaticPaintKey(getStrictStaticStringAttributeValue(fillAttribute)) : null;
+};
+const getStaticBooleanAttributeState = (openingElement, attributeName) => {
+	const attribute = getAuthoritativeJsxAttribute(openingElement.attributes, attributeName, false);
+	if (!attribute) return false;
+	if (!attribute.value) return true;
+	const value = attribute.value;
+	if (isNodeOfType(value, "Literal")) return value.value === false || value.value === null ? false : true;
+	if (!isNodeOfType(value, "JSXExpressionContainer")) return null;
+	const expression = stripParenExpression(value.expression);
+	return isNodeOfType(expression, "Literal") ? expression.value === false || expression.value === null ? false : true : null;
+};
+const getStaticPresentationAttributeValue = (openingElement, attributeName) => {
+	const attribute = getAuthoritativeJsxAttribute(openingElement.attributes, attributeName, false);
+	if (!attribute) return void 0;
+	return getStrictStaticStringAttributeValue(attribute);
+};
+const getStaticStyleNumberValue = (property) => {
+	const numberValue = getStylePropertyNumberValue(property);
+	if (numberValue !== null) return numberValue;
+	const stringValue = getStylePropertyStringValue(property);
+	if (stringValue === null || stringValue.trim() === "") return null;
+	const parsedValue = Number(stringValue);
+	return Number.isFinite(parsedValue) ? parsedValue : null;
+};
+const getStaticRenderingState = (openingElement, context) => {
+	if (openingElement.attributes.some((attribute) => isNodeOfType(attribute, "JSXSpreadAttribute"))) return "unknown";
+	const hiddenState = getStaticBooleanAttributeState(openingElement, "hidden");
+	if (hiddenState === null) return "unknown";
+	if (hiddenState) return "hidden";
+	const displayValue = getStaticPresentationAttributeValue(openingElement, "display");
+	const visibilityValue = getStaticPresentationAttributeValue(openingElement, "visibility");
+	const opacityAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "opacity", false);
+	const opacityValue = opacityAttribute ? getStrictStaticNumericValue(opacityAttribute.value) : void 0;
+	if (displayValue === null || visibilityValue === null || opacityValue === null) return "unknown";
+	if (displayValue?.trim().toLowerCase() === "none" || ["hidden", "collapse"].includes(visibilityValue?.trim().toLowerCase() ?? "") || opacityValue === 0) return "hidden";
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	if (styleAttribute) {
+		const styleExpression = getInlineStyleExpression(styleAttribute, context.scopes);
+		if (!styleExpression || styleExpression.properties.some((property) => !isNodeOfType(property, "Property") || getStylePropertyKey(property) === null)) return "unknown";
+		const displayProperty = getEffectiveStyleProperty(styleExpression.properties, "display");
+		const visibilityProperty = getEffectiveStyleProperty(styleExpression.properties, "visibility");
+		const opacityProperty = getEffectiveStyleProperty(styleExpression.properties, "opacity");
+		const styleDisplayValue = displayProperty ? getStylePropertyStringValue(displayProperty) : void 0;
+		const styleVisibilityValue = visibilityProperty ? getStylePropertyStringValue(visibilityProperty) : void 0;
+		const styleOpacityValue = opacityProperty ? getStaticStyleNumberValue(opacityProperty) : void 0;
+		if (styleDisplayValue === null || styleVisibilityValue === null || opacityProperty && !Number.isFinite(styleOpacityValue)) return "unknown";
+		if (styleDisplayValue?.trim().toLowerCase() === "none" || ["hidden", "collapse"].includes(styleVisibilityValue?.trim().toLowerCase() ?? "") || styleOpacityValue === 0) return "hidden";
+	}
+	if (getAuthoritativeJsxAttribute(openingElement.attributes, "className")) {
+		const classNameValue = getStringFromClassNameAttr(openingElement);
+		if (classNameValue === null) return "unknown";
+		const visibilityAtBreakpoints = getTailwindVisibilityAtBreakpoints(classNameValue);
+		if (visibilityAtBreakpoints === null) return "unknown";
+		if (visibilityAtBreakpoints.every((isVisible) => !isVisible)) return "hidden";
+	}
+	return "visible";
+};
+const isStaticallyEmptySvgExpression = (expression) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "JSXEmptyExpression")) return true;
+	if (isNodeOfType(candidate, "Literal")) return candidate.value === null || typeof candidate.value === "boolean" || typeof candidate.value === "string" && candidate.value.trim() === "";
+	return isNodeOfType(candidate, "TemplateLiteral") && candidate.expressions.length === 0 && (candidate.quasis[0]?.value.cooked ?? candidate.quasis[0]?.value.raw ?? "").trim() === "";
+};
+const collectSvgIllustrationEvidence = (element, evidence, context, isExcludedByAncestor = false) => {
+	const openingElement = element.openingElement;
+	const elementName = getIntrinsicElementName(openingElement);
+	if (!elementName || !SVG_TAGS.has(elementName)) return false;
+	if (elementName === "pattern") evidence.hasPattern = true;
+	const renderingState = getStaticRenderingState(openingElement, context);
+	if (renderingState === "unknown") return false;
+	const isExcluded = isExcludedByAncestor || renderingState === "hidden" || EXCLUDED_SUBTREE_ELEMENT_NAMES.has(elementName) || elementName === "pattern";
+	if (!isExcluded && TEXT_ELEMENT_NAMES.has(elementName)) evidence.visibleTextElementCount += 1;
+	if (!isExcluded && PRIMITIVE_ELEMENT_NAMES.has(elementName)) {
+		const fillKey = getStaticOwnFill(openingElement, context);
+		if (fillKey) evidence.primitiveFillKeys.push(fillKey);
+	}
+	for (const child of element.children) {
+		if (isNodeOfType(child, "JSXText")) continue;
+		if (isNodeOfType(child, "JSXElement")) {
+			if (!collectSvgIllustrationEvidence(child, evidence, context, isExcluded)) return false;
+			continue;
+		}
+		if (isNodeOfType(child, "JSXExpressionContainer")) {
+			if (!isStaticallyEmptySvgExpression(child.expression)) return false;
+			continue;
+		}
+		return false;
+	}
+	return true;
+};
+const noShapeAssembledIllustration = defineRule({
+	id: "no-shape-assembled-illustration",
+	title: "Large illustration is assembled from primitive shapes",
+	severity: "warn",
+	defaultEnabled: false,
+	tags: ["design", "test-noise"],
+	recommendation: "Replace the shape pile with deliberate artwork, a photograph, or a purpose-built graphic that supports the product story.",
+	create: (context) => ({ JSXElement(node) {
+		const openingElement = node.openingElement;
+		if (getIntrinsicElementName(openingElement) !== "svg") return;
+		const dimensions = getStaticSvgDimensions(openingElement, context);
+		if (!dimensions || dimensions[0] < 200 || dimensions[1] < 200) return;
+		const evidence = {
+			hasPattern: false,
+			primitiveFillKeys: [],
+			visibleTextElementCount: 0
+		};
+		if (!collectSvgIllustrationEvidence(node, evidence, context) || evidence.hasPattern) return;
+		if (evidence.visibleTextElementCount > 2) return;
+		const primitiveCount = evidence.primitiveFillKeys.length;
+		if (primitiveCount < 8) return;
+		const distinctFills = new Set(evidence.primitiveFillKeys);
+		if (distinctFills.size < 3) return;
+		context.report({
+			node: openingElement,
+			message: `This ${Math.round(dimensions[0])}×${Math.round(dimensions[1])} SVG assembles a large illustration from ${primitiveCount} basic shapes and ${distinctFills.size} fills. Use deliberate artwork instead of placeholder clip art.`
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-side-effect-in-state-updater-function.ts
 const MESSAGE$21 = "This side-effecting call runs inside a state updater, which React may invoke more than once. Move it outside the setter after computing the next state.";
 const SYNCHRONOUS_CALLBACK_METHOD_NAMES = new Set([
@@ -82518,6 +84659,331 @@ const noSideEffectInStateUpdaterFunction = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/design/no-side-tab-border.ts
+const CHROMATIC_CSS_COLOR_KEYWORDS = new Set([
+	"aqua",
+	"blue",
+	"coral",
+	"crimson",
+	"fuchsia",
+	"gold",
+	"green",
+	"lime",
+	"maroon",
+	"navy",
+	"olive",
+	"orange",
+	"pink",
+	"purple",
+	"rebeccapurple",
+	"red",
+	"teal",
+	"yellow"
+]);
+const SHADOW_LENGTH_PATTERN = /^-?(?:\d+(?:\.\d+)?|\.\d+)(px)?$/i;
+const TAILWIND_SHADOW_GEOMETRY_PATTERN = /^shadow(?:-(?:2xl|inner|lg|md|none|sm|xl|xs|\[.+\]))?$/;
+const TAILWIND_ARBITRARY_SHADOW_PATTERN = /^shadow-\[(.+)\]$/;
+const ZERO_ALPHA_PATTERN = /^(?:0+(?:\.0*)?|\.0+)%?$/;
+const PSEUDO_ELEMENT_NAMES = ["before", "after"];
+const TAILWIND_BACKGROUND_COLOR_PATTERN = /^bg-(?:transparent|black|white|current|inherit|(?:slate|gray|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d+|\[(?!url\(|(?:image|length|position|size):).+\])(?:\/.+)?$/;
+const CHROMATIC_TAILWIND_BACKGROUND_PATTERN = /^bg-(?:red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d+(?:\/.+)?$/;
+const PSEUDO_SIDE_TAB_CONTEXT_PATTERN = /(?:^|[-_:])(?:badge|callout|label|menu-item|nav-item|section-label|side-?tab|tab)(?:$|[-_:])/i;
+const PSEUDO_SIDE_TAB_ART_PATTERN = /(?:^|[-_:])(?:avatar|brand-mark|glyph|icon|logo|logo-mark|mark)(?:$|[-_:])/i;
+const PSEUDO_INTERACTION_OR_SELECTION_VARIANT_PATTERN = /(?:hover|focus|active|checked|target|selection|aria-(?:current|selected)|data-(?:active|current|selected))/i;
+const STATIC_SELECTED_OR_CURRENT_CLASS_PATTERN = /(?:^|[-_:])(?:active|current|selected)(?:$|[-_:])/i;
+const PSEUDO_DISPLAY_UTILITY_PATTERN = /^(?:block|contents|flex|grid|hidden|inline|inline-block|inline-flex|inline-grid)$/;
+const PSEUDO_VISIBILITY_UTILITY_PATTERN = /^(?:visible|invisible|collapse)$/;
+const PSEUDO_OPACITY_UTILITY_PATTERN = /^opacity-(.+)$/;
+const PSEUDO_SIDE_TAB_SAFE_ELEMENT_PATTERN = /(?:^|\.)(?:blockquote|code|hr|pre|table|tbody|td|tfoot|th|thead|tr)$/i;
+const splitShadowLayerTokens = (shadowValue) => {
+	const tokens = [];
+	let currentToken = "";
+	let parenthesisDepth = 0;
+	for (const character of shadowValue) {
+		if (character === "(") {
+			parenthesisDepth += 1;
+			currentToken += character;
+			continue;
+		}
+		if (character === ")") {
+			if (parenthesisDepth === 0) return null;
+			parenthesisDepth -= 1;
+			currentToken += character;
+			continue;
+		}
+		if (character === "," && parenthesisDepth === 0) return null;
+		if (/\s/.test(character) && parenthesisDepth === 0) {
+			if (currentToken) tokens.push(currentToken);
+			currentToken = "";
+			continue;
+		}
+		currentToken += character;
+	}
+	if (parenthesisDepth !== 0) return null;
+	if (currentToken) tokens.push(currentToken);
+	return tokens;
+};
+const parseShadowLength = (token) => {
+	const match = token.match(SHADOW_LENGTH_PATTERN);
+	if (!match) return null;
+	return {
+		hasPixelUnit: Boolean(match[1]),
+		value: parseFloat(token)
+	};
+};
+const isFullyTransparentColor = (color) => {
+	const normalizedColor = color.trim().toLowerCase();
+	if (normalizedColor === "transparent") return true;
+	const hexDigits = normalizedColor.match(/^#([0-9a-f]{4}|[0-9a-f]{8})$/)?.[1];
+	if (hexDigits?.length === 4 && hexDigits.endsWith("0")) return true;
+	if (hexDigits?.length === 8 && hexDigits.endsWith("00")) return true;
+	const functionArguments = normalizedColor.match(/^(?:rgb|hsl)a?\((.*)\)$/)?.[1];
+	if (!functionArguments) return false;
+	const slashAlpha = functionArguments.match(/\/\s*([^/]+)$/)?.[1];
+	if (slashAlpha) return ZERO_ALPHA_PATTERN.test(slashAlpha.trim());
+	const legacyArguments = functionArguments.split(",");
+	return legacyArguments.length === 4 && ZERO_ALPHA_PATTERN.test(legacyArguments[legacyArguments.length - 1]?.trim() ?? "");
+};
+const hasResolvableColorChroma = (color) => {
+	if (isFullyTransparentColor(color)) return false;
+	const parsedColor = parseColorToRgb(color);
+	if (parsedColor) return hasColorChroma(parsedColor);
+	return CHROMATIC_CSS_COLOR_KEYWORDS.has(color.trim().toLowerCase());
+};
+const parseInsetSideTabShadow = (shadowValue) => {
+	const tokens = splitShadowLayerTokens(shadowValue);
+	if (!tokens) return null;
+	if (tokens.filter((token) => token.toLowerCase() === "inset").length !== 1) return null;
+	const shadowLengths = [];
+	const colorTokens = [];
+	for (const token of tokens) {
+		if (token.toLowerCase() === "inset") continue;
+		const shadowLength = parseShadowLength(token);
+		if (shadowLength) shadowLengths.push(shadowLength);
+		else colorTokens.push(token);
+	}
+	if (shadowLengths.length < 2 || shadowLengths.length > 4 || colorTokens.length !== 1) return null;
+	const horizontalOffset = shadowLengths[0];
+	const verticalOffset = shadowLengths[1];
+	const blurRadius = shadowLengths[2]?.value ?? 0;
+	const spreadRadius = shadowLengths[3]?.value ?? 0;
+	if (!horizontalOffset || !verticalOffset || blurRadius !== 0 || spreadRadius !== 0) return null;
+	if (horizontalOffset.value !== 0 && !horizontalOffset.hasPixelUnit || verticalOffset.value !== 0 && !verticalOffset.hasPixelUnit) return null;
+	const horizontalWidth = Math.abs(horizontalOffset.value);
+	const verticalWidth = Math.abs(verticalOffset.value);
+	const isHorizontalEdge = horizontalWidth >= 3 && horizontalWidth <= 12 && verticalWidth === 0;
+	if (!isHorizontalEdge && !(verticalWidth >= 3 && verticalWidth <= 12 && horizontalWidth === 0) || !hasResolvableColorChroma(colorTokens[0])) return null;
+	if (isHorizontalEdge) return {
+		edgeLabel: horizontalOffset.value > 0 ? "left" : "right",
+		widthPx: horizontalWidth
+	};
+	return {
+		edgeLabel: verticalOffset.value > 0 ? "top" : "bottom",
+		widthPx: verticalWidth
+	};
+};
+const isStaticallyFalseJsxAttribute = (attribute) => {
+	const attributeValue = attribute.value;
+	if (!attributeValue) return false;
+	if (isNodeOfType(attributeValue, "Literal")) return attributeValue.value === false || attributeValue.value === "false";
+	if (!isNodeOfType(attributeValue, "JSXExpressionContainer")) return false;
+	return isNodeOfType(attributeValue.expression, "Literal") && (attributeValue.expression.value === false || attributeValue.expression.value === "false");
+};
+const isInteractiveOrSelectedIndicator = (openingElement) => {
+	if (isInteractiveElement(resolveJsxElementType(openingElement), openingElement)) return true;
+	const selectedAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "aria-selected");
+	const currentAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "aria-current");
+	if (selectedAttribute && !isStaticallyFalseJsxAttribute(selectedAttribute) || currentAttribute && !isStaticallyFalseJsxAttribute(currentAttribute)) return true;
+	const roleAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "role");
+	const role = roleAttribute ? getJsxPropStringValue(roleAttribute)?.trim().split(/\s+/)[0] : null;
+	return Boolean(role && isInteractiveRole(role.toLowerCase()));
+};
+const getEffectiveTailwindShadowResolution = (tokens) => resolveEffectiveTailwindClassNameToken(tokens, (utility) => TAILWIND_SHADOW_GEOMETRY_PATTERN.test(utility));
+const getTailwindInsetSideTabShadow = (classNameTokens) => {
+	const shadowResolution = getEffectiveTailwindShadowResolution(classNameTokens);
+	if (shadowResolution.isAmbiguous || !shadowResolution.utility) return null;
+	const arbitraryShadowValue = shadowResolution.utility.match(TAILWIND_ARBITRARY_SHADOW_PATTERN)?.[1];
+	if (!arbitraryShadowValue) return null;
+	const shadow = parseInsetSideTabShadow(arbitraryShadowValue.replace(/_/g, " "));
+	return shadow ? {
+		isImportant: shadowResolution.isImportant,
+		shadow
+	} : null;
+};
+const hasImportantTailwindShadow = (classNameTokens) => classNameTokens.some((classNameToken) => {
+	const parsedToken = parseTailwindClassNameToken(classNameToken);
+	return parsedToken.variants.length === 0 && parsedToken.isImportant && TAILWIND_SHADOW_GEOMETRY_PATTERN.test(parsedToken.utility);
+});
+const hasChromaticTailwindBackground = (utility) => {
+	if (CHROMATIC_TAILWIND_BACKGROUND_PATTERN.test(utility)) {
+		const opacityModifier = utility.match(/\/(.+)$/)?.[1]?.replace(/^\[|\]$/g, "");
+		return !opacityModifier || !ZERO_ALPHA_PATTERN.test(opacityModifier);
+	}
+	const arbitraryColorMatch = utility.match(/^bg-\[(?:color:)?([^\]]+)\](?:\/(.+))?$/);
+	const arbitraryColor = arbitraryColorMatch?.[1];
+	const opacityModifier = arbitraryColorMatch?.[2]?.replace(/^\[|\]$/g, "");
+	return Boolean(arbitraryColor && (!opacityModifier || !ZERO_ALPHA_PATTERN.test(opacityModifier)) && !isFullyTransparentColor(arbitraryColor) && hasResolvableColorChroma(arbitraryColor));
+};
+const getStaticPseudoUtilities = (classNameTokens, pseudoElementName) => {
+	const utilities = [];
+	for (const classNameToken of classNameTokens) {
+		const parsedToken = parseTailwindClassNameToken(classNameToken);
+		if (!parsedToken.variants.includes(pseudoElementName)) continue;
+		if (parsedToken.variants.length !== 1 || parsedToken.variants[0] !== pseudoElementName || parsedToken.variants.some((variant) => PSEUDO_INTERACTION_OR_SELECTION_VARIANT_PATTERN.test(variant))) return null;
+		utilities.push(parsedToken.isImportant ? `!${parsedToken.utility}` : parsedToken.utility);
+	}
+	return utilities;
+};
+const getTailwindDimensionResolution = (utilities, dimensionPrefix) => resolveEffectiveTailwindClassNameToken(utilities, (utility) => utility.startsWith(`${dimensionPrefix}-`) || utility.startsWith("size-"), []);
+const getTailwindDimensionPx = (utility, dimensionPrefix) => {
+	if (!utility) return null;
+	return utility.startsWith("size-") ? parseStaticTailwindLengthPx(utility, "size") : parseStaticTailwindLengthPx(utility, dimensionPrefix);
+};
+const isFullTailwindDimension = (utility, dimensionPrefix) => utility === `${dimensionPrefix}-full` || utility === "size-full";
+const getTailwindOffsetUtilityValue = (utility, sideName) => {
+	const isNegative = utility.startsWith("-");
+	const normalizedUtility = isNegative ? utility.slice(1) : utility;
+	const axisPrefix = sideName === "left" || sideName === "right" ? "inset-x" : "inset-y";
+	const matchingPrefix = normalizedUtility.startsWith(`${sideName}-`) ? sideName : normalizedUtility.startsWith(`${axisPrefix}-`) ? axisPrefix : /^inset-(?![xy]-)/.test(normalizedUtility) ? "inset" : null;
+	if (!matchingPrefix) return void 0;
+	if (normalizedUtility === `${matchingPrefix}-auto`) return null;
+	const valuePx = parseStaticTailwindLengthPx(normalizedUtility, matchingPrefix);
+	return valuePx === null ? null : valuePx * (isNegative ? -1 : 1);
+};
+const getTailwindPseudoOffsetResolution = (utilities, sideName) => {
+	const relevantUtilities = utilities.map(parseTailwindClassNameToken).filter((parsedUtility) => getTailwindOffsetUtilityValue(parsedUtility.utility, sideName) !== void 0);
+	const hasImportantUtility = relevantUtilities.some((parsedUtility) => parsedUtility.isImportant);
+	const effectiveValues = new Set(relevantUtilities.filter((parsedUtility) => !hasImportantUtility || parsedUtility.isImportant).map((parsedUtility) => getTailwindOffsetUtilityValue(parsedUtility.utility, sideName)));
+	if (effectiveValues.size !== 1) return {
+		isAmbiguous: effectiveValues.size > 1,
+		valuePx: null
+	};
+	const valuePx = effectiveValues.values().next().value ?? null;
+	return {
+		isAmbiguous: valuePx === null,
+		valuePx
+	};
+};
+const isNearlyFullPseudoAxis = (utilities, dimensionPrefix, startSide, endSide) => {
+	const dimensionResolution = getTailwindDimensionResolution(utilities, dimensionPrefix);
+	if (dimensionResolution.isAmbiguous) return false;
+	if (dimensionResolution.utility) {
+		const startOffset = getTailwindPseudoOffsetResolution(utilities, startSide);
+		const endOffset = getTailwindPseudoOffsetResolution(utilities, endSide);
+		return isFullTailwindDimension(dimensionResolution.utility, dimensionPrefix) && !startOffset.isAmbiguous && !endOffset.isAmbiguous && (startOffset.valuePx === null || startOffset.valuePx === 0) && (endOffset.valuePx === null || endOffset.valuePx === 0);
+	}
+	const startOffset = getTailwindPseudoOffsetResolution(utilities, startSide);
+	const endOffset = getTailwindPseudoOffsetResolution(utilities, endSide);
+	return !startOffset.isAmbiguous && !endOffset.isAmbiguous && startOffset.valuePx !== null && endOffset.valuePx !== null && startOffset.valuePx >= 0 && startOffset.valuePx <= 20 && endOffset.valuePx >= 0 && endOffset.valuePx <= 20;
+};
+const getAnchoredPseudoEdge = (utilities, startSide, endSide) => {
+	const startOffset = getTailwindPseudoOffsetResolution(utilities, startSide);
+	const endOffset = getTailwindPseudoOffsetResolution(utilities, endSide);
+	if (startOffset.isAmbiguous || endOffset.isAmbiguous) return null;
+	const isStartAnchored = startOffset.valuePx === 0;
+	if (isStartAnchored === (endOffset.valuePx === 0)) return null;
+	return isStartAnchored ? startSide : endSide;
+};
+const getTailwindPseudoSideTabStripe = (classNameTokens) => {
+	for (const pseudoElementName of PSEUDO_ELEMENT_NAMES) {
+		const utilities = getStaticPseudoUtilities(classNameTokens, pseudoElementName);
+		if (!utilities?.length) continue;
+		const positionResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => [
+			"absolute",
+			"fixed",
+			"relative",
+			"static",
+			"sticky"
+		].includes(utility), []);
+		const backgroundResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => TAILWIND_BACKGROUND_COLOR_PATTERN.test(utility), []);
+		const displayResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => PSEUDO_DISPLAY_UTILITY_PATTERN.test(utility), []);
+		const visibilityResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => PSEUDO_VISIBILITY_UTILITY_PATTERN.test(utility), []);
+		const opacityResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => PSEUDO_OPACITY_UTILITY_PATTERN.test(utility), []);
+		const backgroundOpacityResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => utility.startsWith("bg-opacity-"), []);
+		const contentResolution = resolveEffectiveTailwindClassNameToken(utilities, (utility) => utility.startsWith("content-") || utility.startsWith("[content:"), []);
+		if (positionResolution.isAmbiguous || backgroundResolution.isAmbiguous || displayResolution.isAmbiguous || visibilityResolution.isAmbiguous || opacityResolution.isAmbiguous || backgroundOpacityResolution.isAmbiguous || contentResolution.isAmbiguous || positionResolution.utility !== "absolute" || !backgroundResolution.utility || !hasChromaticTailwindBackground(backgroundResolution.utility) || displayResolution.utility === "hidden" || displayResolution.utility === "contents" || visibilityResolution.utility === "invisible" || visibilityResolution.utility === "collapse" || contentResolution.utility === "content-none") continue;
+		const opacityValue = opacityResolution.utility?.match(PSEUDO_OPACITY_UTILITY_PATTERN)?.[1];
+		const backgroundOpacityValue = backgroundOpacityResolution.utility?.slice(11);
+		if (opacityValue && ZERO_ALPHA_PATTERN.test(opacityValue.replace(/^\[|\]$/g, "")) || backgroundOpacityValue && ZERO_ALPHA_PATTERN.test(backgroundOpacityValue.replace(/^\[|\]$/g, ""))) continue;
+		const widthResolution = getTailwindDimensionResolution(utilities, "w");
+		const heightResolution = getTailwindDimensionResolution(utilities, "h");
+		if (widthResolution.isAmbiguous || heightResolution.isAmbiguous) continue;
+		const widthPx = getTailwindDimensionPx(widthResolution.utility, "w");
+		const heightPx = getTailwindDimensionPx(heightResolution.utility, "h");
+		const isVerticalStripe = widthPx !== null && widthPx >= 3 && widthPx <= 12 && isNearlyFullPseudoAxis(utilities, "h", "top", "bottom");
+		if (isVerticalStripe === (heightPx !== null && heightPx >= 3 && heightPx <= 12 && isNearlyFullPseudoAxis(utilities, "w", "left", "right"))) continue;
+		const edgeLabel = isVerticalStripe ? getAnchoredPseudoEdge(utilities, "left", "right") : getAnchoredPseudoEdge(utilities, "top", "bottom");
+		if (!edgeLabel) continue;
+		const stripeWidthPx = isVerticalStripe ? widthPx : heightPx;
+		if (stripeWidthPx === null) continue;
+		return {
+			edgeLabel,
+			pseudoElementName,
+			widthPx: stripeWidthPx
+		};
+	}
+	return null;
+};
+const hasActualSelectedOrCurrentState = (openingElement) => {
+	const selectedAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "aria-selected");
+	const currentAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "aria-current");
+	const dataSelectedAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "data-selected");
+	const dataStateAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "data-state");
+	const dataStateValue = dataStateAttribute ? getJsxPropStringValue(dataStateAttribute)?.toLowerCase() : null;
+	return Boolean(selectedAttribute && !isStaticallyFalseJsxAttribute(selectedAttribute) || currentAttribute && !isStaticallyFalseJsxAttribute(currentAttribute) || dataSelectedAttribute && !isStaticallyFalseJsxAttribute(dataSelectedAttribute) || dataStateAttribute && (!dataStateValue || [
+		"active",
+		"current",
+		"selected"
+	].includes(dataStateValue)));
+};
+const isDynamicJsxContent = (node) => {
+	if (isNodeOfType(node, "JSXExpressionContainer")) return !(isNodeOfType(node.expression, "Literal") || isNodeOfType(node.expression, "TemplateLiteral") && node.expression.expressions.length === 0);
+	if (isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment")) return node.children.some(isDynamicJsxContent);
+	return false;
+};
+const hasStaticSideTabLabelContext = (openingElement, className) => {
+	if (splitTailwindClassName(className).some((token) => PSEUDO_SIDE_TAB_CONTEXT_PATTERN.test(token))) return true;
+	const element = isNodeOfType(openingElement.parent, "JSXElement") ? openingElement.parent : null;
+	if (!element || element.children.some(isDynamicJsxContent)) return false;
+	const labelText = getStaticJsxText(element).replace(/\s+/g, " ").trim();
+	return labelText.length > 0 && labelText.length <= 32 && /[\p{L}\p{N}]/u.test(labelText);
+};
+const isGlyphOrLogoContext = (openingElement, classNameTokens) => {
+	const elementType = resolveJsxElementType(openingElement);
+	if (/^(?:canvas|img|path|picture|svg|use)$/i.test(elementType) || /(?:avatar|glyph|icon|logo|mark)$/i.test(elementType)) return true;
+	if (classNameTokens.some((classNameToken) => {
+		const parsedToken = parseTailwindClassNameToken(classNameToken);
+		return parsedToken.variants.length === 0 && PSEUDO_SIDE_TAB_ART_PATTERN.test(parsedToken.utility);
+	})) return true;
+	const widthResolution = getTailwindDimensionResolution(classNameTokens, "w");
+	const heightResolution = getTailwindDimensionResolution(classNameTokens, "h");
+	const widthPx = getTailwindDimensionPx(widthResolution.utility, "w");
+	const heightPx = getTailwindDimensionPx(heightResolution.utility, "h");
+	const staticLabelText = getStaticJsxText(isNodeOfType(openingElement.parent, "JSXElement") ? openingElement.parent : null).replace(/\s+/g, " ").trim();
+	return !widthResolution.isAmbiguous && !heightResolution.isAmbiguous && widthPx !== null && heightPx !== null && widthPx <= 40 && heightPx <= 40 && staticLabelText.length === 0;
+};
+const isHorizontalUnderlineHost = (openingElement) => {
+	const elementType = resolveJsxElementType(openingElement);
+	return /^(?:a|area|button)$/i.test(elementType) || /(?:button|link)$/i.test(elementType);
+};
+const hasStaticSelectedOrCurrentClass = (classNameTokens) => classNameTokens.some((classNameToken) => {
+	const parsedToken = parseTailwindClassNameToken(classNameToken);
+	return parsedToken.variants.length === 0 && STATIC_SELECTED_OR_CURRENT_CLASS_PATTERN.test(parsedToken.utility);
+});
+const hasStaticPseudoPositioningContext = (classNameTokens) => {
+	const positionResolution = resolveEffectiveTailwindClassNameToken(classNameTokens, (utility) => [
+		"absolute",
+		"fixed",
+		"relative",
+		"static",
+		"sticky"
+	].includes(utility));
+	return !positionResolution.isAmbiguous && Boolean(positionResolution.utility && [
+		"absolute",
+		"fixed",
+		"relative",
+		"sticky"
+	].includes(positionResolution.utility));
+};
 const isNeutralBorderColor = (value) => {
 	const trimmed = value.trim().toLowerCase();
 	if ([
@@ -82600,11 +85066,11 @@ const getTailwindBorderColorNeutrality = (utility, expectedSide) => {
 };
 const noSideTabBorder = defineRule({
 	id: "no-side-tab-border",
-	title: "Thick one-sided border",
+	title: "Thick one-sided stripe",
 	tags: ["design", "test-noise"],
 	severity: "warn",
 	defaultEnabled: false,
-	recommendation: "Use a softer accent like an inset box-shadow, a background, or a thin border-bottom instead of a thick one-sided border.",
+	recommendation: "Use a background change, a thin neutral edge, or a subtler surface treatment instead of a thick one-sided stripe.",
 	create: (context) => ({
 		JSXAttribute(node) {
 			const expression = getInlineStyleExpression(node);
@@ -82613,6 +85079,14 @@ const noSideTabBorder = defineRule({
 			const className = openingElement ? getStringFromClassNameAttr(openingElement) : null;
 			if (className && hasSpinnerClass(className)) return;
 			const classNameTokens = className ? splitTailwindClassName(className) : [];
+			const shadowProperty = getEffectiveStyleProperty(expression.properties, "boxShadow");
+			const shadowValue = shadowProperty ? getStylePropertyStringValue(shadowProperty) : null;
+			const insetSideTabShadow = shadowValue ? parseInsetSideTabShadow(shadowValue) : null;
+			const isImportantTailwindShadowEffective = hasCapabilityOrUnspecified(context.settings, "tailwind") && hasImportantTailwindShadow(classNameTokens);
+			if (shadowProperty && insetSideTabShadow && openingElement && !isImportantTailwindShadowEffective && !isInteractiveOrSelectedIndicator(openingElement)) context.report({
+				node: shadowProperty,
+				message: `Your users see an off, dated inset stripe on one side (${insetSideTabShadow.edgeLabel}: ${insetSideTabShadow.widthPx}px), so use a subtler surface treatment or drop it.`
+			});
 			let hasBorderRadius = false;
 			const borderRadiusProperty = getEffectiveStyleProperty(expression.properties, "borderRadius");
 			if (borderRadiusProperty) {
@@ -82672,6 +85146,23 @@ const noSideTabBorder = defineRule({
 			if (!classStr) return;
 			if (hasSpinnerClass(classStr)) return;
 			const classNameTokens = splitTailwindClassName(classStr);
+			const tailwindInsetSideTabShadow = getTailwindInsetSideTabShadow(classNameTokens);
+			if (tailwindInsetSideTabShadow && !isInteractiveOrSelectedIndicator(node)) {
+				const styleAttribute = getAuthoritativeJsxAttribute(node.attributes, "style");
+				const styleExpression = styleAttribute ? getInlineStyleExpression(styleAttribute) : null;
+				const hasUnknownInlineStyleProperty = Boolean(styleExpression?.properties.some((property) => getStylePropertyKey(property) === null));
+				const hasInlineShadowOverride = Boolean(styleAttribute && (!styleExpression || hasUnknownInlineStyleProperty || getEffectiveStyleProperty(styleExpression.properties, "boxShadow")));
+				if (tailwindInsetSideTabShadow.isImportant || !hasInlineShadowOverride) context.report({
+					node,
+					message: `Your users see an off, dated inset stripe on one side (${tailwindInsetSideTabShadow.shadow.edgeLabel}: ${tailwindInsetSideTabShadow.shadow.widthPx}px), so use a subtler surface treatment or drop it.`
+				});
+			}
+			const pseudoSideTabStripe = getTailwindPseudoSideTabStripe(classNameTokens);
+			const elementType = resolveJsxElementType(node);
+			if (pseudoSideTabStripe && !PSEUDO_SIDE_TAB_SAFE_ELEMENT_PATTERN.test(elementType) && !hasActualSelectedOrCurrentState(node) && !hasStaticSelectedOrCurrentClass(classNameTokens) && hasStaticSideTabLabelContext(node, classStr) && hasStaticPseudoPositioningContext(classNameTokens) && !isGlyphOrLogoContext(node, classNameTokens) && !((pseudoSideTabStripe.edgeLabel === "top" || pseudoSideTabStripe.edgeLabel === "bottom") && isHorizontalUnderlineHost(node))) context.report({
+				node,
+				message: `Your users see an off, dated ${pseudoSideTabStripe.widthPx}px ${pseudoSideTabStripe.pseudoElementName} stripe on the ${pseudoSideTabStripe.edgeLabel} edge, so use a subtler surface treatment or drop it.`
+			});
 			const hasBaseRoundingUtility = classNameTokens.some((classNameToken) => {
 				const parsedToken = parseTailwindClassNameToken(classNameToken);
 				return parsedToken.variants.length === 0 && ROUNDING_PATTERN.test(parsedToken.utility);
@@ -84279,79 +86770,6 @@ const noStringRefs = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/constants/svg-tags.ts
-const SVG_TAGS = new Set([
-	"a",
-	"altGlyph",
-	"altGlyphDef",
-	"altGlyphItem",
-	"animate",
-	"animateColor",
-	"animateMotion",
-	"animateTransform",
-	"circle",
-	"clipPath",
-	"cursor",
-	"defs",
-	"desc",
-	"ellipse",
-	"feBlend",
-	"feColorMatrix",
-	"feComponentTransfer",
-	"feComposite",
-	"feConvolveMatrix",
-	"feDiffuseLighting",
-	"feDisplacementMap",
-	"feDistantLight",
-	"feDropShadow",
-	"feFlood",
-	"feFuncA",
-	"feFuncB",
-	"feFuncG",
-	"feFuncR",
-	"feGaussianBlur",
-	"feImage",
-	"feMerge",
-	"feMergeNode",
-	"feMorphology",
-	"feOffset",
-	"fePointLight",
-	"feSpecularLighting",
-	"feSpotLight",
-	"feTile",
-	"feTurbulence",
-	"filter",
-	"foreignObject",
-	"g",
-	"glyph",
-	"glyphRef",
-	"image",
-	"line",
-	"linearGradient",
-	"marker",
-	"mask",
-	"metadata",
-	"mpath",
-	"path",
-	"pattern",
-	"polygon",
-	"polyline",
-	"radialGradient",
-	"rect",
-	"set",
-	"stop",
-	"svg",
-	"switch",
-	"symbol",
-	"text",
-	"textPath",
-	"title",
-	"tref",
-	"tspan",
-	"use",
-	"view"
-]);
-//#endregion
 //#region src/plugin/rules/design/no-svg-currentcolor-with-fill-class.ts
 const NON_COLOR_PAINT_VALUES = new Set([
 	"current",
@@ -84727,6 +87145,24 @@ const noTightDisplayTracking = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/design/utils/get-effective-nonzero-tailwind-tracking.ts
+const TRACKING_UTILITY_PATTERN = /^-?tracking-/;
+const STATIC_TRACKING_UTILITIES = new Set([
+	"tracking-tight",
+	"tracking-tighter",
+	"tracking-wide",
+	"tracking-wider",
+	"tracking-widest"
+]);
+const NONZERO_ARBITRARY_TRACKING_PATTERN = /^-?tracking-\[(?:length:)?(-?(?:\d+(?:\.\d*)?|\.\d+))(?:cap|ch|cm|dvh|dvw|em|ex|ic|in|lh|lvh|lvw|mm|pc|pt|px|q|rcap|rch|rem|rex|ric|rlh|svh|svw|vb|vh|vi|vmax|vmin|vw)\]$/i;
+const getEffectiveNonzeroTailwindTracking = (tokens) => {
+	const effectiveTracking = getEffectiveTailwindClassNameToken(tokens, (utility) => TRACKING_UTILITY_PATTERN.test(utility));
+	if (!effectiveTracking) return null;
+	if (STATIC_TRACKING_UTILITIES.has(effectiveTracking)) return effectiveTracking;
+	const arbitraryTracking = effectiveTracking.match(NONZERO_ARBITRARY_TRACKING_PATTERN);
+	return arbitraryTracking && Number.parseFloat(arbitraryTracking[1]) !== 0 ? effectiveTracking : null;
+};
+//#endregion
 //#region src/plugin/rules/design/no-tiny-text.ts
 const LETTER_OR_DIGIT_PATTERN = /[\p{L}\p{N}]/u;
 const NAMED_GLYPH_ENTITY_CHARS = {
@@ -84750,12 +87186,22 @@ const NAMED_GLYPH_ENTITY_CHARS = {
 };
 const decodeHtmlEntities = (text) => text.replace(/&#x([0-9a-f]+);/gi, (_, hexCode) => String.fromCodePoint(Number.parseInt(hexCode, 16))).replace(/&#(\d+);/g, (_, decimalCode) => String.fromCodePoint(Number.parseInt(decimalCode, 10))).replace(/&([a-z]+);/gi, (match, entityName) => NAMED_GLYPH_ENTITY_CHARS[entityName.toLowerCase()] ?? match);
 const collectStaticExpressionText = (node) => {
-	if (!node) return "";
-	if (isNodeOfType(node, "Literal")) return typeof node.value === "string" ? node.value : "";
-	if (isNodeOfType(node, "TemplateLiteral")) return (node.quasis ?? []).map((quasi) => quasi.value?.raw ?? "").join("");
-	if (isNodeOfType(node, "ConditionalExpression")) return collectStaticExpressionText(node.consequent) + collectStaticExpressionText(node.alternate);
+	if (!node) return null;
+	if (isNodeOfType(node, "Literal")) {
+		if (node.value === null || typeof node.value === "boolean") return "";
+		return typeof node.value === "string" || typeof node.value === "number" ? String(node.value) : null;
+	}
+	if (isNodeOfType(node, "TemplateLiteral")) {
+		if (node.expressions.length > 0) return null;
+		return (node.quasis ?? []).map((quasi) => quasi.value?.raw ?? "").join("");
+	}
+	if (isNodeOfType(node, "ConditionalExpression")) {
+		const consequentText = collectStaticExpressionText(node.consequent);
+		const alternateText = collectStaticExpressionText(node.alternate);
+		return consequentText === null || alternateText === null ? null : consequentText + alternateText;
+	}
 	if (isNodeOfType(node, "LogicalExpression")) return collectStaticExpressionText(node.right);
-	return "";
+	return null;
 };
 const ICON_IDENTIFIER_NAME_PATTERN = /icon|glyph/i;
 const isIconIdentifierExpression = (node) => {
@@ -84767,9 +87213,7 @@ const isIconIdentifierExpression = (node) => {
 	if (isNodeOfType(node, "LogicalExpression")) return isIconIdentifierExpression(node.right);
 	return false;
 };
-const hasOnlyIconIdentifierChildren = (styleAttribute) => {
-	const jsxElement = styleAttribute.parent?.parent;
-	if (!isNodeOfType(jsxElement, "JSXElement")) return false;
+const hasOnlyIconIdentifierChildren = (jsxElement) => {
 	let expressionChildCount = 0;
 	for (const child of jsxElement.children ?? []) {
 		if (isNodeOfType(child, "JSXText")) {
@@ -84784,9 +87228,7 @@ const hasOnlyIconIdentifierChildren = (styleAttribute) => {
 };
 const REACT_ICONS_COMPONENT_NAME_PATTERN = /^(?:Fa|Md|Io|Bs|Bi|Ri|Gi|Hi|Lu|Tb|Fi|Ai|Cg|Di|Gr|Im|Pi|Si|Sl|Ti|Vsc|Wi)[A-Z0-9]/;
 const ICON_WORD_PATTERN = /icon/i;
-const isChildlessIconComponent = (styleAttribute) => {
-	const openingElement = styleAttribute.parent;
-	if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+const isChildlessIconComponent = (openingElement) => {
 	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
 	const elementName = openingElement.name.name;
 	if (!/^[A-Z]/.test(elementName)) return false;
@@ -84795,16 +87237,184 @@ const isChildlessIconComponent = (styleAttribute) => {
 	if (!isNodeOfType(jsxElement, "JSXElement")) return true;
 	return (jsxElement.children ?? []).every((child) => isNodeOfType(child, "JSXText") && (child.value ?? "").trim() === "");
 };
-const hasGlyphOnlyContent = (styleAttribute) => {
-	const jsxElement = styleAttribute.parent?.parent;
-	if (!isNodeOfType(jsxElement, "JSXElement")) return false;
+const hasGlyphOnlyContent = (jsxElement) => {
 	let staticText = "";
 	for (const child of jsxElement.children ?? []) if (isNodeOfType(child, "JSXText")) staticText += typeof child.value === "string" ? child.value : "";
-	else if (isNodeOfType(child, "JSXExpressionContainer")) staticText += collectStaticExpressionText(child.expression);
+	else if (isNodeOfType(child, "JSXExpressionContainer")) {
+		if (isIconIdentifierExpression(child.expression)) continue;
+		const expressionText = collectStaticExpressionText(child.expression);
+		if (expressionText === null) return false;
+		staticText += expressionText;
+	}
 	const trimmedText = decodeHtmlEntities(staticText.trim());
 	return trimmedText.length > 0 && !LETTER_OR_DIGIT_PATTERN.test(trimmedText);
 };
-const isUppercaseMicroLabel = (expression) => (expression.properties ?? []).some((property) => getStylePropertyKey(property) === "textTransform" && getStylePropertyStringValue(property) === "uppercase");
+const PREFORMATTED_ELEMENT_NAMES$3 = new Set([
+	"code",
+	"head",
+	"kbd",
+	"noscript",
+	"option",
+	"pre",
+	"samp",
+	"script",
+	"style",
+	"sub",
+	"sup",
+	"svg",
+	"template",
+	"title",
+	"var"
+]);
+const FUNCTIONAL_ELEMENT_NAMES = new Set([
+	"a",
+	"button",
+	"caption",
+	"dd",
+	"dt",
+	"figcaption",
+	"footer",
+	"label",
+	"nav",
+	"summary",
+	"td",
+	"th",
+	"time"
+]);
+const FUNCTIONAL_ROLE_NAMES = new Set([
+	"button",
+	"cell",
+	"checkbox",
+	"columnheader",
+	"gridcell",
+	"link",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"navigation",
+	"option",
+	"radio",
+	"rowheader",
+	"switch",
+	"tab",
+	"treeitem"
+]);
+const FUNCTIONAL_CLASS_NAME_PATTERN = /^(?:badge|breadcrumb|caption|category|chip|eyebrow|kicker|label|meta|nav|pill|tag|timestamp)(?:$|-)/i;
+const PREFORMATTED_CLASS_NAME_PATTERN = /^(?:code|console|diff|editor|syntax|terminal)(?:$|-)/i;
+const PREFORMATTED_COMPONENT_NAME_PATTERN = /^(?:(?:Code|Console|Diff|Editor|Syntax|Terminal)(?:Block|Output|Pane|Renderer|View|Viewer)?|SyntaxHighlighter)$/;
+const VISUALLY_HIDDEN_CLASS_NAMES = new Set([
+	"a11y-hidden",
+	"hidden-visually",
+	"offscreen",
+	"screen-reader",
+	"screen-reader-only",
+	"screenreader",
+	"sr-only",
+	"visually-hidden",
+	"visuallyhidden"
+]);
+const CASE_TOKENS$2 = new Set([
+	"capitalize",
+	"lowercase",
+	"normal-case",
+	"uppercase"
+]);
+const getAncestorOpeningElements = (jsxElement) => {
+	const openingElements = [];
+	let currentNode = jsxElement;
+	while (currentNode) {
+		if (isNodeOfType(currentNode, "JSXElement")) openingElements.push(currentNode.openingElement);
+		currentNode = currentNode.parent;
+	}
+	return openingElements;
+};
+const hasUnresolvedVisibilityAttribute = (openingElement) => {
+	for (const attributeName of ["hidden", "aria-hidden"]) {
+		const attribute = getAuthoritativeJsxAttribute(openingElement.attributes, attributeName, false);
+		if (attribute?.value && isNodeOfType(attribute.value, "JSXExpressionContainer") && !isNodeOfType(attribute.value.expression, "Literal") && (!isNodeOfType(attribute.value.expression, "TemplateLiteral") || attribute.value.expression.expressions.length > 0)) return true;
+	}
+	return false;
+};
+const hasUnresolvedClassName = (openingElement) => Boolean(getAuthoritativeJsxAttribute(openingElement.attributes, "className") && getStringFromClassNameAttr(openingElement) === null);
+const hasUnresolvedInlineVisibility = (openingElement) => {
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	if (!styleAttribute) return false;
+	const expression = getInlineStyleExpression(styleAttribute);
+	if (!expression) return true;
+	if (expression.properties.some((property) => getStylePropertyKey(property) === null)) return true;
+	for (const propertyName of ["display", "visibility"]) {
+		const property = getEffectiveStyleProperty(expression.properties, propertyName);
+		if (property && getStylePropertyStringValue(property) === null) return true;
+	}
+	return false;
+};
+const hasUnresolvedRenderingState = (openingElement) => hasJsxSpreadAttribute(openingElement.attributes) || hasUnresolvedVisibilityAttribute(openingElement) || hasUnresolvedClassName(openingElement) || hasUnresolvedInlineVisibility(openingElement);
+const isStaticallyNonRendered = (openingElement, hasTailwind) => {
+	const hiddenAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "hidden", false);
+	if (hiddenAttribute && getStringLiteralAttributeValue(hiddenAttribute) !== null) return true;
+	if (isHiddenFromScreenReader(openingElement, void 0)) return true;
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	const expression = styleAttribute ? getInlineStyleExpression(styleAttribute) : null;
+	if (expression) {
+		const displayProperty = getEffectiveStyleProperty(expression.properties, "display");
+		if (displayProperty && getStylePropertyStringValue(displayProperty)?.toLowerCase() === "none") return true;
+		const visibilityProperty = getEffectiveStyleProperty(expression.properties, "visibility");
+		const visibilityValue = visibilityProperty ? getStylePropertyStringValue(visibilityProperty)?.toLowerCase() : null;
+		if (visibilityValue === "hidden" || visibilityValue === "collapse") return true;
+	}
+	if (!hasTailwind) return false;
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	if (!classNameValue) return false;
+	const visibilityAtBreakpoints = getTailwindVisibilityAtBreakpoints(classNameValue);
+	return Boolean(visibilityAtBreakpoints && visibilityAtBreakpoints.every((isVisible) => !isVisible));
+};
+const isVisuallyHidden = (openingElement) => {
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	if (!classNameValue) return false;
+	const tokens = splitTailwindClassName(classNameValue).map(parseTailwindClassNameToken);
+	const hasImportantScreenReaderOnly = tokens.some((token) => token.utility === "sr-only" && token.isImportant);
+	const hasImportantVisibleOverride = tokens.some((token) => token.utility === "not-sr-only" && token.isImportant);
+	if (hasImportantScreenReaderOnly && !hasImportantVisibleOverride) return true;
+	if (tokens.some((token) => token.utility === "not-sr-only")) return false;
+	return tokens.some((token) => VISUALLY_HIDDEN_CLASS_NAMES.has(token.utility.toLowerCase()));
+};
+const isPreformattedContext = (openingElement) => {
+	const elementName = resolveJsxElementType(openingElement);
+	if (PREFORMATTED_ELEMENT_NAMES$3.has(elementName.toLowerCase()) || PREFORMATTED_COMPONENT_NAME_PATTERN.test(elementName)) return true;
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	return Boolean(classNameValue && splitTailwindClassName(classNameValue).map(parseTailwindClassNameToken).some((token) => PREFORMATTED_CLASS_NAME_PATTERN.test(token.utility)));
+};
+const isFunctionalTextContext = (openingElements) => openingElements.some((openingElement) => {
+	const elementName = resolveJsxElementType(openingElement).toLowerCase();
+	if (FUNCTIONAL_ELEMENT_NAMES.has(elementName)) return true;
+	const roleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "role", false);
+	const roleValue = roleAttribute ? getStringLiteralAttributeValue(roleAttribute) : null;
+	if (roleValue && FUNCTIONAL_ROLE_NAMES.has(roleValue.toLowerCase())) return true;
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	return Boolean(classNameValue && splitTailwindClassName(classNameValue).map(parseTailwindClassNameToken).some((token) => FUNCTIONAL_CLASS_NAME_PATTERN.test(token.utility)));
+});
+const hasNonzeroInlineLetterSpacing = (expression) => {
+	const property = getEffectiveStyleProperty(expression.properties, "letterSpacing");
+	if (!property) return false;
+	const numberValue = getStylePropertyNumberValue(property);
+	if (numberValue !== null) return numberValue !== 0;
+	const stringValue = getStylePropertyStringValue(property);
+	if (!stringValue || stringValue === "normal") return false;
+	const parsedValue = Number.parseFloat(stringValue);
+	return Number.isFinite(parsedValue) && parsedValue !== 0;
+};
+const isUppercaseTrackedMicroLabel = (openingElement) => {
+	const styleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "style");
+	const expression = styleAttribute ? getInlineStyleExpression(styleAttribute) : null;
+	if (expression) {
+		const textTransformProperty = getEffectiveStyleProperty(expression.properties, "textTransform");
+		if (textTransformProperty && getStylePropertyStringValue(textTransformProperty) === "uppercase" && hasNonzeroInlineLetterSpacing(expression)) return true;
+	}
+	const classNameValue = getStringFromClassNameAttr(openingElement);
+	if (!classNameValue) return false;
+	const tokens = getUnvariantClassNameTokensWithImportantModifiers(classNameValue);
+	return getEffectiveTailwindClassNameToken(tokens, (utility) => CASE_TOKENS$2.has(utility)) === "uppercase" && Boolean(getEffectiveNonzeroTailwindTracking(tokens));
+};
 const noTinyText = defineRule({
 	id: "no-tiny-text",
 	title: "Text is too small",
@@ -84814,55 +87424,23 @@ const noTinyText = defineRule({
 	recommendation: "Use at least 12px for body text, and 16px is best. Small text is hard to read, especially on phones.",
 	create: (context) => {
 		const reportedPxValues = /* @__PURE__ */ new Set();
-		return { JSXAttribute(node) {
-			const expression = getInlineStyleExpression(node);
-			if (!expression) return;
-			for (const property of expression.properties ?? []) {
-				if (getStylePropertyKey(property) !== "fontSize") continue;
-				let pxValue = null;
-				const numValue = getStylePropertyNumberValue(property);
-				const strValue = getStylePropertyStringValue(property);
-				if (numValue !== null) pxValue = numValue;
-				else if (strValue !== null) {
-					const pxMatch = strValue.match(/^([\d.]+)px$/);
-					if (pxMatch) pxValue = parseFloat(pxMatch[1]);
-					const remMatch = strValue.match(/^([\d.]+)rem$/);
-					if (remMatch) pxValue = parseFloat(remMatch[1]) * 16;
-				}
-				if (pxValue === null || pxValue <= 0 || pxValue >= 12) continue;
-				if (reportedPxValues.has(pxValue)) continue;
-				if (isUppercaseMicroLabel(expression)) continue;
-				if (hasGlyphOnlyContent(node)) continue;
-				if (hasOnlyIconIdentifierChildren(node)) continue;
-				if (isChildlessIconComponent(node)) continue;
-				reportedPxValues.add(pxValue);
-				context.report({
-					node: property,
-					message: `Your users strain to read ${pxValue}px text, so use at least 12px for body text, & 16px is best.`
-				});
-			}
+		const hasTailwind = hasCapabilityOrUnspecified(context.settings, "tailwind");
+		return { JSXElement(node) {
+			const openingElement = node.openingElement;
+			const openingElements = getAncestorOpeningElements(node);
+			if (openingElements.some(hasUnresolvedRenderingState)) return;
+			if (openingElements.some((ancestorOpeningElement) => isStaticallyNonRendered(ancestorOpeningElement, hasTailwind) || isVisuallyHidden(ancestorOpeningElement) || isPreformattedContext(ancestorOpeningElement))) return;
+			const pxValue = getStaticEffectiveFontSize(openingElement, hasTailwind);
+			if (pxValue === null || pxValue <= 0 || pxValue >= 12 || reportedPxValues.has(pxValue) || hasGlyphOnlyContent(node) || hasOnlyIconIdentifierChildren(node) || isChildlessIconComponent(openingElement) || isUppercaseTrackedMicroLabel(openingElement) && !isFunctionalTextContext(openingElements)) return;
+			reportedPxValues.add(pxValue);
+			context.report({
+				node: openingElement,
+				message: `Your users strain to read ${pxValue}px text, so use at least 12px for readable interface text, & 16px is best.`
+			});
 		} };
 	}
 });
 //#endregion
-//#region src/plugin/rules/design/utils/get-effective-nonzero-tailwind-tracking.ts
-const TRACKING_UTILITY_PATTERN = /^-?tracking-/;
-const STATIC_TRACKING_UTILITIES = new Set([
-	"tracking-tight",
-	"tracking-tighter",
-	"tracking-wide",
-	"tracking-wider",
-	"tracking-widest"
-]);
-const NONZERO_ARBITRARY_TRACKING_PATTERN = /^-?tracking-\[(?:length:)?(-?(?:\d+(?:\.\d*)?|\.\d+))(?:cap|ch|cm|dvh|dvw|em|ex|ic|in|lh|lvh|lvw|mm|pc|pt|px|q|rcap|rch|rem|rex|ric|rlh|svh|svw|vb|vh|vi|vmax|vmin|vw)\]$/i;
-const getEffectiveNonzeroTailwindTracking = (tokens) => {
-	const effectiveTracking = getEffectiveTailwindClassNameToken(tokens, (utility) => TRACKING_UTILITY_PATTERN.test(utility));
-	if (!effectiveTracking) return null;
-	if (STATIC_TRACKING_UTILITIES.has(effectiveTracking)) return effectiveTracking;
-	const arbitraryTracking = effectiveTracking.match(NONZERO_ARBITRARY_TRACKING_PATTERN);
-	return arbitraryTracking && Number.parseFloat(arbitraryTracking[1]) !== 0 ? effectiveTracking : null;
-};
-//#endregion
 //#region src/plugin/rules/design/utils/is-technical-label-text.ts
 const UPPERCASE_TECHNICAL_TOKEN_PATTERN = /^[A-Z0-9][A-Z0-9_.:/-]*$/;
 const TECHNICAL_TOKEN_PATTERN = /^[A-Za-z0-9]+(?:[-_./:][A-Za-z0-9]+)+$/;
@@ -85641,12 +88219,6 @@ const isIconOnlyButton = (node) => {
 	}
 	return iconCount === 1;
 };
-const parseTailwindLength = (token, prefix) => {
-	const arbitraryMatch = token.match(new RegExp(`^${prefix}-\\[([\\d.]+)px\\]$`));
-	if (arbitraryMatch) return Number.parseFloat(arbitraryMatch[1]);
-	const scaleMatch = token.match(new RegExp(`^${prefix}-([\\d.]+)$`));
-	return scaleMatch ? Number.parseFloat(scaleMatch[1]) * 4 : null;
-};
 const WIDTH_UTILITY_PATTERN = /^(?:size|w)-/;
 const HEIGHT_UTILITY_PATTERN = /^(?:h|size)-/;
 const HORIZONTAL_PADDING_UTILITY_PATTERN = /^p(?:[xlr])?-/;
@@ -85673,8 +88245,8 @@ const getTailwindTargetSize = (node) => {
 	})) return null;
 	const effectiveWidth = getEffectiveTailwindClassNameToken(tokens, (utility) => WIDTH_UTILITY_PATTERN.test(utility));
 	const effectiveHeight = getEffectiveTailwindClassNameToken(tokens, (utility) => HEIGHT_UTILITY_PATTERN.test(utility));
-	const width = effectiveWidth ? parseTailwindLength(effectiveWidth, "size") ?? parseTailwindLength(effectiveWidth, "w") : null;
-	const height = effectiveHeight ? parseTailwindLength(effectiveHeight, "size") ?? parseTailwindLength(effectiveHeight, "h") : null;
+	const width = effectiveWidth ? parseStaticTailwindLengthPx(effectiveWidth, "size") ?? parseStaticTailwindLengthPx(effectiveWidth, "w") : null;
+	const height = effectiveHeight ? parseStaticTailwindLengthPx(effectiveHeight, "size") ?? parseStaticTailwindLengthPx(effectiveHeight, "h") : null;
 	return width !== null && height !== null ? [width, height] : null;
 };
 const getInlineTargetSize = (node) => {
@@ -127742,6 +130314,18 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noAsyncEventHandlerWithoutReentryGuard.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-auto-scrolling-content",
+		id: "no-auto-scrolling-content",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noAutoScrollingContent,
+			framework: "global",
+			category: "Maintainability",
+			tags: [...new Set(["design", ...noAutoScrollingContent.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-autofocus",
 		id: "no-autofocus",
@@ -128100,6 +130684,18 @@ const reactDoctorRules = [
 			tags: [...new Set(["design", ...noDecorativePulse.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-decorative-radial-spotlight",
+		id: "no-decorative-radial-spotlight",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noDecorativeRadialSpotlight,
+			framework: "global",
+			category: "Maintainability",
+			tags: [...new Set(["design", ...noDecorativeRadialSpotlight.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-default-props",
 		id: "no-default-props",
@@ -129828,6 +132424,18 @@ const reactDoctorRules = [
 			category: "Maintainability"
 		}
 	},
+	{
+		key: "react-doctor/no-pulsing-status-dot",
+		id: "no-pulsing-status-dot",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noPulsingStatusDot,
+			framework: "global",
+			category: "Maintainability",
+			tags: [...new Set(["design", ...noPulsingStatusDot.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-pure-black-background",
 		id: "no-pure-black-background",
@@ -129852,6 +132460,18 @@ const reactDoctorRules = [
 			tags: [...new Set(["design", ...noPureBlackShadow.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-radial-halo",
+		id: "no-radial-halo",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noRadialHalo,
+			framework: "global",
+			category: "Maintainability",
+			tags: [...new Set(["design", ...noRadialHalo.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-random-key",
 		id: "no-random-key",
@@ -130015,6 +132635,18 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noRenderReturnValue.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-repeated-container-text",
+		id: "no-repeated-container-text",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noRepeatedContainerText,
+			framework: "global",
+			category: "Maintainability",
+			tags: [...new Set(["design", ...noRepeatedContainerText.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-repeated-emoji-tiles",
 		id: "no-repeated-emoji-tiles",
@@ -130206,6 +132838,18 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noSetStateInRender.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-shape-assembled-illustration",
+		id: "no-shape-assembled-illustration",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noShapeAssembledIllustration,
+			framework: "global",
+			category: "Maintainability",
+			tags: [...new Set(["design", ...noShapeAssembledIllustration.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-side-effect-in-state-updater-function",
 		id: "no-side-effect-in-state-updater-function",