DioxusLabs · nicoburns · Sep 7, 2026 · Aug 21, 2026 · Aug 21, 2026 · Sep 2, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -188,6 +188,7 @@ smol_str = "0.3"
 bitflags = "2.8.0"
 bytemuck = "1"
 rayon = "1"
+test-that = "0.5.2"
 thread_local = "1"
 
 [profile.profile]

diff --git a/packages/blitz-dom/src/accessibility.rs b/packages/blitz-dom/src/accessibility.rs
@@ -1,12 +1,23 @@
 use crate::{BaseDocument, ElementData, Node as BlitzDomNode, local_name};
 use accesskit::{Node as AccessKitNode, NodeId, Role, Tree, TreeId, TreeUpdate};
+use style::properties::longhands::visibility;
 
 impl BaseDocument {
     pub fn build_accessibility_tree(&self) -> TreeUpdate {
         let mut nodes = std::collections::HashMap::new();
         let mut window = AccessKitNode::new(Role::Window);
+        let mut hidden_nodes = std::collections::HashSet::new();
 
         self.visit(|node_id, node| {
+            if node.is_hidden_from_accessibility_tree()
+                || node
+                    .parent
+                    .map(|p| hidden_nodes.contains(&p))
+                    .unwrap_or(false)
+            {
+                hidden_nodes.insert(node_id);
+                return;
+            }
             let parent = node
                 .parent
                 .and_then(|parent_id| nodes.get_mut(&parent_id))
@@ -55,6 +66,11 @@ impl BaseDocument {
 
             builder.set_role(role);
             builder.set_html_tag(name);
+
+            // https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion
+            if element_data.attr(local_name!("aria-hidden")) == Some("true") {
+                builder.set_hidden();
+            }
         } else if node.is_text_node() {
             builder.set_role(Role::TextRun);
             builder.set_value(node.text_content());
@@ -67,6 +83,21 @@ impl BaseDocument {
     }
 }
 
+impl BlitzDomNode {
+    // https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion
+    fn is_hidden_from_accessibility_tree(&self) -> bool {
+        self.try_stylo_element_data()
+            .as_ref()
+            .and_then(|s| s.get())
+            .map(|s| {
+                s.styles.is_display_none()
+                    || s.styles.primary().clone_visibility()
+                        == visibility::computed_value::T::Hidden
+            })
+            .unwrap_or(false)
+    }
+}
+
 fn role_from_name(name: &str) -> Option<Role> {
     match name {
         "alert" => Some(Role::Alert),

diff --git a/tests/blitz-tests/Cargo.toml b/tests/blitz-tests/Cargo.toml
@@ -31,6 +31,7 @@ accesskit = { workspace = true }
 markup5ever = { workspace = true }
 keyboard-types = { workspace = true }
 taffy = { workspace = true }
+test-that = { workspace = true }
 usvg = { workspace = true }
 
 [lib]

diff --git a/tests/blitz-tests/tests/accessibility_hidden.rs b/tests/blitz-tests/tests/accessibility_hidden.rs
@@ -0,0 +1,145 @@
+use accesskit::{Node as AccessKitNode, Role};
+use blitz_dom::DocumentConfig;
+use blitz_html::{HtmlDocument, HtmlProvider};
+use blitz_traits::shell::{ColorScheme, Viewport};
+use std::sync::Arc;
+use test_that::prelude::*;
+
+#[test]
+fn includes_ordinary_div_as_node() -> TestResult<()> {
+    let mut document =
+        HtmlDocument::from_html("<html><div></div></html>", default_document_config());
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::GenericContainer),
+                is_hidden(): eq(false),
+            })
+        ))
+    )
+}
+
+#[test]
+fn excludes_div_with_hidden_attribute() -> TestResult<()> {
+    let mut document =
+        HtmlDocument::from_html("<html><div hidden></div></html>", default_document_config());
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        not(contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::GenericContainer)
+            })
+        )))
+    )
+}
+
+#[test]
+fn excludes_div_with_display_none() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><div style="display: none;"></div></html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        not(contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::GenericContainer)
+            })
+        )))
+    )
+}
+
+#[test]
+fn excludes_div_with_visibility_hidden() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><div style="visibility: hidden;"></div></html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        not(contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::GenericContainer)
+            })
+        )))
+    )
+}
+
+#[test]
+fn sets_hidden_flag_on_element_with_aria_hidden_attribute() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><div aria-hidden="true"></div></html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::GenericContainer),
+                is_hidden(): eq(true),
+            })
+        ))
+    )
+}
+
+#[test]
+fn excludes_child_element_of_hidden_element() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <head/>
+          <body>
+            <div hidden="true">
+              <button/>
+            </div>
+          </body>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        not(contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::Button),
+            })
+        )))
+    )
+}
+
+fn default_document_config() -> DocumentConfig {
+    DocumentConfig {
+        viewport: Some(Viewport::new(800, 600, 1.0, ColorScheme::Light)),
+        html_parser_provider: Some(Arc::new(HtmlProvider) as _),
+        ..Default::default()
+    }
+}
diff --git a/tests/blitz-tests/tests/accessibility_roles.rs b/tests/blitz-tests/tests/accessibility_roles.rs
@@ -192,7 +192,7 @@ fn a_semantic_page_has_no_unknown_elements() {
         <footer>End</footer>
     </body></html>"##;
 
-    // <html>, <head> and <body> have no roles of their own. Everything else in
+    // <html> and <body> have no roles of their own. Everything else in
     // this document should map to something an assistive technology can use.
-    assert_eq!(unknown_tags(html), vec!["body", "head", "html"]);
+    assert_eq!(unknown_tags(html), vec!["body", "html"]);
 }