diff --git a/CHANGELOG.md b/CHANGELOG.md
index d5da26aea..86ee0a317 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,12 +10,14 @@ All notable changes to **bUnit** will be documented in this file. The project ad
 
 - Added generic overloads `Find{TComponent, TElement}` and `FindAll{TComponent, TElement}` to query for specific element types (e.g., `IHtmlInputElement`). By [@linkdotnet](https://github.com/linkdotnet).
 - Added generic overloads `WaitForElement{TComponent, TElement}` and `WaitForElements{TComponent, TElement}` to wait for specific element types. By [@linkdotnet](https://github.com/linkdotnet).
+- Added `FindByRole` and `FindAllByRole` to `bunit.web.query` package. By [@linkdotnet](https://github.com/linkdotnet).
 
 ## [2.2.2] - 2025-12-08
 
 ### Added
 
 - Added `FindByAllByLabel` to `bunit.web.query` package. By [@linkdotnet](https://github.com/linkdotnet).
+- Added `FindByRole` and `FindAllByRole` to `bunit.web.query` package. By [@linkdotnet](https://github.com/linkdotnet).
 
 ### Fixed
 
diff --git a/src/bunit.web.query/Roles/AccessibleNameComputation.cs b/src/bunit.web.query/Roles/AccessibleNameComputation.cs
new file mode 100644
index 000000000..7e7a8e68b
--- /dev/null
+++ b/src/bunit.web.query/Roles/AccessibleNameComputation.cs
@@ -0,0 +1,193 @@
+using AngleSharp.Dom;
+
+namespace Bunit;
+
+/// <summary>
+/// Provides methods to compute the accessible name of an element.
+/// </summary>
+/// <remarks>
+/// This is a simplified implementation of the Accessible Name and Description Computation algorithm.
+/// See https://www.w3.org/TR/accname-1.1/ for the full specification.
+/// </remarks>
+[SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Using lowercase for comparison with lowercase constant values.")]
+internal static class AccessibleNameComputation
+{
+	/// <summary>
+	/// Computes the accessible name of an element.
+	/// </summary>
+	public static string? GetAccessibleName(IElement element)
+	{
+		return GetNameFromAriaLabelledBy(element)
+			?? GetNameFromAriaLabel(element)
+			?? GetNameFromAssociatedLabelOrNativeContent(element)
+			?? GetNameFromTitleAttribute(element)
+			?? GetNameFromPlaceholder(element);
+	}
+
+	private static string? GetNameFromAriaLabelledBy(IElement element)
+	{
+		var labelledBy = element.GetAttribute("aria-labelledby");
+		if (string.IsNullOrWhiteSpace(labelledBy))
+			return null;
+
+		return GetTextFromReferencedElements(element, labelledBy);
+	}
+
+	private static string? GetNameFromAriaLabel(IElement element)
+	{
+		var ariaLabel = element.GetAttribute("aria-label");
+		return string.IsNullOrWhiteSpace(ariaLabel) ? null : ariaLabel;
+	}
+
+	private static string? GetNameFromAssociatedLabelOrNativeContent(IElement element)
+	{
+		var tagName = element.TagName.ToUpperInvariant();
+
+		if (tagName is "INPUT" or "SELECT" or "TEXTAREA")
+		{
+			return GetNameFromLinkedLabel(element)
+				?? GetNameFromInputButtonValue(element);
+		}
+
+		if (tagName == "IMG")
+		{
+			return GetNameFromAltAttribute(element);
+		}
+
+		if (tagName is "BUTTON" or "A" or "H1" or "H2" or "H3" or "H4" or "H5" or "H6")
+		{
+			return GetNonEmptyTextContent(element);
+		}
+
+		return null;
+	}
+
+	private static string? GetNameFromTitleAttribute(IElement element)
+	{
+		var title = element.GetAttribute("title");
+		return string.IsNullOrWhiteSpace(title) ? null : title;
+	}
+
+	private static string? GetNameFromPlaceholder(IElement element)
+	{
+		var tagName = element.TagName.ToUpperInvariant();
+		if (tagName is not ("INPUT" or "TEXTAREA"))
+			return null;
+
+		var placeholder = element.GetAttribute("placeholder");
+		return string.IsNullOrWhiteSpace(placeholder) ? null : placeholder;
+	}
+
+	private static string? GetTextFromReferencedElements(IElement element, string spaceDelimitedIds)
+	{
+		var ids = spaceDelimitedIds.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+		var texts = new List<string>();
+		var root = GetRootElement(element);
+
+		foreach (var id in ids)
+		{
+			var referencedElement = element.Owner?.GetElementById(id) ?? root?.QuerySelector($"#{id}");
+			if (referencedElement == null)
+				continue;
+
+			var text = referencedElement.TextContent.Trim();
+			if (!string.IsNullOrWhiteSpace(text))
+				texts.Add(text);
+		}
+
+		return texts.Count > 0 ? string.Join(" ", texts) : null;
+	}
+
+	private static IElement? GetRootElement(IElement element)
+	{
+		var current = element;
+		while (current.ParentElement != null)
+		{
+			current = current.ParentElement;
+		}
+		return current;
+	}
+
+	private static string? GetNameFromLinkedLabel(IElement element)
+	{
+		var id = element.GetAttribute("id");
+		if (!string.IsNullOrWhiteSpace(id))
+		{
+			var linkedLabel = FindLabelWithForAttribute(element, id);
+			if (linkedLabel != null)
+			{
+				return linkedLabel.TextContent.Trim();
+			}
+		}
+
+		var wrappingLabel = element.Closest("label");
+		if (wrappingLabel != null)
+		{
+			return GetTextContentExcludingElement(wrappingLabel, element);
+		}
+
+		return null;
+	}
+
+	private static IElement? FindLabelWithForAttribute(IElement element, string id)
+	{
+		var label = element.Owner?.QuerySelector($"label[for='{id}']");
+		if (label != null)
+			return label;
+
+		var root = GetRootElement(element);
+		return root?.QuerySelector($"label[for='{id}']");
+	}
+
+	private static string? GetNameFromInputButtonValue(IElement element)
+	{
+		if (!element.TagName.Equals("INPUT", StringComparison.OrdinalIgnoreCase))
+			return null;
+
+		var inputType = element.GetAttribute("type")?.ToLowerInvariant();
+		if (inputType is not ("button" or "submit" or "reset"))
+			return null;
+
+		var value = element.GetAttribute("value");
+		return string.IsNullOrWhiteSpace(value) ? null : value;
+	}
+
+	private static string? GetNameFromAltAttribute(IElement element)
+	{
+		var alt = element.GetAttribute("alt");
+		return string.IsNullOrWhiteSpace(alt) ? null : alt;
+	}
+
+	private static string? GetNonEmptyTextContent(IElement element)
+	{
+		var textContent = element.TextContent.Trim();
+		return string.IsNullOrWhiteSpace(textContent) ? null : textContent;
+	}
+
+	private static string GetTextContentExcludingElement(IElement container, IElement excludeElement)
+	{
+		var texts = new List<string>();
+		CollectTextNodesExcluding(container, excludeElement, texts);
+		return string.Join(" ", texts).Trim();
+	}
+
+	private static void CollectTextNodesExcluding(INode node, IElement excludeElement, List<string> texts)
+	{
+		foreach (var child in node.ChildNodes)
+		{
+			if (child == excludeElement)
+				continue;
+
+			if (child.NodeType == NodeType.Text)
+			{
+				var text = child.TextContent.Trim();
+				if (!string.IsNullOrWhiteSpace(text))
+					texts.Add(text);
+			}
+			else if (child.NodeType == NodeType.Element)
+			{
+				CollectTextNodesExcluding(child, excludeElement, texts);
+			}
+		}
+	}
+}
diff --git a/src/bunit.web.query/Roles/AriaRole.cs b/src/bunit.web.query/Roles/AriaRole.cs
new file mode 100644
index 000000000..f158de9c7
--- /dev/null
+++ b/src/bunit.web.query/Roles/AriaRole.cs
@@ -0,0 +1,475 @@
+namespace Bunit;
+
+/// <summary>
+/// Represents ARIA roles that can be used to query elements.
+/// </summary>
+/// <remarks>
+/// See https://www.w3.org/TR/wai-aria-1.2/#role_definitions for the full specification.
+/// </remarks>
+public enum AriaRole
+{
+	/// <summary>
+	/// A message with important, and usually time-sensitive, information.
+	/// </summary>
+	Alert,
+
+	/// <summary>
+	/// A type of dialog that contains an alert message.
+	/// </summary>
+	AlertDialog,
+
+	/// <summary>
+	/// A structure containing one or more focusable elements requiring user input.
+	/// </summary>
+	Application,
+
+	/// <summary>
+	/// An independent section of the document, page, or site.
+	/// </summary>
+	Article,
+
+	/// <summary>
+	/// A section of content that is quoted from another source.
+	/// </summary>
+	Blockquote,
+
+	/// <summary>
+	/// An input that allows for user-triggered actions when clicked or pressed.
+	/// </summary>
+	Button,
+
+	/// <summary>
+	/// Visible content that names, and may also describe, a figure, table, grid, or treegrid.
+	/// </summary>
+	Caption,
+
+	/// <summary>
+	/// A checkable input that has three possible values: true, false, or mixed.
+	/// </summary>
+	Checkbox,
+
+	/// <summary>
+	/// A cell in a tabular container.
+	/// </summary>
+	Cell,
+
+	/// <summary>
+	/// A section whose content represents a fragment of computer code.
+	/// </summary>
+	Code,
+
+	/// <summary>
+	/// A cell containing header information for a column.
+	/// </summary>
+	ColumnHeader,
+
+	/// <summary>
+	/// A composite widget containing a single-line textbox and another element.
+	/// </summary>
+	Combobox,
+
+	/// <summary>
+	/// A form of widget that performs an action but does not receive input data. (Abstract)
+	/// </summary>
+	Command,
+
+	/// <summary>
+	/// A supporting section of the document, designed to be complementary to the main content.
+	/// </summary>
+	Complementary,
+
+	/// <summary>
+	/// A large perceivable region that contains information about the parent document.
+	/// </summary>
+	ContentInfo,
+
+	/// <summary>
+	/// A widget that may contain navigable descendants or owned children. (Abstract)
+	/// </summary>
+	Composite,
+
+	/// <summary>
+	/// A definition of a term or concept.
+	/// </summary>
+	Definition,
+
+	/// <summary>
+	/// A deletion contains content that is marked as removed or suggested for removal.
+	/// </summary>
+	Deletion,
+
+	/// <summary>
+	/// A dialog is a descendant window of the primary window of a web application.
+	/// </summary>
+	Dialog,
+
+	/// <summary>
+	/// A structure containing one or more focusable elements.
+	/// </summary>
+	Document,
+
+	/// <summary>
+	/// [Deprecated in ARIA 1.2] A list of references to members of a group.
+	/// </summary>
+	Directory,
+
+	/// <summary>
+	/// A scrollable list of articles.
+	/// </summary>
+	Feed,
+
+	/// <summary>
+	/// A figure is a perceivable section of content.
+	/// </summary>
+	Figure,
+
+	/// <summary>
+	/// A landmark region that contains a collection of items and objects.
+	/// </summary>
+	Form,
+
+	/// <summary>
+	/// A set of user interface objects that are not intended to be included in a page summary.
+	/// </summary>
+	Generic,
+
+	/// <summary>
+	/// A grid is an interactive control that contains cells of tabular data arranged in rows and columns.
+	/// </summary>
+	Grid,
+
+	/// <summary>
+	/// A cell in a grid or treegrid.
+	/// </summary>
+	GridCell,
+
+	/// <summary>
+	/// A set of user interface objects that are not intended to be included in a page summary or table of contents.
+	/// </summary>
+	Group,
+
+	/// <summary>
+	/// A heading for a section of the page.
+	/// </summary>
+	Heading,
+
+	/// <summary>
+	/// A container for a collection of elements that form an image.
+	/// </summary>
+	Img,
+
+	/// <summary>
+	/// A generic type of widget that allows user input. (Abstract)
+	/// </summary>
+	Input,
+
+	/// <summary>
+	/// An insertion contains content that is marked as added or suggested for addition.
+	/// </summary>
+	Insertion,
+
+	/// <summary>
+	/// A perceivable section for a specific purpose that users can navigate to. (Abstract)
+	/// </summary>
+	Landmark,
+
+	/// <summary>
+	/// An interactive reference to an internal or external resource.
+	/// </summary>
+	Link,
+
+	/// <summary>
+	/// A section containing listitem elements.
+	/// </summary>
+	List,
+
+	/// <summary>
+	/// A widget that allows the user to select one or more items from a list of choices.
+	/// </summary>
+	Listbox,
+
+	/// <summary>
+	/// A single item in a list or directory.
+	/// </summary>
+	Listitem,
+
+	/// <summary>
+	/// A type of live region where new information is added in meaningful order.
+	/// </summary>
+	Log,
+
+	/// <summary>
+	/// The main content of a document.
+	/// </summary>
+	Main,
+
+	/// <summary>
+	/// A type of live region where non-essential information changes frequently.
+	/// </summary>
+	Marquee,
+
+	/// <summary>
+	/// Content that represents a mathematical expression.
+	/// </summary>
+	Math,
+
+	/// <summary>
+	/// A type of widget that offers a list of choices to the user.
+	/// </summary>
+	Menu,
+
+	/// <summary>
+	/// A presentation of menu that usually remains visible and is usually presented horizontally.
+	/// </summary>
+	Menubar,
+
+	/// <summary>
+	/// An option in a set of choices contained by a menu or menubar.
+	/// </summary>
+	Menuitem,
+
+	/// <summary>
+	/// A menuitem with a checkable state.
+	/// </summary>
+	MenuitemCheckbox,
+
+	/// <summary>
+	/// A checkable menuitem in a set of elements with the same role.
+	/// </summary>
+	MenuitemRadio,
+
+	/// <summary>
+	/// A graphical display of values.
+	/// </summary>
+	Meter,
+
+	/// <summary>
+	/// A section of a page that represents navigation links.
+	/// </summary>
+	Navigation,
+
+	/// <summary>
+	/// A section whose content represents additional information.
+	/// </summary>
+	Note,
+
+	/// <summary>
+	/// An element whose implicit native role semantics will not be mapped to the accessibility API. Synonym of Presentation.
+	/// </summary>
+	None,
+
+	/// <summary>
+	/// A selectable item in a select list.
+	/// </summary>
+	Option,
+
+	/// <summary>
+	/// A paragraph of content.
+	/// </summary>
+	Paragraph,
+
+	/// <summary>
+	/// An element whose implicit native role semantics will not be mapped to the accessibility API.
+	/// </summary>
+	Presentation,
+
+	/// <summary>
+	/// An element that displays the progress status for tasks that take a long time.
+	/// </summary>
+	Progressbar,
+
+	/// <summary>
+	/// A checkable input in a group of elements with the same role.
+	/// </summary>
+	Radio,
+
+	/// <summary>
+	/// A group of radio buttons.
+	/// </summary>
+	RadioGroup,
+
+	/// <summary>
+	/// An element representing a range of values. (Abstract)
+	/// </summary>
+	Range,
+
+	/// <summary>
+	/// A perceivable section containing content that is relevant to a specific, author-specified purpose.
+	/// </summary>
+	Region,
+
+	/// <summary>
+	/// The base role from which all other roles inherit. (Abstract)
+	/// </summary>
+	RoleType,
+
+	/// <summary>
+	/// A row of cells in a tabular container.
+	/// </summary>
+	Row,
+
+	/// <summary>
+	/// A group containing one or more row elements in a grid.
+	/// </summary>
+	RowGroup,
+
+	/// <summary>
+	/// A cell containing header information for a row in a grid.
+	/// </summary>
+	RowHeader,
+
+	/// <summary>
+	/// A graphical object that controls the scrolling of content within a viewing area.
+	/// </summary>
+	Scrollbar,
+
+	/// <summary>
+	/// A landmark region that contains a collection of items and objects that, as a whole, combine to create a search facility.
+	/// </summary>
+	Search,
+
+	/// <summary>
+	/// A type of textbox intended for specifying search criteria.
+	/// </summary>
+	Searchbox,
+
+	/// <summary>
+	/// A divider that separates and distinguishes sections of content or groups of menuitems.
+	/// </summary>
+	Separator,
+
+	/// <summary>
+	/// An input where the user selects a value from within a given range.
+	/// </summary>
+	Slider,
+
+	/// <summary>
+	/// A form of range that expects the user to select from among discrete choices.
+	/// </summary>
+	Spinbutton,
+
+	/// <summary>
+	/// A type of live region whose content is advisory information for the user.
+	/// </summary>
+	Status,
+
+	/// <summary>
+	/// A type of checkbox that represents on/off values.
+	/// </summary>
+	Switch,
+
+	/// <summary>
+	/// A grouping label providing a mechanism for selecting the tab content that is to be rendered to the user.
+	/// </summary>
+	Tab,
+
+	/// <summary>
+	/// A section containing data arranged in rows and columns.
+	/// </summary>
+	Table,
+
+	/// <summary>
+	/// A list of tab elements, which are references to tabpanel elements.
+	/// </summary>
+	Tablist,
+
+	/// <summary>
+	/// A container for the resources associated with a tab.
+	/// </summary>
+	Tabpanel,
+
+	/// <summary>
+	/// An element that represents a specific value within a range.
+	/// </summary>
+	Term,
+
+	/// <summary>
+	/// A type of input that allows free-form text as its value.
+	/// </summary>
+	Textbox,
+
+	/// <summary>
+	/// An element that represents a specific point in time.
+	/// </summary>
+	Time,
+
+	/// <summary>
+	/// A type of live region containing a numerical counter.
+	/// </summary>
+	Timer,
+
+	/// <summary>
+	/// A collection of commonly used function buttons or controls represented in compact visual form.
+	/// </summary>
+	Toolbar,
+
+	/// <summary>
+	/// A contextual popup that displays a description for an element.
+	/// </summary>
+	Tooltip,
+
+	/// <summary>
+	/// A widget that allows the user to select one or more items from a hierarchically organized collection.
+	/// </summary>
+	Tree,
+
+	/// <summary>
+	/// A grid whose rows can be expanded and collapsed in the same manner as for a tree.
+	/// </summary>
+	Treegrid,
+
+	/// <summary>
+	/// An item in a tree.
+	/// </summary>
+	Treeitem,
+
+	/// <summary>
+	/// A document structural element. (Abstract)
+	/// </summary>
+	Structure,
+
+	/// <summary>
+	/// One or more subscripted characters.
+	/// </summary>
+	Subscript,
+
+	/// <summary>
+	/// One or more superscripted characters.
+	/// </summary>
+	Superscript,
+
+	/// <summary>
+	/// Content that is important, serious, or urgent.
+	/// </summary>
+	Strong,
+
+	/// <summary>
+	/// A renderable structural containment unit in a document or application. (Abstract)
+	/// </summary>
+	Section,
+
+	/// <summary>
+	/// A structure that labels or summarizes the topic of its related section. (Abstract)
+	/// </summary>
+	Sectionhead,
+
+	/// <summary>
+	/// A form widget that allows the user to make selections from a set of choices. (Abstract)
+	/// </summary>
+	Select,
+
+	/// <summary>
+	/// An interactive component of a graphical user interface (GUI). (Abstract)
+	/// </summary>
+	Widget,
+
+	/// <summary>
+	/// A browser or application window.
+	/// </summary>
+	Window,
+
+	/// <summary>
+	/// A landmark that contains mostly site-oriented content, rather than page-specific content.
+	/// </summary>
+	Banner,
+}
diff --git a/src/bunit.web.query/Roles/ByRoleOptions.cs b/src/bunit.web.query/Roles/ByRoleOptions.cs
new file mode 100644
index 000000000..aea7a637b
--- /dev/null
+++ b/src/bunit.web.query/Roles/ByRoleOptions.cs
@@ -0,0 +1,71 @@
+namespace Bunit;
+
+/// <summary>
+/// Allows overrides of behavior for FindByRole method.
+/// </summary>
+public record class ByRoleOptions
+{
+	/// <summary>
+	/// The default behavior used by FindByRole if no overrides are specified.
+	/// </summary>
+	internal static readonly ByRoleOptions Default = new();
+
+	/// <summary>
+	/// The StringComparison used for comparing the accessible name. Defaults to Ordinal (case sensitive).
+	/// </summary>
+	public StringComparison ComparisonType { get; set; } = StringComparison.Ordinal;
+
+	/// <summary>
+	/// If true, includes elements that are normally excluded from the accessibility tree.
+	/// Elements can be excluded via aria-hidden="true" or the hidden attribute.
+	/// Defaults to false.
+	/// </summary>
+	public bool Hidden { get; set; }
+
+	/// <summary>
+	/// Filters elements by their accessible name (e.g., aria-label, button text, label text).
+	/// When null, no filtering by name is applied.
+	/// </summary>
+	public string? Name { get; set; }
+
+	/// <summary>
+	/// Filters elements by their selected state (aria-selected).
+	/// Use for elements like tabs or options.
+	/// </summary>
+	public bool? Selected { get; set; }
+
+	/// <summary>
+	/// Filters elements by their checked state (aria-checked or native checked).
+	/// Use for checkboxes and radio buttons.
+	/// </summary>
+	public bool? Checked { get; set; }
+
+	/// <summary>
+	/// Filters elements by their pressed state (aria-pressed).
+	/// Use for toggle buttons.
+	/// </summary>
+	public bool? Pressed { get; set; }
+
+	/// <summary>
+	/// Filters elements by their current state (aria-current).
+	/// Can be true/false or a specific token like "page", "step", "location", "date", "time".
+	/// </summary>
+	public object? Current { get; set; }
+
+	/// <summary>
+	/// Filters elements by their expanded state (aria-expanded).
+	/// Use for elements like accordions, dropdowns, or tree items.
+	/// </summary>
+	public bool? Expanded { get; set; }
+
+	/// <summary>
+	/// Filters elements by their busy state (aria-busy).
+	/// </summary>
+	public bool? Busy { get; set; }
+
+	/// <summary>
+	/// Filters headings by their level (1-6).
+	/// Only applicable when searching for the "heading" role.
+	/// </summary>
+	public int? Level { get; set; }
+}
diff --git a/src/bunit.web.query/Roles/ImplicitRoleMapper.cs b/src/bunit.web.query/Roles/ImplicitRoleMapper.cs
new file mode 100644
index 000000000..bddadf806
--- /dev/null
+++ b/src/bunit.web.query/Roles/ImplicitRoleMapper.cs
@@ -0,0 +1,178 @@
+using AngleSharp.Dom;
+
+namespace Bunit;
+
+/// <summary>
+/// Maps HTML elements to their implicit ARIA roles.
+/// </summary>
+/// <remarks>
+/// See https://www.w3.org/TR/html-aria/ for the full specification.
+/// </remarks>
+internal static class ImplicitRoleMapper
+{
+	private static readonly string[] SectioningElements = ["ARTICLE", "ASIDE", "MAIN", "NAV", "SECTION"];
+
+	/// <summary>
+	/// Gets the implicit ARIA role for an HTML element.
+	/// </summary>
+	public static AriaRole? GetImplicitRole(IElement element)
+	{
+		var tagName = element.TagName.ToUpperInvariant();
+
+		return tagName switch
+		{
+			"A" when element.HasAttribute("href") => AriaRole.Link,
+			"AREA" when element.HasAttribute("href") => AriaRole.Link,
+			"ARTICLE" => AriaRole.Article,
+			"ASIDE" => AriaRole.Complementary,
+			"BUTTON" => AriaRole.Button,
+			"DATALIST" => AriaRole.Listbox,
+			"DETAILS" => AriaRole.Group,
+			"DIALOG" => AriaRole.Dialog,
+			"FIGURE" => AriaRole.Figure,
+			"FORM" => GetFormRoleWhenHasAccessibleName(element),
+			"FOOTER" => GetFooterRoleWhenNotInSectioningContent(element),
+			"H1" or "H2" or "H3" or "H4" or "H5" or "H6" => AriaRole.Heading,
+			"HEADER" => GetHeaderRoleWhenNotInSectioningContent(element),
+			"HR" => AriaRole.Separator,
+			"IMG" => GetImgRoleBasedOnAltAttribute(element),
+			"INPUT" => GetInputRole(element),
+			"LI" => AriaRole.Listitem,
+			"MAIN" => AriaRole.Main,
+			"MATH" => AriaRole.Math,
+			"MENU" => AriaRole.List,
+			"METER" => AriaRole.Meter,
+			"NAV" => AriaRole.Navigation,
+			"OL" => AriaRole.List,
+			"OPTGROUP" => AriaRole.Group,
+			"OPTION" => AriaRole.Option,
+			"OUTPUT" => AriaRole.Status,
+			"PROGRESS" => AriaRole.Progressbar,
+			"SECTION" => GetSectionRoleWhenHasAccessibleName(element),
+			"SELECT" => GetSelectRoleBasedOnMultipleOrSize(element),
+			"SUMMARY" => AriaRole.Button,
+			"TABLE" => AriaRole.Table,
+			"TBODY" or "TFOOT" or "THEAD" => AriaRole.RowGroup,
+			"TD" => AriaRole.Cell,
+			"TEXTAREA" => AriaRole.Textbox,
+			"TH" => GetThRoleBasedOnScopeAndContext(element),
+			"TR" => AriaRole.Row,
+			"UL" => AriaRole.List,
+			_ => null
+		};
+	}
+
+	/// <summary>
+	/// Gets the heading level for heading elements.
+	/// </summary>
+	public static int? GetHeadingLevel(IElement element)
+	{
+		var explicitAriaLevel = element.GetAttribute("aria-level");
+		if (!string.IsNullOrWhiteSpace(explicitAriaLevel) && int.TryParse(explicitAriaLevel, out var level))
+		{
+			return level;
+		}
+
+		return element.TagName.ToUpperInvariant() switch
+		{
+			"H1" => 1,
+			"H2" => 2,
+			"H3" => 3,
+			"H4" => 4,
+			"H5" => 5,
+			"H6" => 6,
+			_ => null
+		};
+	}
+
+	private static AriaRole? GetFormRoleWhenHasAccessibleName(IElement element) =>
+		HasAccessibleName(element) ? AriaRole.Form : null;
+
+	private static AriaRole? GetFooterRoleWhenNotInSectioningContent(IElement element) =>
+		IsDescendantOfSectioningContent(element) ? null : AriaRole.ContentInfo;
+
+	private static AriaRole? GetHeaderRoleWhenNotInSectioningContent(IElement element) =>
+		IsDescendantOfSectioningContent(element) ? null : AriaRole.Banner;
+
+	private static AriaRole? GetImgRoleBasedOnAltAttribute(IElement element)
+	{
+		var alt = element.GetAttribute("alt");
+		var hasEmptyAltForDecorativeImage = alt is { Length: 0 };
+		return hasEmptyAltForDecorativeImage ? AriaRole.Presentation : AriaRole.Img;
+	}
+
+	private static AriaRole? GetInputRole(IElement element)
+	{
+		var type = element.GetAttribute("type")?.ToUpperInvariant() ?? "TEXT";
+
+		return type switch
+		{
+			"BUTTON" or "IMAGE" or "RESET" or "SUBMIT" => AriaRole.Button,
+			"CHECKBOX" => AriaRole.Checkbox,
+			"EMAIL" or "TEL" or "TEXT" or "URL" => GetTextInputRoleBasedOnDatalist(element, AriaRole.Textbox),
+			"NUMBER" => AriaRole.Spinbutton,
+			"RADIO" => AriaRole.Radio,
+			"RANGE" => AriaRole.Slider,
+			"SEARCH" => GetTextInputRoleBasedOnDatalist(element, AriaRole.Searchbox),
+			_ => null
+		};
+	}
+
+	private static AriaRole GetTextInputRoleBasedOnDatalist(IElement element, AriaRole defaultRole)
+	{
+		var listAttributeId = element.GetAttribute("list");
+		if (string.IsNullOrWhiteSpace(listAttributeId))
+			return defaultRole;
+
+		var hasAssociatedDatalist = element.Owner?.GetElementById(listAttributeId) != null;
+		return hasAssociatedDatalist ? AriaRole.Combobox : defaultRole;
+	}
+
+	private static AriaRole? GetSectionRoleWhenHasAccessibleName(IElement element) =>
+		HasAccessibleName(element) ? AriaRole.Region : null;
+
+	private static AriaRole GetSelectRoleBasedOnMultipleOrSize(IElement element)
+	{
+		if (element.HasAttribute("multiple"))
+			return AriaRole.Listbox;
+
+		var size = element.GetAttribute("size");
+		var hasMultipleVisibleOptions = !string.IsNullOrWhiteSpace(size)
+			&& int.TryParse(size, out var sizeValue)
+			&& sizeValue > 1;
+
+		return hasMultipleVisibleOptions ? AriaRole.Listbox : AriaRole.Combobox;
+	}
+
+	private static AriaRole GetThRoleBasedOnScopeAndContext(IElement element)
+	{
+		var scope = element.GetAttribute("scope")?.ToUpperInvariant();
+		if (scope == "ROW")
+		{
+			return AriaRole.RowHeader;
+		}
+
+		var isInTableHeader = element.Closest("thead") != null;
+		return isInTableHeader ? AriaRole.ColumnHeader : AriaRole.Cell;
+	}
+
+	private static bool HasAccessibleName(IElement element)
+	{
+		return !string.IsNullOrWhiteSpace(element.GetAttribute("aria-label"))
+			|| !string.IsNullOrWhiteSpace(element.GetAttribute("aria-labelledby"))
+			|| !string.IsNullOrWhiteSpace(element.GetAttribute("title"));
+	}
+
+	private static bool IsDescendantOfSectioningContent(IElement element)
+	{
+		var parent = element.ParentElement;
+		while (parent != null)
+		{
+			if (SectioningElements.Contains(parent.TagName.ToUpperInvariant()))
+				return true;
+			parent = parent.ParentElement;
+		}
+
+		return false;
+	}
+}
diff --git a/src/bunit.web.query/Roles/RoleElementExtensions.cs b/src/bunit.web.query/Roles/RoleElementExtensions.cs
new file mode 100644
index 000000000..a31489332
--- /dev/null
+++ b/src/bunit.web.query/Roles/RoleElementExtensions.cs
@@ -0,0 +1,193 @@
+using AngleSharp.Dom;
+
+namespace Bunit;
+
+/// <summary>
+/// Provides helper methods for checking element state related to ARIA roles.
+/// </summary>
+internal static class RoleElementExtensions
+{
+	private const string AriaHiddenTrue = "true";
+
+	/// <summary>
+	/// Determines if an element is hidden from the accessibility tree.
+	/// </summary>
+	public static bool IsHiddenFromAccessibilityTree(this IElement element)
+	{
+		return HasAriaHiddenTrue(element)
+		       || element.HasAttribute("hidden")
+		       || HasHiddenAncestor(element);
+	}
+
+	/// <summary>
+	/// Gets the checked state of an element.
+	/// </summary>
+	public static bool? GetCheckedState(this IElement element)
+	{
+		var ariaChecked = element.GetAttribute("aria-checked");
+		return !string.IsNullOrWhiteSpace(ariaChecked)
+			? ParseTriStateBoolean(ariaChecked)
+			: GetNativeCheckedStateForCheckboxOrRadio(element);
+	}
+
+	/// <summary>
+	/// Gets the selected state of an element.
+	/// </summary>
+	public static bool? GetSelectedState(this IElement element)
+	{
+		var ariaSelected = element.GetAttribute("aria-selected");
+		return !string.IsNullOrWhiteSpace(ariaSelected)
+			? ParseBooleanAttribute(ariaSelected)
+			: GetNativeSelectedStateForOption(element);
+	}
+
+	/// <summary>
+	/// Gets the pressed state of an element.
+	/// </summary>
+	public static bool? GetPressedState(this IElement element)
+	{
+		var ariaPressed = element.GetAttribute("aria-pressed");
+		return string.IsNullOrWhiteSpace(ariaPressed)
+			? null
+			: ParseTriStateBoolean(ariaPressed);
+	}
+
+	/// <summary>
+	/// Gets the expanded state of an element.
+	/// </summary>
+	public static bool? GetExpandedState(this IElement element)
+	{
+		var ariaExpanded = element.GetAttribute("aria-expanded");
+		return !string.IsNullOrWhiteSpace(ariaExpanded)
+			? ParseBooleanAttribute(ariaExpanded)
+			: GetNativeExpandedStateForDetails(element);
+	}
+
+	/// <summary>
+	/// Gets the busy state of an element.
+	/// </summary>
+	public static bool? GetBusyState(this IElement element)
+	{
+		var ariaBusy = element.GetAttribute("aria-busy");
+		return string.IsNullOrWhiteSpace(ariaBusy) ? null : ParseBooleanAttribute(ariaBusy);
+	}
+
+	/// <summary>
+	/// Gets the current state of an element.
+	/// </summary>
+	public static object? GetCurrentState(this IElement element)
+	{
+		var ariaCurrent = element.GetAttribute("aria-current");
+		if (string.IsNullOrWhiteSpace(ariaCurrent))
+		{
+			return null;
+		}
+
+		return ariaCurrent.ToUpperInvariant() switch
+		{
+			"TRUE" => true,
+			"FALSE" => false,
+			_ => ariaCurrent
+		};
+	}
+
+	/// <summary>
+	/// Gets the explicit role of an element from the role attribute.
+	/// </summary>
+	public static AriaRole? GetExplicitRole(this IElement element)
+	{
+		var role = element.GetAttribute("role");
+		if (string.IsNullOrWhiteSpace(role))
+		{
+			return null;
+		}
+
+		var firstRole = role.Split(' ', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
+		if (string.IsNullOrWhiteSpace(firstRole))
+		{
+			return null;
+		}
+
+		return Enum.TryParse<AriaRole>(firstRole, ignoreCase: true, out var ariaRole)
+			? ariaRole
+			: null;
+	}
+
+	/// <summary>
+	/// Gets the role of an element, checking explicit role first, then implicit role.
+	/// </summary>
+	public static AriaRole? GetRole(this IElement element)
+	{
+		return element.GetExplicitRole() ?? ImplicitRoleMapper.GetImplicitRole(element);
+	}
+
+	private static bool HasAriaHiddenTrue(IElement element) =>
+		element.GetAttribute("aria-hidden") == AriaHiddenTrue;
+
+	private static bool HasHiddenAncestor(IElement element)
+	{
+		var parent = element.ParentElement;
+		while (parent != null)
+		{
+			if (parent.GetAttribute("aria-hidden") == AriaHiddenTrue || parent.HasAttribute("hidden"))
+			{
+				return true;
+			}
+
+			parent = parent.ParentElement;
+		}
+
+		return false;
+	}
+
+	private static bool? ParseTriStateBoolean(string value)
+	{
+		return value.ToUpperInvariant() switch
+		{
+			"TRUE" => true,
+			"FALSE" => false,
+			"MIXED" => null,
+			_ => null
+		};
+	}
+
+	private static bool? ParseBooleanAttribute(string value)
+	{
+		return value.ToUpperInvariant() switch
+		{
+			"TRUE" => true,
+			"FALSE" => false,
+			_ => null
+		};
+	}
+
+	private static bool? GetNativeCheckedStateForCheckboxOrRadio(IElement element)
+	{
+		if (!element.TagName.Equals("INPUT", StringComparison.OrdinalIgnoreCase))
+		{
+			return null;
+		}
+
+		var type = element.GetAttribute("type")?.ToUpperInvariant();
+		if (type is not ("CHECKBOX" or "RADIO"))
+		{
+			return null;
+		}
+
+		return element.HasAttribute("checked");
+	}
+
+	private static bool? GetNativeSelectedStateForOption(IElement element)
+	{
+		return !element.TagName.Equals("OPTION", StringComparison.OrdinalIgnoreCase)
+			? null
+			: element.HasAttribute("selected");
+	}
+
+	private static bool? GetNativeExpandedStateForDetails(IElement element)
+	{
+		return !element.TagName.Equals("DETAILS", StringComparison.OrdinalIgnoreCase)
+			? null
+			: element.HasAttribute("open");
+	}
+}
diff --git a/src/bunit.web.query/Roles/RoleNotFoundException.cs b/src/bunit.web.query/Roles/RoleNotFoundException.cs
new file mode 100644
index 000000000..efdb8cf72
--- /dev/null
+++ b/src/bunit.web.query/Roles/RoleNotFoundException.cs
@@ -0,0 +1,38 @@
+namespace Bunit;
+
+/// <summary>
+/// Represents a failure to find an element in the searched target
+/// using the specified role.
+/// </summary>
+public sealed class RoleNotFoundException : Exception
+{
+	/// <summary>
+	/// Gets the role used to search with.
+	/// </summary>
+	public AriaRole Role { get; }
+
+	/// <summary>
+	/// Gets the accessible name filter that was applied, if any.
+	/// </summary>
+	public string? AccessibleName { get; }
+
+	/// <summary>
+	/// Initializes a new instance of the <see cref="RoleNotFoundException"/> class.
+	/// </summary>
+	/// <param name="role">The role that was searched for.</param>
+	/// <param name="accessibleName">The accessible name filter that was applied, if any.</param>
+	public RoleNotFoundException(AriaRole role, string? accessibleName = null)
+		: base(CreateMessage(role, accessibleName))
+	{
+		Role = role;
+		AccessibleName = accessibleName;
+	}
+
+	private static string CreateMessage(AriaRole role, string? accessibleName)
+	{
+		var roleString = role.ToString();
+		return accessibleName is not null
+			? $"Unable to find an element with the role '{roleString}' and accessible name '{accessibleName}'."
+			: $"Unable to find an element with the role '{roleString}'.";
+	}
+}
diff --git a/src/bunit.web.query/Roles/RoleQueryExtensions.cs b/src/bunit.web.query/Roles/RoleQueryExtensions.cs
new file mode 100644
index 000000000..e8d80e199
--- /dev/null
+++ b/src/bunit.web.query/Roles/RoleQueryExtensions.cs
@@ -0,0 +1,154 @@
+using AngleSharp.Dom;
+using Bunit.Web.AngleSharp;
+
+namespace Bunit;
+
+/// <summary>
+/// Extension methods for querying <see cref="IRenderedComponent{TComponent}" /> by ARIA role.
+/// </summary>
+public static class RoleQueryExtensions
+{
+	/// <summary>
+	/// Returns the first element with the specified ARIA role.
+	/// </summary>
+	/// <param name="renderedComponent">The rendered fragment to search.</param>
+	/// <param name="role">The ARIA role to search for (e.g., AriaRole.Button, AriaRole.Link).</param>
+	/// <param name="configureOptions">Method used to override the default behavior of FindByRole.</param>
+	/// <returns>The first element matching the specified role and options.</returns>
+	/// <exception cref="RoleNotFoundException">Thrown when no element matching the role is found.</exception>
+	public static IElement FindByRole(this IRenderedComponent<IComponent> renderedComponent, AriaRole role, Action<ByRoleOptions>? configureOptions = null)
+	{
+		var options = ByRoleOptions.Default;
+		if (configureOptions is not null)
+		{
+			options = options with { };
+			configureOptions.Invoke(options);
+		}
+
+		return FindByRoleInternal(renderedComponent, role, options) ?? throw new RoleNotFoundException(role, options.Name);
+	}
+
+	/// <summary>
+	/// Returns all elements with the specified ARIA role.
+	/// </summary>
+	/// <param name="renderedComponent">The rendered fragment to search.</param>
+	/// <param name="role">The ARIA role to search for (e.g., AriaRole.Button, AriaRole.Link).</param>
+	/// <param name="configureOptions">Method used to override the default behavior of FindAllByRole.</param>
+	/// <returns>A read-only collection of elements matching the role. Returns an empty collection if no matches are found.</returns>
+	public static IReadOnlyList<IElement> FindAllByRole(this IRenderedComponent<IComponent> renderedComponent, AriaRole role, Action<ByRoleOptions>? configureOptions = null)
+	{
+		ArgumentNullException.ThrowIfNull(renderedComponent);
+
+		var options = ByRoleOptions.Default;
+		if (configureOptions is not null)
+		{
+			options = options with { };
+			configureOptions.Invoke(options);
+		}
+
+		return FindAllByRoleInternal(renderedComponent, role, options);
+	}
+
+	private static IElement? FindByRoleInternal(IRenderedComponent<IComponent> renderedComponent, AriaRole role, ByRoleOptions options)
+	{
+		var results = FindAllByRoleInternal(renderedComponent, role, options);
+		return results.Count > 0 ? results[0] : null;
+	}
+
+	private static List<IElement> FindAllByRoleInternal(IRenderedComponent<IComponent> renderedComponent, AriaRole role, ByRoleOptions options)
+	{
+		var allElements = renderedComponent.Nodes.TryQuerySelectorAll("*");
+		var results = new List<IElement>();
+		var seen = new HashSet<IElement>();
+
+		foreach (var element in allElements)
+		{
+			if (!MatchesRole(element, role, options))
+				continue;
+
+			// Deduplicate using the underlying element
+			var underlyingElement = element.Unwrap();
+			if (seen.Add(underlyingElement))
+			{
+				results.Add(element);
+			}
+		}
+
+		return results;
+	}
+
+	private static bool MatchesRole(IElement element, AriaRole role, ByRoleOptions options)
+	{
+		if (!options.Hidden && element.IsHiddenFromAccessibilityTree())
+			return false;
+
+		var elementRole = element.GetRole();
+		if (elementRole != role)
+			return false;
+
+		if (options.Name is not null)
+		{
+			var accessibleName = AccessibleNameComputation.GetAccessibleName(element);
+			if (accessibleName is null || !accessibleName.Equals(options.Name, options.ComparisonType))
+				return false;
+		}
+
+		if (options.Level.HasValue)
+		{
+			if (role != AriaRole.Heading)
+				return false;
+
+			var level = ImplicitRoleMapper.GetHeadingLevel(element);
+			if (level != options.Level.Value)
+				return false;
+		}
+
+		if (options.Checked.HasValue)
+		{
+			var checkedState = element.GetCheckedState();
+			if (checkedState != options.Checked.Value)
+				return false;
+		}
+
+		if (options.Selected.HasValue)
+		{
+			var selectedState = element.GetSelectedState();
+			if (selectedState != options.Selected.Value)
+				return false;
+		}
+
+		if (options.Pressed.HasValue)
+		{
+			var pressedState = element.GetPressedState();
+			if (pressedState != options.Pressed.Value)
+				return false;
+		}
+
+		if (options.Expanded.HasValue)
+		{
+			var expandedState = element.GetExpandedState();
+			if (expandedState != options.Expanded.Value)
+				return false;
+		}
+
+		if (options.Busy.HasValue)
+		{
+			var busyState = element.GetBusyState();
+			if (busyState != options.Busy.Value)
+				return false;
+		}
+
+		if (options.Current is not null)
+		{
+			var currentState = element.GetCurrentState();
+			switch (options.Current)
+			{
+				case bool currentBool when !Equals(currentState, currentBool):
+				case string currentString when !currentString.Equals(currentState as string, options.ComparisonType):
+					return false;
+			}
+		}
+
+		return true;
+	}
+}
diff --git a/src/bunit/BunitContext.Obsoletes.cs b/src/bunit/BunitContext.Obsoletes.cs
index 121e95636..07ddb1caa 100644
--- a/src/bunit/BunitContext.Obsoletes.cs
+++ b/src/bunit/BunitContext.Obsoletes.cs
@@ -1,5 +1,6 @@
 namespace Bunit;
 
+[RemovedInFutureVersion("Obsolete in v2, removed in future version")]
 public partial class BunitContext
 {
 	/// <summary>
diff --git a/src/bunit/TestContext.cs b/src/bunit/TestContext.cs
index 2f3ad5022..615dc0599 100644
--- a/src/bunit/TestContext.cs
+++ b/src/bunit/TestContext.cs
@@ -2,6 +2,7 @@ namespace Bunit;
 
 /// <inheritdoc />
 [Obsolete($"Use {nameof(BunitContext)} instead. TestContext will be removed in a future release.", false, UrlFormat = "https://bunit.dev/docs/migrations")]
+[RemovedInFutureVersion("Obsolete in v2, removed in future version")]
 public class TestContext : BunitContext
 {
 }
diff --git a/tests/bunit.web.query.tests/Roles/RoleQueryExtensionsTest.cs b/tests/bunit.web.query.tests/Roles/RoleQueryExtensionsTest.cs
new file mode 100644
index 000000000..68cacc214
--- /dev/null
+++ b/tests/bunit.web.query.tests/Roles/RoleQueryExtensionsTest.cs
@@ -0,0 +1,825 @@
+namespace Bunit.Roles;
+
+public class RoleQueryExtensionsTest : BunitContext
+{
+	[Fact(DisplayName = "Should return element with explicit role attribute")]
+	public void Test001()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<div role="button">Click me</div>"""));
+
+		var element = cut.FindByRole(AriaRole.Button);
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Click me");
+	}
+
+	[Fact(DisplayName = "Should throw RoleNotFoundException when role does not exist")]
+	public void Test002()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<div>Just a div</div>"""));
+
+		var exception = Should.Throw<RoleNotFoundException>(() => cut.FindByRole(AriaRole.Button));
+		exception.Role.ShouldBe(AriaRole.Button);
+	}
+
+	[Fact(DisplayName = "FindAllByRole should return empty collection when no matches")]
+	public void Test003()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<div>Just a div</div>"""));
+
+		var elements = cut.FindAllByRole(AriaRole.Button);
+
+		elements.ShouldBeEmpty();
+	}
+
+	[Fact(DisplayName = "FindAllByRole should return all matching elements")]
+	public void Test004()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<button>Button 1</button>
+				<button>Button 2</button>
+				<button>Button 3</button>
+			"""));
+
+		var elements = cut.FindAllByRole(AriaRole.Button);
+
+		elements.Count.ShouldBe(3);
+	}	[Fact(DisplayName = "Should find button element by implicit button role")]
+	public void Test010()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<button>Click me</button>"""));
+
+		var element = cut.FindByRole(AriaRole.Button);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("BUTTON", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find input type=button by implicit button role")]
+	public void Test011()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<input type="button" value="Click me" />"""));
+
+		var element = cut.FindByRole(AriaRole.Button);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("type").ShouldBe("button");
+	}
+
+	[Fact(DisplayName = "Should find input type=submit by implicit button role")]
+	public void Test012()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<input type="submit" value="Submit" />"""));
+
+		var element = cut.FindByRole(AriaRole.Button);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("type").ShouldBe("submit");
+	}
+
+	[Fact(DisplayName = "Should find input type=reset by implicit button role")]
+	public void Test013()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<input type="reset" value="Reset" />"""));
+
+		var element = cut.FindByRole(AriaRole.Button);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("type").ShouldBe("reset");
+	}
+
+	[Fact(DisplayName = "Should find summary element by implicit button role")]
+	public void Test014()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<details><summary>Details</summary>Content</details>"""));
+
+		var element = cut.FindByRole(AriaRole.Button);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("SUMMARY", StringCompareShould.IgnoreCase);
+	}
+	
+	[Fact(DisplayName = "Should find anchor with href by implicit link role")]
+	public void Test020()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<a href="/home">Home</a>"""));
+
+		var element = cut.FindByRole(AriaRole.Link);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("A", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should not find anchor without href by link role")]
+	public void Test021()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<a>Not a link</a>"""));
+
+		var elements = cut.FindAllByRole(AriaRole.Link);
+
+		elements.ShouldBeEmpty();
+	}
+
+	[Theory(DisplayName = "Should find heading elements by implicit heading role")]
+	[InlineData("h1")]
+	[InlineData("h2")]
+	[InlineData("h3")]
+	[InlineData("h4")]
+	[InlineData("h5")]
+	[InlineData("h6")]
+	public void Test030(string headingTag)
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent($"<{headingTag}>Heading</{headingTag}>"));
+
+		var element = cut.FindByRole(AriaRole.Heading);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe(headingTag, StringCompareShould.IgnoreCase);
+	}
+
+	[Theory(DisplayName = "Should filter headings by level option")]
+	[InlineData(1, "h1")]
+	[InlineData(2, "h2")]
+	[InlineData(3, "h3")]
+	[InlineData(4, "h4")]
+	[InlineData(5, "h5")]
+	[InlineData(6, "h6")]
+	public void Test031(int level, string expectedTag)
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<h1>Level 1</h1>
+				<h2>Level 2</h2>
+				<h3>Level 3</h3>
+				<h4>Level 4</h4>
+				<h5>Level 5</h5>
+				<h6>Level 6</h6>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Heading, o => o.Level = level);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe(expectedTag, StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find all headings when no level specified")]
+	public void Test032()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<h1>Level 1</h1>
+				<h2>Level 2</h2>
+				<h3>Level 3</h3>
+			"""));
+
+		var elements = cut.FindAllByRole(AriaRole.Heading);
+
+		elements.Count.ShouldBe(3);
+	}
+
+	[Fact(DisplayName = "Should respect aria-level attribute for heading level")]
+	public void Test033()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<div role="heading" aria-level="2">Custom Heading</div>"""));
+
+		var element = cut.FindByRole(AriaRole.Heading, o => o.Level = 2);
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Custom Heading");
+	}
+	
+	[Fact(DisplayName = "Should find checkbox input by implicit checkbox role")]
+	public void Test040()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<input type="checkbox" />"""));
+
+		var element = cut.FindByRole(AriaRole.Checkbox);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("type").ShouldBe("checkbox");
+	}
+
+	[Fact(DisplayName = "Should filter checkbox by checked state")]
+	public void Test041()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<input type="checkbox" id="unchecked" />
+				<input type="checkbox" id="checked" checked />
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Checkbox, o => o.Checked = true);
+
+		element.ShouldNotBeNull();
+		element.Id.ShouldBe("checked");
+	}
+
+	[Fact(DisplayName = "Should filter checkbox by unchecked state")]
+	public void Test042()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<input type="checkbox" id="unchecked" />
+				<input type="checkbox" id="checked" checked />
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Checkbox, o => o.Checked = false);
+
+		element.ShouldNotBeNull();
+		element.Id.ShouldBe("unchecked");
+	}
+
+	[Fact(DisplayName = "Should find radio input by implicit radio role")]
+	public void Test050()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<input type="radio" name="choice" />"""));
+
+		var element = cut.FindByRole(AriaRole.Radio);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("type").ShouldBe("radio");
+	}
+
+	[Fact(DisplayName = "Should find text input by implicit textbox role")]
+	public void Test060()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<input type="text" />"""));
+
+		var element = cut.FindByRole(AriaRole.Textbox);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("type").ShouldBe("text");
+	}
+
+	[Fact(DisplayName = "Should find textarea by implicit textbox role")]
+	public void Test061()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<textarea></textarea>"""));
+
+		var element = cut.FindByRole(AriaRole.Textbox);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("TEXTAREA", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find email input by implicit textbox role")]
+	public void Test062()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<input type="email" />"""));
+
+		var element = cut.FindByRole(AriaRole.Textbox);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("type").ShouldBe("email");
+	}
+
+	[Theory(DisplayName = "Should find list elements by implicit list role")]
+	[InlineData("ul")]
+	[InlineData("ol")]
+	public void Test070(string listTag)
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent($"<{listTag}><li>Item</li></{listTag}>"));
+
+		var element = cut.FindByRole(AriaRole.List);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe(listTag, StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find li element by implicit listitem role")]
+	public void Test071()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<ul><li>Item</li></ul>"""));
+
+		var element = cut.FindByRole(AriaRole.Listitem);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("LI", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find nav element by implicit navigation role")]
+	public void Test080()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<nav><a href="/">Home</a></nav>"""));
+
+		var element = cut.FindByRole(AriaRole.Navigation);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("NAV", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find main element by implicit main role")]
+	public void Test081()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<main>Content</main>"""));
+
+		var element = cut.FindByRole(AriaRole.Main);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("MAIN", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find aside element by implicit complementary role")]
+	public void Test082()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<aside>Sidebar</aside>"""));
+
+		var element = cut.FindByRole(AriaRole.Complementary);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("ASIDE", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should filter by accessible name from aria-label")]
+	public void Test090()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<button aria-label="Submit form">Submit</button>
+				<button aria-label="Cancel form">Cancel</button>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Button, o => o.Name = "Submit form");
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Submit");
+	}
+
+	[Fact(DisplayName = "Should filter by accessible name from button text content")]
+	public void Test091()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<button>Submit</button>
+				<button>Cancel</button>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Button, o => o.Name = "Submit");
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Submit");
+	}
+
+	[Fact(DisplayName = "Should filter by accessible name from aria-labelledby")]
+	public void Test092()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<span id="label1">First Label</span>
+				<button aria-labelledby="label1">Button 1</button>
+				<span id="label2">Second Label</span>
+				<button aria-labelledby="label2">Button 2</button>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Button, o => o.Name = "First Label");
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Button 1");
+	}
+
+	[Fact(DisplayName = "Should throw RoleNotFoundException when name does not match")]
+	public void Test093()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<button>Submit</button>"""));
+
+		var exception = Should.Throw<RoleNotFoundException>(() =>
+			cut.FindByRole(AriaRole.Button, o => o.Name = "NonExistent"));
+		exception.AccessibleName.ShouldBe("NonExistent");
+	}
+
+	[Theory(DisplayName = "Should respect ComparisonType for name filter")]
+	[InlineData(StringComparison.OrdinalIgnoreCase, true)]
+	[InlineData(StringComparison.Ordinal, false)]
+	public void Test094(StringComparison comparison, bool shouldFind)
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<button>Submit</button>"""));
+
+		if (shouldFind)
+		{
+			var element = cut.FindByRole(AriaRole.Button, o =>
+			{
+				o.Name = "SUBMIT";
+				o.ComparisonType = comparison;
+			});
+			element.ShouldNotBeNull();
+		}
+		else
+		{
+			Should.Throw<RoleNotFoundException>(() =>
+				cut.FindByRole(AriaRole.Button, o =>
+				{
+					o.Name = "SUBMIT";
+					o.ComparisonType = comparison;
+				}));
+		}
+	}
+
+	[Fact(DisplayName = "Should filter by accessible name from linked label")]
+	public void Test095()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<label for="email">Email Address</label>
+				<input type="text" id="email" />
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Textbox, o => o.Name = "Email Address");
+
+		element.ShouldNotBeNull();
+		element.Id.ShouldBe("email");
+	}
+
+	[Fact(DisplayName = "Should exclude aria-hidden elements by default")]
+	public void Test100()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<button aria-hidden="true">Hidden</button>
+				<button>Visible</button>
+			"""));
+
+		var elements = cut.FindAllByRole(AriaRole.Button);
+
+		elements.Count.ShouldBe(1);
+		elements[0].TextContent.ShouldBe("Visible");
+	}
+
+	[Fact(DisplayName = "Should include aria-hidden elements when Hidden option is true")]
+	public void Test101()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<button aria-hidden="true">Hidden</button>
+				<button>Visible</button>
+			"""));
+
+		var elements = cut.FindAllByRole(AriaRole.Button, o => o.Hidden = true);
+
+		elements.Count.ShouldBe(2);
+	}
+
+	[Fact(DisplayName = "Should exclude elements with hidden attribute by default")]
+	public void Test102()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<button hidden>Hidden</button>
+				<button>Visible</button>
+			"""));
+
+		var elements = cut.FindAllByRole(AriaRole.Button);
+
+		elements.Count.ShouldBe(1);
+		elements[0].TextContent.ShouldBe("Visible");
+	}
+
+	[Fact(DisplayName = "Should filter by pressed state")]
+	public void Test110()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<button aria-pressed="true">Pressed</button>
+				<button aria-pressed="false">Not Pressed</button>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Button, o => o.Pressed = true);
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Pressed");
+	}
+
+	[Fact(DisplayName = "Should filter by expanded state")]
+	public void Test120()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<button aria-expanded="true">Expanded</button>
+				<button aria-expanded="false">Collapsed</button>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Button, o => o.Expanded = true);
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Expanded");
+	}
+
+	[Fact(DisplayName = "Should detect expanded state from details open attribute")]
+	public void Test121()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<details open>
+					<summary>Open Details</summary>
+					Content
+				</details>
+				<details>
+					<summary>Closed Details</summary>
+					Content
+				</details>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Group, o => o.Expanded = true);
+
+		element.ShouldNotBeNull();
+		element.HasAttribute("open").ShouldBeTrue();
+	}
+
+	[Fact(DisplayName = "Should filter by selected state")]
+	public void Test130()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<div role="tablist">
+					<button role="tab" aria-selected="true">Tab 1</button>
+					<button role="tab" aria-selected="false">Tab 2</button>
+				</div>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Tab, o => o.Selected = true);
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Tab 1");
+	}
+
+	[Fact(DisplayName = "Should filter by busy state")]
+	public void Test140()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<button aria-busy="true">Loading</button>
+				<button aria-busy="false">Ready</button>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Button, o => o.Busy = true);
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Loading");
+	}
+
+	[Fact(DisplayName = "Should filter by current state with boolean")]
+	public void Test150()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<a href="/" aria-current="true">Current</a>
+				<a href="/about" aria-current="false">About</a>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Link, o => o.Current = true);
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Current");
+	}
+
+	[Fact(DisplayName = "Should filter by current state with token value")]
+	public void Test151()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<a href="/" aria-current="page">Home</a>
+				<a href="/about" aria-current="false">About</a>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Link, o => o.Current = "page");
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Home");
+	}
+
+	[Fact(DisplayName = "Should combine multiple filters")]
+	public void Test160()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<button aria-pressed="true">Bold</button>
+				<button aria-pressed="false">Italic</button>
+				<button aria-pressed="true">Underline</button>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Button, o =>
+		{
+			o.Pressed = true;
+			o.Name = "Bold";
+		});
+
+		element.ShouldNotBeNull();
+		element.TextContent.ShouldBe("Bold");
+	}
+
+	[Fact(DisplayName = "Should find elements by combobox role for select")]
+	public void Test170()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<select>
+					<option>Option 1</option>
+					<option>Option 2</option>
+				</select>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Combobox);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("SELECT", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find elements by listbox role for select with multiple")]
+	public void Test171()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<select multiple>
+					<option>Option 1</option>
+					<option>Option 2</option>
+				</select>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Listbox);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("SELECT", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find img element by img role")]
+	public void Test180()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<img src="test.png" alt="Test image" />"""));
+
+		var element = cut.FindByRole(AriaRole.Img);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("alt").ShouldBe("Test image");
+	}
+
+	[Fact(DisplayName = "Should find img with empty alt as presentation role")]
+	public void Test181()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<img src="test.png" alt="" />"""));
+
+		var element = cut.FindByRole(AriaRole.Presentation);
+
+		element.ShouldNotBeNull();
+	}
+
+	[Fact(DisplayName = "Should filter img by accessible name from alt")]
+	public void Test182()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<img src="logo.png" alt="Company Logo" />
+				<img src="banner.png" alt="Banner Image" />
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Img, o => o.Name = "Company Logo");
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("src").ShouldBe("logo.png");
+	}
+
+	[Fact(DisplayName = "Should find table element by table role")]
+	public void Test190()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<table>
+					<tr><th>Header</th></tr>
+					<tr><td>Cell</td></tr>
+				</table>
+			"""));
+
+		var element = cut.FindByRole(AriaRole.Table);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("TABLE", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find row elements by row role")]
+	public void Test191()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<table>
+					<tr><td>Row 1</td></tr>
+					<tr><td>Row 2</td></tr>
+				</table>
+			"""));
+
+		var elements = cut.FindAllByRole(AriaRole.Row);
+
+		elements.Count.ShouldBe(2);
+	}
+
+	[Fact(DisplayName = "Should find cell elements by cell role")]
+	public void Test192()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""
+				<table>
+					<tr><td>Cell 1</td><td>Cell 2</td></tr>
+				</table>
+			"""));
+
+		var elements = cut.FindAllByRole(AriaRole.Cell);
+
+		elements.Count.ShouldBe(2);
+	}
+
+	[Fact(DisplayName = "Should find progress element by progressbar role")]
+	public void Test200()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<progress value="50" max="100">50%</progress>"""));
+
+		var element = cut.FindByRole(AriaRole.Progressbar);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("PROGRESS", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find meter element by meter role")]
+	public void Test201()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<meter value="0.6">60%</meter>"""));
+
+		var element = cut.FindByRole(AriaRole.Meter);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("METER", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find slider input by slider role")]
+	public void Test202()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<input type="range" min="0" max="100" />"""));
+
+		var element = cut.FindByRole(AriaRole.Slider);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("type").ShouldBe("range");
+	}
+
+	[Fact(DisplayName = "Should find spinbutton input by spinbutton role")]
+	public void Test203()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<input type="number" />"""));
+
+		var element = cut.FindByRole(AriaRole.Spinbutton);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("type").ShouldBe("number");
+	}
+
+	[Fact(DisplayName = "Should find dialog element by dialog role")]
+	public void Test210()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<dialog open>Dialog content</dialog>"""));
+
+		var element = cut.FindByRole(AriaRole.Dialog);
+
+		element.ShouldNotBeNull();
+		element.TagName.ShouldBe("DIALOG", StringCompareShould.IgnoreCase);
+	}
+
+	[Fact(DisplayName = "Should find search input by searchbox role")]
+	public void Test220()
+	{
+		var cut = Render<Wrapper>(ps =>
+			ps.AddChildContent("""<input type="search" />"""));
+
+		var element = cut.FindByRole(AriaRole.Searchbox);
+
+		element.ShouldNotBeNull();
+		element.GetAttribute("type").ShouldBe("search");
+	}
+}