diff --git a/Cargo.lock b/Cargo.lock
index 3321e20335..1fadb41229 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -907,6 +907,7 @@ dependencies = [
  "parley",
  "percent-encoding",
  "rayon",
+ "rustc-hash 2.1.3",
  "selectors",
  "skrifa",
  "slotmap",
@@ -1068,6 +1069,7 @@ dependencies = [
  "dioxus-native-dom",
  "keyboard-types",
  "markup5ever",
+ "rstest",
  "stylo",
  "taffy",
  "test-that",
@@ -6767,6 +6769,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "relative-path"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
+
 [[package]]
 name = "renderdoc-sys"
 version = "1.1.0"
@@ -6892,6 +6900,32 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "rstest"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b376e512f30a7686a8dbc6aeaace99b3ade1c26c1c63473473a817ade226dafc"
+dependencies = [
+ "rstest_macros",
+]
+
+[[package]]
+name = "rstest_macros"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88512dbfb5b73a0dfa38aef7bc73b5657035fce477b923faf12d332dd83051ea"
+dependencies = [
+ "cfg-if",
+ "glob",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "relative-path",
+ "rustc_version",
+ "syn 2.0.119",
+ "unicode-ident",
+]
+
 [[package]]
 name = "rusqlite"
 version = "0.32.1"
diff --git a/Cargo.toml b/Cargo.toml
index 7e73613667..7e5e782fdc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -189,6 +189,7 @@ bitflags = "2.8.0"
 bytemuck = "1"
 rayon = "1"
 test-that = "0.6.0"
+rstest = { version = "0.28", default-features = false }
 thread_local = "1"
 
 # Unicode (ICU4X)
diff --git a/packages/blitz-dom/Cargo.toml b/packages/blitz-dom/Cargo.toml
index a36fdfa3d7..fabef756db 100644
--- a/packages/blitz-dom/Cargo.toml
+++ b/packages/blitz-dom/Cargo.toml
@@ -85,6 +85,7 @@ writeable = { workspace = true, optional = true }
 # Other dependencies
 slotmap = { workspace = true }
 bitflags = { workspace = true }
+rustc-hash = { workspace = true }
 tracing = { workspace = true, optional = true }
 rayon = { workspace = true }
 
diff --git a/packages/blitz-dom/src/accessibility.rs b/packages/blitz-dom/src/accessibility.rs
index 6b1b2f721f..1cc7e37a48 100644
--- a/packages/blitz-dom/src/accessibility.rs
+++ b/packages/blitz-dom/src/accessibility.rs
@@ -1,223 +1,58 @@
-use crate::{
-    BaseDocument, ElementData, Node as BlitzDomNode, NodeData, NodeId as BlitzDomNodeId, local_name,
-};
-use accesskit::{Node as AccessKitNode, NodeId, Role, TreeId, TreeInfo, TreeUpdate};
-use style::properties::longhands::visibility;
-use stylo_taffy::CopyStyleGetters;
+mod node;
+mod tree_builder;
+
+use crate::{BaseDocument, Node, accessibility::tree_builder::TreeBuilder};
+use accesskit::TreeUpdate;
+use blitz_traits::NodeId;
+use markup5ever::local_name;
 
 impl BaseDocument {
+    /// Builds the AccessKit tree of this document.
+    ///
+    /// The root is a window node with the ID `u64::MAX`, whose only child is the document node.
+    /// The other node IDs are the raw IDs of the DOM nodes. Nodes hidden with CSS, by
+    /// `display: none` or `visibility: hidden`, are left out along with their descendants. Nodes
+    /// with `aria-hidden="true"` are included and flagged as hidden.
+    ///
+    /// The label and description of a node are its accessible name and description as computed by
+    /// the W3C specification, except that `title` only provides the description and never the
+    /// name.
+    ///
+    /// <https://www.w3.org/TR/accname-1.2/>
     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();
-        let mut labelled_by_nodes = Vec::new();
-        let mut described_by_nodes = Vec::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))
-                .map(|(_, parent)| parent)
-                .unwrap_or(&mut window);
-            let (id, builder) = self.build_accessibility_node(node, parent);
-
-            if node.attr(local_name!("aria-labelledby")).is_some() {
-                labelled_by_nodes.push(node_id);
-            }
-            if node.attr(local_name!("aria-describedby")).is_some() {
-                described_by_nodes.push(node_id);
-            }
-            nodes.insert(node_id, (id, builder));
-        });
-
-        let mut label = FlatText::default();
-        for node_id in labelled_by_nodes {
-            let Some(id_refs) = self.nodes[node_id].attr(local_name!("aria-labelledby")) else {
-                continue;
-            };
-            let Some((id, mut builder)) = nodes.remove(&node_id) else {
-                continue;
-            };
-            let mut has_target = false;
-            label.clear();
-            for target in self.referenced_dom_ids_to_node_ids(id_refs) {
-                if !has_target {
-                    builder.clear_labelled_by();
-                    has_target = true;
-                }
-                if target == node_id || nodes.contains_key(&target) {
-                    builder.push_labelled_by(NodeId(target.as_u64()));
-                }
-                self.nodes[target].write_text_alternative(&mut label);
-                label.break_word();
-            }
-            if !label.text.is_empty() {
-                builder.set_label(label.text.as_str());
-            }
-            nodes.insert(node_id, (id, builder));
-        }
-
-        for node_id in described_by_nodes {
-            let Some(id_refs) = self.nodes[node_id].attr(local_name!("aria-describedby")) else {
-                continue;
-            };
-            let Some((id, mut builder)) = nodes.remove(&node_id) else {
-                continue;
-            };
-            for target in self.referenced_dom_ids_to_node_ids(id_refs) {
-                if target == node_id || nodes.contains_key(&target) {
-                    builder.push_described_by(NodeId(target.as_u64()));
-                }
-            }
-            nodes.insert(node_id, (id, builder));
-        }
-
-        let mut nodes: Vec<_> = nodes
-            .into_iter()
-            .map(|(_, (id, node))| (id, node))
-            .collect();
-        nodes.push((NodeId(u64::MAX), window));
-
-        let tree = TreeInfo::new(NodeId(u64::MAX));
-        TreeUpdate {
-            tree_id: TreeId::ROOT,
-            nodes,
-            tree: Some(tree),
-            focus: NodeId(self.focus_node_id.map(|id| id.as_u64()).unwrap_or(u64::MAX)),
-        }
+        TreeBuilder::new(self).build()
     }
 
+    /// The elements whose IDs appear in `nodes_reference`, a space-separated list, in that order.
+    /// IDs which match no element are skipped.
     fn referenced_dom_ids_to_node_ids<'a>(
         &'a self,
         nodes_reference: &'a str,
-    ) -> impl Iterator<Item = BlitzDomNodeId> + 'a {
+    ) -> impl Iterator<Item = NodeId> + 'a {
         nodes_reference
             .split_ascii_whitespace()
-            .filter_map(|dom_id| self.nodes_to_id.get(dom_id)?.first().copied())
+            .filter_map(|dom_id| self.get_element_by_id(dom_id))
     }
 
-    fn build_accessibility_node(
-        &self,
-        node: &BlitzDomNode,
-        parent: &mut AccessKitNode,
-    ) -> (NodeId, AccessKitNode) {
-        let id = NodeId(node.id.as_u64());
-
-        let mut builder = AccessKitNode::default();
-        if node.parent.is_none() {
-            builder.set_role(Role::Window)
-        } else if let Some(element_data) = node.element_data() {
-            let name = element_data.name.local.to_string();
-            let role_attr = element_data.attr(local_name!("role"));
-
-            // TODO: The roles of elements with strong native semantics cannot be overridden; see
-            // https://www.w3.org/TR/wai-aria-1.2/#host_general_conflict.
-            let role = role_attr
-                .and_then(role_from_name)
-                .or_else(|| role_from_element_data(element_data))
-                .unwrap_or(Role::Unknown);
-
-            builder.set_role(role);
-
-            // https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion
-            if element_data.attr(local_name!("aria-hidden")) == Some("true") {
-                builder.set_hidden();
-            }
-
-            if let Some(aria_expanded) = element_data.attr(local_name!("aria-expanded"))
-                && let Ok(aria_expanded) = aria_expanded.parse()
-            {
-                builder.set_expanded(aria_expanded);
-            }
-
-            if element_data.attr(local_name!("aria-disabled")) == Some("true") {
-                builder.set_disabled();
-            }
-
-            if let Some(aria_selected) = element_data.attr(local_name!("aria-selected"))
-                && let Ok(aria_selected) = aria_selected.parse()
-            {
-                builder.set_selected(aria_selected);
-            }
-
-            if let Some(aria_label) = element_data.attr(local_name!("aria-label")) {
-                builder.set_label(aria_label);
-            }
-            if let Some(aria_description) = element_data.attr(local_name!("aria-description")) {
-                builder.set_description(aria_description);
-            }
-            if let Some(aria_level) = element_data.attr(local_name!("aria-level"))
-                && let Ok(aria_level) = aria_level.parse::<usize>()
-                // Accesskit levels are 0-based, while ARIA levels are 1-based
-                // See https://docs.rs/accesskit/latest/accesskit/struct.Node.html#method.level
-                && let Some(aria_level) = aria_level.checked_sub(1)
-            {
-                builder.set_level(aria_level);
-            } else if let Some(default_level) = default_level_for_tag(&name) {
-                builder.set_level(default_level);
-            } else if let Some(default_level) = default_level_for_role(role) {
-                builder.set_level(default_level);
-            }
-
-            builder.set_html_tag(name);
-        } else if node.is_text_node() {
-            builder.set_role(Role::TextRun);
-            builder.set_value(node.text_content());
-            parent.push_labelled_by(id)
-        }
-
-        parent.push_child(id);
-
-        (id, builder)
-    }
-}
-
-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 write_text_alternative(&self, out: &mut FlatText) {
-        match self
-            .attr(local_name!("aria-label"))
-            .filter(|aria_label| !aria_label.trim_ascii().is_empty())
-        {
-            Some(aria_label) => out.push(aria_label),
-            None => self.write_flat_text_content(out),
-        }
-    }
-
-    fn write_flat_text_content(&self, out: &mut FlatText) {
-        match &self.data {
-            NodeData::Text(data) => out.push(&data.content),
-            NodeData::Element(..) | NodeData::AnonymousBlock(..) => {
-                for &child_id in &self.children {
-                    self.with(child_id).write_flat_text_content(out);
-                }
-            }
-            _ => {}
+    /// The element labelled by the given `<label>` element, if any. This is the element which the
+    /// `for` attribute refers to or, without that attribute, the first labelable descendant.
+    ///
+    /// <https://html.spec.whatwg.org/multipage/forms.html#dom-label-control>
+    fn label_control(&self, label: &Node) -> Option<NodeId> {
+        match label.attr(local_name!("for")) {
+            // The spec restricts which elements can be labelled. If the first element with the id
+            // is not labelable, no later element with the same id is used and the descendants of
+            // the label are not considered either.
+            Some(for_id) => self
+                .get_element_by_id(for_id)
+                .filter(|&target| self.nodes[target].is_labelable()),
+            None => label.first_labelable_descendant(),
         }
     }
 }
 
+/// Text which is collected piece by piece, with each run of ASCII whitespace collapsed to a single
+/// space and no space at either end.
 #[derive(Default)]
 struct FlatText {
     text: String,
@@ -225,6 +60,8 @@ struct FlatText {
 }
 
 impl FlatText {
+    /// Appends `text`. A space separates it from the earlier text if there is whitespace at the
+    /// boundary or [FlatText::break_word] was called since.
     fn push(&mut self, text: &str) {
         for (i, word) in text.split(|c: char| c.is_ascii_whitespace()).enumerate() {
             self.pending_space |= i > 0;
@@ -239,191 +76,32 @@ impl FlatText {
         }
     }
 
+    /// Separates the next text pushed from the previous text by a space, even without whitespace
+    /// at the boundary.
     fn break_word(&mut self) {
         self.pending_space = true;
     }
-
-    fn clear(&mut self) {
-        self.text.clear();
-        self.pending_space = false;
-    }
-}
-
-fn role_from_name(name: &str) -> Option<Role> {
-    match name {
-        "alert" => Some(Role::Alert),
-        "alertdialog" => Some(Role::AlertDialog),
-        "button" => Some(Role::Button),
-        "checkbox" => Some(Role::CheckBox),
-        "dialog" => Some(Role::Dialog),
-        "gridcell" => Some(Role::GridCell),
-        "link" => Some(Role::Link),
-        "log" => Some(Role::Log),
-        "marquee" => Some(Role::Marquee),
-        "menuitem" => Some(Role::MenuItem),
-        "menuitemcheckbox" => Some(Role::MenuItemCheckBox),
-        "menuitemradio" => Some(Role::MenuItemRadio),
-        "option" => Some(Role::ListBoxOption),
-        "progressbar" => Some(Role::ProgressIndicator),
-        "radio" => Some(Role::RadioButton),
-        "scrollbar" => Some(Role::ScrollBar),
-        "slider" => Some(Role::Slider),
-        "spinbutton" => Some(Role::SpinButton),
-        "status" => Some(Role::Status),
-        "tab" => Some(Role::Tab),
-        "tabpanel" => Some(Role::TabPanel),
-        "textbox" => Some(Role::TextInput),
-        "timer" => Some(Role::Timer),
-        "tooltip" => Some(Role::Tooltip),
-        "treeitem" => Some(Role::TreeItem),
-        "combobox" => Some(Role::ComboBox),
-        "grid" => Some(Role::Grid),
-        "listbox" => Some(Role::ListBox),
-        "menu" => Some(Role::Menu),
-        "menubar" => Some(Role::MenuBar),
-        "radiogroup" => Some(Role::RadioGroup),
-        "tablist" => Some(Role::TabList),
-        "tree" => Some(Role::Tree),
-        "treegrid" => Some(Role::TreeGrid),
-        "article" => Some(Role::Article),
-        "columnheader" => Some(Role::ColumnHeader),
-        "definition" => Some(Role::Definition),
-        "document" => Some(Role::Document),
-        "group" => Some(Role::Group),
-        "heading" => Some(Role::Heading),
-        "img" => Some(Role::Image),
-        "list" => Some(Role::List),
-        "listitem" => Some(Role::ListItem),
-        "math" => Some(Role::Math),
-        "note" => Some(Role::Note),
-        "region" => Some(Role::Region),
-        "row" => Some(Role::Row),
-        "rowgroup" => Some(Role::RowGroup),
-        "rowheader" => Some(Role::RowHeader),
-        "toolbar" => Some(Role::Toolbar),
-        "application" => Some(Role::Application),
-        "banner" => Some(Role::Banner),
-        "complementary" => Some(Role::Complementary),
-        "contentinfo" => Some(Role::ContentInfo),
-        "form" => Some(Role::Form),
-        "main" => Some(Role::Main),
-        "navigation" => Some(Role::Navigation),
-        "search" => Some(Role::Search),
-        _ => None,
-    }
 }
 
-fn default_level_for_tag(name: &str) -> Option<usize> {
-    // Accesskit levels are 0-based, while ARIA levels are 1-based
-    // See https://docs.rs/accesskit/latest/accesskit/struct.Node.html#method.level
-    match name {
-        "h1" => Some(0),
-        "h2" => Some(1),
-        "h3" => Some(2),
-        "h4" => Some(3),
-        "h5" => Some(4),
-        "h6" => Some(5),
-        _ => None,
-    }
+/// `text` with leading and trailing whitespace removed and each run of ASCII whitespace
+/// collapsed to a single space, or `None` if nothing is left.
+fn normalize(text: &str) -> Option<String> {
+    let mut normalizer = FlatText::default();
+    normalizer.push(text);
+    (!normalizer.text.is_empty()).then_some(normalizer.text)
 }
 
-fn default_level_for_role(role: Role) -> Option<usize> {
-    match role {
-        // ARIA specifies an implicit level of 2 for the heading role. Accesskit levels are 0-based,
-        // so this turns into level 1
-        Role::Heading => Some(1),
-        _ => None,
-    }
+/// The AccessKit ID of the DOM node with the given ID.
+fn to_accesskit_node_id(node_id: NodeId) -> accesskit::NodeId {
+    accesskit::NodeId(node_id.as_u64())
 }
 
-fn role_from_element_data(element_data: &ElementData) -> Option<Role> {
-    // <https://www.w3.org/TR/html-aam-1.0/>
-    match &*element_data.name.local {
-        // Document structure
-        "article" => Some(Role::Article),
-        "aside" => Some(Role::Complementary),
-        "footer" => Some(Role::Footer),
-        "header" => Some(Role::Header),
-        "main" => Some(Role::Main),
-        "nav" => Some(Role::Navigation),
-        "search" => Some(Role::Search),
-        "section" => Some(Role::Section),
-        "h1" | "h2" | "h3" | "h4" | "h5" | "h6" => Some(Role::Heading),
-        "p" => Some(Role::Paragraph),
-        "blockquote" => Some(Role::Blockquote),
-        "figure" => Some(Role::Figure),
-        "figcaption" | "caption" => Some(Role::Caption),
-        "hr" => Some(Role::Splitter),
-
-        // Grouping
-        "ul" | "ol" | "menu" => Some(Role::List),
-        "li" => Some(Role::ListItem),
-        "dl" => Some(Role::DescriptionList),
-        "dt" => Some(Role::Term),
-        "dd" => Some(Role::Definition),
-        "dialog" => Some(Role::Dialog),
-        "fieldset" => Some(Role::Group),
-        "form" => Some(Role::Form),
-        "div" => Some(Role::GenericContainer),
-
-        // Tables
-        "table" => Some(Role::Table),
-        "thead" | "tbody" | "tfoot" => Some(Role::RowGroup),
-        "tr" => Some(Role::Row),
-        "td" => Some(Role::Cell),
-        "th" => match element_data.attr(local_name!("scope")) {
-            Some("row") | Some("rowgroup") => Some(Role::RowHeader),
-            _ => Some(Role::ColumnHeader),
-        },
-
-        // Interactive
-        // An <a> is only a link when it has an href.
-        "a" => match element_data.attr(local_name!("href")) {
-            Some(_) => Some(Role::Link),
-            None => Some(Role::GenericContainer),
-        },
-        "button" => Some(Role::Button),
-        "label" => Some(Role::Label),
-        "legend" => Some(Role::Label),
-        "select" => match element_data.attr(local_name!("multiple")) {
-            Some(_) => Some(Role::ListBox),
-            None => Some(Role::ComboBox),
-        },
-        "option" => Some(Role::ListBoxOption),
-        "textarea" => Some(Role::MultilineTextInput),
-        "progress" => Some(Role::ProgressIndicator),
-        "meter" => Some(Role::Meter),
-        "output" => Some(Role::Status),
-        "summary" => Some(Role::DisclosureTriangle),
-
-        // Inline semantics
-        "code" => Some(Role::Code),
-        "em" => Some(Role::Emphasis),
-        "strong" => Some(Role::Strong),
-        "mark" => Some(Role::Mark),
-        "time" => Some(Role::Time),
-        "img" => Some(Role::Image),
-        "iframe" => Some(Role::Iframe),
-
-        "input" => {
-            let ty = element_data.attr(local_name!("type")).unwrap_or("text");
-            match ty {
-                "button" | "submit" | "reset" => Some(Role::Button),
-                "checkbox" => Some(Role::CheckBox),
-                "color" => Some(Role::ColorWell),
-                "date" => Some(Role::DateInput),
-                "datetime-local" => Some(Role::DateTimeInput),
-                "email" => Some(Role::EmailInput),
-                "number" => Some(Role::NumberInput),
-                "password" => Some(Role::PasswordInput),
-                "radio" => Some(Role::RadioButton),
-                "range" => Some(Role::Slider),
-                "search" => Some(Role::SearchInput),
-                "tel" => Some(Role::PhoneNumberInput),
-                "time" => Some(Role::TimeInput),
-                _ => Some(Role::TextInput),
-            }
-        }
-        _ => None,
-    }
+/// The AccessKit IDs of the DOM nodes with the given IDs, in the same order.
+fn to_accesskit_node_id_vec<'a>(
+    node_ids: impl IntoIterator<Item = &'a NodeId>,
+) -> Vec<accesskit::NodeId> {
+    node_ids
+        .into_iter()
+        .map(|n| to_accesskit_node_id(*n))
+        .collect::<Vec<_>>()
 }
diff --git a/packages/blitz-dom/src/accessibility/node.rs b/packages/blitz-dom/src/accessibility/node.rs
new file mode 100644
index 0000000000..7fe21f2b85
--- /dev/null
+++ b/packages/blitz-dom/src/accessibility/node.rs
@@ -0,0 +1,815 @@
+use crate::{
+    ElementData, Node, NodeData,
+    accessibility::{FlatText, normalize},
+    layout::replaced::is_inline_box_element,
+};
+use accesskit::Role;
+use blitz_traits::NodeId;
+use markup5ever::{LocalName, local_name};
+use std::borrow::Cow;
+use style::{
+    properties::longhands::visibility,
+    values::specified::box_::{DisplayInside, DisplayOutside},
+};
+use stylo_taffy::CopyStyleGetters as _;
+
+impl Node {
+    /// Builds an [accesskit::Node] with data from this instance alone.
+    ///
+    /// For an element, this sets the role, the HTML tag, the level, and the flags for
+    /// `aria-hidden`, `aria-expanded`, `aria-disabled`, and `aria-selected`. For a text node, it
+    /// sets the text as the value. The node without a parent, which is the document, gets the role
+    /// [Role::Window].
+    ///
+    /// It does not set the properties which depend on other nodes or on the results above. In
+    /// particular, the following are left to
+    /// [TreeBuilder](super::tree_builder::TreeBuilder):
+    ///
+    /// - label, `labelled_by`, and the value of nodes with the role [Role::Label]
+    /// - description and `described_by`
+    /// - children
+    pub(super) fn build_accesskit_node(&self) -> accesskit::Node {
+        let mut accesskit_node = accesskit::Node::default();
+        if self.parent.is_none() {
+            accesskit_node.set_role(Role::Window)
+        } else if let Some(element_data) = self.element_data() {
+            accesskit_node.set_html_tag(element_data.name.local.as_str());
+
+            // TODO: The roles of elements with strong native semantics cannot be overridden; see
+            // https://www.w3.org/TR/wai-aria-1.2/#host_general_conflict.
+            let role = element_role(element_data);
+            accesskit_node.set_role(role);
+
+            if let Some(aria_level) = element_data.attr(local_name!("aria-level"))
+                && let Ok(aria_level) = aria_level.parse::<usize>()
+                // Accesskit levels are 0-based, while ARIA levels are 1-based
+                // See https://docs.rs/accesskit/latest/accesskit/struct.Node.html#method.level
+                && let Some(aria_level) = aria_level.checked_sub(1)
+            {
+                accesskit_node.set_level(aria_level);
+            } else if let Some(default_level) =
+                default_level_for_tag(element_data.name.local.as_str())
+            {
+                accesskit_node.set_level(default_level);
+            } else if let Some(default_level) = default_level_for_role(role) {
+                accesskit_node.set_level(default_level);
+            }
+
+            // https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion
+            if element_data.attr(local_name!("aria-hidden")) == Some("true") {
+                accesskit_node.set_hidden();
+            }
+
+            if let Some(aria_expanded) = element_data.attr(local_name!("aria-expanded"))
+                && let Ok(aria_expanded) = aria_expanded.parse()
+            {
+                accesskit_node.set_expanded(aria_expanded);
+            }
+
+            if element_data.attr(local_name!("aria-disabled")) == Some("true") {
+                accesskit_node.set_disabled();
+            }
+
+            if let Some(aria_selected) = element_data.attr(local_name!("aria-selected"))
+                && let Ok(aria_selected) = aria_selected.parse()
+            {
+                accesskit_node.set_selected(aria_selected);
+            }
+        } else if self.is_text_node() {
+            accesskit_node.set_role(Role::TextRun);
+            accesskit_node.set_value(self.text_content());
+        }
+
+        accesskit_node
+    }
+
+    /// Sets the label in the given [accesskit::Node] to the accessible name computed from this
+    /// node, its subtree and, for images, the enclosing `figure`. It does not take into account
+    /// the nodes which refer to this node. [TreeBuilder](super::tree_builder::TreeBuilder) handles
+    /// those first and falls back to this method.
+    ///
+    /// The role of `accesskit_node` must already be set. Call [Node::build_accesskit_node] first.
+    ///
+    /// <https://www.w3.org/TR/accname-1.2/#computation-steps>
+    pub(super) fn set_accesskit_node_label(&self, accesskit_node: &mut accesskit::Node) {
+        let Some(element_data) = self.element_data() else {
+            return;
+        };
+
+        if let Some(aria_label) = element_data.attr(local_name!("aria-label"))
+            && let Some(normalized_aria_label) = normalize(aria_label)
+        {
+            accesskit_node.set_label(normalized_aria_label);
+            return;
+        }
+
+        if let Some(host_language_label) = self.host_language_label(element_data) {
+            accesskit_node.set_label(host_language_label);
+        } else if names_from_content(accesskit_node.role(), element_data) {
+            let mut content = FlatText::default();
+            self.write_text_alternative(&mut content, None);
+            if !content.text.is_empty() {
+                accesskit_node.set_label(content.text);
+            }
+        }
+    }
+
+    /// Sets the description in the given [accesskit::Node] from the attributes of this node. It
+    /// does not take into account `aria-describedby`.
+    /// [TreeBuilder](super::tree_builder::TreeBuilder) handles that first and falls back to this
+    /// method.
+    ///
+    /// The label of `accesskit_node` must already be resolved, since `title` is only the
+    /// description when it did not provide the name. See [Node::set_accesskit_node_label].
+    ///
+    /// <https://www.w3.org/TR/accname-1.2/#mapping_additional_nd_description>
+    pub(super) fn set_accesskit_node_description(&self, accesskit_node: &mut accesskit::Node) {
+        let Some(element_data) = self.element_data() else {
+            return;
+        };
+
+        if let Some(aria_description) = element_data.attr(local_name!("aria-description"))
+            && let Some(normalized_description) = normalize(aria_description)
+        {
+            accesskit_node.set_description(normalized_description);
+            return;
+        }
+
+        if let Some(title) = element_data.attr(local_name!("title"))
+            && let Some(normalized_title) = normalize(title)
+            && (accesskit_node.label().is_some()
+                || role_prohibits_naming(accesskit_node.role())
+                || (accesskit_node.role() == Role::Image
+                    && element_data
+                        .attr(local_name!("alt"))
+                        .is_some_and(|s| s.trim_ascii().is_empty())))
+        {
+            accesskit_node.set_description(normalized_title);
+        }
+    }
+
+    /// The text alternative provided by the host language markup of this element itself.
+    ///
+    /// The `title` attribute is deliberately not used here. AccessKit expects a name which comes
+    /// only from a tooltip in `Node::tooltip`, not `Node::label`, and that is not set yet. The
+    /// `title` is used as the description; see [Node::set_accesskit_node_description]. Also not
+    /// covered are `placeholder` and the strings which user agents supply for `input` elements of
+    /// the submit, reset and image types lacking any other source. `area` elements are never
+    /// exposed in the accessibility tree because the user agent stylesheet hides them.
+    ///
+    /// <https://www.w3.org/TR/html-aam-1.0/#accessible-name-and-description-computation>
+    fn host_language_label<'a>(&'a self, element_data: &'a ElementData) -> Option<Cow<'a, str>> {
+        match &*element_data.name.local {
+            "img" => match element_data.attr(local_name!("alt")) {
+                // An explicit `alt` attribute, even an empty one, rules out the other sources.
+                Some(alt) => is_non_blank(Some(alt)).map(Cow::Borrowed),
+                // Per HTML-AAM, the order of sources is `alt`, then `title`, then `figcaption`.
+                // `title` is deliberately not exposed as the label here: AccessKit expects a name
+                // which comes only from a tooltip in `Node::tooltip`, not `Node::label`. Its
+                // presence still has to be checked, because it ranks above `figcaption`: with a
+                // `title`, the `figcaption` is not the name, so it must not become the label.
+                None if element_data.attr(local_name!("title")).is_none() => {
+                    self.figcaption_text().map(Cow::Owned)
+                }
+                None => None,
+            },
+            "input" => {
+                let input_type = element_data.attr(local_name!("type")).unwrap_or_default();
+                let source = if ["button", "submit", "reset"]
+                    .iter()
+                    .any(|button_type| input_type.eq_ignore_ascii_case(button_type))
+                {
+                    local_name!("value")
+                } else if input_type.eq_ignore_ascii_case("image") {
+                    local_name!("alt")
+                } else {
+                    return None;
+                };
+                is_non_blank(element_data.attr(source)).map(Cow::Borrowed)
+            }
+            "fieldset" => self
+                .first_child_named(local_name!("legend"))?
+                .subtree_text()
+                .map(Cow::Owned),
+            "table" => self
+                .first_child_named(local_name!("caption"))?
+                .subtree_text()
+                .map(Cow::Owned),
+            "summary" if self.is_first_summary_of_details() => self.subtree_text().map(Cow::Owned),
+            _ => None,
+        }
+    }
+
+    /// The text of the `figcaption` which names this element, if any. That is the first
+    /// `figcaption` child of the closest `figure` ancestor, provided that this element and the
+    /// `figcaption` are the only content of the `figure`. Any other element counts as content,
+    /// even an empty one.
+    fn figcaption_text(&self) -> Option<String> {
+        let mut path_to_figure = Vec::new();
+        let mut current = self.parent;
+        let figure = loop {
+            let ancestor = self.with(current?);
+            if ancestor.is_element_named(local_name!("figure")) {
+                break ancestor;
+            }
+            path_to_figure.push(ancestor.id);
+            current = ancestor.parent;
+        };
+        let figcaption = figure.first_child_named(local_name!("figcaption"))?;
+        if figure.has_content_other_than(self.id, figcaption.id, &path_to_figure) {
+            return None;
+        }
+        figcaption.subtree_text()
+    }
+
+    /// The first child of this node which is an element with the given name.
+    fn first_child_named(&self, name: LocalName) -> Option<&Node> {
+        self.children
+            .iter()
+            .map(|&child_id| self.with(child_id))
+            .find(|child| child.is_element_named(name.clone()))
+    }
+
+    /// Whether this is the first `summary` child of a `details` element.
+    fn is_first_summary_of_details(&self) -> bool {
+        self.parent
+            .map(|parent_id| self.with(parent_id))
+            .filter(|parent| parent.is_element_named(local_name!("details")))
+            .and_then(|details| details.first_child_named(local_name!("summary")))
+            .is_some_and(|summary| summary.id == self.id)
+    }
+
+    /// Whether the subtree of this node has non-whitespace text or elements besides `exempt` and
+    /// `exempt_caption`. Elements in `ancestors_of_exempt` are searched rather than counted.
+    fn has_content_other_than(
+        &self,
+        exempt: NodeId,
+        exempt_caption: NodeId,
+        ancestors_of_exempt: &[NodeId],
+    ) -> bool {
+        self.children.iter().any(|&child_id| {
+            let child = self.with(child_id);
+            if child_id == exempt || child_id == exempt_caption {
+                false
+            } else if ancestors_of_exempt.contains(&child_id) {
+                child.has_content_other_than(exempt, exempt_caption, ancestors_of_exempt)
+            } else {
+                match &child.data {
+                    NodeData::Text(data) => !data.content.trim_ascii().is_empty(),
+                    NodeData::Element(..) => true,
+                    _ => false,
+                }
+            }
+        })
+    }
+
+    /// Whether this node or any of its ancestors is hidden for naming; see
+    /// [Node::is_hidden_for_naming].
+    pub(super) fn is_in_hidden_subtree(&self) -> bool {
+        let mut node = self;
+        loop {
+            if node.is_hidden_for_naming() {
+                return true;
+            }
+            match node.parent {
+                Some(parent_id) => node = self.with(parent_id),
+                None => return false,
+            }
+        }
+    }
+
+    /// Whether this node is hidden from the accessibility tree (see
+    /// [Node::is_hidden_from_accessibility_tree]) or has `aria-hidden="true"`. Only this node is
+    /// considered, not its ancestors.
+    ///
+    /// <https://www.w3.org/TR/accname-1.2/#comp_hidden_not_referenced>
+    fn is_hidden_for_naming(&self) -> bool {
+        self.is_hidden_from_accessibility_tree()
+            || self.attr(local_name!("aria-hidden")) == Some("true")
+    }
+
+    /// Whether the style of this node excludes it from the accessibility tree, with
+    /// `display: none` or `visibility: hidden`. This does not look at the ancestors.
+    /// [TreeBuilder](super::tree_builder::TreeBuilder) excludes the descendants of such nodes.
+    ///
+    /// Nodes with `aria-hidden="true"` stay in the tree, flagged as hidden. See
+    /// [Node::is_hidden_for_naming].
+    ///
+    /// <https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion>
+    pub(super) fn is_hidden_from_accessibility_tree(&self) -> bool {
+        self.try_stylo_element_data()
+            .as_ref()
+            .and_then(|s| s.get())
+            .is_some_and(|s| {
+                s.styles.is_display_none()
+                    || s.styles.primary().clone_visibility()
+                        == visibility::computed_value::T::Hidden
+            })
+    }
+
+    /// Whether a `<label>` can be associated with this element.
+    ///
+    /// Form-associated custom elements are also labelable per the HTML specification, but cannot
+    /// be recognized here. `input type="hidden"` is not labelable either, but it is never exposed
+    /// in the accessibility tree, so it needs no handling.
+    ///
+    /// <https://html.spec.whatwg.org/multipage/forms.html#category-label>
+    pub(super) fn is_labelable(&self) -> bool {
+        self.element_data().is_some_and(|element_data| {
+            matches!(
+                &*element_data.name.local,
+                "button" | "input" | "meter" | "output" | "progress" | "select" | "textarea"
+            )
+        })
+    }
+
+    /// The first labelable element in the subtree of this node, in tree order.
+    pub(super) fn first_labelable_descendant(&self) -> Option<NodeId> {
+        self.children.iter().find_map(|&child_id| {
+            let child = self.with(child_id);
+            if child.is_labelable() {
+                Some(child_id)
+            } else {
+                child.first_labelable_descendant()
+            }
+        })
+    }
+
+    /// Writes the text alternative of this node, leaving out the content of the node `skip`.
+    ///
+    /// Hidden nodes are left out, unless this node or one of its ancestors is hidden. Then the
+    /// whole subtree is included.
+    ///
+    /// <https://www.w3.org/TR/accname-1.2/#comp_hidden_not_referenced>
+    pub(super) fn write_text_alternative(&self, out: &mut FlatText, skip: Option<NodeId>) {
+        let context = TextContext {
+            skip,
+            include_hidden: self.is_in_hidden_subtree(),
+        };
+        self.write_flat_text_content(out, context);
+    }
+
+    /// Writes the text alternative of this node, following the steps of
+    /// <https://www.w3.org/TR/accname-1.2/#computation-steps> which apply to a node reached by
+    /// `aria-labelledby` or by name from content.
+    ///
+    /// `context` says which node to leave out and whether hidden nodes count. Where the
+    /// specification says nothing about it, words are separated by a space around block-level
+    /// boxes, atomic inlines, and line breaks, but not around plain inline content.
+    fn write_flat_text_content(&self, out: &mut FlatText, context: TextContext) {
+        if context.skip == Some(self.id) {
+            return;
+        }
+        let element_data = match &self.data {
+            NodeData::Text(data) => {
+                out.push(&data.content);
+                return;
+            }
+            NodeData::Element(element_data) | NodeData::AnonymousBlock(element_data) => {
+                element_data
+            }
+            _ => return,
+        };
+        if !context.include_hidden && self.is_hidden_for_naming() {
+            return;
+        }
+        if self.write_embedded_control_text(element_data, out) {
+            return;
+        }
+        if let Some(aria_label) = is_non_blank(element_data.attr(local_name!("aria-label"))) {
+            out.push(aria_label);
+            return;
+        }
+        if self.is_element_named(local_name!("br")) {
+            out.break_word();
+            return;
+        }
+        if self.is_element_named(local_name!("img")) {
+            if let Some(alt) = is_non_blank(element_data.attr(local_name!("alt"))) {
+                out.push(alt);
+            }
+            return;
+        }
+
+        // Generated content is part of the content of the element: `::before` comes before the
+        // children and `::after` after them. The accname spec joins it to the content of the
+        // element without a space, and so do we, unless the pseudo-element is itself block-level
+        // or an atomic inline. Those are separated like any other child; the spec leaves this
+        // open (https://github.com/w3c/accname/issues/225).
+        let before = self.before();
+        let after = self.after();
+        for &child_id in before
+            .iter()
+            .chain(self.children.iter())
+            .chain(after.iter())
+        {
+            let child = self.with(child_id);
+            let separate_child_from_siblings = child.should_separate_from_siblings();
+            if separate_child_from_siblings {
+                out.break_word();
+            }
+            child.write_flat_text_content(out, context);
+            if separate_child_from_siblings {
+                out.break_word();
+            }
+        }
+    }
+
+    /// Whether the text of this node is separated by a space from the text around it. This is the
+    /// case for visible block-level boxes, atomic inlines, and inline box elements. The
+    /// specification leaves this open: <https://github.com/w3c/accname/issues/225>
+    fn should_separate_from_siblings(&self) -> bool {
+        (self.is_block_or_atomic_inline() || self.is_inline_box_element())
+            && !self.is_hidden_for_naming()
+    }
+
+    /// Whether this node generates a block-level box, a table caption or internal table box, or
+    /// an atomic inline such as `inline-block` or `inline-flex`. Plain inline boxes, and nodes
+    /// with `display: none` or `display: contents`, do not.
+    fn is_block_or_atomic_inline(&self) -> bool {
+        self.display_style()
+            .is_some_and(|display| match display.outside() {
+                DisplayOutside::Block
+                | DisplayOutside::TableCaption
+                | DisplayOutside::InternalTable => true,
+                DisplayOutside::Inline => display.inside() != DisplayInside::Flow,
+                DisplayOutside::None => false,
+            })
+    }
+
+    /// Whether this is an element which is laid out as an inline box: a replaced element such as
+    /// `img`, an `input`, a `textarea`, or a `button`.
+    fn is_inline_box_element(&self) -> bool {
+        self.element_data()
+            .is_some_and(|element_data| is_inline_box_element(&element_data.name.local))
+    }
+
+    /// Writes the value of this element, if it is a control the user can adjust, in place of
+    /// its content. Returns whether it did.
+    ///
+    /// Password inputs are deliberately not included, so as not to expose their value.
+    ///
+    /// <https://www.w3.org/TR/accname-1.2/#comp_embedded_control>
+    fn write_embedded_control_text(&self, element_data: &ElementData, out: &mut FlatText) -> bool {
+        let role = element_role(element_data);
+        match role {
+            Role::TextInput
+            | Role::MultilineTextInput
+            | Role::EmailInput
+            | Role::SearchInput
+            | Role::PhoneNumberInput => {
+                // Only native controls have a value distinct from their content.
+                let Some(text_input) = element_data.text_input_data() else {
+                    return false;
+                };
+                out.push(&text_input.editor.text().to_string());
+                true
+            }
+            Role::Slider | Role::SpinButton | Role::NumberInput => {
+                let value = element_data
+                    .attr(local_name!("aria-valuetext"))
+                    .or_else(|| element_data.attr(local_name!("aria-valuenow")))
+                    .or_else(|| element_data.attr(local_name!("value")));
+                if let Some(value) = value {
+                    out.push(value);
+                }
+                true
+            }
+            Role::ComboBox | Role::ListBox => {
+                let options = self.option_descendants();
+                let mut chosen: Vec<_> = options
+                    .iter()
+                    .filter(|option| {
+                        option.attr(local_name!("selected")).is_some()
+                            || option.attr(local_name!("aria-selected")) == Some("true")
+                    })
+                    .collect();
+                // A drop-down `select` always has a chosen option, which is the first one unless
+                // another is marked as selected.
+                let is_single_select = element_data.name.local == local_name!("select")
+                    && element_data.attr(local_name!("multiple")).is_none();
+                if chosen.is_empty() && is_single_select {
+                    chosen.extend(options.first());
+                }
+                for (index, option) in chosen.into_iter().enumerate() {
+                    // The specification only describes a single chosen option. Several are
+                    // separated by a space, as browsers do.
+                    if index > 0 {
+                        out.break_word();
+                    }
+                    // The options of a collapsed `select` are not rendered, but the chosen one is
+                    // still the value of the control.
+                    let context = TextContext {
+                        skip: None,
+                        include_hidden: true,
+                    };
+                    option.write_flat_text_content(out, context);
+                }
+                true
+            }
+            _ => false,
+        }
+    }
+
+    /// The `option` elements in the subtree of this node, in tree order.
+    fn option_descendants(&self) -> Vec<&Node> {
+        let mut options = Vec::new();
+        let mut pending: Vec<_> = self.children.iter().rev().copied().collect();
+        while let Some(node_id) = pending.pop() {
+            let node = self.with(node_id);
+            if node
+                .element_data()
+                .is_some_and(|element_data| element_role(element_data) == Role::ListBoxOption)
+            {
+                options.push(node);
+            } else {
+                pending.extend(node.children.iter().rev().copied());
+            }
+        }
+        options
+    }
+
+    /// The text alternative of the subtree of this node, if it is not empty.
+    ///
+    /// Unlike [Node::write_text_alternative], hidden nodes are always left out, including this
+    /// node itself.
+    fn subtree_text(&self) -> Option<String> {
+        let mut text = FlatText::default();
+        self.write_flat_text_content(&mut text, TextContext::default());
+        (!text.text.is_empty()).then_some(text.text)
+    }
+
+    /// Returns whether this instance has the given [LocalName] as HTML tag.
+    pub(super) fn is_element_named(&self, name: LocalName) -> bool {
+        self.element_data()
+            .is_some_and(|element_data| element_data.name.local == name)
+    }
+}
+
+/// How the text alternative of a subtree is written.
+#[derive(Clone, Copy, Default)]
+struct TextContext {
+    /// A node whose content is left out.
+    skip: Option<NodeId>,
+    /// Whether hidden nodes are included. This is the case when the root of the computation is
+    /// itself hidden or inside a hidden subtree, and for the chosen options of a `select`.
+    include_hidden: bool,
+}
+
+/// The given text, if it contains something other than ASCII whitespace.
+fn is_non_blank(text: Option<&str>) -> Option<&str> {
+    text.filter(|text| !text.trim_ascii().is_empty())
+}
+
+/// The role of an element: its `role` attribute if it has a valid one, or else its native role.
+fn element_role(element_data: &ElementData) -> Role {
+    element_data
+        .attr(local_name!("role"))
+        .and_then(role_from_name)
+        .or_else(|| role_from_element_data(element_data))
+        .unwrap_or(Role::Unknown)
+}
+
+/// The role which the value of a `role` attribute names, if it is one of the supported roles.
+/// Other values give `None`, and the element then has its native role.
+fn role_from_name(name: &str) -> Option<Role> {
+    match name {
+        "alert" => Some(Role::Alert),
+        "alertdialog" => Some(Role::AlertDialog),
+        "button" => Some(Role::Button),
+        "checkbox" => Some(Role::CheckBox),
+        "dialog" => Some(Role::Dialog),
+        "gridcell" => Some(Role::GridCell),
+        "link" => Some(Role::Link),
+        "log" => Some(Role::Log),
+        "marquee" => Some(Role::Marquee),
+        "menuitem" => Some(Role::MenuItem),
+        "menuitemcheckbox" => Some(Role::MenuItemCheckBox),
+        "menuitemradio" => Some(Role::MenuItemRadio),
+        "option" => Some(Role::ListBoxOption),
+        "progressbar" => Some(Role::ProgressIndicator),
+        "radio" => Some(Role::RadioButton),
+        "scrollbar" => Some(Role::ScrollBar),
+        "slider" => Some(Role::Slider),
+        "spinbutton" => Some(Role::SpinButton),
+        "status" => Some(Role::Status),
+        "tab" => Some(Role::Tab),
+        "tabpanel" => Some(Role::TabPanel),
+        "textbox" => Some(Role::TextInput),
+        "timer" => Some(Role::Timer),
+        "tooltip" => Some(Role::Tooltip),
+        "treeitem" => Some(Role::TreeItem),
+        "combobox" => Some(Role::ComboBox),
+        "grid" => Some(Role::Grid),
+        "listbox" => Some(Role::ListBox),
+        "menu" => Some(Role::Menu),
+        "menubar" => Some(Role::MenuBar),
+        "radiogroup" => Some(Role::RadioGroup),
+        "tablist" => Some(Role::TabList),
+        "tree" => Some(Role::Tree),
+        "treegrid" => Some(Role::TreeGrid),
+        "article" => Some(Role::Article),
+        "columnheader" => Some(Role::ColumnHeader),
+        "definition" => Some(Role::Definition),
+        "document" => Some(Role::Document),
+        "group" => Some(Role::Group),
+        "heading" => Some(Role::Heading),
+        "img" => Some(Role::Image),
+        "list" => Some(Role::List),
+        "listitem" => Some(Role::ListItem),
+        "math" => Some(Role::Math),
+        "note" => Some(Role::Note),
+        "region" => Some(Role::Region),
+        "row" => Some(Role::Row),
+        "rowgroup" => Some(Role::RowGroup),
+        "rowheader" => Some(Role::RowHeader),
+        "toolbar" => Some(Role::Toolbar),
+        "application" => Some(Role::Application),
+        "banner" => Some(Role::Banner),
+        "complementary" => Some(Role::Complementary),
+        "contentinfo" => Some(Role::ContentInfo),
+        "form" => Some(Role::Form),
+        "main" => Some(Role::Main),
+        "navigation" => Some(Role::Navigation),
+        "search" => Some(Role::Search),
+        _ => None,
+    }
+}
+
+/// The native role of an element as given by HTML-AAM, or `None` if there is no mapping.
+///
+/// <https://www.w3.org/TR/html-aam-1.0/>
+fn role_from_element_data(element_data: &ElementData) -> Option<Role> {
+    // <https://www.w3.org/TR/html-aam-1.0/>
+    match &*element_data.name.local {
+        // Document structure
+        "article" => Some(Role::Article),
+        "aside" => Some(Role::Complementary),
+        "footer" => Some(Role::Footer),
+        "header" => Some(Role::Header),
+        "main" => Some(Role::Main),
+        "nav" => Some(Role::Navigation),
+        "search" => Some(Role::Search),
+        "section" => Some(Role::Section),
+        "h1" | "h2" | "h3" | "h4" | "h5" | "h6" => Some(Role::Heading),
+        "p" => Some(Role::Paragraph),
+        "blockquote" => Some(Role::Blockquote),
+        "figure" => Some(Role::Figure),
+        "figcaption" | "caption" => Some(Role::Caption),
+        "hr" => Some(Role::Splitter),
+
+        // Grouping
+        "ul" | "ol" | "menu" => Some(Role::List),
+        "li" => Some(Role::ListItem),
+        "dl" => Some(Role::DescriptionList),
+        "dt" => Some(Role::Term),
+        "dd" => Some(Role::Definition),
+        "dialog" => Some(Role::Dialog),
+        "fieldset" => Some(Role::Group),
+        "form" => Some(Role::Form),
+        "div" => Some(Role::GenericContainer),
+        "span" => Some(Role::GenericContainer),
+
+        // Tables
+        "table" => Some(Role::Table),
+        "thead" | "tbody" | "tfoot" => Some(Role::RowGroup),
+        "tr" => Some(Role::Row),
+        "td" => Some(Role::Cell),
+        "th" => match element_data.attr(local_name!("scope")) {
+            Some("row") | Some("rowgroup") => Some(Role::RowHeader),
+            _ => Some(Role::ColumnHeader),
+        },
+
+        // Interactive
+        // An <a> is only a link when it has an href.
+        "a" => match element_data.attr(local_name!("href")) {
+            Some(_) => Some(Role::Link),
+            None => Some(Role::GenericContainer),
+        },
+        "button" => Some(Role::Button),
+        "label" => Some(Role::Label),
+        "legend" => Some(Role::Label),
+        "select" => match element_data.attr(local_name!("multiple")) {
+            Some(_) => Some(Role::ListBox),
+            None => Some(Role::ComboBox),
+        },
+        "option" => Some(Role::ListBoxOption),
+        "textarea" => Some(Role::MultilineTextInput),
+        "progress" => Some(Role::ProgressIndicator),
+        "meter" => Some(Role::Meter),
+        "output" => Some(Role::Status),
+        "summary" => Some(Role::DisclosureTriangle),
+
+        // Inline semantics
+        "code" => Some(Role::Code),
+        "em" => Some(Role::Emphasis),
+        "strong" => Some(Role::Strong),
+        "mark" => Some(Role::Mark),
+        "time" => Some(Role::Time),
+        "img" => Some(Role::Image),
+        "iframe" => Some(Role::Iframe),
+
+        "input" => {
+            let ty = element_data.attr(local_name!("type")).unwrap_or("text");
+            match ty {
+                "button" | "submit" | "reset" => Some(Role::Button),
+                "checkbox" => Some(Role::CheckBox),
+                "color" => Some(Role::ColorWell),
+                "date" => Some(Role::DateInput),
+                "datetime-local" => Some(Role::DateTimeInput),
+                "email" => Some(Role::EmailInput),
+                "number" => Some(Role::NumberInput),
+                "password" => Some(Role::PasswordInput),
+                "radio" => Some(Role::RadioButton),
+                "range" => Some(Role::Slider),
+                "search" => Some(Role::SearchInput),
+                "tel" => Some(Role::PhoneNumberInput),
+                "time" => Some(Role::TimeInput),
+                _ => Some(Role::TextInput),
+            }
+        }
+        _ => None,
+    }
+}
+
+/// The default level of a heading element. AccessKit levels are zero-based, while ARIA levels are
+/// one-based.
+fn default_level_for_tag(name: &str) -> Option<usize> {
+    // Accesskit levels are 0-based, while ARIA levels are 1-based
+    // See https://docs.rs/accesskit/latest/accesskit/struct.Node.html#method.level
+    match name {
+        "h1" => Some(0),
+        "h2" => Some(1),
+        "h3" => Some(2),
+        "h4" => Some(3),
+        "h5" => Some(4),
+        "h6" => Some(5),
+        _ => None,
+    }
+}
+
+/// The implicit level of an element with the given role, if its role has one. AccessKit levels
+/// are zero-based, while ARIA levels are one-based.
+fn default_level_for_role(role: Role) -> Option<usize> {
+    match role {
+        // ARIA specifies an implicit level of 2 for the heading role. Accesskit levels are 0-based,
+        // so this turns into level 1
+        Role::Heading => Some(1),
+        _ => None,
+    }
+}
+
+/// Whether the name of an element with the given role is computed from its content.
+///
+/// <https://www.w3.org/TR/wai-aria-1.2/#namefromcontent>
+///
+/// HTML-AAM names the native `tr`, `td` and `th` elements from their `title` only, so they are
+/// exceptions unless a `role` attribute gives them a role.
+fn names_from_content(role: Role, element_data: &ElementData) -> bool {
+    let is_native_table_part = matches!(&*element_data.name.local, "tr" | "td" | "th")
+        && element_data
+            .attr(local_name!("role"))
+            .and_then(role_from_name)
+            .is_none();
+    !is_native_table_part
+        && matches!(
+            role,
+            Role::Button
+                | Role::Cell
+                | Role::CheckBox
+                | Role::ColumnHeader
+                | Role::DefaultButton
+                | Role::GridCell
+                | Role::Heading
+                | Role::Link
+                | Role::ListBoxOption
+                | Role::MenuItem
+                | Role::MenuItemCheckBox
+                | Role::MenuItemRadio
+                | Role::MenuListOption
+                | Role::RadioButton
+                | Role::Row
+                | Role::RowHeader
+                | Role::Switch
+                | Role::Tab
+                | Role::Tooltip
+                | Role::TreeItem
+        )
+}
+
+/// Whether an element with the given role cannot be named.
+///
+/// <https://www.w3.org/TR/wai-aria-1.2/#namefromprohibited>
+fn role_prohibits_naming(role: Role) -> bool {
+    matches!(
+        role,
+        Role::Caption
+            | Role::Code
+            | Role::ContentDeletion
+            | Role::ContentInsertion
+            | Role::Emphasis
+            | Role::GenericContainer
+            | Role::Paragraph
+            | Role::Strong
+    )
+}
diff --git a/packages/blitz-dom/src/accessibility/tree_builder.rs b/packages/blitz-dom/src/accessibility/tree_builder.rs
new file mode 100644
index 0000000000..0046401b06
--- /dev/null
+++ b/packages/blitz-dom/src/accessibility/tree_builder.rs
@@ -0,0 +1,262 @@
+use crate::{
+    BaseDocument, Node,
+    accessibility::{FlatText, to_accesskit_node_id, to_accesskit_node_id_vec},
+};
+use accesskit::{Role, TreeId, TreeInfo, TreeUpdate};
+use blitz_traits::NodeId;
+use markup5ever::local_name;
+use rustc_hash::{FxHashMap, FxHashSet};
+
+/// The ID of the window node, which is the root of the tree. It is also the focus when no node is
+/// focused.
+const DEFAULT_ACCESSKIT_NODE_ID: accesskit::NodeId = accesskit::NodeId(u64::MAX);
+
+/// A utility to build accesskit trees out of [BaseDocument].
+///
+/// To use this, construct an instance with [TreeBuilder::new], then invoke [TreeBuilder::build] on
+/// it.
+pub(super) struct TreeBuilder<'doc> {
+    /// The document whose tree is built.
+    document: &'doc BaseDocument,
+    /// How the name and the description of a node derive from other nodes, by the ID of the node.
+    relations: FxHashMap<NodeId, Relations>,
+    /// The nodes which are not in the tree: those hidden with CSS, and their descendants.
+    excluded_nodes: FxHashSet<NodeId>,
+}
+
+impl<'doc> TreeBuilder<'doc> {
+    /// Collects what building needs: the nodes which are excluded from the tree and the relations
+    /// between nodes. This traverses the whole document.
+    pub fn new(document: &'doc BaseDocument) -> Self {
+        let mut excluded_nodes = FxHashSet::default();
+        let mut relations = FxHashMap::default();
+        document.visit(|node_id, node| {
+            if node.is_hidden_from_accessibility_tree()
+                || node
+                    .parent
+                    .is_some_and(|parent_id| excluded_nodes.contains(&parent_id))
+            {
+                excluded_nodes.insert(node_id);
+                return;
+            }
+            Self::collect_relations(&mut relations, node_id, node, document);
+        });
+        Self {
+            document,
+            relations,
+            excluded_nodes,
+        }
+    }
+
+    /// Records in `relations_map` the nodes which name or describe `node`. A `<label>` is recorded
+    /// on the element which it labels, not on itself. How the sources take precedence over one
+    /// another follows the specification.
+    ///
+    /// <https://www.w3.org/TR/accname-1.2/#computation-steps>
+    fn collect_relations(
+        relations_map: &mut FxHashMap<NodeId, Relations>,
+        node_id: NodeId,
+        node: &Node,
+        document: &BaseDocument,
+    ) {
+        if let Some(id_refs) = node.attr(local_name!("aria-labelledby")) {
+            let labelled_by = NameSource::AriaLabelledBy(
+                document.referenced_dom_ids_to_node_ids(id_refs).collect(),
+            );
+            relations_map.entry(node_id).or_default().labelled_by = Some(labelled_by);
+        } else if node.is_element_named(local_name!("label"))
+                && let Some(target) = document.label_control(node)
+                // aria-label on the target takes precedence over <label>.
+                && document.nodes[target]
+                    .attr(local_name!("aria-label"))
+                    .is_none_or(|aria_label| aria_label.trim_ascii().is_empty())
+        {
+            match relations_map.entry(target).or_default().labelled_by {
+                // The target has no label yet.
+                ref mut labelled_by @ None => {
+                    *labelled_by = Some(NameSource::LabelElements(vec![node_id]));
+                }
+
+                // The target has one label and this element adds another.
+                Some(NameSource::LabelElements(ref mut e)) => {
+                    e.push(node_id);
+                }
+
+                // The target already uses "aria-labelledby", which takes precedence over the
+                // <label> element.
+                Some(NameSource::AriaLabelledBy(_)) => {}
+            }
+        }
+
+        if let Some(aria_describedby) = node.attr(local_name!("aria-describedby")) {
+            let described_by = document
+                .referenced_dom_ids_to_node_ids(aria_describedby)
+                .collect();
+            relations_map.entry(node_id).or_default().described_by = Some(described_by);
+        }
+    }
+
+    /// Builds the tree update.
+    pub fn build(self) -> TreeUpdate {
+        TreeUpdate {
+            tree_id: TreeId::ROOT,
+            nodes: self.create_nodes(),
+            tree: Some(TreeInfo::new(DEFAULT_ACCESSKIT_NODE_ID)),
+            focus: self
+                .document
+                .focus_node_id
+                .map(to_accesskit_node_id)
+                .unwrap_or(DEFAULT_ACCESSKIT_NODE_ID),
+        }
+    }
+
+    /// The AccessKit nodes in document order, followed by the window node. The children of each
+    /// node are its children in the DOM except for the excluded ones.
+    fn create_nodes(&self) -> Vec<(accesskit::NodeId, accesskit::Node)> {
+        let mut window = accesskit::Node::new(Role::Window);
+        window.push_child(to_accesskit_node_id(self.document.root_node_id));
+        let mut nodes = Vec::new();
+        self.document.visit(|node_id, node| {
+            if self.excluded_nodes.contains(&node_id) {
+                return;
+            }
+            let mut accesskit_node = node.build_accesskit_node();
+            if accesskit_node.role() == Role::Label {
+                self.set_value_of_label(node, &mut accesskit_node);
+            }
+            let children: Vec<_> = node
+                .children
+                .iter()
+                .filter(|n| !self.excluded_nodes.contains(n))
+                .map(|n| to_accesskit_node_id(*n))
+                .collect();
+            accesskit_node.set_children(children);
+            self.resolve_name(node_id, node, &mut accesskit_node);
+            self.resolve_description(node_id, node, &mut accesskit_node);
+            nodes.push((to_accesskit_node_id(node_id), accesskit_node));
+        });
+        nodes
+            .into_iter()
+            .chain([(DEFAULT_ACCESSKIT_NODE_ID, window)])
+            .collect()
+    }
+
+    /// Sets the value of a node with the role [accesskit::Role::Label] to its text. AccessKit
+    /// expects the text of such a node in its value, not its label, and `accesskit_consumer` reads
+    /// it there when the node labels another node. A control wrapped by the `<label>` is left out.
+    fn set_value_of_label(&self, node: &Node, accesskit_node: &mut accesskit::Node) {
+        // A control wrapped by a <label> is not part of the text of the label.
+        let skip = node
+            .is_element_named(local_name!("label"))
+            .then(|| self.document.label_control(node))
+            .flatten();
+        let mut text = FlatText::default();
+        node.write_text_alternative(&mut text, skip);
+        if !text.text.is_empty() {
+            accesskit_node.set_value(text.text);
+        }
+    }
+
+    /// Sets the label of `accesskit_node`, and `labelled_by` if other nodes name it. The text of
+    /// those nodes takes precedence. Without any, this falls back to
+    /// [Node::set_accesskit_node_label].
+    ///
+    /// The `labelled_by` of an `aria-labelledby` leaves out the targets which are not in the tree,
+    /// but their text still counts.
+    ///
+    /// <https://www.w3.org/TR/accname-1.2/#comp_hidden_not_referenced>
+    fn resolve_name(&self, node_id: NodeId, node: &Node, accesskit_node: &mut accesskit::Node) {
+        let mut label = FlatText::default();
+        if let Some(labelled_by) = self
+            .relations
+            .get(&node_id)
+            .and_then(|r| r.labelled_by.as_ref())
+        {
+            match labelled_by {
+                NameSource::AriaLabelledBy(node_ids) => {
+                    accesskit_node.set_labelled_by(to_accesskit_node_id_vec(
+                        node_ids
+                            .iter()
+                            .filter(|id| !self.excluded_nodes.contains(id)),
+                    ));
+                    for label_node_id in node_ids {
+                        self.document.nodes[*label_node_id]
+                            .write_text_alternative(&mut label, None);
+                        label.break_word();
+                    }
+                }
+                NameSource::LabelElements(node_ids) => {
+                    accesskit_node.set_labelled_by(to_accesskit_node_id_vec(node_ids));
+                    for label_node_id in node_ids {
+                        self.document.nodes[*label_node_id].write_text_alternative(
+                            &mut label,
+                            // A <label> does not contribute the content of the element it labels.
+                            Some(node_id),
+                        );
+                        label.break_word();
+                    }
+                }
+            }
+        }
+        if !label.text.is_empty() {
+            accesskit_node.set_label(label.text.as_str());
+        } else {
+            node.set_accesskit_node_label(accesskit_node);
+        }
+    }
+
+    /// Sets the description of `accesskit_node`, and `described_by` if `aria-describedby` refers
+    /// to other nodes. Their text takes precedence. Without any, this falls back to
+    /// [Node::set_accesskit_node_description].
+    ///
+    /// The `described_by` leaves out the targets which are not in the tree, but their text still
+    /// counts. This must come after [TreeBuilder::resolve_name], since the description of a node
+    /// can depend on its label.
+    ///
+    /// <https://www.w3.org/TR/accname-1.2/#mapping_additional_nd_description>
+    fn resolve_description(
+        &self,
+        node_id: NodeId,
+        node: &Node,
+        accesskit_node: &mut accesskit::Node,
+    ) {
+        let mut description = FlatText::default();
+        if let Some(described_by) = self
+            .relations
+            .get(&node_id)
+            .and_then(|r| r.described_by.as_ref())
+        {
+            for description_node_id in described_by {
+                let description_node = &self.document.nodes[*description_node_id];
+                if !self.excluded_nodes.contains(description_node_id) {
+                    accesskit_node.push_described_by(to_accesskit_node_id(*description_node_id));
+                }
+                description_node.write_text_alternative(&mut description, None);
+                description.break_word();
+            }
+        }
+        if !description.text.is_empty() {
+            accesskit_node.set_description(description.text.as_str());
+        } else {
+            node.set_accesskit_node_description(accesskit_node);
+        }
+    }
+}
+
+/// The nodes which name or describe a node, other than the node itself.
+#[derive(Default, Debug)]
+struct Relations {
+    /// What provides the name, if anything.
+    labelled_by: Option<NameSource>,
+    /// The targets of `aria-describedby`, in order.
+    described_by: Option<Vec<NodeId>>,
+}
+
+/// What provides the name of a node, other than the node itself.
+#[derive(Debug)]
+enum NameSource {
+    /// The targets of `aria-labelledby`, in order. IDs which match no element are left out.
+    AriaLabelledBy(Vec<NodeId>),
+    /// The `<label>` elements which label the node, in document order.
+    LabelElements(Vec<NodeId>),
+}
diff --git a/tests/blitz-tests/Cargo.toml b/tests/blitz-tests/Cargo.toml
index 7b39bb89d1..3b4843a5bb 100644
--- a/tests/blitz-tests/Cargo.toml
+++ b/tests/blitz-tests/Cargo.toml
@@ -34,6 +34,7 @@ cursor-icon = { workspace = true }
 keyboard-types = { workspace = true }
 taffy = { workspace = true }
 test-that = { workspace = true }
+rstest = { workspace = true }
 usvg = { workspace = true }
 
 [lib]
diff --git a/tests/blitz-tests/tests/accessibility_description.rs b/tests/blitz-tests/tests/accessibility_description.rs
index dc14f77c9b..565fe38753 100644
--- a/tests/blitz-tests/tests/accessibility_description.rs
+++ b/tests/blitz-tests/tests/accessibility_description.rs
@@ -2,6 +2,7 @@ use accesskit::{Node as AccessKitNode, Role};
 use blitz_dom::DocumentConfig;
 use blitz_html::{HtmlDocument, HtmlProvider};
 use blitz_traits::shell::{ColorScheme, Viewport};
+use rstest::rstest;
 use std::sync::Arc;
 use test_that::prelude::*;
 
@@ -27,6 +28,28 @@ fn includes_aria_description_as_description() -> TestResult<()> {
     )
 }
 
+#[test]
+fn normalises_aria_description() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><div role="button" aria-description=" A  description "></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::Button),
+                description(): some(eq("A description")),
+            })
+        ))
+    )
+}
+
 #[test]
 fn includes_aria_describedby_targets_as_described_by_in_order() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
@@ -92,6 +115,714 @@ fn excludes_aria_describedby_targets_which_are_not_in_the_accessibility_tree() -
     )
 }
 
+#[test]
+fn has_no_description_when_there_is_no_source() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><button>Content</button></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::Button),
+                description(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn has_no_description_when_aria_describedby_targets_do_not_exist() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><div role="button" aria-describedby="nonexistent-element"></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::Button),
+                description(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn has_no_description_when_aria_describedby_targets_have_no_text() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <div role="button" aria-describedby="empty"></div>
+          <span id="empty"></span>
+        </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::Button),
+                description(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn does_not_use_aria_label_as_description() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><div role="button" aria-label="A label"></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::Button),
+                label(): some(eq("A label")),
+                description(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn does_not_use_text_of_aria_describedby_target_as_label() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <span id="target">Description</span>
+        </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::Button),
+                label(): none(),
+                description(): some(eq("Description")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn computes_label_and_description_independently() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <div role="button" aria-labelledby="label" aria-describedby="description"></div>
+          <span id="label">Label</span>
+          <span id="description">Description</span>
+        </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::Button),
+                label(): some(eq("Label")),
+                description(): some(eq("Description")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn uses_text_of_hidden_aria_describedby_target_without_referencing_it() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <div role="button" aria-describedby="hidden-element"></div>
+          <span id="hidden-element" style="display: none">Hidden</span>
+        </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::Button),
+                description(): some(eq("Hidden")),
+                *described_by(): is_empty(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn uses_title_as_description_of_img_with_alt() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><img alt="Alt text" title="Title text"></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::Image),
+                label(): some(eq("Alt text")),
+                description(): some(eq("Title text")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn uses_title_as_description_of_input_named_by_label_element() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <label for="arbitrary-input">Name</label>
+          <input id="arbitrary-input" title="Hint">
+        </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::TextInput),
+                label(): some(eq("Name")),
+                description(): some(eq("Hint")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn does_not_use_title_as_description_when_it_provides_the_name() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><button title="Tip text"></button></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::Button),
+                description(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn uses_title_as_description_of_element_whose_role_prohibits_naming() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><div title="Tip">text</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 {
+                html_tag(): some(eq("div")),
+                label(): none(),
+                description(): some(eq("Tip")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn uses_title_as_description_of_img_with_empty_alt() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><img alt="" title="Title text"></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 {
+                html_tag(): some(eq("img")),
+                label(): none(),
+                description(): some(eq("Title text")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn does_not_use_title_as_description_of_img_without_alt() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><img title="Title text"></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 {
+                html_tag(): some(eq("img")),
+                description(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn uses_title_as_description_when_aria_descrpition_is_blank() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><div aria-description="  " title="Title text"></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 {
+                html_tag(): some(eq("div")),
+                description(): some(eq("Title text")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn ignores_blank_title_as_description() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><button title="   ">Save</button></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::Button),
+                description(): none(),
+            })
+        ))
+    )
+}
+
+#[rstest]
+#[case::uses_text_of_aria_describedby_targets_in_attribute_order(
+    r#"<html>
+          <div role="button" aria-describedby="second first"></div>
+          <span id="first">  First </span>
+          <span id="second">Second
+            label</span>
+        </html>"#,
+    "Second label First"
+)]
+#[case::uses_aria_label_of_aria_describedby_target(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <span id="target" aria-label="From aria-label">From content</span>
+        </html>"#,
+    "From aria-label"
+)]
+#[case::aria_describedby_takes_precedence_over_aria_description(
+    r#"<html>
+          <div role="button" aria-description="Ignored" aria-describedby="target"></div>
+          <span id="target">Referenced</span>
+        </html>"#,
+    "Referenced"
+)]
+#[case::falls_back_to_aria_description_when_aria_describedby_targets_have_no_text(
+    r#"<html>
+          <div role="button" aria-description="Fallback" aria-describedby="empty"></div>
+          <span id="empty"></span>
+        </html>"#,
+    "Fallback"
+)]
+#[case::ignores_invalid_idrefs_among_valid_aria_describedby_idrefs(
+    r#"<html>
+          <div role="button" aria-describedby="nonexistent-element first"></div>
+          <span id="first">First</span>
+        </html>"#,
+    "First"
+)]
+#[case::does_not_follow_aria_labelledby_of_aria_describedby_target(
+    r#"<html>
+          <div role="button" aria-describedby="first"></div>
+          <span id="first" aria-labelledby="second">First</span>
+          <span id="second">Second</span>
+        </html>"#,
+    "First"
+)]
+#[case::does_not_follow_aria_describedby_of_aria_describedby_target(
+    r#"<html>
+          <div role="button" aria-describedby="first"></div>
+          <span id="first" aria-describedby="second">First</span>
+          <span id="second">Second</span>
+        </html>"#,
+    "First"
+)]
+#[case::ignores_aria_description_of_aria_describedby_target(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <span id="target" aria-description="Ignored">Text</span>
+        </html>"#,
+    "Text"
+)]
+#[case::uses_text_of_aria_hidden_aria_describedby_target(
+    r#"<html>
+          <div role="button" aria-describedby="hidden-element"></div>
+          <span id="hidden-element" aria-hidden="true">Save</span>
+        </html>"#,
+    "Save"
+)]
+#[case::uses_hidden_aria_describedby_targets_for_description_without_referencing_them(
+    r#"<html>
+          <div role="button" aria-describedby="hidden-element hidden-descendant"></div>
+          <span id="hidden-element" style="display: none">Save</span>
+          <div style="visibility: hidden"><span id="hidden-descendant">file</span></div>
+        </html>"#,
+    "Save file"
+)]
+#[case::includes_self_reference_and_nested_text_in_aria_describedby(
+    r#"<html>
+          <div role="button" id="self" aria-describedby="self label">Delete</div>
+          <span id="label">file<b>name</b></span>
+        </html>"#,
+    "Delete filename"
+)]
+#[case::uses_text_of_label_element_referenced_by_aria_describedby(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <label id="target">Save <span>the file</span></label>
+        </html>"#,
+    "Save the file"
+)]
+#[case::includes_img_alt_in_aria_describedby_target_text(
+    r#"<html>
+          <div role="button" aria-describedby="nested-img direct-img"></div>
+          <span id="nested-img">Save <img alt="logo"></span>
+          <img id="direct-img" alt="now" aria-label="">
+        </html>"#,
+    "Save logo now"
+)]
+#[case::prefers_img_aria_label_over_alt_in_aria_describedby_target(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <img id="target" alt="Alt text" aria-label="Aria label">
+        </html>"#,
+    "Aria label"
+)]
+#[case::concatenates_elements_with_space_between_them_when_markup_does_not_include_whitespace(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target"><div>Node</div><div>content</div></div></html>"#,
+    "Node content"
+)]
+#[case::separates_text_from_following_block_element_within_inline_parent(
+    r#"<html><div role="button" aria-describedby="target"></div><span id="target">Save<div>file</div></span></html>"#,
+    "Save file"
+)]
+#[case::does_not_separate_adjacent_inline_content_in_block_parent(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target">Sa<b>ve</b></div></html>"#,
+    "Save"
+)]
+#[case::does_not_separate_text_around_comment(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target">Sa<!-- arbitrary comment -->ve</div></html>"#,
+    "Save"
+)]
+#[case::does_not_separate_text_around_display_none_element(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target">Sa<span style="display: none">arbitrary</span>ve</div></html>"#,
+    "Save"
+)]
+#[case::does_not_separate_text_around_display_contents_inline_element(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target">Sa<span style="display: contents">v</span>e</div></html>"#,
+    "Save"
+)]
+#[case::separates_table_cells(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target"><table><tr><td>First</td><td>second</td></tr></table></div></html>"#,
+    "First second"
+)]
+#[case::separates_elements_with_display_table_cell(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target"><span style="display: table-cell">First</span><span style="display: table-cell">second</span></div></html>"#,
+    "First second"
+)]
+#[case::separates_floated_element_from_surrounding_text(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target"><span style="float: left">First</span>second</div></html>"#,
+    "First second"
+)]
+#[case::separates_absolutely_positioned_element_from_surrounding_text(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target"><span style="position: absolute">First</span>second</div></html>"#,
+    "First second"
+)]
+#[case::separates_img_alt_from_adjacent_text(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target">Save<img alt="the">file</div></html>"#,
+    "Save the file"
+)]
+#[case::separates_embedded_input_value_from_adjacent_text(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target">Flash<input value="5">times</div></html>"#,
+    "Flash 5 times"
+)]
+#[case::separates_inline_block_element_from_adjacent_text(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target">Save<span style="display: inline-block">the</span>file</div></html>"#,
+    "Save the file"
+)]
+#[case::does_not_separate_text_around_inline_element_containing_only_aria_hidden_block(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target">Sa<span><div aria-hidden="true">arbitrary</div></span>ve</div></html>"#,
+    "Save"
+)]
+#[case::separates_text_around_line_break(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target">First<br>second</div></html>"#,
+    "First second"
+)]
+#[case::does_not_separate_text_around_hidden_line_break(
+    r#"<html><div role="button" aria-describedby="target"></div><div id="target">First<br style="display: none;">second</div></html>"#,
+    "Firstsecond"
+)]
+#[case::separates_block_before_pseudo_element_from_content(
+    r#"<html>
+          <style>.arbitrary::before { content: "First"; display: block; }</style>
+          <div role="button" aria-describedby="target"></div>
+          <div id="target"><div class="arbitrary">second</div></div>
+        </html>"#,
+    "First second"
+)]
+#[case::separates_block_after_pseudo_element_from_content(
+    r#"<html>
+          <style>.arbitrary::after { content: "second"; display: block; }</style>
+          <div role="button" aria-describedby="target"></div>
+          <div id="target"><div class="arbitrary">First</div></div>
+        </html>"#,
+    "First second"
+)]
+#[case::separates_inline_block_pseudo_element_from_content(
+    r#"<html>
+          <style>.arbitrary::before { content: "First"; display: inline-block; }</style>
+          <div role="button" aria-describedby="target"></div>
+          <div id="target"><span class="arbitrary">second</span></div>
+        </html>"#,
+    "First second"
+)]
+#[case::joins_inline_pseudo_elements_to_content_without_space(
+    r#"<html>
+          <style>
+            .arbitrary::before { content: "Sa"; }
+            .arbitrary::after { content: "e"; }
+          </style>
+          <div role="button" aria-describedby="target"></div>
+          <div id="target"><span class="arbitrary">v</span></div>
+        </html>"#,
+    "Save"
+)]
+#[case::excludes_hidden_descendants_of_visible_aria_describedby_target(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <span id="target">Save
+            <span style="display: none">secret</span>
+            <span aria-hidden="true">hidden</span>
+            <span style="visibility: hidden">invisible</span>
+            file</span>
+        </html>"#,
+    "Save file"
+)]
+#[case::includes_hidden_descendants_of_hidden_aria_describedby_target(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <div id="target" style="visibility: hidden">Save
+            <span style="display: none">file</span></div>
+        </html>"#,
+    "Save file"
+)]
+#[case::uses_aria_label_of_descendants_of_aria_describedby_target(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <span id="target">Save <span aria-label="the file">ignored</span> now
+            <b aria-label="  ">blank aria-label is ignored</b></span>
+        </html>"#,
+    "Save the file now blank aria-label is ignored"
+)]
+#[case::uses_value_of_embedded_text_inputs(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <span id="target">Flash <input value="5"> times and
+            <textarea>notes</textarea> then <input type="password" value="secret"> done</span>
+        </html>"#,
+    "Flash 5 times and notes then done"
+)]
+#[case::uses_value_of_directly_referenced_text_input(
+    r#"<html>
+          <div role="button" aria-describedby="referenced"></div>
+          <input id="referenced" value="Entered" aria-label="Ignored">
+        </html>"#,
+    "Entered"
+)]
+#[case::uses_value_of_embedded_range_controls(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <span id="target">
+            <div role="slider" aria-valuenow="3" aria-valuetext="three"></div>
+            <div role="spinbutton" aria-valuenow="4" aria-valuemin="0"></div>
+            <input type="range" value="7">
+          </span>
+        </html>"#,
+    "three 4 7"
+)]
+#[case::uses_chosen_option_of_embedded_select(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <span id="target">
+            Send
+            <select><option>One</option><option selected>Two</option></select>
+            and
+            <select><option>Three</option><option>Four</option></select>
+          </span>
+        </html>"#,
+    "Send Two and Three"
+)]
+#[case::separates_chosen_options_of_embedded_multiple_select(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <span id="target">Pick
+            <select multiple>
+              <option selected>One</option>
+              <option>Two</option>
+              <option selected>Three</option>
+            </select>
+            now</span>
+        </html>"#,
+    "Pick One Three now"
+)]
+#[case::separates_selected_options_of_embedded_listbox(
+    r#"<html>
+          <div role="button" aria-describedby="target"></div>
+          <span id="target">Pick
+            <div role="listbox">
+              <div role="option" aria-selected="true">One</div>
+              <div role="option" aria-selected="false">Two</div>
+              <div role="option" aria-selected="true">Three</div>
+            </div>
+            now</span>
+        </html>"#,
+    "Pick One Three now"
+)]
+#[case::includes_generated_content_of_aria_describedby_target_and_descendants(
+    r#"<html>
+          <head><style>
+            #target::before { content: "Before-"; }
+            #target::after { content: "-after"; }
+            #inner::before { content: "["; }
+            #inner::after { content: "]"; }
+          </style></head>
+          <body>
+            <div role="button" aria-describedby="target"></div>
+            <span id="target">text <span id="inner">inner</span></span>
+          </body>
+        </html>"#,
+    "Before-text [inner]-after"
+)]
+#[case::uses_title_as_description_when_name_comes_from_content(
+    r#"<html><button title="Tip text">Save</button></html>"#,
+    "Tip text"
+)]
+#[case::uses_title_as_description_when_name_comes_from_aria_label(
+    r#"<html><button title="Tip text" aria-label="Label">x</button></html>"#,
+    "Tip text"
+)]
+#[case::aria_describedby_takes_precedence_over_title(
+    r#"<html>
+          <div role="button" title="Ignored" aria-describedby="target"></div>
+          <span id="target">Referenced</span>
+        </html>"#,
+    "Referenced"
+)]
+#[case::aria_description_takes_precedence_over_title(
+    r#"<html><button title="Ignored" aria-description="Description">Save</button></html>"#,
+    "Description"
+)]
+#[case::collapses_whitespace_in_title_used_as_description(
+    r#"<html><button title="  Tip   text ">Save</button></html>"#,
+    "Tip text"
+)]
+fn button_has_description(
+    #[case] html: &str,
+    #[case] expected_description: &str,
+) -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(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::Button),
+                description(): some(eq(expected_description)),
+            })
+        ))
+    )
+}
+
 fn default_document_config() -> DocumentConfig {
     DocumentConfig {
         viewport: Some(Viewport::new(800, 600, 1.0, ColorScheme::Light)),
diff --git a/tests/blitz-tests/tests/accessibility_label.rs b/tests/blitz-tests/tests/accessibility_label.rs
index 21b57910e6..318d9fbf37 100644
--- a/tests/blitz-tests/tests/accessibility_label.rs
+++ b/tests/blitz-tests/tests/accessibility_label.rs
@@ -1,38 +1,44 @@
-use accesskit::{Node as AccessKitNode, Role};
-use blitz_dom::DocumentConfig;
+use accesskit::{Node as AccessKitNode, NodeId, Role, TreeUpdate};
+use blitz_dom::{DocumentConfig, QualName, local_name, ns};
 use blitz_html::{HtmlDocument, HtmlProvider};
 use blitz_traits::shell::{ColorScheme, Viewport};
+use rstest::rstest;
 use std::sync::Arc;
 use test_that::prelude::*;
 
 #[test]
-fn includes_aria_label_as_label() -> TestResult<()> {
+fn includes_aria_labelledby_as_labelled_by_for_one_node() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
-        r#"<html><div role="button" aria-label="A node"></div></html>"#,
+        r#"<html>
+          <div role="button" aria-labelledby="arbitrary-element"></div>
+          <label id="arbitrary-element">Label</label>
+        </html>"#,
         default_document_config(),
     );
     document.resolve(0.0);
 
     let tree_update = document.build_accessibility_tree();
 
+    let label_node_id = node_id_with_role(&tree_update, Role::Label)?;
     verify_that!(
         tree_update.nodes,
         contains((
             anything(),
             matches_pattern!(AccessKitNode {
                 role(): eq(Role::Button),
-                label(): some(eq("A node")),
+                *labelled_by(): container_eq(vec![label_node_id]),
             })
         ))
     )
 }
 
 #[test]
-fn includes_aria_labelledby_as_labelled_by_for_one_node() -> TestResult<()> {
+fn includes_aria_labelledby_as_labelled_by_for_two_nodes() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
         r#"<html>
-          <div role="button" aria-labelledby="arbitrary-element"></div>
-          <label id="arbitrary-element">Label</label>
+          <div role="button" aria-labelledby="arbitrary-element another-element"></div>
+          <label id="another-element">Another label</label>
+          <nav id="arbitrary-element">Label</nav>
         </html>"#,
         default_document_config(),
     );
@@ -40,30 +46,52 @@ fn includes_aria_labelledby_as_labelled_by_for_one_node() -> TestResult<()> {
 
     let tree_update = document.build_accessibility_tree();
 
-    let (label_node_id, _) = tree_update
-        .nodes
-        .iter()
-        .find(|(_, node)| node.role() == Role::Label)
-        .expect("Label must be present in accessibility tree");
+    // The order of the IDs is the order of the IDs in the aria-labelledby attribute, which is
+    // important to the assertion.
+    let expected_node_ids = [
+        node_id_with_role(&tree_update, Role::Navigation)?,
+        node_id_with_role(&tree_update, Role::Label)?,
+    ];
     verify_that!(
         tree_update.nodes,
         contains((
             anything(),
             matches_pattern!(AccessKitNode {
                 role(): eq(Role::Button),
-                *labelled_by(): container_eq(vec![*label_node_id]),
+                *labelled_by(): container_eq(expected_node_ids),
             })
         ))
     )
 }
 
 #[test]
-fn includes_aria_labelledby_as_labelled_by_for_two_nodes() -> TestResult<()> {
+fn ignores_labelledby_element_which_does_not_correspond_to_element_in_the_dom() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><div role="button" aria-labelledby="nonexistent-element"></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::Button),
+                *labelled_by(): is_empty(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn aria_labelledby_takes_precedence_over_aria_label_and_content() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
         r#"<html>
-          <div role="button" aria-labelledby="arbitrary-element another-element"></div>
-          <label id="another-element">Another label</label>
-          <nav id="arbitrary-element">Label</nav>
+          <button aria-label="Ignored" aria-labelledby="label">Click</button>
+          <span id="label">Save</span>
         </html>"#,
         default_document_config(),
     );
@@ -71,42 +99,56 @@ fn includes_aria_labelledby_as_labelled_by_for_two_nodes() -> TestResult<()> {
 
     let tree_update = document.build_accessibility_tree();
 
-    // This awkward construction is due to having to fetch the node IDs for the label
-    // elements in the same order they appear in the aria-labelledby attribute. The
-    // order is also important to the assertion.
-    let mut expected_node_ids = Vec::new();
-    expected_node_ids.push(
-        tree_update
-            .nodes
-            .iter()
-            .find(|(_, node)| node.role() == Role::Navigation)
-            .expect("Expected to find label arbitrary-element in the tree")
-            .0,
-    );
-    expected_node_ids.push(
-        tree_update
-            .nodes
-            .iter()
-            .find(|(_, node)| node.role() == Role::Label)
-            .expect("Expected to find label another-element in the tree")
-            .0,
+    let span_node_id = node_id_with_tag(&tree_update, "span")?;
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::Button),
+                label(): some(eq("Save")),
+                *labelled_by(): container_eq(vec![span_node_id]),
+            })
+        ))
+    )
+}
+
+#[test]
+fn includes_self_reference_and_nested_text_in_aria_labelledby() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <div role="button" id="self" aria-labelledby="self label">Delete</div>
+          <span id="label">file<b>name</b></span>
+        </html>"#,
+        default_document_config(),
     );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    let button_node_id = node_id_with_role(&tree_update, Role::Button)?;
+    let span_node_id = node_id_with_tag(&tree_update, "span")?;
     verify_that!(
         tree_update.nodes,
         contains((
             anything(),
             matches_pattern!(AccessKitNode {
                 role(): eq(Role::Button),
-                *labelled_by(): container_eq(expected_node_ids),
+                label(): some(eq("Delete filename")),
+                *labelled_by(): container_eq(vec![button_node_id, span_node_id]),
             })
         ))
     )
 }
 
 #[test]
-fn ignores_labelledby_element_which_does_not_correspond_to_element_in_the_dom() -> TestResult<()> {
+fn uses_hidden_aria_labelledby_targets_for_label_without_referencing_them() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
-        r#"<html><div role="button" aria-labelledby="nonexistent-element"></div></html>"#,
+        r#"<html>
+          <div role="button" aria-labelledby="hidden-element hidden-descendant"></div>
+          <span id="hidden-element" style="display: none">Save</span>
+          <div style="visibility: hidden"><span id="hidden-descendant">file</span></div>
+        </html>"#,
         default_document_config(),
     );
     document.resolve(0.0);
@@ -119,6 +161,7 @@ fn ignores_labelledby_element_which_does_not_correspond_to_element_in_the_dom()
             anything(),
             matches_pattern!(AccessKitNode {
                 role(): eq(Role::Button),
+                label(): some(eq("Save file")),
                 *labelled_by(): is_empty(),
             })
         ))
@@ -126,13 +169,35 @@ fn ignores_labelledby_element_which_does_not_correspond_to_element_in_the_dom()
 }
 
 #[test]
-fn uses_text_of_aria_labelledby_targets_as_label() -> TestResult<()> {
+fn uses_img_alt_text_as_accessible_name() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
         r#"<html>
-          <div role="button" aria-labelledby="second first"></div>
-          <span id="first">  First </span>
-          <span id="second">Second
-            label</span>
+          <img alt="Image label">
+        </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::Image),
+                label(): some(eq("Image label")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn populates_labelled_by_from_label_element() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <button id="arbitrary-button"></button>
+          <label for="arbitrary-button">Button label</label>
         </html>"#,
         default_document_config(),
     );
@@ -140,24 +205,25 @@ fn uses_text_of_aria_labelledby_targets_as_label() -> TestResult<()> {
 
     let tree_update = document.build_accessibility_tree();
 
+    let label_node_id = node_id_with_role(&tree_update, Role::Label)?;
     verify_that!(
         tree_update.nodes,
         contains((
             anything(),
             matches_pattern!(AccessKitNode {
                 role(): eq(Role::Button),
-                label(): some(eq("Second label First")),
+                *labelled_by(): container_eq([label_node_id]),
             })
         ))
     )
 }
 
 #[test]
-fn aria_labelledby_takes_precedence_over_aria_label_and_content() -> TestResult<()> {
+fn populates_labelled_by_when_label_element_precedes_target() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
         r#"<html>
-          <button aria-label="Ignored" aria-labelledby="label">Click</button>
-          <span id="label">Save</span>
+          <label for="arbitrary-button">Button label</label>
+          <button id="arbitrary-button"></button>
         </html>"#,
         default_document_config(),
     );
@@ -165,30 +231,27 @@ fn aria_labelledby_takes_precedence_over_aria_label_and_content() -> TestResult<
 
     let tree_update = document.build_accessibility_tree();
 
-    let (span_node_id, _) = tree_update
-        .nodes
-        .iter()
-        .find(|(_, node)| node.html_tag() == Some("span"))
-        .expect("Span must be present in accessibility tree");
+    let label_node_id = node_id_with_role(&tree_update, Role::Label)?;
     verify_that!(
         tree_update.nodes,
         contains((
             anything(),
             matches_pattern!(AccessKitNode {
                 role(): eq(Role::Button),
-                label(): some(eq("Save")),
-                *labelled_by(): container_eq(vec![*span_node_id]),
+                *labelled_by(): container_eq([label_node_id]),
+                label(): some(eq("Button label")),
             })
         ))
     )
 }
 
 #[test]
-fn includes_self_reference_and_nested_text_in_aria_labelledby() -> TestResult<()> {
+fn includes_all_label_elements_referencing_the_same_target_in_document_order() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
         r#"<html>
-          <div role="button" id="self" aria-labelledby="self label">Delete</div>
-          <span id="label">file<b>name</b></span>
+          <label for="arbitrary-button">First</label>
+          <button id="arbitrary-button"></button>
+          <label for="arbitrary-button">Second</label>
         </html>"#,
         default_document_config(),
     );
@@ -196,35 +259,63 @@ fn includes_self_reference_and_nested_text_in_aria_labelledby() -> TestResult<()
 
     let tree_update = document.build_accessibility_tree();
 
-    let (button_node_id, _) = tree_update
-        .nodes
-        .iter()
-        .find(|(_, node)| node.role() == Role::Button)
-        .expect("Button must be present in accessibility tree");
-    let (span_node_id, _) = tree_update
-        .nodes
-        .iter()
-        .find(|(_, node)| node.html_tag() == Some("span"))
-        .expect("Span must be present in accessibility tree");
+    let first_label_id = label_node_id_with_value(&tree_update, "First")?;
+    let second_label_id = label_node_id_with_value(&tree_update, "Second")?;
     verify_that!(
         tree_update.nodes,
         contains((
             anything(),
             matches_pattern!(AccessKitNode {
                 role(): eq(Role::Button),
-                label(): some(eq("Delete filename")),
-                *labelled_by(): container_eq(vec![*button_node_id, *span_node_id]),
+                *labelled_by(): container_eq([first_label_id, second_label_id]),
+                label(): some(eq("First Second")),
             })
         ))
     )
 }
 
 #[test]
-fn uses_aria_label_of_aria_labelledby_target() -> TestResult<()> {
+fn labels_each_target_with_its_own_label_element() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
         r#"<html>
-          <div role="button" aria-labelledby="label"></div>
-          <span id="label" aria-label="From aria-label">From content</span>
+          <button id="first-button"></button>
+          <label for="first-button">First label</label>
+          <button id="second-button"></button>
+          <label for="second-button">Second label</label>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                    label(): some(eq("First label")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                    label(): some(eq("Second label")),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn label_element_takes_precedence_over_content_of_target() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <button id="arbitrary-button">Content</button>
+          <label for="arbitrary-button">Label</label>
         </html>"#,
         default_document_config(),
     );
@@ -232,25 +323,27 @@ fn uses_aria_label_of_aria_labelledby_target() -> TestResult<()> {
 
     let tree_update = document.build_accessibility_tree();
 
+    let label_node_id = node_id_with_role(&tree_update, Role::Label)?;
     verify_that!(
         tree_update.nodes,
         contains((
             anything(),
             matches_pattern!(AccessKitNode {
                 role(): eq(Role::Button),
-                label(): some(eq("From aria-label")),
+                label(): some(eq("Label")),
+                *labelled_by(): container_eq([label_node_id]),
             })
         ))
     )
 }
 
 #[test]
-fn uses_hidden_aria_labelledby_targets_for_label_without_referencing_them() -> TestResult<()> {
+fn aria_labelledby_takes_precedence_over_label_element() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
         r#"<html>
-          <div role="button" aria-labelledby="hidden-element hidden-descendant"></div>
-          <span id="hidden-element" style="display: none">Save</span>
-          <div style="visibility: hidden"><span id="hidden-descendant">file</span></div>
+          <button id="arbitrary-button" aria-labelledby="referenced"></button>
+          <label for="arbitrary-button">Label element</label>
+          <span id="referenced">Referenced</span>
         </html>"#,
         default_document_config(),
     );
@@ -258,13 +351,40 @@ fn uses_hidden_aria_labelledby_targets_for_label_without_referencing_them() -> T
 
     let tree_update = document.build_accessibility_tree();
 
+    let span_node_id = node_id_with_tag(&tree_update, "span")?;
     verify_that!(
         tree_update.nodes,
         contains((
             anything(),
             matches_pattern!(AccessKitNode {
                 role(): eq(Role::Button),
-                label(): some(eq("Save file")),
+                label(): some(eq("Referenced")),
+                *labelled_by(): container_eq([span_node_id]),
+            })
+        ))
+    )
+}
+
+#[test]
+fn aria_label_takes_precedence_over_label_element() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <button id="arbitrary-button" aria-label="Aria label"></button>
+          <label for="arbitrary-button">Label element</label>
+        </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::Button),
+                label(): some(eq("Aria label")),
                 *labelled_by(): is_empty(),
             })
         ))
@@ -272,11 +392,63 @@ fn uses_hidden_aria_labelledby_targets_for_label_without_referencing_them() -> T
 }
 
 #[test]
-fn falls_back_to_aria_label_when_aria_labelledby_targets_have_no_text() -> TestResult<()> {
+fn ignores_label_element_whose_for_does_not_match_any_element() -> TestResult<()> {
     let mut document = HtmlDocument::from_html(
         r#"<html>
-          <div role="button" aria-label="Fallback" aria-labelledby="empty"></div>
-          <span id="empty"></span>
+          <button id="arbitrary-button"></button>
+          <label for="nonexistent-element">Label</label>
+        </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::Button),
+                *labelled_by(): is_empty(),
+                label(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn ignores_label_element_without_for_attribute() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <button id="arbitrary-button"></button>
+          <label>Label</label>
+        </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::Button),
+                *labelled_by(): is_empty(),
+                label(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn ignores_label_element_which_is_hidden() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <button id="arbitrary-button"></button>
+          <label for="arbitrary-button" style="display: none;">Label</label>
         </html>"#,
         default_document_config(),
     );
@@ -290,12 +462,1701 @@ fn falls_back_to_aria_label_when_aria_labelledby_targets_have_no_text() -> TestR
             anything(),
             matches_pattern!(AccessKitNode {
                 role(): eq(Role::Button),
-                label(): some(eq("Fallback")),
+                *labelled_by(): is_empty(),
+                label(): none(),
             })
         ))
     )
 }
 
+#[test]
+fn ignores_label_element_whose_target_is_hidden() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <button id="arbitrary-button" style="display: none;"></button>
+          <label for="arbitrary-button">Label</label>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Label),
+                })
+            )),
+            not(contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                })
+            )))
+        )
+    )
+}
+
+#[test]
+fn associates_label_element_with_first_element_having_the_referenced_id() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <button id="duplicate"></button>
+          <nav id="duplicate" role="checkbox"></nav>
+          <label for="duplicate">Label</label>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                    label(): some(eq("Label")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::CheckBox),
+                    *labelled_by(): is_empty(),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn blank_aria_label_does_not_take_precedence_over_label_element() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <button id="arbitrary-button" aria-label="   "></button>
+          <label for="arbitrary-button">Label element</label>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    let label_node_id = node_id_with_role(&tree_update, Role::Label)?;
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::Button),
+                label(): some(eq("Label element")),
+                *labelled_by(): container_eq([label_node_id]),
+            })
+        ))
+    )
+}
+
+#[test]
+fn aria_label_takes_precedence_over_img_alt() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><img alt="Alt text" aria-label="Aria label"></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::Image),
+                label(): some(eq("Aria label")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn aria_labelledby_takes_precedence_over_img_alt() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <img alt="Alt text" aria-labelledby="referenced">
+          <span id="referenced">Referenced</span>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    let span_node_id = node_id_with_tag(&tree_update, "span")?;
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::Image),
+                label(): some(eq("Referenced")),
+                *labelled_by(): container_eq([span_node_id]),
+            })
+        ))
+    )
+}
+
+#[test]
+fn img_without_alt_has_no_label() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(r#"<html><img></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::Image),
+                label(): none(),
+                *labelled_by(): is_empty(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn populates_label_of_text_input_textarea_and_select_from_label_element() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <label for="text-input">Input label</label>
+          <input id="text-input">
+          <label for="text-area">Textarea label</label>
+          <textarea id="text-area"></textarea>
+          <label for="select-box">Select label</label>
+          <select id="select-box"><option>One</option></select>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::TextInput),
+                    label(): some(eq("Input label")),
+                    *labelled_by(): len(eq(1)),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::MultilineTextInput),
+                    label(): some(eq("Textarea label")),
+                    *labelled_by(): len(eq(1)),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::ComboBox),
+                    label(): some(eq("Select label")),
+                    *labelled_by(): len(eq(1)),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn ignores_invalid_idrefs_among_valid_aria_labelledby_idrefs() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <div role="button" aria-labelledby="nonexistent-element first"></div>
+          <span id="first">First</span>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    let span_node_id = node_id_with_tag(&tree_update, "span")?;
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::Button),
+                label(): some(eq("First")),
+                *labelled_by(): container_eq([span_node_id]),
+            })
+        ))
+    )
+}
+
+#[test]
+fn ignores_blank_aria_label() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <div role="button" aria-label=""></div>
+          <div role="checkbox" aria-label="   "></div>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                    label(): none(),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::CheckBox),
+                    label(): none(),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn falls_back_to_img_alt_when_aria_label_is_blank() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><img alt="Alt text" aria-label="  "></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::Image),
+                label(): some(eq("Alt text")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn ignores_empty_and_blank_img_alt() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><img alt=""><img alt="   "></html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        labels_of_elements_with_tag(&tree_update, "img"),
+        {none(), none()}
+    )
+}
+
+#[test]
+fn uses_figcaption_as_label_of_img_without_alt() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <figure>
+            <img>
+            <figcaption>Caption <b>text</b></figcaption>
+          </figure>
+        </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::Image),
+                label(): some(eq("Caption text")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn uses_figcaption_as_label_of_img_nested_in_figure_content() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <figure>
+            <div><a href="arbitrary"><img></a></div>
+            <figcaption>Caption</figcaption>
+          </figure>
+        </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::Image),
+                label(): some(eq("Caption")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn img_alt_takes_precedence_over_figcaption() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <figure>
+            <img alt="Alt text">
+            <figcaption>Caption</figcaption>
+          </figure>
+        </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::Image),
+                label(): some(eq("Alt text")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn does_not_use_figcaption_for_img_with_empty_alt() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <figure>
+            <img alt="">
+            <figcaption>Caption</figcaption>
+          </figure>
+        </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 {
+                html_tag(): some(eq("img")),
+                label(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn does_not_use_figcaption_for_img_with_title() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <figure>
+            <img title="Title text">
+            <figcaption>Caption</figcaption>
+          </figure>
+        </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 {
+                html_tag(): some(eq("img")),
+                label(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn does_not_use_figcaption_for_img_in_figure_with_other_content() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <figure>
+            <img>
+            <p>Other content</p>
+            <figcaption>Caption</figcaption>
+          </figure>
+          <figure>
+            <img>
+            <img>
+            <figcaption>Another caption</figcaption>
+          </figure>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        labels_of_elements_with_tag(&tree_update, "img"),
+        {none(), none(), none()}
+    )
+}
+
+#[test]
+fn does_not_use_figcaption_for_img_outside_figure_with_figcaption() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <img>
+          <figure><figcaption>Caption</figcaption></figure>
+        </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::Image),
+                label(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn ignores_label_element_whose_target_is_not_labelable() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <div id="div-target" role="button"></div>
+          <label for="div-target">Div label</label>
+          <nav id="nav-target" role="checkbox"></nav>
+          <label for="nav-target">Nav label</label>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                    label(): none(),
+                    *labelled_by(): is_empty(),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::CheckBox),
+                    label(): none(),
+                    *labelled_by(): is_empty(),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn ignores_label_element_when_first_element_with_the_referenced_id_is_not_labelable()
+-> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <div id="duplicate"></div>
+          <button id="duplicate"></button>
+          <label for="duplicate">Label</label>
+        </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::Button),
+                label(): none(),
+                *labelled_by(): is_empty(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn populates_label_of_meter_output_progress_and_checkbox_from_label_element() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <label for="meter-target">Meter label</label>
+          <meter id="meter-target"></meter>
+          <label for="output-target">Output label</label>
+          <output id="output-target"></output>
+          <label for="progress-target">Progress label</label>
+          <progress id="progress-target"></progress>
+          <label for="checkbox-target">Checkbox label</label>
+          <input id="checkbox-target" type="checkbox">
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Meter),
+                    label(): some(eq("Meter label")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Status),
+                    label(): some(eq("Output label")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::ProgressIndicator),
+                    label(): some(eq("Progress label")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::CheckBox),
+                    label(): some(eq("Checkbox label")),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn populates_label_from_label_element_wrapping_the_target() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><label>Name <input></label></html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    let label_node_id = node_id_with_role(&tree_update, Role::Label)?;
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::TextInput),
+                label(): some(eq("Name")),
+                *labelled_by(): container_eq([label_node_id]),
+            })
+        ))
+    )
+}
+
+#[test]
+fn excludes_wrapped_target_content_from_label_text() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <label>Notes <textarea>Draft</textarea> here</label>
+          <label>Save <button>Go</button> now</label>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::MultilineTextInput),
+                    label(): some(eq("Notes here")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                    label(): some(eq("Save now")),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn wrapping_label_element_labels_only_its_first_labelable_descendant() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <label>
+            <span>Label</span>
+            <input>
+            <textarea></textarea>
+          </label>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::TextInput),
+                    label(): some(eq("Label")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::MultilineTextInput),
+                    label(): none(),
+                    *labelled_by(): is_empty(),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn for_attribute_takes_precedence_over_wrapped_target() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <label for="referenced">Label <input></label>
+          <button id="referenced"></button>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                    label(): some(eq("Label")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::TextInput),
+                    label(): none(),
+                    *labelled_by(): is_empty(),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn does_not_label_wrapped_target_when_for_attribute_references_non_labelable_element()
+-> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <label for="not-labelable">Label <input></label>
+          <nav id="not-labelable"></nav>
+        </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::TextInput),
+                label(): none(),
+                *labelled_by(): is_empty(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn combines_wrapping_and_for_label_elements_in_document_order() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <label>Outer <input id="target"></label>
+          <label for="target">Second</label>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    let outer_label_id = label_node_id_with_value(&tree_update, "Outer")?;
+    let second_label_id = label_node_id_with_value(&tree_update, "Second")?;
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::TextInput),
+                label(): some(eq("Outer Second")),
+                *labelled_by(): container_eq([outer_label_id, second_label_id]),
+            })
+        ))
+    )
+}
+
+#[test]
+fn aria_label_of_wrapped_target_takes_precedence_over_wrapping_label_element() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><label>Label <input aria-label="Aria label"></label></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::TextInput),
+                label(): some(eq("Aria label")),
+                *labelled_by(): is_empty(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn uses_alt_of_image_input_as_label() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <input type="image" alt="Image button">
+          <input type="image" alt="  ">
+          <input type="text" alt="Ignored on other types">
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        labels_of_elements_with_tag(&tree_update, "input"),
+        {some(eq("Image button")), none(), none()}
+    )
+}
+
+#[test]
+fn uses_value_of_button_inputs_as_label() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <input type="button" value="Click">
+          <input type="submit" value="Send">
+          <input type="reset" value="Clear">
+          <input type="button">
+          <input type="text" value="Not a label">
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        labels_of_elements_with_tag(&tree_update, "input"),
+        {
+            some(eq("Click")),
+            some(eq("Send")),
+            some(eq("Clear")),
+            none(),
+            none()
+        }
+    )
+}
+
+#[test]
+fn label_element_and_aria_label_take_precedence_over_input_value_and_alt() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <input id="button-input" type="button" value="Value">
+          <label for="button-input">Label element</label>
+          <input id="image-input" type="image" alt="Alt" aria-label="Aria label">
+          <label for="image-input">Ignored label element</label>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        labels_of_elements_with_tag(&tree_update, "input"),
+        {some(eq("Label element")), some(eq("Aria label"))}
+    )
+}
+
+#[test]
+fn uses_first_legend_child_as_label_of_fieldset() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <fieldset>
+            <div><legend>Nested legend</legend></div>
+            <legend>Group <b>name</b></legend>
+            <legend>Second legend</legend>
+          </fieldset>
+          <fieldset><div>No legend</div></fieldset>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        labels_of_elements_with_tag(&tree_update, "fieldset"),
+        {some(eq("Group name")), none()}
+    )
+}
+
+#[test]
+fn uses_first_caption_child_as_label_of_table() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <table>
+            <caption>Sales <i>figures</i></caption>
+            <tr><td>1</td></tr>
+          </table>
+          <table><tr><td>No caption</td></tr></table>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        labels_of_elements_with_tag(&tree_update, "table"),
+        {some(eq("Sales figures")), none()}
+    )
+}
+
+#[test]
+fn uses_subtree_of_first_summary_child_of_details_as_label() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <details open>
+            <summary>More <i>info</i></summary>
+            <summary>Second summary</summary>
+            Details content
+          </details>
+          <div><summary>Not in details</summary></div>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        labels_of_elements_with_tag(&tree_update, "summary"),
+        {some(eq("More info")), none(), none()}
+    )
+}
+
+#[test]
+fn provides_text_of_label_element_as_value() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <label for="arbitrary-button">  Save <span>the   file</span> </label>
+          <button id="arbitrary-button"></button>
+        </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::Label),
+                value(): some(eq("Save the file")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn excludes_wrapped_control_from_value_of_label_element() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><label>Notes <textarea>Draft</textarea> here</label></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::Label),
+                value(): some(eq("Notes here")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn provides_text_of_legend_element_as_value() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><fieldset><legend>Group <b>name</b></legend></fieldset></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::Label),
+                value(): some(eq("Group name")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn omits_value_of_label_element_without_text() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><label for="arbitrary-button"></label><button id="arbitrary-button"></button></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::Label),
+                value(): none(),
+            })
+        ))
+    )
+}
+
+#[test]
+fn uses_content_as_label_of_elements_named_from_content() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <button>Click <b>me</b></button>
+          <a href="arbitrary">Link text</a>
+          <h1>Heading text</h1>
+          <div role="tab">Tab text</div>
+          <div role="menuitem">Item text</div>
+          <div role="gridcell">Cell text</div>
+          <div role="columnheader">Column text</div>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                    label(): some(eq("Click me")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Link),
+                    label(): some(eq("Link text")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Heading),
+                    label(): some(eq("Heading text")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Tab),
+                    label(): some(eq("Tab text")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::MenuItem),
+                    label(): some(eq("Item text")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::GridCell),
+                    label(): some(eq("Cell text")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::ColumnHeader),
+                    label(): some(eq("Column text")),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn aria_label_takes_precedence_over_content() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <button aria-label="Aria label">Content</button>
+          <a href="arbitrary" aria-label="  ">Blank aria-label</a>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                    label(): some(eq("Aria label")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Link),
+                    label(): some(eq("Blank aria-label")),
+                })
+            ))
+        )
+    )
+}
+
+#[test]
+fn does_not_use_content_as_label_of_elements_not_named_from_content() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <p>Paragraph text</p>
+          <span>Span text</span>
+          <div>Div text</div>
+          <table><tr><th>Header text</th><td>Cell text</td></tr></table>
+          <button></button>
+        </html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        each(
+            (
+                anything(),
+                matches_pattern!(AccessKitNode { label(): none() })
+            )
+                .or((
+                    anything(),
+                    matches_pattern!(AccessKitNode { role(): eq(Role::TextRun) })
+                ))
+        )
+    )
+}
+
+#[test]
+fn does_not_populate_labelled_by_from_text_content() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html><p>Paragraph text</p><button>Click</button><h1>Heading</h1></html>"#,
+        default_document_config(),
+    );
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        each((
+            anything(),
+            matches_pattern!(AccessKitNode { *labelled_by(): is_empty() })
+        ))
+    )
+}
+
+#[test]
+fn aria_labelledby_references_first_element_in_tree_order_with_duplicate_id() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <div role="button" aria-labelledby="duplicate"></div>
+          <span id="first">First</span>
+          <span id="second">Second</span>
+        </html>"#,
+        default_document_config(),
+    );
+    assign_duplicate_id_in_reverse_tree_order(&mut document, "duplicate", "#first", "#second");
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            anything(),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::Button),
+                label(): some(eq("First")),
+            })
+        ))
+    )
+}
+
+#[test]
+fn label_element_labels_first_element_in_tree_order_with_duplicate_id() -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(
+        r#"<html>
+          <label for="duplicate">Label</label>
+          <button id="first"></button>
+          <textarea id="second"></textarea>
+        </html>"#,
+        default_document_config(),
+    );
+    assign_duplicate_id_in_reverse_tree_order(&mut document, "duplicate", "#first", "#second");
+    document.resolve(0.0);
+
+    let tree_update = document.build_accessibility_tree();
+
+    verify_that!(
+        tree_update.nodes,
+        all!(
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::Button),
+                    label(): some(eq("Label")),
+                })
+            )),
+            contains((
+                anything(),
+                matches_pattern!(AccessKitNode {
+                    role(): eq(Role::MultilineTextInput),
+                    label(): none(),
+                    *labelled_by(): is_empty(),
+                })
+            ))
+        )
+    )
+}
+
+#[rstest]
+#[case::includes_aria_label_as_label(
+    r#"<html><div role="button" aria-label="A node"></div></html>"#,
+    "A node"
+)]
+#[case::uses_text_of_aria_labelledby_targets_as_label(
+    r#"<html>
+          <div role="button" aria-labelledby="second first"></div>
+          <span id="first">  First </span>
+          <span id="second">Second
+            label</span>
+        </html>"#,
+    "Second label First"
+)]
+#[case::uses_aria_label_of_aria_labelledby_target(
+    r#"<html>
+          <div role="button" aria-labelledby="label"></div>
+          <span id="label" aria-label="From aria-label">From content</span>
+        </html>"#,
+    "From aria-label"
+)]
+#[case::falls_back_to_aria_label_when_aria_labelledby_targets_have_no_text(
+    r#"<html>
+          <div role="button" aria-label="Fallback" aria-labelledby="empty"></div>
+          <span id="empty"></span>
+        </html>"#,
+    "Fallback"
+)]
+#[case::uses_text_of_label_element_as_label_of_target(
+    r#"<html>
+          <button id="arbitrary-button"></button>
+          <label for="arbitrary-button">  Button   label </label>
+        </html>"#,
+    "Button label"
+)]
+#[case::uses_text_of_nested_elements_in_label_element(
+    r#"<html>
+          <button id="arbitrary-button"></button>
+          <label for="arbitrary-button">Save <span>the file</span> now</label>
+        </html>"#,
+    "Save the file now"
+)]
+#[case::does_not_follow_aria_labelledby_of_aria_labelledby_target(
+    r#"<html>
+          <div role="button" aria-labelledby="first"></div>
+          <span id="first" aria-labelledby="second">First</span>
+          <span id="second">Second</span>
+        </html>"#,
+    "First"
+)]
+#[case::uses_text_of_aria_hidden_aria_labelledby_target_as_label(
+    r#"<html>
+          <div role="button" aria-labelledby="hidden-element"></div>
+          <span id="hidden-element" aria-hidden="true">Save</span>
+        </html>"#,
+    "Save"
+)]
+#[case::includes_img_alt_in_label_element_text(
+    r#"<html>
+          <button id="arbitrary-button"></button>
+          <label for="arbitrary-button">Save <img alt="the file"> now</label>
+        </html>"#,
+    "Save the file now"
+)]
+#[case::includes_img_alt_in_aria_labelledby_target_text(
+    r#"<html>
+          <div role="button" aria-labelledby="nested-img direct-img"></div>
+          <span id="nested-img">Save <img alt="logo"></span>
+          <img id="direct-img" alt="now" aria-label="">
+        </html>"#,
+    "Save logo now"
+)]
+#[case::prefers_img_aria_label_over_alt_in_label_element_text(
+    r#"<html>
+          <button id="arbitrary-button"></button>
+          <label for="arbitrary-button"><img alt="Alt text" aria-label="Aria label"></label>
+        </html>"#,
+    "Aria label"
+)]
+#[case::concatenates_elements_with_space_between_them_when_markup_does_not_include_whitespace(
+    "<html><button><div>Node</div><div>content</div></button></html>",
+    "Node content"
+)]
+#[case::separates_text_from_following_block_element_within_inline_parent(
+    r#"<html><div role="button" aria-labelledby="target"></div><span id="target">Save<div>file</div></span></html>"#,
+    "Save file"
+)]
+#[case::does_not_separate_adjacent_inline_content_in_block_parent(
+    "<html><button>Sa<b>ve</b></button></html>",
+    "Save"
+)]
+#[case::does_not_separate_text_around_comment(
+    "<html><button>Sa<!-- arbitrary comment -->ve</button></html>",
+    "Save"
+)]
+#[case::does_not_separate_text_around_display_none_element(
+    r#"<html><button>Sa<span style="display: none">arbitrary</span>ve</button></html>"#,
+    "Save"
+)]
+#[case::does_not_separate_text_around_display_contents_inline_element(
+    r#"<html><button>Sa<span style="display: contents">v</span>e</button></html>"#,
+    "Save"
+)]
+#[case::separates_table_cells(
+    "<html><button><table><tr><td>First</td><td>second</td></tr></table></button></html>",
+    "First second"
+)]
+#[case::separates_elements_with_display_table_cell(
+    r#"<html><button><span style="display: table-cell">First</span><span style="display: table-cell">second</span></button></html>"#,
+    "First second"
+)]
+#[case::separates_floated_element_from_surrounding_text(
+    r#"<html><button><span style="float: left">First</span>second</button></html>"#,
+    "First second"
+)]
+#[case::separates_absolutely_positioned_element_from_surrounding_text(
+    r#"<html><button><span style="position: absolute">First</span>second</button></html>"#,
+    "First second"
+)]
+#[case::separates_img_alt_from_adjacent_text(
+    r#"<html><button>Save<img alt="the">file</button></html>"#,
+    "Save the file"
+)]
+#[case::separates_embedded_input_value_from_adjacent_text(
+    r#"<html><button>Flash<input value="5">times</button></html>"#,
+    "Flash 5 times"
+)]
+#[case::separates_inline_block_element_from_adjacent_text(
+    r#"<html><button>Save<span style="display: inline-block">the</span>file</button></html>"#,
+    "Save the file"
+)]
+#[case::does_not_separate_text_around_inline_element_containing_only_aria_hidden_block(
+    r#"<html><button>Sa<span><div aria-hidden="true">arbitrary</div></span>ve</button></html>"#,
+    "Save"
+)]
+#[case::separates_text_around_line_break(
+    "<html><button>First<br>second</button></html>",
+    "First second"
+)]
+#[case::does_not_separate_text_around_hidden_line_break(
+    r#"<html><button>First<br style="display: none;">second</button></html>"#,
+    "Firstsecond"
+)]
+#[case::separates_block_before_pseudo_element_from_content(
+    r#"<html>
+          <style>.arbitrary::before { content: "First"; display: block; }</style>
+          <button><div class="arbitrary">second</div></button>
+        </html>"#,
+    "First second"
+)]
+#[case::separates_block_after_pseudo_element_from_content(
+    r#"<html>
+          <style>.arbitrary::after { content: "second"; display: block; }</style>
+          <button><div class="arbitrary">First</div></button>
+        </html>"#,
+    "First second"
+)]
+#[case::separates_inline_block_pseudo_element_from_content(
+    r#"<html>
+          <style>.arbitrary::before { content: "First"; display: inline-block; }</style>
+          <button><span class="arbitrary">second</span></button>
+        </html>"#,
+    "First second"
+)]
+#[case::joins_inline_pseudo_elements_to_content_without_space(
+    r#"<html>
+          <style>
+            .arbitrary::before { content: "Sa"; }
+            .arbitrary::after { content: "e"; }
+          </style>
+          <button><span class="arbitrary">v</span></button>
+        </html>"#,
+    "Save"
+)]
+#[case::excludes_hidden_descendants_of_visible_aria_labelledby_target(
+    r#"<html>
+          <div role="button" aria-labelledby="target"></div>
+          <span id="target">Save
+            <span style="display: none">secret</span>
+            <span aria-hidden="true">hidden</span>
+            <span style="visibility: hidden">invisible</span>
+            file</span>
+        </html>"#,
+    "Save file"
+)]
+#[case::excludes_hidden_descendants_of_label_element(
+    r#"<html>
+          <button id="arbitrary-button"></button>
+          <label for="arbitrary-button">Save <span style="display: none">secret</span> file</label>
+        </html>"#,
+    "Save file"
+)]
+#[case::includes_hidden_descendants_of_hidden_aria_labelledby_target(
+    r#"<html>
+          <div role="button" aria-labelledby="target"></div>
+          <div id="target" style="visibility: hidden">Save
+            <span style="display: none">file</span></div>
+        </html>"#,
+    "Save file"
+)]
+#[case::uses_aria_label_of_descendants_of_aria_labelledby_target(
+    r#"<html>
+          <div role="button" aria-labelledby="target"></div>
+          <span id="target">Save <span aria-label="the file">ignored</span> now
+            <b aria-label="  ">blank aria-label is ignored</b></span>
+        </html>"#,
+    "Save the file now blank aria-label is ignored"
+)]
+#[case::uses_aria_label_of_descendants_of_label_element(
+    r#"<html>
+          <button id="arbitrary-button"></button>
+          <label for="arbitrary-button">Save <span aria-label="the file">ignored</span></label>
+        </html>"#,
+    "Save the file"
+)]
+#[case::uses_value_of_embedded_text_inputs(
+    r#"<html>
+          <div role="button" aria-labelledby="target"></div>
+          <span id="target">Flash <input value="5"> times and
+            <textarea>notes</textarea> then <input type="password" value="secret"> done</span>
+        </html>"#,
+    "Flash 5 times and notes then done"
+)]
+#[case::uses_value_of_directly_referenced_text_input(
+    r#"<html>
+          <div role="button" aria-labelledby="referenced"></div>
+          <input id="referenced" value="Entered" aria-label="Ignored">
+        </html>"#,
+    "Entered"
+)]
+#[case::uses_value_of_embedded_text_input_in_label_element_for_other_target(
+    r#"<html>
+          <label for="target">Flash <input value="5"> times</label>
+          <button id="target"></button>
+        </html>"#,
+    "Flash 5 times"
+)]
+#[case::uses_value_of_embedded_range_controls(
+    r#"<html>
+          <div role="button" aria-labelledby="target"></div>
+          <span id="target">
+            <div role="slider" aria-valuenow="3" aria-valuetext="three"></div>
+            <div role="spinbutton" aria-valuenow="4" aria-valuemin="0"></div>
+            <input type="range" value="7">
+          </span>
+        </html>"#,
+    "three 4 7"
+)]
+#[case::uses_chosen_option_of_embedded_select(
+    r#"<html>
+          <div role="button" aria-labelledby="target"></div>
+          <span id="target">
+            Send
+            <select><option>One</option><option selected>Two</option></select>
+            and
+            <select><option>Three</option><option>Four</option></select>
+          </span>
+        </html>"#,
+    "Send Two and Three"
+)]
+#[case::includes_generated_content_of_aria_labelledby_target_and_descendants(
+    r#"<html>
+          <head><style>
+            #target::before { content: "Before-"; }
+            #target::after { content: "-after"; }
+            #inner::before { content: "["; }
+            #inner::after { content: "]"; }
+          </style></head>
+          <body>
+            <div role="button" aria-labelledby="target"></div>
+            <span id="target">text <span id="inner">inner</span></span>
+          </body>
+        </html>"#,
+    "Before-text [inner]-after"
+)]
+#[case::includes_img_alt_in_label_from_content(
+    r#"<html><button><img alt="Save"> Draft</button></html>"#,
+    "Save Draft"
+)]
+#[case::excludes_hidden_descendants_from_label_from_content(
+    r#"<html>
+          <button>Visible <span style="display: none">secret</span> <span aria-hidden="true">hidden</span>text</button>
+        </html>"#,
+    "Visible text"
+)]
+#[case::separates_chosen_options_of_embedded_multiple_select(
+    r#"<html>
+          <div role="button" aria-labelledby="target"></div>
+          <span id="target">Pick
+            <select multiple>
+              <option selected>One</option>
+              <option>Two</option>
+              <option selected>Three</option>
+            </select>
+            now</span>
+        </html>"#,
+    "Pick One Three now"
+)]
+#[case::separates_selected_options_of_embedded_listbox(
+    r#"<html>
+          <div role="button" aria-labelledby="target"></div>
+          <span id="target">Pick
+            <div role="listbox">
+              <div role="option" aria-selected="true">One</div>
+              <div role="option" aria-selected="false">Two</div>
+              <div role="option" aria-selected="true">Three</div>
+            </div>
+            now</span>
+        </html>"#,
+    "Pick One Three now"
+)]
+fn button_has_label(#[case] html: &str, #[case] expected_label: &str) -> TestResult<()> {
+    let mut document = HtmlDocument::from_html(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::Button),
+                label(): some(eq(expected_label)),
+            })
+        ))
+    )
+}
+
+/// Gives the elements matching the two selectors the same id, assigning it to the one which is
+/// later in tree order first. This makes the order in which the document records the elements
+/// differ from the tree order.
+fn assign_duplicate_id_in_reverse_tree_order(
+    document: &mut HtmlDocument,
+    id: &str,
+    first_in_tree_order: &str,
+    second_in_tree_order: &str,
+) {
+    let first = document
+        .query_selector(first_in_tree_order)
+        .unwrap()
+        .expect(first_in_tree_order);
+    let second = document
+        .query_selector(second_in_tree_order)
+        .unwrap()
+        .expect(second_in_tree_order);
+    let id_attribute = QualName::new(None, ns!(), local_name!("id"));
+    let mut mutator = document.mutate();
+    mutator.set_attribute(second, id_attribute.clone(), id);
+    mutator.set_attribute(first, id_attribute, id);
+}
+
+/// The ID of the only node in the tree with the role.
+fn node_id_with_role(tree_update: &TreeUpdate, role: Role) -> TestResult<NodeId> {
+    node_id_where(tree_update, &format!("Node with role {role:?}"), |node| {
+        node.role() == role
+    })
+}
+
+/// The ID of the only node in the tree with the HTML tag.
+fn node_id_with_tag(tree_update: &TreeUpdate, html_tag: &str) -> TestResult<NodeId> {
+    node_id_where(
+        tree_update,
+        &format!("Node with tag {html_tag:?}"),
+        |node| node.html_tag() == Some(html_tag),
+    )
+}
+
+/// The ID of the only node in the tree with the role `Role::Label` which has the given value,
+/// which is its text.
+fn label_node_id_with_value(tree_update: &TreeUpdate, value: &str) -> TestResult<NodeId> {
+    node_id_where(
+        tree_update,
+        &format!("Label with value {value:?}"),
+        |node| node.role() == Role::Label && node.value() == Some(value),
+    )
+}
+
+/// The ID of the only node in the tree which satisfies the predicate. Panics, naming
+/// `description`, if there is no such node or more than one.
+fn node_id_where(
+    tree_update: &TreeUpdate,
+    description: &str,
+    predicate: impl Fn(&AccessKitNode) -> bool,
+) -> TestResult<NodeId> {
+    let mut ids = tree_update
+        .nodes
+        .iter()
+        .filter(|(_, node)| predicate(node))
+        .map(|(id, _)| *id);
+    let Some(id) = ids.next() else {
+        fail!("Expected to find {description}, but not found. Tree is:\n{tree_update:#?}")?;
+        unreachable!();
+    };
+    verify_that!(ids.next(), none())
+        .with_failure_message(|| format!("{description} must be unique in accessibility tree"))?;
+    Ok(id)
+}
+
+/// The labels of the nodes with the given HTML tag in the tree, in no particular order.
+fn labels_of_elements_with_tag<'a>(
+    tree_update: &'a TreeUpdate,
+    html_tag: &str,
+) -> Vec<Option<&'a str>> {
+    tree_update
+        .nodes
+        .iter()
+        .filter(|(_, node)| node.html_tag() == Some(html_tag))
+        .map(|(_, node)| node.label())
+        .collect()
+}
+
 fn default_document_config() -> DocumentConfig {
     DocumentConfig {
         viewport: Some(Viewport::new(800, 600, 1.0, ColorScheme::Light)),
diff --git a/tests/blitz-tests/tests/accessibility_tree.rs b/tests/blitz-tests/tests/accessibility_tree.rs
new file mode 100644
index 0000000000..d501e5ad11
--- /dev/null
+++ b/tests/blitz-tests/tests/accessibility_tree.rs
@@ -0,0 +1,65 @@
+//! The structure of the accessibility tree as a whole, as opposed to the properties of its nodes.
+
+use accesskit::{Node as AccessKitNode, Role, TreeUpdate};
+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_the_root_of_the_tree_as_a_node_with_window_role() -> 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();
+
+    let root = root_node_id(&tree_update)?;
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            eq(root),
+            matches_pattern!(AccessKitNode {
+                role(): eq(Role::Window),
+            })
+        ))
+    )
+}
+
+#[test]
+fn attaches_the_content_of_the_document_to_the_root_of_the_tree() -> 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();
+
+    let root = root_node_id(&tree_update)?;
+    verify_that!(
+        tree_update.nodes,
+        contains((
+            eq(root),
+            matches_pattern!(AccessKitNode {
+                *children(): not(is_empty()),
+            })
+        ))
+    )
+}
+
+/// The ID which the tree names as its root.
+fn root_node_id(tree_update: &TreeUpdate) -> TestResult<accesskit::NodeId> {
+    let Some(tree) = &tree_update.tree else {
+        fail!("Expected the update to describe the tree, but it does not")?;
+        unreachable!();
+    };
+    Ok(tree.root)
+}
+
+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/all.rs b/tests/blitz-tests/tests/all.rs
index b3f5f639a1..811019166d 100644
--- a/tests/blitz-tests/tests/all.rs
+++ b/tests/blitz-tests/tests/all.rs
@@ -5,6 +5,7 @@ mod accessibility_description;
 mod accessibility_hidden;
 mod accessibility_label;
 mod accessibility_roles;
+mod accessibility_tree;
 mod animations;
 mod anonymous_block_cache_invalidation;
 mod anonymous_block_leak;