blitz_dom/

document.rs

use crate::NodeTree;
use crate::events::{DragMode, ScrollAnimationState, handle_dom_event};
use crate::font_metrics::BlitzFontMetricsProvider;
use crate::layout::construct::ConstructionTask;
use crate::layout::damage::ALL_DAMAGE;
use crate::mutator::ViewportMut;
use crate::net::{
    Resource, ResourceHandler, ResourceLoadResponse, StylesheetHandler, StylesheetLoader,
};
use crate::node::{
    ImageData, NodeFlags, RasterImageData, SpecialElementData, Status, TextBrush, TextGranularity,
};
use crate::selection::TextSelection;
use crate::stylo_to_cursor_icon::stylo_to_cursor_icon;
use crate::traversal::TreeTraverser;
use crate::url::DocumentUrl;
use crate::util::ImageType;
use crate::{
    DEFAULT_CSS, DocumentConfig, DocumentMutator, DummyHtmlParserProvider, ElementData,
    EventDriver, HtmlParserProvider, Node, NodeData, NoopEventHandler, StyleThreading,
    TextNodeData,
};
use blitz_traits::devtools::DevtoolSettings;
use blitz_traits::events::{BlitzScrollEvent, DomEvent, DomEventData, HitResult, UiEvent};
use blitz_traits::navigation::{DummyNavigationProvider, NavigationProvider};
use blitz_traits::net::{AbortSignal, DummyNetProvider, NetProvider, Request, RequestDestination};
use blitz_traits::node_id::NodeId;
use blitz_traits::shell::{ColorScheme, DummyShellProvider, ShellProvider, Viewport};
use cursor_icon::CursorIcon;
use linebender_resource_handle::Blob;
use markup5ever::{local_name, ns};
use parley::{FontContext, PlainEditorDriver};
use rustc_hash::FxHashSet;
use selectors::{Element, matching::QuirksMode};
use smallvec::SmallVec;
use std::any::Any;
use std::cell::RefCell;
use std::collections::{BTreeMap, Bound, HashMap, HashSet};
use std::ops::{Deref, DerefMut};
use std::rc::Rc;
use std::str::FromStr;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::mpsc::{Receiver, Sender, channel};
use std::sync::{Arc, Mutex, MutexGuard, OnceLock, RwLockReadGuard, RwLockWriteGuard};
use std::task::{Context as TaskContext, Waker};
use style::Atom;
use style::animation::{AnimationState, DocumentAnimationSet};
use style::attr::{AttrIdentifier, AttrValue};
use style::data::{ElementData as StyloElementData, ElementStyles};
use style::invalidation::element::restyle_hints::RestyleHint;
use style::media_queries::MediaType;
use style::properties::ComputedValues;
use style::properties::style_structs::Font;
use style::queries::values::PrefersColorScheme;
use style::selector_parser::ServoElementSnapshot;
use style::servo::media_features::PointerCapabilities;
use style::servo_arc::Arc as ServoArc;
use style::values::GenericAtomIdent;
use style::values::computed::ui::CursorKind;
use style::values::computed::{Overflow, UserSelect};
use style::values::specified::box_::{DisplayInside, DisplayOutside};
use style::{
    device::Device,
    dom::{TDocument, TNode},
    media_queries::MediaList,
    selector_parser::SnapshotMap,
    shared_lock::{SharedRwLock, StylesheetGuards},
    stylesheets::{AllowImportRules, DocumentStyleSheet, Origin, Stylesheet},
    stylist::Stylist,
};
use thin_vec::ThinVec;
use url::Url;
use web_time::Instant;

#[cfg(feature = "parallel-construct")]
use thread_local::ThreadLocal;

pub enum DocGuard<'a> {
    Ref(&'a BaseDocument),
    RefCell(std::cell::Ref<'a, BaseDocument>),
    RwLock(RwLockReadGuard<'a, BaseDocument>),
    Mutex(MutexGuard<'a, BaseDocument>),
}

impl Deref for DocGuard<'_> {
    type Target = BaseDocument;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        match self {
            Self::Ref(base_document) => base_document,
            Self::RefCell(refcell_guard) => refcell_guard,
            Self::RwLock(rw_lock_read_guard) => rw_lock_read_guard,
            Self::Mutex(mutex_guard) => mutex_guard,
        }
    }
}

pub enum DocGuardMut<'a> {
    Ref(&'a mut BaseDocument),
    RefCell(std::cell::RefMut<'a, BaseDocument>),
    RwLock(RwLockWriteGuard<'a, BaseDocument>),
    Mutex(MutexGuard<'a, BaseDocument>),
}

impl Deref for DocGuardMut<'_> {
    type Target = BaseDocument;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        match self {
            Self::Ref(base_document) => base_document,
            Self::RefCell(refcell_guard) => refcell_guard,
            Self::RwLock(rw_lock_read_guard) => rw_lock_read_guard,
            Self::Mutex(mutex_guard) => mutex_guard,
        }
    }
}

impl DerefMut for DocGuardMut<'_> {
    #[inline(always)]
    fn deref_mut(&mut self) -> &mut Self::Target {
        match self {
            Self::Ref(base_document) => base_document,
            Self::RefCell(refcell_guard) => &mut *refcell_guard,
            Self::RwLock(rw_lock_read_guard) => &mut *rw_lock_read_guard,
            Self::Mutex(mutex_guard) => &mut *mutex_guard,
        }
    }
}

/// Abstraction over wrappers around [`BaseDocument`] to allow for them all to
/// be driven by [`blitz-shell`](https://docs.rs/blitz-shell)
pub trait Document: Any + 'static {
    fn inner(&self) -> DocGuard<'_>;
    fn inner_mut(&mut self) -> DocGuardMut<'_>;

    /// Update the [`Document`] in response to a [`UiEvent`] (click, keypress, etc)
    fn handle_ui_event(&mut self, event: UiEvent) {
        let mut doc = self.inner_mut();
        let mut driver = EventDriver::new(&mut *doc, NoopEventHandler);
        driver.handle_ui_event(event);
    }

    /// Poll any pending async operations, and flush changes to the underlying [`BaseDocument`]
    fn poll(&mut self, task_context: Option<TaskContext>) -> bool {
        // Default implementation does nothing
        let _ = task_context;
        false
    }

    /// Drain immediate work for a host's settle loop.
    ///
    /// Pass `run_timers = true` only on the first pass to allow one batch of
    /// due timer and animation callbacks. Subsequent passes must leave those
    /// callbacks scheduled while draining scripts and microtasks.
    ///
    /// Documents that execute timers must override this method. Wrappers that
    /// poll child documents must propagate the policy to their children.
    fn poll_for_settle(&mut self, task_context: Option<TaskContext>, run_timers: bool) -> bool {
        let _ = run_timers;
        self.poll(task_context)
    }

    /// Get the [`Document`]'s id
    fn id(&self) -> usize {
        self.inner().id
    }
}

/// What the pre-click activation steps changed, so a cancelled click can put
/// it back. Produced by [`BaseDocument::run_pre_click_activation`].
#[derive(Debug, Clone, PartialEq)]
pub struct PreClickActivation {
    /// Every node whose checkedness moved, paired with the value it held.
    previous: Vec<(NodeId, bool)>,
}

/// Escape text for inclusion in an HTML clipboard payload.
///
/// The five characters that would otherwise be read as markup. A selection is
/// document text, so a paragraph containing `a < b` must arrive as `a &lt; b`
/// rather than opening a tag in whatever receives the paste.
fn escape_html(text: &str) -> String {
    let mut out = String::with_capacity(text.len());
    for ch in text.chars() {
        match ch {
            '&' => out.push_str("&amp;"),
            '<' => out.push_str("&lt;"),
            '>' => out.push_str("&gt;"),
            '"' => out.push_str("&quot;"),
            _ => out.push(ch),
        }
    }
    out
}

pub struct PlainDocument(pub BaseDocument);
impl Document for PlainDocument {
    fn inner(&self) -> DocGuard<'_> {
        DocGuard::Ref(&self.0)
    }
    fn inner_mut(&mut self) -> DocGuardMut<'_> {
        DocGuardMut::Ref(&mut self.0)
    }
}

impl Document for BaseDocument {
    fn inner(&self) -> DocGuard<'_> {
        DocGuard::Ref(self)
    }
    fn inner_mut(&mut self) -> DocGuardMut<'_> {
        DocGuardMut::Ref(self)
    }
}

impl Document for Rc<RefCell<BaseDocument>> {
    fn inner(&self) -> DocGuard<'_> {
        DocGuard::RefCell(self.borrow())
    }

    fn inner_mut(&mut self) -> DocGuardMut<'_> {
        DocGuardMut::RefCell(self.borrow_mut())
    }
}

pub enum DocumentEvent {
    ResourceLoad(ResourceLoadResponse),
    /// A navigation originating from within an iframe's sub-document
    /// (e.g. a link click), to be applied to the iframe identified by `node_id`.
    NavigateIframe {
        node_id: NodeId,
        url: Url,
    },
}

/// How urgently a document needs another animation frame.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum AnimationPacing {
    Idle,
    Caret,
    SlowCss,
    Interactive,
}

pub struct BaseDocument {
    /// ID of the document
    id: usize,

    // Config
    /// Base url for resolving linked resources (stylesheets, images, fonts, etc)
    pub(crate) url: DocumentUrl,
    // Devtool settings. Currently used to render debug overlays
    pub(crate) devtool_settings: DevtoolSettings,
    // Viewport details such as the dimensions, HiDPI scale, and zoom factor,
    pub(crate) viewport: Viewport,
    // Scroll within our viewport
    pub(crate) viewport_scroll: crate::Point<f64>,
    /// Changes recorded for a script's `MutationObserver`, or `None` while no
    /// observer is registered. See [`crate::DomMutation`].
    pub(crate) mutation_log: Option<Vec<crate::DomMutation>>,
    /// Content handler changes, independent of MutationObserver recording.
    inline_handler_changes: Vec<(NodeId, crate::QualName, Option<crate::node::AttrAtom>)>,
    /// Weak registrations make pages without live ranges pay only a branch.
    pub(crate) live_ranges: Vec<crate::range::WeakRange>,
    /// Script Selection shares the same live range object as getRangeAt().
    pub dom_selection: Option<crate::LiveRange>,
    /// CSS media type used to evaluate `@media` rules.
    pub(crate) media_type: MediaType,
    /// Strategy for Stylo's style traversal during `resolve`.
    pub(crate) style_threading: StyleThreading,
    /// Whether incremental layout is enabled for this document.
    pub(crate) incremental_layout: bool,
    /// How deeply this document is nested within other documents
    /// (0 for a root document). Used to limit `<iframe>` nesting depth.
    pub(crate) subdocument_depth: usize,

    // Events
    pub(crate) tx: Sender<DocumentEvent>,
    // rx will always be Some, except temporarily while processing events
    pub(crate) rx: Option<Receiver<DocumentEvent>>,

    /// A slotmap-backed tree of nodes
    ///
    /// We pin the tree to a guarantee to the nodes it creates that the tree is stable in memory.
    /// There is no way to create the tree - publicly or privately - that would invalidate that invariant.
    pub(crate) nodes: Box<NodeTree>,

    /// Batch cache invalidation across recursive subtree teardown.
    node_drop_depth: usize,
    /// Active mutation scopes defer redraw until the outermost scope ends.
    pub(crate) mutator_depth: usize,
    pub(crate) mutator_redraw_pending: bool,
    /// `<details>` elements whose `open` attribute appeared or disappeared since the script
    /// runtime last took them, each with whether it was open before its first change. The
    /// HTML toggle task coalesces per element, so an element is listed once.
    details_toggles: Vec<(NodeId, bool)>,
    /// Bumped whenever the stylist device changes (viewport size, scale or colour scheme),
    /// so script can skip re-evaluating media queries while it stays the same.
    viewport_generation: u64,
    /// The inert document that owns every `<template>`'s contents, made on first use. It
    /// has no browsing context, so nothing in it is upgraded as a custom element.
    template_contents_owner: Option<NodeId>,
    dropped_node_ids: FxHashSet<NodeId>,
    dropped_node_parents: FxHashSet<NodeId>,
    /// Survivors that can still point at an id freed by this batch.
    ///
    /// Recorded while the node is still in the slab. The purge runs after a
    /// subtree drop has already removed those nodes, so the links have to be
    /// captured first.
    dropped_reference_owners: FxHashSet<NodeId>,

    /// The id of the root node (a Document node)
    pub(crate) root_node_id: NodeId,

    /// For each `position: fixed` node reparented onto the root element, the
    /// layout parent it was taken from.
    ///
    /// Hoisting gives a fixed node the viewport as its containing block, which
    /// is what CSS asks for. It must not also decide which stacking context the
    /// node paints in: that follows the box tree, and the two are independent.
    /// Without this record the node joins the root's stacking context, so a
    /// negative z-index fixed layer inside an `isolation: isolate` ancestor
    /// paints beneath every background between them and disappears.
    pub(crate) hoisted_fixed_parents: HashMap<NodeId, NodeId>,

    /// Authored child slots restored temporarily for static-position layout.
    pub(crate) hoisted_fixed_indices: HashMap<NodeId, usize>,

    /// Escaped absolute boxes whose explicit axes follow a containing block.
    pub(crate) abspos_placements: Vec<crate::layout::abspos::AbsposPlacement>,

    /// Maintained during the existing fixed/sticky walk on style or tree changes.
    pub(crate) abspos_candidates: Vec<crate::layout::abspos::AbsposCandidate>,
    pub(crate) abspos_candidate_ids: HashSet<NodeId>,
    pub(crate) abspos_inputs: HashMap<NodeId, crate::layout::abspos::AbsposInputs>,
    /// Candidates whose hypothetical layouts or styles were written this pass.
    pub(crate) abspos_written: HashSet<NodeId>,
    pub(crate) abspos_candidates_dirty: bool,
    pub(crate) abspos_layout_dirty: bool,
    /// Whether the normal root layout missed its PerformLayout cache.
    pub(crate) abspos_normal_layout: bool,

    /// Every `position: fixed` node whose containing block is the viewport,
    /// which is every one of them except those under a transformed ancestor.
    ///
    /// Collected by the walk that hoists them, and used by
    /// `resolve_fixed_positions` to hold them still while the page scrolls.
    pub(crate) fixed_nodes: Vec<NodeId>,

    /// The viewport scroll currently baked into those nodes' locations.
    ///
    /// One value for the whole document rather than one per node: the pin is
    /// the same displacement for every fixed box, because they all share the
    /// viewport as their containing block. Reset by `resolve_layout`, which
    /// rewrites the locations it was added to.
    pub(crate) fixed_scroll_offset: crate::Point<f64>,

    /// Every `position: sticky` node in the document, in tree order.
    ///
    /// Collected by the same walk that hoists fixed nodes, because both need
    /// one pre-order pass over the box tree and a second one would cost the
    /// same on every frame of every document, sticky or not. Tree order matters:
    /// a sticky box inside another sticky box is adjusted on top of its
    /// ancestor's adjustment, so the ancestor has to be settled first.
    pub(crate) sticky_nodes: Vec<NodeId>,

    /// For each sticky node, the offset currently baked into its
    /// `final_layout().location`.
    ///
    /// The adjustment is written into the box itself so that paint, hit testing
    /// and `absolute_position` cannot disagree about where the box is. That
    /// makes the pass non-idempotent unless it can recover the flow position it
    /// started from, which is what this records. Cleared by `resolve_layout`,
    /// which rewrites every location from taffy and so discards the offsets
    /// along with them.
    pub(crate) sticky_offsets: HashMap<NodeId, taffy::Point<f32>>,

    /// Stacking contexts holding a hoisted child that an ancestor clips.
    ///
    /// Collected while flushing styles so that `resolve_hoisted_clips` visits
    /// those contexts alone, rather than scanning every node in the document
    /// after every layout to find the handful that hoist anything at all.
    pub(crate) hoisted_clip_hosts: HashSet<NodeId>,

    /// Contexts with hoisted paint children, maintained by the style flush.
    pub(crate) hoisted_position_hosts: HashSet<NodeId>,

    // Stylo
    /// The Stylo engine
    pub(crate) stylist: Stylist,
    pub(crate) animations: DocumentAnimationSet,
    /// Monotonic animation clock used by the most recent resolve.
    ///
    /// Embedders may inspect or capture between window frames. A diagnostic
    /// caller historically passed `0.0` and rewound every CSS transition in
    /// the document; retaining the high-water mark makes that impossible at
    /// the document boundary.
    pub(crate) last_resolve_animation_time: f64,
    /// Stylo shared lock
    pub(crate) guard: SharedRwLock,
    /// Stylo invalidation map. We insert into this map prior to mutating nodes.
    pub(crate) snapshots: SnapshotMap,

    // Parley contexts
    /// A Parley font context
    pub(crate) font_ctx: Arc<Mutex<parley::FontContext>>,
    #[cfg(feature = "parallel-construct")]
    /// Thread-and-document-local copies to the font context
    pub(crate) thread_font_contexts: ThreadLocal<RefCell<Box<FontContext>>>,
    /// A Parley layout context
    pub(crate) layout_ctx: parley::LayoutContext<TextBrush>,

    /// The real (non-anonymous) node which is currently hovered (if any).
    /// This is never a layout-generated (anonymous) node, so it remains valid
    /// across box-tree reconstruction.
    pub(crate) hover_node_id: Option<NodeId>,
    /// The precise (may be anonymous) layout node under the pointer (if any).
    /// This can be invalidated by box-tree reconstruction, and is re-resolved against
    /// fresh layout at the end of every `resolve` pass.
    pub(crate) hover_hit_node_id: Option<NodeId>,
    /// Whether the node which is currently hovered is a text node/span
    pub(crate) hover_node_is_text: bool,
    /// The last known pointer position in client coordinates (viewport-relative, unscrolled).
    pub(crate) last_client_pointer_position: Option<taffy::Point<f32>>,
    /// Exact DOM target selected by semantic automation.
    ///
    /// Window pointers leave this empty and are re-hit-tested after layout.
    /// An inspector already resolved identity, so re-hit-testing its synthetic
    /// centre coordinate would silently replace that target with an overlap.
    pub(crate) semantic_hover_node_id: Option<NodeId>,
    /// The node which is currently focussed (if any)
    pub(crate) focus_node_id: Option<NodeId>,
    /// The node which is currently active (if any)
    pub(crate) active_node_id: Option<NodeId>,
    /// The node which recieved a mousedown event (if any)
    pub(crate) mousedown_node_id: Option<NodeId>,
    /// The last time a mousedown was made (for double-click detection)
    pub(crate) last_mousedown_time: Option<Instant>,
    /// The position where mousedown occurred (for selection drags and double-click detection)
    pub(crate) mousedown_position: taffy::Point<f32>,
    /// How many clicks have been made in quick succession
    pub(crate) click_count: u16,
    /// Whether we're currently in a text selection drag (moved 2px+ from mousedown)
    pub(crate) drag_mode: DragMode,
    /// The scrollbar thumb currently under the pointer, if any
    pub(crate) hovered_scrollbar: Option<crate::node::ScrollbarRef>,
    /// When each scroll container's overlay scrollbars were last shown
    /// (scrolled, or the pointer left the thumb); drives their fade-out
    pub(crate) scrollbar_activity: HashMap<NodeId, Instant>,
    /// Whether and what kind of scroll animation is currently in progress
    pub(crate) scroll_animation: ScrollAnimationState,

    /// Text selection state (for non-input text)
    pub(crate) text_selection: TextSelection,

    // TODO: collapse animating state into a bitflags
    /// Whether there are active CSS animations/transitions (so we should re-render every frame)
    pub(crate) has_active_animations: bool,
    /// Whether there is a `<canvas>` element in the DOM (so we should re-render every frame)
    pub(crate) has_canvas: bool,
    /// The most urgent animation cadence required by any subdocument.
    pub(crate) subdoc_animation_pacing: AnimationPacing,

    /// Map of id attribute values to node IDs for fast lookups.
    /// May contain multiple nodes for the same id: `get_element_by_id`
    /// returns the first in tree order.
    pub(crate) nodes_to_id: HashMap<String, SmallVec<[NodeId; 1]>>,
    /// Map of `<style>` and `<link>` node IDs to their associated stylesheet
    pub(crate) nodes_to_stylesheet: BTreeMap<NodeId, DocumentStyleSheet>,
    /// `<style>`/`<link>` nodes whose sheet is in the document Stylist. Shadow
    /// tree sheets live elsewhere, and Stylo panics on removing a sheet it
    /// does not hold.
    pub(crate) document_sheet_nodes: HashSet<NodeId>,
    /// The shadow root each shadow-tree `<style>`/`<link>` sheet was installed
    /// into. Unloading happens after the node is detached, when its root can
    /// no longer be found by walking up, so the owner is remembered here.
    #[cfg(feature = "shadow-dom")]
    pub(crate) shadow_sheet_roots: HashMap<NodeId, NodeId>,
    /// Stylesheets added by the useragent
    /// where the key is the hashed CSS
    pub(crate) ua_stylesheets: HashMap<String, DocumentStyleSheet>,
    /// Map from form control node ID's to their associated forms node ID's
    pub(crate) controls_to_form: HashMap<NodeId, NodeId>,
    /// Nodes that contain sub documents
    pub(crate) sub_document_nodes: HashSet<NodeId>,
    /// Load state (abort controller and in-flight request id) for each
    /// `<iframe>` element whose sub-document is loaded automatically
    pub(crate) iframe_loads: HashMap<NodeId, crate::iframe::IframeLoad>,
    /// Nodes whose layout construction is waiting for a later pass.
    pub(crate) deferred_construction_nodes: Vec<ConstructionTask>,
    /// Which parts of the document differ from the previously painted frame.
    ///
    /// Off unless a consumer asks for it, so a document that never questions
    /// its own frames does not pay to answer. See
    /// [`set_paint_damage_tracking`](Self::set_paint_damage_tracking).
    pub(crate) paint_damage: crate::paint_damage::PaintDamageTracker,

    /// Nodes that contain custom widgets
    #[cfg(feature = "custom-widget")]
    pub(crate) custom_widget_nodes: HashSet<NodeId>,
    /// Rendering resources allocated by custom widgets that should be deallocated during the next render
    #[cfg(feature = "custom-widget")]
    pub(crate) pending_resource_deallocations: Vec<anyrender::ResourceId>,

    /// Registry of custom element definitions keyed by tag name
    #[cfg(feature = "shadow-dom")]
    pub(crate) custom_element_registry: crate::node::CustomElementRegistry,
    /// Nodes that are shadow hosts (have an attached shadow root)
    #[cfg(feature = "shadow-dom")]
    pub(crate) shadow_host_nodes: HashSet<NodeId>,
    #[cfg(feature = "shadow-dom")]
    pub(crate) dirty_shadow_hosts: HashSet<NodeId>,
    #[cfg(feature = "shadow-dom")]
    pub(crate) pending_slot_changes: Vec<NodeId>,
    #[cfg(feature = "shadow-dom")]
    pub(crate) signaled_slots: HashSet<NodeId>,
    #[cfg(feature = "shadow-dom")]
    pub(crate) adopted_stylesheets: HashMap<NodeId, Vec<DocumentStyleSheet>>,
    /// Nodes that have an attached custom element controller
    #[cfg(feature = "shadow-dom")]
    pub(crate) custom_element_nodes: HashSet<NodeId>,
    /// Template element -> declarative shadow root, while that template is open
    /// on the parser stack. Stored here because each streaming sink call builds
    /// a new parser.
    #[cfg(feature = "shadow-dom")]
    pub(crate) declarative_template_shadows: HashMap<NodeId, NodeId>,

    /// Native candidate index and mutation reactions for JavaScript custom elements.
    pub(crate) script_custom_elements: crate::node::script_custom_element::Registry,

    /// Cache of loaded images, keyed by URL. Allows reusing images across multiple
    /// elements without re-fetching from the network.
    pub(crate) image_cache: HashMap<String, ImageData>,

    /// Tracks in-flight image requests. When an image is being fetched, additional
    /// requests for the same URL are queued here instead of starting new fetches.
    /// Value is a list of (node_id, image_type) pairs waiting for the image.
    pub(crate) pending_images: HashMap<String, Vec<(NodeId, ImageType)>>,

    // Tracks in-flight "critical" resources (e.g. stylesheets linked from the `<head>`),
    // keyed by request id
    pub(crate) pending_critical_resources: HashSet<usize>,

    pub(crate) web_fonts: Vec<Arc<crate::net::web_fonts::WebFont>>,
    pub(crate) font_epoch: usize,
    document_referrer: String,
    document_content_type: String,
    document_window_focused: bool,

    // Service providers
    /// Network provider. Can be used to fetch assets.
    pub net_provider: Arc<dyn NetProvider>,
    /// Navigation provider. Can be used to navigate to a new page (bubbles up the event
    /// on e.g. clicking a Link)
    pub navigation_provider: Arc<dyn NavigationProvider>,
    /// Shell provider. Can be used to request a redraw or set the cursor icon
    pub shell_provider: Arc<dyn ShellProvider>,
    /// HTML parser provider. Used to parse HTML for setInnerHTML
    pub html_parser_provider: Arc<dyn HtmlParserProvider>,
    /// Carried on every sub-resource `Request` this document issues; aborting
    /// it cancels all in-flight fetches tied to this document. Set via
    /// [`DocumentConfig::abort_signal`].
    pub(crate) abort_signal: Option<AbortSignal>,
}

pub(crate) fn make_device(
    viewport: &Viewport,
    media_type: MediaType,
    font_ctx: Arc<Mutex<FontContext>>,
) -> Device {
    let width = viewport.window_size.0 as f32 / viewport.scale();
    let height = viewport.window_size.1 as f32 / viewport.scale();
    let viewport_size = euclid::Size2D::new(width, height);
    let device_size = euclid::Size2D::new(width, height) * viewport.scale();
    let device_pixel_ratio = euclid::Scale::new(viewport.scale());

    Device::new(
        media_type,
        selectors::matching::QuirksMode::NoQuirks,
        viewport_size,
        device_size,
        device_pixel_ratio,
        Box::new(BlitzFontMetricsProvider { font_ctx }),
        ComputedValues::initial_values_with_font_override(Font::initial_values()),
        match viewport.color_scheme {
            ColorScheme::Light => PrefersColorScheme::Light,
            ColorScheme::Dark => PrefersColorScheme::Dark,
        },
        PointerCapabilities::default(),
        PointerCapabilities::default(),
    )
}

/// Whether layout reuses its caches, and how that can be overridden at runtime.
///
/// Incremental layout is on unless a caller or the environment turns it off.
///
/// The environment override exists so a single build can be measured both ways:
/// with it off every `resolve` clears the Taffy cache and re-shapes every inline
/// root from scratch, so comparing the two in separate binaries would also
/// compare two different compilations. `BLITZ_INCREMENTAL=0` forces the old
/// behaviour, `=1` forces the new one.
///
/// This used to fall back to `cfg!(feature = "incremental")`. That feature is
/// gone, replaced by `DocumentConfig::incremental`, and for a while afterwards
/// this function was never called at all: the config read
/// `unwrap_or(true)` directly, so `BLITZ_INCREMENTAL` was accepted and ignored.
fn incremental_layout_default() -> bool {
    !matches!(
        std::env::var("BLITZ_INCREMENTAL").ok().as_deref(),
        Some("0" | "false" | "off")
    )
}

impl BaseDocument {
    /// Create a new (empty) [`BaseDocument`] with the specified configuration
    pub fn new(config: DocumentConfig) -> Self {
        static ID_GENERATOR: AtomicUsize = AtomicUsize::new(1);

        let id = ID_GENERATOR.fetch_add(1, Ordering::SeqCst);

        let font_ctx = config
            .font_ctx
            .map(|mut font_ctx| {
                font_ctx.source_cache.make_shared();
                // font_ctx.collection.make_shared();
                font_ctx
            })
            .unwrap_or_else(|| {
                use parley::fontique::{Collection, CollectionOptions, SourceCache};
                let mut font_ctx = FontContext {
                    source_cache: SourceCache::new_shared(),
                    collection: Collection::new(CollectionOptions {
                        shared: false,
                        system_fonts: cfg!(all(
                            feature = "system-fonts",
                            not(target_arch = "wasm32")
                        )),
                    }),
                };
                font_ctx
                    .collection
                    .register_fonts(Blob::new(Arc::new(crate::BULLET_FONT) as _), None);
                font_ctx
            });
        let font_ctx = Arc::new(Mutex::new(font_ctx));
        if let Some(fallback) = config.family_fallback {
            crate::font_fallback::set(fallback);
        }

        // Make sure we turn on stylo features *before* creating the Stylist
        style_config::set_pref!("layout.grid.enabled", true);
        style_config::set_pref!("layout.unimplemented", true);
        style_config::set_pref!("layout.columns.enabled", true);
        style_config::set_pref!("layout.css.basic-shape-shape.enabled", true);
        style_config::set_pref!("layout.threads", -1);

        let viewport = config.viewport.unwrap_or_default();
        let media_type = config.media_type.unwrap_or_else(MediaType::screen);
        let device = make_device(&viewport, media_type.clone(), font_ctx.clone());
        let stylist = Stylist::new(device, QuirksMode::NoQuirks);
        let snapshots = SnapshotMap::new();
        let nodes = Box::new(NodeTree::new());
        let guard = SharedRwLock::new();
        let nodes_to_id = HashMap::new();

        let base_url = config
            .base_url
            .and_then(|url| DocumentUrl::from_str(&url).ok())
            .unwrap_or_default();

        let net_provider = config
            .net_provider
            .unwrap_or_else(|| Arc::new(DummyNetProvider));
        let navigation_provider = config
            .navigation_provider
            .unwrap_or_else(|| Arc::new(DummyNavigationProvider));
        let shell_provider = config
            .shell_provider
            .unwrap_or_else(|| Arc::new(DummyShellProvider));
        let html_parser_provider = config
            .html_parser_provider
            .unwrap_or_else(|| Arc::new(DummyHtmlParserProvider));

        let (tx, rx) = channel();

        let mut doc = Self {
            node_drop_depth: 0,
            mutator_depth: 0,
            mutator_redraw_pending: false,
            details_toggles: Vec::new(),
            viewport_generation: 0,
            template_contents_owner: None,
            dropped_node_ids: FxHashSet::default(),
            dropped_node_parents: FxHashSet::default(),
            dropped_reference_owners: FxHashSet::default(),
            hoisted_fixed_parents: HashMap::new(),
            hoisted_fixed_indices: HashMap::new(),
            abspos_placements: Vec::new(),
            abspos_candidates: Vec::new(),
            abspos_candidate_ids: HashSet::new(),
            abspos_inputs: HashMap::new(),
            abspos_written: HashSet::new(),
            abspos_candidates_dirty: true,
            abspos_layout_dirty: true,
            abspos_normal_layout: false,
            fixed_nodes: Vec::new(),
            fixed_scroll_offset: crate::Point::ZERO,
            sticky_nodes: Vec::new(),
            sticky_offsets: HashMap::new(),
            hoisted_clip_hosts: HashSet::new(),
            hoisted_position_hosts: HashSet::new(),
            id,
            tx,
            rx: Some(rx),

            guard,
            nodes,
            root_node_id: NodeId::default(),
            stylist,
            animations: DocumentAnimationSet::default(),
            last_resolve_animation_time: 0.0,
            snapshots,
            nodes_to_id,
            viewport,
            media_type,
            style_threading: config.style_threading,
            incremental_layout: config
                .incremental
                .unwrap_or_else(incremental_layout_default),
            subdocument_depth: config.subdocument_depth,
            devtool_settings: DevtoolSettings::default(),
            viewport_scroll: crate::Point::ZERO,
            mutation_log: None,
            inline_handler_changes: Vec::new(),
            live_ranges: Vec::new(),
            dom_selection: None,
            url: base_url,
            ua_stylesheets: HashMap::new(),
            nodes_to_stylesheet: BTreeMap::new(),
            document_sheet_nodes: HashSet::new(),
            #[cfg(feature = "shadow-dom")]
            shadow_sheet_roots: HashMap::new(),
            font_ctx,
            #[cfg(feature = "parallel-construct")]
            thread_font_contexts: ThreadLocal::new(),
            layout_ctx: parley::LayoutContext::new(),

            hover_node_id: None,
            hover_hit_node_id: None,
            hover_node_is_text: false,
            last_client_pointer_position: None,
            semantic_hover_node_id: None,
            focus_node_id: None,
            active_node_id: None,
            mousedown_node_id: None,
            has_active_animations: false,
            subdoc_animation_pacing: AnimationPacing::Idle,
            has_canvas: false,
            sub_document_nodes: HashSet::new(),
            iframe_loads: HashMap::new(),

            #[cfg(feature = "custom-widget")]
            custom_widget_nodes: HashSet::new(),
            #[cfg(feature = "custom-widget")]
            pending_resource_deallocations: Vec::new(),

            #[cfg(feature = "shadow-dom")]
            custom_element_registry: crate::node::CustomElementRegistry::new(),
            #[cfg(feature = "shadow-dom")]
            shadow_host_nodes: HashSet::new(),
            #[cfg(feature = "shadow-dom")]
            dirty_shadow_hosts: HashSet::new(),
            #[cfg(feature = "shadow-dom")]
            pending_slot_changes: Vec::new(),
            #[cfg(feature = "shadow-dom")]
            signaled_slots: HashSet::new(),
            #[cfg(feature = "shadow-dom")]
            adopted_stylesheets: HashMap::new(),
            #[cfg(feature = "shadow-dom")]
            custom_element_nodes: HashSet::new(),
            #[cfg(feature = "shadow-dom")]
            declarative_template_shadows: HashMap::new(),

            deferred_construction_nodes: Vec::new(),
            paint_damage: Default::default(),
            script_custom_elements: Default::default(),
            image_cache: HashMap::new(),
            pending_images: HashMap::new(),
            pending_critical_resources: HashSet::new(),
            web_fonts: Vec::new(),
            font_epoch: 0,
            document_referrer: String::new(),
            document_content_type: String::from("text/html"),
            document_window_focused: false,
            controls_to_form: HashMap::new(),
            net_provider,
            navigation_provider,
            shell_provider,
            html_parser_provider,
            abort_signal: config.abort_signal,
            last_mousedown_time: None,
            mousedown_position: taffy::Point::ZERO,
            click_count: 0,
            drag_mode: DragMode::None,
            hovered_scrollbar: None,
            scrollbar_activity: HashMap::new(),
            scroll_animation: ScrollAnimationState::None,
            text_selection: TextSelection::default(),
        };

        // Initialise document with root Document node
        doc.root_node_id = doc.create_node(NodeData::Document(Box::default()));
        doc.root_node_mut().flags.insert(NodeFlags::IS_IN_DOCUMENT);

        match config.ua_stylesheets {
            Some(stylesheets) => {
                for ss in &stylesheets {
                    doc.add_user_agent_stylesheet(ss);
                }
            }
            None => doc.add_user_agent_stylesheet(DEFAULT_CSS),
        }

        // Stylo data on the root node container is needed to render the node
        let stylo_element_data = StyloElementData {
            styles: ElementStyles {
                primary: Some(
                    ComputedValues::initial_values_with_font_override(Font::initial_values())
                        .to_arc(),
                ),
                ..Default::default()
            },
            ..Default::default()
        };
        let stylo_data = doc.root_node_mut().stylo_element_data_mut();
        *stylo_data.ensure_init_mut() = stylo_element_data;

        doc
    }

    /// Set the Document's networking provider
    pub fn set_net_provider(&mut self, net_provider: Arc<dyn NetProvider>) {
        self.net_provider = net_provider;
    }

    /// Set the Document's navigation provider
    pub fn set_navigation_provider(&mut self, navigation_provider: Arc<dyn NavigationProvider>) {
        self.navigation_provider = navigation_provider;
    }

    /// Set the Document's shell provider
    pub fn set_shell_provider(&mut self, shell_provider: Arc<dyn ShellProvider>) {
        self.shell_provider = shell_provider;
    }

    /// Set the Document's html parser provider
    pub fn set_html_parser_provider(&mut self, html_parser_provider: Arc<dyn HtmlParserProvider>) {
        self.html_parser_provider = html_parser_provider;
    }

    /// Set base url for resolving linked resources (stylesheets, images, fonts, etc)
    pub fn set_base_url(&mut self, url: &str) {
        self.url = DocumentUrl::from(Url::parse(url).unwrap());
    }

    pub fn guard(&self) -> &SharedRwLock {
        &self.guard
    }

    pub fn tree(&self) -> &NodeTree {
        &self.nodes
    }

    pub fn id(&self) -> usize {
        self.id
    }

    /// Wrapper around [`crate::net::stamped_request`]. Use the free function
    /// when `&self` would conflict with a held `&mut` borrow on a field.
    pub(crate) fn build_request(&self, url: url::Url) -> Request {
        crate::net::with_referrer(
            crate::net::stamped_request(url, self.abort_signal.as_ref()),
            self.url(),
        )
    }

    pub fn favicon_url(&self) -> Option<String> {
        self.tree().iter().find_map(|(_, node)| {
            let data = &node.data;
            if !data.is_element_with_tag_name(&local_name!("link")) {
                return None;
            }
            let rel = data.attr(local_name!("rel"))?;
            if !rel
                .split_ascii_whitespace()
                .any(|v| v.eq_ignore_ascii_case("icon"))
            {
                return None;
            }
            data.attr(local_name!("href")).map(|s| s.to_string())
        })
    }

    pub fn get_node(&self, node_id: NodeId) -> Option<&Node> {
        self.nodes.get(node_id)
    }

    pub fn get_node_mut(&mut self, node_id: NodeId) -> Option<&mut Node> {
        self.nodes.get_mut(node_id)
    }

    pub fn get_focussed_node_id(&self) -> Option<NodeId> {
        self.focus_node_id
            .or(self.try_root_element().map(|el| el.id))
    }

    pub fn mutate<'doc>(&'doc mut self) -> DocumentMutator<'doc> {
        DocumentMutator::new(self)
    }

    pub fn handle_dom_event<F: FnMut(DomEvent)>(
        &mut self,
        event: &mut DomEvent,
        dispatch_event: F,
    ) {
        handle_dom_event(self, event, dispatch_event)
    }

    pub fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }

    /// Find the label's bound input elements:
    /// the element id referenced by the "for" attribute of a given label element
    /// or the first input element which is nested in the label
    /// Note that although there should only be one bound element,
    /// we return all possibilities instead of just the first
    /// in order to allow the caller to decide which one is correct
    pub fn label_bound_input_element(&self, label_node_id: NodeId) -> Option<&Node> {
        let label_element = self.nodes[label_node_id].element_data()?;
        if let Some(target_element_dom_id) = label_element.attr(local_name!("for")) {
            TreeTraverser::new(self)
                .filter_map(|id| {
                    let node = self.get_node(id)?;
                    let element_data = node.element_data()?;
                    if element_data.name.local != local_name!("input") {
                        return None;
                    }
                    let id = element_data.id.as_ref()?;
                    if *id == *target_element_dom_id {
                        Some(node)
                    } else {
                        None
                    }
                })
                .next()
        } else {
            TreeTraverser::new_with_root(self, label_node_id)
                .filter_map(|child_id| {
                    let node = self.get_node(child_id)?;
                    let element_data = node.element_data()?;
                    if element_data.name.local == local_name!("input") {
                        Some(node)
                    } else {
                        None
                    }
                })
                .next()
        }
    }

    /// The checkedness a click changed, kept so the click's *canceled
    /// activation steps* can put it back when a listener calls
    /// `preventDefault()`.
    ///
    /// A radio carries its whole set, because selecting one clears the others.
    pub fn run_pre_click_activation(&mut self, target: NodeId) -> Option<PreClickActivation> {
        let node_id = crate::events::pointer::checkable_activation_target(self, target)?;
        let el = self.get_node(node_id)?.data.downcast_element()?;
        let is_radio = el.attr(local_name!("type")) == Some("radio");

        if !is_radio {
            let previous = el.checkbox_input_checked()?;
            let el = self.get_node_mut(node_id)?.data.downcast_element_mut()?;
            Self::toggle_checkbox(el);
            return Some(PreClickActivation {
                previous: vec![(node_id, previous)],
            });
        }

        let radio_set = el.attr(local_name!("name")).map(str::to_string);
        let Some(radio_set) = radio_set else {
            let previous = el.checkbox_input_checked()?;
            let el = self.get_node_mut(node_id)?.data.downcast_element_mut()?;
            *el.checkbox_input_checked_mut()? = true;
            return Some(PreClickActivation {
                previous: vec![(node_id, previous)],
            });
        };

        // Recorded *while* selecting rather than before it. Selecting one radio
        // clears every other in the set, so cancelling has to restore all of
        // them, and reading them first meant walking the whole arena twice for
        // one press. The membership test is `toggle_radio`'s, deliberately: two
        // predicates that disagreed would restore a different set than the one
        // that changed.
        //
        // That predicate is name plus "has checkbox state", which is neither
        // scoped to `type=radio` nor to a form owner. Wrong per HTML, and
        // longstanding; matching it here keeps this change to the ordering it
        // is about.
        let mut previous: Vec<(NodeId, bool)> = Vec::new();
        for (id, node) in self.nodes.iter_mut() {
            let Some(el) = node.data.downcast_element_mut() else {
                continue;
            };
            if el.attr(local_name!("name")) != Some(&*radio_set) {
                continue;
            }
            let Some(is_checked) = el.checkbox_input_checked_mut() else {
                continue;
            };
            previous.push((id, *is_checked));
            *is_checked = id == node_id;
        }
        Some(PreClickActivation { previous })
    }

    /// Undo [`Self::run_pre_click_activation`]. The click's *canceled
    /// activation steps*.
    pub fn undo_pre_click_activation(&mut self, activation: PreClickActivation) {
        for (node_id, was_checked) in activation.previous {
            let Some(node) = self.get_node_mut(node_id) else {
                continue;
            };
            let Some(el) = node.data.downcast_element_mut() else {
                continue;
            };
            if let Some(is_checked) = el.checkbox_input_checked_mut() {
                *is_checked = was_checked;
            }
        }
    }

    pub fn toggle_checkbox(el: &mut ElementData) -> bool {
        let Some(is_checked) = el.checkbox_input_checked_mut() else {
            return false;
        };
        *is_checked = !*is_checked;

        *is_checked
    }

    pub fn toggle_radio(&mut self, radio_set_name: String, target_radio_id: NodeId) {
        for (i, node) in self.nodes.iter_mut() {
            if let Some(node_data) = node.data.downcast_element_mut() {
                if node_data.attr(local_name!("name")) == Some(&radio_set_name) {
                    let was_clicked = i == target_radio_id;
                    let Some(is_checked) = node_data.checkbox_input_checked_mut() else {
                        continue;
                    };
                    *is_checked = was_clicked;
                }
            }
        }
    }

    /// Toggle the `open` attribute of a `<details>` element, expanding or
    /// collapsing it. This is the default action triggered when the element's
    /// first `<summary>` child is activated.
    pub fn toggle_details_open(&mut self, details_id: NodeId) {
        use crate::qual_name;

        let node = &self.nodes[details_id];
        if !node.data.is_element_with_tag_name(&local_name!("details")) {
            return;
        }
        let is_open = node.data.has_attr(local_name!("open"));

        // Note: HTML attributes are in the empty (null) namespace, so the
        // QualName must not use the html namespace here, else it won't match
        // an `open` attribute created by the HTML parser.
        let mut mutator = self.mutate();
        if is_open {
            mutator.clear_attribute(details_id, qual_name!("open"));
        } else {
            mutator.set_attribute(details_id, qual_name!("open"), "");
        }
        drop(mutator);

        self.shell_provider.request_redraw();
    }

    pub fn set_style_property(&mut self, node_id: NodeId, name: &str, value: &str) {
        let node = &mut self.nodes[node_id];
        let did_change = node.element_data_mut().unwrap().set_style_property(
            name,
            value,
            &self.guard,
            self.url.url_extra_data(),
        );
        if did_change {
            node.mark_style_attr_updated();
        }
    }

    pub fn remove_style_property(&mut self, node_id: NodeId, name: &str) {
        let node = &mut self.nodes[node_id];
        let did_change = node.element_data_mut().unwrap().remove_style_property(
            name,
            &self.guard,
            self.url.url_extra_data(),
        );
        if did_change {
            node.mark_style_attr_updated();
        }
    }

    pub fn sub_document_node_ids(&self) -> Vec<NodeId> {
        self.sub_document_nodes.iter().copied().collect()
    }

    /// Install the effective navigation referrer and response MIME type.
    pub fn set_navigation_metadata(&mut self, request: &Request, content_type: Option<&str>) {
        self.document_referrer = request
            .headers
            .get(blitz_traits::net::http::header::REFERER)
            .and_then(|value| value.to_str().ok())
            .and_then(|value| Url::parse(value).ok())
            .map(|mut url| {
                let _ = url.set_username("");
                let _ = url.set_password(None);
                url.set_fragment(None);
                url.to_string()
            })
            .unwrap_or_default();
        self.document_content_type = content_type
            .and_then(|value| value.split(';').next())
            .map(str::trim)
            .filter(|value| !value.is_empty())
            .unwrap_or("text/html")
            .to_ascii_lowercase();
    }

    pub fn referrer(&self) -> &str {
        &self.document_referrer
    }

    pub fn content_type(&self) -> &str {
        &self.document_content_type
    }

    pub fn window_focused(&self) -> bool {
        self.document_window_focused
    }

    /// Hosts must deliver focus changes on the document's owning thread.
    pub fn set_window_focused(&mut self, focused: bool) {
        self.document_window_focused = focused;
        for id in self.sub_document_node_ids() {
            if let Some(child) = self
                .get_node_mut(id)
                .and_then(|node| node.element_data_mut())
                .and_then(|element| element.sub_doc_data_mut())
            {
                child.inner_mut().set_window_focused(focused);
            }
        }
    }

    /// 0 is standards, 1 is limited quirks, and 2 is quirks.
    pub fn set_document_quirks_mode(&mut self, mode: u8) {
        if let NodeData::Document(data) = &mut self.root_node_mut().data {
            data.quirks_mode = mode;
        }
    }

    pub fn compat_mode(&self) -> &'static str {
        if matches!(&self.root_node().data, NodeData::Document(data) if data.quirks_mode == 2) {
            "BackCompat"
        } else {
            "CSS1Compat"
        }
    }

    pub fn begin_document_stream(&mut self) {
        self.reset_web_fonts();
        self.pending_critical_resources.clear();
        self.pending_images.clear();
        self.set_document_quirks_mode(0);
    }

    pub fn set_sub_document(&mut self, node_id: NodeId, mut sub_document: Box<dyn Document>) {
        sub_document
            .inner_mut()
            .set_window_focused(self.document_window_focused);
        self.nodes[node_id]
            .element_data_mut()
            .unwrap()
            .set_sub_document(sub_document);
        self.sub_document_nodes.insert(node_id);
    }

    pub fn remove_sub_document(&mut self, node_id: NodeId) {
        self.nodes[node_id]
            .element_data_mut()
            .unwrap()
            .remove_sub_document();
        self.sub_document_nodes.remove(&node_id);
        if let Some(load) = self.iframe_loads.remove(&node_id) {
            load.abort_controller.abort();
        }
    }

    /// Poll all sub-documents (see [`Document::poll`]), allowing them to make progress
    /// on any pending async operations (e.g. JavaScript timers). Hosts which poll a
    /// wrapper around a [`BaseDocument`] should call this from their `poll` implementation.
    ///
    /// Returns `true` if any sub-document reported changes.
    pub fn poll_subdocuments(&mut self, waker: Option<&Waker>) -> bool {
        self.poll_subdocuments_inner(waker, None)
    }

    /// Propagate a settle pass's timer policy to every child document.
    pub fn poll_subdocuments_for_settle(
        &mut self,
        waker: Option<&Waker>,
        run_timers: bool,
    ) -> bool {
        self.poll_subdocuments_inner(waker, Some(run_timers))
    }

    fn poll_subdocuments_inner(
        &mut self,
        waker: Option<&Waker>,
        settle_timers: Option<bool>,
    ) -> bool {
        let mut has_changes = false;
        let node_ids: Vec<NodeId> = self.sub_document_nodes.iter().copied().collect();
        for node_id in node_ids {
            let Some(sub_doc) = self
                .nodes
                .get_mut(node_id)
                .and_then(|node| node.subdoc_mut())
            else {
                continue;
            };
            let task_context = waker.map(TaskContext::from_waker);
            has_changes |= match settle_timers {
                Some(run_timers) => sub_doc.poll_for_settle(task_context, run_timers),
                None => sub_doc.poll(task_context),
            };
        }
        has_changes
    }

    #[cfg(feature = "custom-widget")]
    pub fn custom_widget_node_ids(&self) -> Vec<NodeId> {
        self.custom_widget_nodes.iter().copied().collect()
    }

    #[cfg(feature = "custom-widget")]
    pub fn take_pending_resource_deallocations(&mut self) -> Vec<anyrender::ResourceId> {
        std::mem::take(&mut self.pending_resource_deallocations)
    }

    #[cfg(feature = "custom-widget")]
    pub fn set_custom_widget(&mut self, node_id: NodeId, widget: Box<dyn crate::Widget>) {
        self.nodes[node_id]
            .element_data_mut()
            .unwrap()
            .set_custom_widget(widget);
        self.custom_widget_nodes.insert(node_id);
    }

    #[cfg(feature = "custom-widget")]
    pub fn remove_custom_widget(&mut self, node_id: NodeId) {
        let resources_to_deallocate = self.nodes[node_id]
            .element_data_mut()
            .unwrap()
            .remove_custom_widget();
        self.pending_resource_deallocations
            .extend_from_slice(&resources_to_deallocate);
        self.custom_widget_nodes.remove(&node_id);
    }

    /// Mutable access to the custom element registry. Use
    /// [`CustomElementRegistry::define`](crate::node::CustomElementRegistry::define)
    /// to register custom elements by tag name.
    #[cfg(feature = "shadow-dom")]
    pub fn custom_elements_mut(&mut self) -> &mut crate::node::CustomElementRegistry {
        &mut self.custom_element_registry
    }

    /// Register a custom element definition against a tag name (analogous to
    /// `customElements.define`).
    #[cfg(feature = "shadow-dom")]
    pub fn define_custom_element(
        &mut self,
        name: markup5ever::LocalName,
        definition: crate::node::CustomElementDefinition,
    ) {
        self.custom_element_registry.define(name, definition);
    }

    /// The node ids of all shadow hosts in the document.
    #[cfg(feature = "shadow-dom")]
    pub fn shadow_host_node_ids(&self) -> Vec<NodeId> {
        self.shadow_host_nodes.iter().copied().collect()
    }

    /// If `host_id` is a shadow host, returns the node id of its shadow root.
    #[cfg(feature = "shadow-dom")]
    pub fn shadow_root_id(&self, host_id: NodeId) -> Option<NodeId> {
        self.get_node(host_id)
            .and_then(|node| node.shadow_root_id())
    }

    /// Attach a shadow root to the given host element, returning the node id of
    /// the newly-created shadow root. If the host already has a shadow root, its
    /// existing shadow root id is returned unchanged.
    #[cfg(feature = "shadow-dom")]
    pub fn attach_shadow(&mut self, host_id: NodeId, mode: crate::node::ShadowRootMode) -> NodeId {
        if let Some(existing) = self.nodes[host_id].shadow_root_id() {
            return existing;
        }

        let shadow_root_id = self.create_node(NodeData::ShadowRoot(
            crate::node::ShadowRootData::new(host_id, mode),
        ));

        // The shadow root's parent is the host. It is *not* added to the host's
        // `children` list (which holds light-DOM children); it is referenced via
        // the host's `ElementData::shadow_root` field instead.
        self.nodes[shadow_root_id].parent = Some(host_id);
        self.nodes[shadow_root_id].owner_document = self.nodes[host_id].owner_document;
        if self.nodes[host_id].flags.is_in_document() {
            self.nodes[shadow_root_id]
                .flags
                .insert(NodeFlags::IS_IN_DOCUMENT);
        }

        self.nodes[host_id]
            .element_data_mut()
            .expect("Shadow host must be an element")
            .shadow_root = Some(shadow_root_id);
        self.shadow_host_nodes.insert(host_id);
        self.dirty_shadow_hosts.insert(host_id);
        self.nodes[host_id].set_restyle_hint(
            style::invalidation::element::restyle_hints::RestyleHint::restyle_subtree(),
        );

        // Host needs its box tree rebuilt to account for the shadow tree.
        self.nodes[host_id].insert_damage(ALL_DAMAGE);
        self.nodes[host_id].mark_ancestors_dirty();

        shadow_root_id
    }

    /// HTML elements that `Element.attachShadow` accepts.
    ///
    /// Hyphenated names are included, matching the existing script binding.
    /// `template` is not a host.
    #[cfg(feature = "shadow-dom")]
    pub fn element_can_be_shadow_host(element: &ElementData) -> bool {
        let tag = element.name.local.as_ref();
        element.name.ns == ns!(html)
            && (tag.contains('-')
                || matches!(
                    tag,
                    "article"
                        | "aside"
                        | "blockquote"
                        | "body"
                        | "div"
                        | "footer"
                        | "h1"
                        | "h2"
                        | "h3"
                        | "h4"
                        | "h5"
                        | "h6"
                        | "header"
                        | "main"
                        | "nav"
                        | "p"
                        | "section"
                        | "span"
                ))
    }

    /// Attach a declarative shadow root, or return false and leave the template
    /// as a normal template.
    ///
    /// Failure is the host being missing, not a shadow host, or already having
    /// a root. Success records the template so parsed children land in the root.
    #[cfg(feature = "shadow-dom")]
    pub fn try_attach_declarative_shadow(
        &mut self,
        host_id: NodeId,
        template_id: NodeId,
        mode: crate::node::ShadowRootMode,
        clonable: bool,
        serializable: bool,
        delegates_focus: bool,
    ) -> bool {
        let can_attach = self.nodes.get(host_id).is_some_and(|node| {
            node.element_data().is_some_and(|element| {
                Self::element_can_be_shadow_host(element) && element.shadow_root.is_none()
            })
        });
        if !can_attach {
            return false;
        }
        let root_id = self.attach_shadow(host_id, mode);
        if let Some(root) = self.nodes[root_id].shadow_root_data_mut() {
            root.declarative = true;
            root.clonable = clonable;
            root.serializable = serializable;
            root.delegates_focus = delegates_focus;
        }
        self.declarative_template_shadows
            .insert(template_id, root_id);
        true
    }

    /// Detach (and drop) the shadow root of the given host element, if any.
    #[cfg(feature = "shadow-dom")]
    pub fn detach_shadow(&mut self, host_id: NodeId) {
        let shadow_root_id = self.nodes[host_id]
            .element_data_mut()
            .and_then(|el| el.shadow_root.take());
        if let Some(shadow_root_id) = shadow_root_id {
            self.drop_node_ignoring_parent(shadow_root_id);
            self.shadow_host_nodes.remove(&host_id);
            self.dirty_shadow_hosts.remove(&host_id);
            self.nodes[host_id].flattened_children = None;
            self.nodes[host_id].set_restyle_hint(
                style::invalidation::element::restyle_hints::RestyleHint::restyle_subtree(),
            );
            self.nodes[host_id].insert_damage(ALL_DAMAGE);
            self.nodes[host_id].mark_ancestors_dirty();
        }
    }

    /// Attach a custom element controller to the given node.
    #[cfg(feature = "shadow-dom")]
    pub fn set_custom_element(
        &mut self,
        node_id: NodeId,
        controller: Box<dyn crate::node::CustomElement>,
    ) {
        use crate::node::{CustomElementData, SpecialElementData};
        self.nodes[node_id]
            .element_data_mut()
            .expect("Custom element host must be an element")
            .special_data = SpecialElementData::CustomElement(CustomElementData::new(controller));
        self.custom_element_nodes.insert(node_id);
    }

    /// Detach the custom element controller from the given node (without running
    /// the `disconnected` callback). Returns the controller if present.
    #[cfg(feature = "shadow-dom")]
    pub fn take_custom_element(
        &mut self,
        node_id: NodeId,
    ) -> Option<Box<dyn crate::node::CustomElement>> {
        use crate::node::SpecialElementData;
        self.custom_element_nodes.remove(&node_id);
        let element = self.nodes[node_id].element_data_mut()?;
        if matches!(element.special_data, SpecialElementData::CustomElement(_)) {
            if let SpecialElementData::CustomElement(mut data) = element.special_data.take() {
                return data.controller.take();
            }
        }
        None
    }

    pub fn root_node(&self) -> &Node {
        &self.nodes[self.root_node_id]
    }

    pub fn root_node_mut(&mut self) -> &mut Node {
        &mut self.nodes[self.root_node_id]
    }

    /// Ask this document to work out which regions differ between frames.
    ///
    /// Off by default. A consumer that turns it on is charged one pass over the
    /// node list per [`resolve`](Self::resolve) - a pass `resolve` already makes
    /// to clear damage - plus a hash lookup and a rectangle comparison per node.
    /// Nothing else in the document reads the result, so leaving it off costs a
    /// single branch.
    ///
    /// The consumer this exists for is a `backdrop-filter` cache. Blurring what
    /// is behind an element costs a render pass and a filter every frame, and
    /// the only way that stops being permanent is to skip the elements whose
    /// input has not changed. Turning this on is what makes that question
    /// answerable.
    ///
    /// The first frame after enabling reports everything as changed, because
    /// there is no previous frame to compare against.
    pub fn set_paint_damage_tracking(&mut self, enabled: bool) {
        self.paint_damage.set_enabled(enabled);
    }

    /// Whether [`set_paint_damage_tracking`](Self::set_paint_damage_tracking) is on.
    pub fn paint_damage_tracking(&self) -> bool {
        self.paint_damage.is_enabled()
    }

    /// What changed since the previously resolved frame.
    ///
    /// Empty when tracking is off, which is indistinguishable from "nothing
    /// changed" and deliberately so: a consumer that has not asked for the
    /// question to be answered must not read the empty answer as a licence to
    /// reuse a cache. Check
    /// [`paint_damage_tracking`](Self::paint_damage_tracking) first.
    pub fn paint_damage(&self) -> &crate::paint_damage::PaintDamage {
        self.paint_damage.damage()
    }

    pub fn try_root_element(&self) -> Option<&Node> {
        TDocument::as_node(&self.root_node()).first_element_child()
    }

    pub fn root_element(&self) -> &Node {
        TDocument::as_node(&self.root_node())
            .first_element_child()
            .unwrap()
            .as_element()
            .unwrap()
    }

    pub fn create_node(&mut self, node_data: NodeData) -> NodeId {
        let tree_ptr = self.nodes.as_mut() as *mut NodeTree;
        let guard = self.guard.clone();
        let is_document = matches!(node_data, NodeData::Document(_));
        let id = self
            .nodes
            .insert_with_key(|id| Node::new(tree_ptr, id, guard, node_data));
        if !is_document {
            self.nodes[id].owner_document = Some(self.root_node_id);
        }
        self.register_script_custom_element(id);
        if let Some(attributes) = self.nodes[id]
            .element_data()
            .and_then(|element| element.inline_event_attributes.as_deref())
        {
            self.inline_handler_changes.extend(
                attributes
                    .iter()
                    .map(|attr| (id, attr.name.clone(), Some(attr.value.clone()))),
            );
        }
        id
    }

    pub fn add_to_document_id_map(&mut self, document_id: NodeId, id: &str, node_id: NodeId) {
        if document_id == self.root_node_id || id.is_empty() {
            return;
        }
        let Some(node) = self.get_node_mut(document_id) else {
            return;
        };
        let NodeData::Document(data) = &mut node.data else {
            return;
        };
        let candidates = data.ids.entry(id.to_owned()).or_default();
        if !candidates.contains(&node_id) {
            candidates.push(node_id);
        }
    }

    pub fn remove_from_document_id_map(&mut self, document_id: NodeId, id: &str, node_id: NodeId) {
        if document_id == self.root_node_id {
            return;
        }
        let Some(node) = self.get_node_mut(document_id) else {
            return;
        };
        let NodeData::Document(data) = &mut node.data else {
            return;
        };
        if let Some(candidates) = data.ids.get_mut(id) {
            candidates.retain(|candidate| *candidate != node_id);
            if candidates.is_empty() {
                data.ids.remove(id);
            }
        }
    }

    /// Indexed lookup scoped to one document. Parent child-list membership
    /// excludes removed nodes, template contents, and shadow trees.
    pub fn get_element_by_id_in(&self, document_id: NodeId, id: &str) -> Option<NodeId> {
        if document_id == self.root_node_id {
            return self.get_element_by_id(id);
        }
        if id.is_empty() {
            return None;
        }
        let NodeData::Document(data) = &self.get_node(document_id)?.data else {
            return None;
        };
        data.ids
            .get(id)?
            .iter()
            .filter_map(|candidate| {
                let mut current = *candidate;
                let mut path = Vec::new();
                while current != document_id {
                    let node = self.get_node(current)?;
                    let parent_id = node.parent?;
                    let parent = self.get_node(parent_id)?;
                    path.push(parent.index_of_child(current)?);
                    current = parent_id;
                }
                path.reverse();
                Some((path, *candidate))
            })
            .min_by(|left, right| left.0.cmp(&right.0))
            .map(|(_, node_id)| node_id)
    }

    /// Nodes that still hold a link to `node_id` after it leaves the document.
    ///
    /// Direct parents are recorded separately and force reconstruction. This
    /// collects everyone else the old document-wide pass would have mutated:
    /// surviving layout children (their `layout_parent` still points here),
    /// anonymous blocks that list the id without being its DOM parent, shadow
    /// slots and hosts, the authored parent of a hoisted fixed box, and
    /// ancestors whose inline layout, list marker, table grid, or stacking
    /// context stores a descendant id. Ancestors inside `removed` are not
    /// walked; detachment does not clean lists on nodes that are themselves
    /// going away.
    fn collect_live_reference_owners(
        nodes: &NodeTree,
        hoisted_fixed_parents: &HashMap<NodeId, NodeId>,
        removed: &FxHashSet<NodeId>,
        node_id: NodeId,
        candidates: &mut FxHashSet<NodeId>,
    ) {
        fn push_survivor(
            removed: &FxHashSet<NodeId>,
            candidates: &mut FxHashSet<NodeId>,
            id: NodeId,
        ) {
            if !removed.contains(&id) {
                candidates.insert(id);
            }
        }

        let (removed_is_text, dom_parent, layout_parent, seeds) = {
            let Some(node) = nodes.get(node_id) else {
                return;
            };
            let mut seeds: SmallVec<[NodeId; 8]> = SmallVec::new();
            {
                let borrowed = node.layout_children.borrow();
                if let Some(children) = borrowed.as_ref() {
                    seeds.extend(children.iter().copied());
                }
            }
            seeds.extend(node.children.iter().copied());
            seeds.extend(node.anonymous_blocks.iter().copied());
            seeds.extend(node.before());
            seeds.extend(node.after());
            #[cfg(feature = "shadow-dom")]
            {
                seeds.extend(node.assigned_slot);
                seeds.extend(
                    node.element_data()
                        .and_then(|element| element.assigned_slot),
                );
                if let Some(assigned) = node.assigned_nodes.as_ref() {
                    seeds.extend(assigned.iter().copied());
                }
                if let Some(root) = node.shadow_root_data() {
                    seeds.push(root.host);
                }
            }
            (
                node.is_text_node(),
                node.parent,
                node.layout_parent.get(),
                seeds,
            )
        };

        for parent_id in [dom_parent, layout_parent].into_iter().flatten() {
            let Some(parent) = nodes.get(parent_id) else {
                continue;
            };
            let anons: SmallVec<[NodeId; 4]> = parent.anonymous_blocks.iter().copied().collect();
            for anon in anons {
                let Some(anon_node) = nodes.get(anon) else {
                    continue;
                };
                let listed = anon_node
                    .children
                    .iter()
                    .any(|child| removed.contains(child))
                    || anon_node
                        .layout_children
                        .borrow()
                        .as_ref()
                        .is_some_and(|children| {
                            children.iter().any(|child| removed.contains(child))
                        });
                if listed {
                    push_survivor(removed, candidates, anon);
                }
            }
        }
        for id in seeds {
            push_survivor(removed, candidates, id);
        }

        let mut stack: SmallVec<[NodeId; 16]> = SmallVec::new();
        if let Some(id) = dom_parent {
            if !removed.contains(&id) {
                stack.push(id);
            }
        }
        if let Some(id) = layout_parent {
            if !removed.contains(&id) {
                stack.push(id);
            }
        }
        if let Some(origin) = hoisted_fixed_parents.get(&node_id).copied() {
            // Hoist drops the layout edge before paint children are rebuilt, so
            // the authored parent can still name the fixed box.
            push_survivor(removed, candidates, origin);
            if !removed.contains(&origin) {
                stack.push(origin);
            }
        }

        let mut seen: SmallVec<[NodeId; 16]> = SmallVec::new();
        seen.push(node_id);
        while let Some(id) = stack.pop() {
            if seen.contains(&id) {
                continue;
            }
            seen.push(id);
            let Some(ancestor) = nodes.get(id) else {
                continue;
            };
            let stacking = ancestor.stacking_context.as_ref().is_some_and(|context| {
                context.children.iter().any(|child| {
                    removed.contains(&child.node_id)
                        || child
                            .clip_ancestors
                            .iter()
                            .any(|clip| removed.contains(clip))
                })
            });
            let inline_or_list = ancestor.element_data().is_some_and(|element| {
                element.inline_layout_data.is_some() || element.list_item_data.is_some()
            });
            // Table grids store cells, rows, and row groups, never text nodes.
            let table_root = !removed_is_text && ancestor.flags.is_table_root();
            #[cfg(feature = "shadow-dom")]
            let shadow_hit = {
                let mut hit = ancestor
                    .flattened_children
                    .as_ref()
                    .is_some_and(|children| children.iter().any(|child| removed.contains(child)))
                    || ancestor.assigned_nodes.as_ref().is_some_and(|assigned| {
                        assigned.iter().any(|child| removed.contains(child))
                    });
                if let Some(root) = ancestor.shadow_root_data() {
                    let host = root.host;
                    hit = hit
                        || root.slots.iter().any(|slot| removed.contains(slot))
                        || root
                            .slottables
                            .iter()
                            .any(|slottable| removed.contains(slottable))
                        || root
                            .stylesheet_nodes
                            .iter()
                            .any(|sheet| removed.contains(sheet));
                    stack.push(host);
                }
                hit
            };
            #[cfg(not(feature = "shadow-dom"))]
            let shadow_hit = false;
            if stacking || inline_or_list || table_root || shadow_hit {
                push_survivor(removed, candidates, id);
            }
            if let Some(parent) = ancestor.parent {
                stack.push(parent);
            }
            if let Some(parent) = ancestor.layout_parent.get() {
                stack.push(parent);
            }
        }
    }

    /// Stacking-context hosts are few, and a fixed box can paint in one that
    /// is not a layout ancestor of its current parent. Visit a host only when
    /// its hoisted list actually names a removed id.
    fn collect_stacking_context_owners(
        nodes: &NodeTree,
        position_hosts: &HashSet<NodeId>,
        clip_hosts: &HashSet<NodeId>,
        removed: &FxHashSet<NodeId>,
        candidates: &mut FxHashSet<NodeId>,
    ) {
        for host in position_hosts.iter().chain(clip_hosts.iter()).copied() {
            if removed.contains(&host) {
                continue;
            }
            let Some(node) = nodes.get(host) else {
                continue;
            };
            let Some(context) = node.stacking_context.as_ref() else {
                continue;
            };
            let references = context.children.iter().any(|child| {
                removed.contains(&child.node_id)
                    || child
                        .clip_ancestors
                        .iter()
                        .any(|clip| removed.contains(clip))
            });
            if references {
                candidates.insert(host);
            }
        }
    }

    /// Remove detached or freed ids from every persistent rendering cache.
    ///
    /// DOM ancestry alone cannot find the owners: fixed boxes can belong to
    /// the root's layout list and another ancestor's stacking context, while
    /// inline boxes and table cells have additional flattened representations.
    /// Invalidate those owners before this mutation returns. Hidden subtrees
    /// retain caches, so leaving cleanup until resolve is insufficient.
    ///
    /// Only those owners are visited. A pass over every node made each
    /// `textContent` write rescan the whole document.
    pub(crate) fn invalidate_node_references(
        &mut self,
        removed: &FxHashSet<NodeId>,
        mut parents: FxHashSet<NodeId>,
        extra_owners: FxHashSet<NodeId>,
    ) {
        if removed.is_empty() {
            return;
        }

        fn layout_references_removed(
            layout: &parley::Layout<TextBrush>,
            removed: &FxHashSet<NodeId>,
        ) -> bool {
            layout
                .inline_boxes()
                .iter()
                .any(|ibox| removed.contains(&NodeId::from_u64(ibox.id)))
                || layout.styles().iter().any(|style| {
                    removed.contains(&style.brush.id)
                        || style
                            .brush
                            .text_node
                            .is_some_and(|id| removed.contains(&id))
                })
        }

        // An anonymous origin can disappear while its hoisted fixed box
        // survives. Reconstruct the root edge too, so construction can give
        // that box a current authored origin.
        for (&id, &origin) in &self.hoisted_fixed_parents {
            if removed.contains(&id) || removed.contains(&origin) {
                if let Some(node) = self.nodes.get(id) {
                    parents.extend(node.layout_parent.get());
                }
            }
        }

        let mut candidates: FxHashSet<NodeId> = FxHashSet::with_capacity_and_hasher(
            parents.len() + extra_owners.len() + removed.len(),
            Default::default(),
        );
        for &id in &parents {
            if !removed.contains(&id) {
                candidates.insert(id);
            }
        }
        for id in extra_owners {
            if !removed.contains(&id) {
                candidates.insert(id);
            }
        }
        for &id in removed {
            let detach = self
                .nodes
                .get(id)
                .and_then(|node| node.layout_parent.get())
                .is_some_and(|parent| !removed.contains(&parent));
            if detach {
                candidates.insert(id);
            }
            if self.nodes.contains_key(id) {
                Self::collect_live_reference_owners(
                    &self.nodes,
                    &self.hoisted_fixed_parents,
                    removed,
                    id,
                    &mut candidates,
                );
            }
        }
        Self::collect_stacking_context_owners(
            &self.nodes,
            &self.hoisted_position_hosts,
            &self.hoisted_clip_hosts,
            removed,
            &mut candidates,
        );

        self.fixed_nodes.retain(|id| !removed.contains(id));
        self.sticky_nodes.retain(|id| !removed.contains(id));
        self.sticky_offsets.retain(|id, _| !removed.contains(id));
        self.hoisted_fixed_parents
            .retain(|id, origin| !removed.contains(id) && !removed.contains(origin));
        let fixed_parents = &self.hoisted_fixed_parents;
        self.hoisted_fixed_indices
            .retain(|id, _| fixed_parents.contains_key(id));
        self.hoisted_clip_hosts.retain(|id| !removed.contains(id));
        self.hoisted_position_hosts
            .retain(|id| !removed.contains(id));

        // These snapshots contain both box ids and containing-block/parent
        // ids. Discard the complete snapshots rather than retaining inputs
        // computed against a box tree that has just changed.
        self.abspos_placements.clear();
        self.abspos_candidates.clear();
        self.abspos_candidate_ids.clear();
        self.abspos_inputs.clear();
        self.abspos_written.clear();
        self.abspos_candidates_dirty = true;
        self.abspos_layout_dirty = true;

        let mut dirty = FxHashSet::default();
        for id in candidates {
            let Some(node) = self.nodes.get_mut(id) else {
                continue;
            };
            // Detached nodes still owned by script keep their internal box
            // tree, but must lose any edge back into the live layout tree.
            if removed.contains(&id) {
                if node
                    .layout_parent
                    .get()
                    .is_some_and(|parent| !removed.contains(&parent))
                {
                    node.layout_parent.set(None);
                }
                continue;
            }

            let mut reconstruct = parents.contains(&id);
            reconstruct |= node
                .layout_children
                .get_mut()
                .as_ref()
                .is_some_and(|children| children.iter().any(|id| removed.contains(id)));
            let mut repaint = node
                .paint_children
                .get_mut()
                .as_ref()
                .is_some_and(|children| children.iter().any(|id| removed.contains(id)));

            let old_anonymous_count = node.anonymous_blocks.len();
            node.anonymous_blocks.retain(|id| !removed.contains(id));
            reconstruct |= old_anonymous_count != node.anonymous_blocks.len();
            if node.is_anonymous() {
                let old_child_count = node.children.len();
                node.children.retain(|id| !removed.contains(id));
                reconstruct |= old_child_count != node.children.len();
            }
            if node
                .layout_parent
                .get()
                .is_some_and(|parent| removed.contains(&parent))
            {
                node.layout_parent.set(None);
                reconstruct = true;
            }

            if let Some(context) = node.stacking_context.as_mut() {
                let old_count = context.children.len();
                context.children.retain(|child| {
                    !removed.contains(&child.node_id)
                        && !child.clip_ancestors.iter().any(|id| removed.contains(id))
                });
                if old_count != context.children.len() {
                    // Filtering changes the split between negative and
                    // non-negative children as well as the content bounds.
                    context.sort();
                    context.content_area = taffy::Rect::ZERO;
                    repaint = true;
                }
            }

            #[cfg(feature = "shadow-dom")]
            {
                for children in [
                    node.flattened_children.as_mut(),
                    node.assigned_nodes.as_mut(),
                ]
                .into_iter()
                .flatten()
                {
                    let old_count = children.len();
                    children.retain(|id| !removed.contains(id));
                    reconstruct |= old_count != children.len();
                }
                if node.assigned_slot.is_some_and(|id| removed.contains(&id)) {
                    node.assigned_slot = None;
                    reconstruct = true;
                }
                if let Some(root) = node.shadow_root_data_mut() {
                    let old_count = root.slots.len() + root.slottables.len();
                    root.slots.retain(|id| !removed.contains(id));
                    root.slottables.retain(|id| !removed.contains(id));
                    root.stylesheet_nodes.retain(|id| !removed.contains(id));
                    reconstruct |= old_count != root.slots.len() + root.slottables.len();
                }
            }

            let mut table_removed = false;
            if let Some(element) = node.data.downcast_element_mut() {
                for pseudo in [&mut element.before, &mut element.after] {
                    if pseudo.is_some_and(|id| removed.contains(&id)) {
                        *pseudo = None;
                        reconstruct = true;
                    }
                }
                if element
                    .inline_layout_data
                    .as_ref()
                    .is_some_and(|inline| layout_references_removed(&inline.layout, removed))
                {
                    element.inline_layout_data = None;
                    reconstruct = true;
                }
                if element
                    .list_item_data
                    .as_ref()
                    .is_some_and(|item| match &item.position {
                        crate::node::ListItemLayoutPosition::Outside(layout) => {
                            layout_references_removed(layout, removed)
                        }
                        crate::node::ListItemLayoutPosition::Inside => false,
                    })
                {
                    element.list_item_data = None;
                    reconstruct = true;
                }
                if let SpecialElementData::TableRoot(context) = &element.special_data {
                    table_removed = context.references_removed_nodes(removed);
                }
                if table_removed {
                    element.special_data = SpecialElementData::None;
                    reconstruct = true;
                }
                #[cfg(feature = "shadow-dom")]
                if element
                    .assigned_slot
                    .is_some_and(|id| removed.contains(&id))
                {
                    element.assigned_slot = None;
                    reconstruct = true;
                }
            }
            if table_removed {
                node.flags.remove(NodeFlags::IS_TABLE_ROOT);
            }

            if reconstruct || repaint {
                node.layout_children.get_mut().take();
                node.paint_children.get_mut().take();
                if let Some(element) = node.data.downcast_element_mut() {
                    element.inline_layout_data = None;
                }
                dirty.insert(id);
            }
        }

        // Clear ancestor layout caches immediately, including ancestors that
        // the next incremental traversal would otherwise skip. Follow both
        // trees and tolerate parents already freed by a root-first drop.
        let mut stack: Vec<NodeId> = dirty.iter().copied().collect();
        let mut visited = FxHashSet::default();
        while let Some(id) = stack.pop() {
            if !visited.insert(id) || removed.contains(&id) {
                continue;
            }
            let Some(node) = self.nodes.get_mut(id) else {
                continue;
            };
            stack.extend(node.parent);
            stack.extend(node.layout_parent.get());
            #[cfg(feature = "shadow-dom")]
            {
                stack.extend(node.assigned_slot);
                if let Some(root) = node.shadow_root_data() {
                    stack.push(root.host);
                }
            }
            node.set_dirty_descendants();
            if node.stylo_element_data_opt().is_some() {
                node.insert_damage(if dirty.contains(&id) {
                    ALL_DAMAGE
                } else {
                    crate::layout::damage::ONLY_RELAYOUT
                        | style::selector_parser::RestyleDamage::REPAINT
                });
                node.cache_mut().clear();
            }
            if let Some(inline) = node
                .data
                .downcast_element_mut()
                .and_then(|element| element.inline_layout_data.as_mut())
            {
                inline.content_widths = None;
            }
        }

        #[cfg(feature = "shadow-dom")]
        {
            let nodes = &self.nodes;
            self.shadow_host_nodes.retain(|id| nodes.contains_key(*id));
            self.dirty_shadow_hosts.retain(|id| nodes.contains_key(*id));
            self.pending_slot_changes
                .retain(|id| nodes.contains_key(*id));
            self.signaled_slots.retain(|id| nodes.contains_key(*id));
            self.dirty_shadow_hosts
                .extend(self.shadow_host_nodes.iter().copied());
        }

        self.controls_to_form
            .retain(|control, form| !removed.contains(control) && !removed.contains(form));
        // Detached owners still need their caches cleared, but cannot affect
        // the frame. Live owners share the surrounding mutator's redraw.
        if dirty.iter().any(|id| {
            self.nodes
                .get(*id)
                .is_some_and(|node| node.flags.is_in_document())
        }) {
            if self.mutator_depth == 0 {
                self.shell_provider.request_redraw();
            } else {
                self.mutator_redraw_pending = true;
            }
        }

        // PaintDamage deliberately keeps old rectangles until resolve so
        // pixels formerly occupied by removed boxes are included in damage.
    }

    fn purge_dropped_node_references(&mut self) {
        if self.node_drop_depth != 0 || self.dropped_node_ids.is_empty() {
            return;
        }
        let removed = std::mem::take(&mut self.dropped_node_ids);
        let parents = std::mem::take(&mut self.dropped_node_parents);
        let owners = std::mem::take(&mut self.dropped_reference_owners);
        self.invalidate_node_references(&removed, parents, owners);
    }

    /// Remove a node from the node tree, clearing interaction state and
    /// invalidating rendering references before the surrounding drop returns.
    pub(crate) fn remove_node_from_tree(&mut self, node_id: NodeId) -> Option<Node> {
        self.clear_interaction_state_for_removed_node(node_id);
        let indexed = self.get_node(node_id).and_then(|node| {
            Some((
                node.owner_document?,
                node.element_data()?.id.as_ref()?.to_string(),
            ))
        });
        if let Some((document_id, id)) = indexed {
            self.remove_from_document_id_map(document_id, &id, node_id);
        }
        self.forget_script_custom_element(node_id);
        if self.nodes.contains_key(node_id) {
            self.dropped_node_ids.insert(node_id);
            let mut owners = FxHashSet::default();
            Self::collect_live_reference_owners(
                &self.nodes,
                &self.hoisted_fixed_parents,
                &self.dropped_node_ids,
                node_id,
                &mut owners,
            );
            self.dropped_reference_owners.extend(owners);
        }
        let node = self.nodes.remove(node_id);
        if let Some(node) = &node {
            self.dropped_node_parents.extend(
                [node.parent, node.layout_parent.get()]
                    .into_iter()
                    .flatten(),
            );
            self.purge_dropped_node_references();
        }
        node
    }

    /// The nearest element ancestor of `node_id` that is still in the
    /// document. Used to retarget hover/active state when the node they
    /// reference is removed. Tolerates already-removed ancestors (subtree
    /// teardown proceeds root-first) by giving up and returning `None`.
    fn nearest_surviving_element_ancestor(&self, node_id: NodeId) -> Option<NodeId> {
        let mut current = self.get_node(node_id)?.parent;
        while let Some(id) = current {
            let node = self.get_node(id)?;
            if node.is_element() && node.flags.is_in_document() {
                return Some(id);
            }
            current = node.parent;
        }
        None
    }

    /// Clear any interaction state (hover/active/focus/mousedown/selection/
    /// drag/scrollbar) that references `node_id`, which is being removed from
    /// the document, running the usual teardown steps. `node_id` must still be
    /// present in the slab.
    ///
    /// This matches browser semantics (WebKit `hoveredElementDidDetach` /
    /// `elementInActiveChainDidDetach`, Blink `HoveredElementDetached` /
    /// `ActiveChainNodeDetached`):
    /// - Hover and active retarget to the nearest surviving element ancestor
    ///   as a *transient bridge*: the HOVER/ACTIVE element-state bits along
    ///   the surviving chain stay lit (no one-frame gap in `:hover`/`:active`
    ///   styling), and the subsequent hover diff can unset exactly the right
    ///   bits. Hover is then re-resolved against the pointer position by
    ///   [`Self::refresh_hover`] at the end of the next resolve pass (the
    ///   analogue of WebKit's "fake mouse move"), which corrects the bridge
    ///   value — including cases where the removed node overflowed its
    ///   ancestor's box, so the ancestor was never truly under the pointer.
    /// - Focus resets to the body (encoded as `None`), running blur
    ///   side-effects (clearing focus element state and disabling IME for
    ///   text inputs).
    pub(crate) fn clear_interaction_state_for_removed_node(&mut self, node_id: NodeId) {
        if !self.nodes.contains_key(node_id) {
            return;
        }

        if self.hover_node_id == Some(node_id) {
            self.hover_node_id = self.nearest_surviving_element_ancestor(node_id);
            self.hover_node_is_text = false;
        }
        if self.hover_hit_node_id == Some(node_id) {
            self.hover_hit_node_id = None;
        }
        if self.semantic_hover_node_id == Some(node_id) {
            self.semantic_hover_node_id = None;
        }
        if self.active_node_id == Some(node_id) {
            self.active_node_id = self.nearest_surviving_element_ancestor(node_id);
        }
        if self.focus_node_id == Some(node_id) {
            let shell_provider = self.shell_provider.clone();
            self.nodes[node_id].blur(shell_provider);
            self.focus_node_id = None;
        }
        if self.mousedown_node_id == Some(node_id) {
            self.mousedown_node_id = None;
        }
        if self.text_selection.anchor.node_or_parent == Some(node_id)
            || self.text_selection.focus.node_or_parent == Some(node_id)
        {
            self.text_selection.clear();
        }
        if self
            .hovered_scrollbar
            .is_some_and(|scrollbar| scrollbar.node_id == node_id)
        {
            self.hovered_scrollbar = None;
        }
        let drag_references_node = match &self.drag_mode {
            DragMode::Panning(state) => state.target == node_id,
            DragMode::ScrollbarDrag(state) => state.scrollbar.node_id == node_id,
            DragMode::Selecting | DragMode::None => false,
        };
        if drag_references_node {
            self.drag_mode = DragMode::None;
        }
        if matches!(
            &self.scroll_animation,
            ScrollAnimationState::Fling(state) if state.target == node_id
        ) {
            self.scroll_animation = ScrollAnimationState::None;
        }
        self.scrollbar_activity.remove(&node_id);

        // The form-owner map is keyed by control id and was never pruned, so a
        // page that re-renders its fields grew an entry per render, every one
        // of them a freed slot. Nothing dereferences those any more, but an
        // unbounded map keyed on dead ids is a leak either way.
        self.controls_to_form.remove(&node_id);
    }

    pub(crate) fn drop_node_ignoring_parent(&mut self, node_id: NodeId) -> Option<Node> {
        self.drop_node_ignoring_parent_with(node_id, &mut |_| {})
    }

    /// Like [`Self::drop_node_ignoring_parent`], but calls `on_drop` with the id of
    /// every dropped node (the node itself and all of its descendants).
    pub(crate) fn drop_node_ignoring_parent_with(
        &mut self,
        node_id: NodeId,
        on_drop: &mut dyn FnMut(NodeId),
    ) -> Option<Node> {
        self.node_drop_depth += 1;
        let mut node = self.remove_node_from_tree(node_id);
        if let Some(node) = &mut node {
            on_drop(node_id);
            if let Some(before) = node.before() {
                self.drop_node_ignoring_parent_with(before, on_drop);
            }
            if let Some(after) = node.after() {
                self.drop_node_ignoring_parent_with(after, on_drop);
            }

            for &child in &node.children {
                self.drop_node_ignoring_parent_with(child, on_drop);
            }
            if let Some(contents) = node
                .element_data()
                .and_then(|element| element.template_contents)
            {
                self.drop_node_ignoring_parent_with(contents, on_drop);
            }

            // Anonymous blocks live only in the slab, so deallocate the ones this
            // node owns rather than leaking them.
            for &anon_id in &node.anonymous_blocks {
                self.deallocate_anonymous_block(anon_id);
            }

            // Drop any attached shadow root (its children are dropped recursively
            // via the recursive call below).
            #[cfg(feature = "shadow-dom")]
            if let Some(shadow_root_id) = node.shadow_root_id() {
                self.shadow_host_nodes.remove(&node_id);
                self.dirty_shadow_hosts.remove(&node_id);
                self.custom_element_nodes.remove(&node_id);
                self.drop_node_ignoring_parent_with(shadow_root_id, on_drop);
            }
        }
        self.node_drop_depth -= 1;
        self.purge_dropped_node_references();
        node
    }

    /// Deallocate an anonymous block created in a previous construction
    /// round, along with any anonymous blocks nested within it.
    pub(crate) fn deallocate_anonymous_block(&mut self, anon_id: NodeId) {
        // The block may already have been removed from the slab (e.g. a
        // whitespace-only anonymous block dropped during construction).
        if !self.nodes.contains_key(anon_id) {
            return;
        }

        // Free any anonymous blocks that this block owns before removing it.
        self.node_drop_depth += 1;
        let nested = std::mem::take(&mut self.nodes[anon_id].anonymous_blocks);
        for nested_id in nested {
            self.deallocate_anonymous_block(nested_id);
        }

        self.remove_node_from_tree(anon_id);
        self.node_drop_depth -= 1;
        self.purge_dropped_node_references();
    }

    pub fn create_text_node(&mut self, text: &str) -> NodeId {
        let content = text.to_string();
        let data = NodeData::Text(TextNodeData::new(content));
        self.create_node(data)
    }

    pub fn deep_clone_node(&mut self, node_id: NodeId) -> NodeId {
        // Load existing node
        let node = &self.nodes[node_id];
        let mut data = node.data.clone();

        match &mut data {
            NodeData::Element(elem) | NodeData::AnonymousBlock(elem) => {
                if let Some(arc) = elem.style_attribute.as_mut() {
                    let read_guard = self.guard().read();
                    let block = arc.read_with(&read_guard);
                    *arc = ServoArc::new(self.guard().wrap(block.clone()));
                }
            }
            _ => {}
        }

        let children = node.children.clone();
        #[cfg(feature = "shadow-dom")]
        let shadow_source = node.shadow_root_id();
        let template_contents = node
            .element_data()
            .and_then(|element| element.template_contents);
        let owner_document = node.owner_document;
        let markup = node.markup.clone();
        let inert_script = node
            .flags
            .contains(crate::node::NodeFlags::IS_PARSER_INERT_SCRIPT);

        // Create new node
        let new_node_id = self.create_node(data);
        self.nodes[new_node_id].owner_document = owner_document;
        self.nodes[new_node_id].markup = markup;
        self.nodes[new_node_id]
            .flags
            .set(crate::node::NodeFlags::IS_PARSER_INERT_SCRIPT, inert_script);
        if let Some(document_id) = owner_document {
            let id = self.nodes[new_node_id]
                .element_data()
                .and_then(|element| element.id.as_ref())
                .map(ToString::to_string);
            if let Some(id) = id {
                self.add_to_document_id_map(document_id, &id, new_node_id);
            }
        }
        if let Some(contents) = template_contents {
            let cloned_contents = self.deep_clone_node(contents);
            self.nodes[new_node_id]
                .element_data_mut()
                .expect("template clone must be an element")
                .template_contents = Some(cloned_contents);
        }

        // Recursively clone children
        let new_children: ThinVec<NodeId> = children
            .into_iter()
            .map(|child_id| self.deep_clone_node(child_id))
            .collect();
        for &child_id in &new_children {
            self.nodes[child_id].parent = Some(new_node_id);
            self.attach_script_custom_element_subtree(child_id, new_node_id);
        }
        self.nodes[new_node_id].children = new_children;

        // Only a shadow root that opted into `clonable` is copied. Imperative
        // roots keep the previous behavior of not cloning.
        #[cfg(feature = "shadow-dom")]
        if let Some(source_root) = shadow_source {
            let clonable = self
                .nodes
                .get(source_root)
                .and_then(|node| node.shadow_root_data())
                .is_some_and(|root| root.clonable);
            if clonable {
                let mode = self.nodes[source_root].shadow_root_data().unwrap().mode;
                let serializable = self.nodes[source_root]
                    .shadow_root_data()
                    .unwrap()
                    .serializable;
                let delegates_focus = self.nodes[source_root]
                    .shadow_root_data()
                    .unwrap()
                    .delegates_focus;
                let declarative = self.nodes[source_root]
                    .shadow_root_data()
                    .unwrap()
                    .declarative;
                let shadow_children = self.nodes[source_root].children.clone();
                let new_root = self.attach_shadow(new_node_id, mode);
                if let Some(root) = self.nodes[new_root].shadow_root_data_mut() {
                    root.clonable = true;
                    root.serializable = serializable;
                    root.delegates_focus = delegates_focus;
                    root.declarative = declarative;
                }
                let cloned_shadow_children: ThinVec<NodeId> = shadow_children
                    .into_iter()
                    .map(|child_id| self.deep_clone_node(child_id))
                    .collect();
                for &child_id in &cloned_shadow_children {
                    self.nodes[child_id].parent = Some(new_root);
                    self.attach_script_custom_element_subtree(child_id, new_root);
                }
                self.nodes[new_root].children = cloned_shadow_children;
            }
        }

        new_node_id
    }

    pub(crate) fn remove_and_drop_pe(&mut self, node_id: NodeId) -> Option<Node> {
        fn remove_pe_ignoring_parent(doc: &mut BaseDocument, node_id: NodeId) -> Option<Node> {
            let mut node = doc.remove_node_from_tree(node_id);
            if let Some(node) = &mut node {
                for &child in &node.children {
                    remove_pe_ignoring_parent(doc, child);
                }
                for &anon_id in &node.anonymous_blocks {
                    doc.deallocate_anonymous_block(anon_id);
                }
            }
            node
        }

        self.node_drop_depth += 1;
        let node = remove_pe_ignoring_parent(self, node_id);

        // Update child_idx values
        if let Some(parent_id) = node.as_ref().and_then(|node| node.parent) {
            let parent = &mut self.nodes[parent_id];
            parent.children.retain(|id| *id != node_id);
        }

        self.node_drop_depth -= 1;
        self.purge_dropped_node_references();
        node
    }

    pub(crate) fn resolve_url(&self, raw: &str) -> url::Url {
        self.url.resolve_relative(raw).unwrap_or_else(|| {
            panic!(
                "to be able to resolve {raw} with the base_url: {:?}",
                *self.url
            )
        })
    }

    /// Navigate to `raw`, resolved against this document's base URL.
    ///
    /// The same route a link click takes, exposed so that script can reach it:
    /// `location.assign`, `location.replace` and `location.reload` had nowhere
    /// to go, because `resolve_url` and the navigation provider are both
    /// internal to this crate. Returns `false` when `raw` will not resolve,
    /// so the caller can report that rather than navigate somewhere wrong.
    pub fn navigate_to_url(&self, raw: &str) -> bool {
        let Some(url) = self.url.resolve_relative(raw) else {
            return false;
        };
        self.navigation_provider
            .navigate_to(blitz_traits::navigation::NavigationOptions::new(
                url,
                None,
                self.id(),
            ));
        true
    }

    /// This document's URL, as a page's `location.href` reads it.
    pub fn current_url(&self) -> String {
        self.url.to_string()
    }

    pub fn print_tree(&self) {
        crate::util::walk_tree(0, self.root_node());
    }

    pub fn print_subtree(&self, node_id: NodeId) {
        crate::util::walk_tree(0, &self.nodes[node_id]);
    }

    pub fn reload_resource_by_href(&mut self, href_to_reload: &str) {
        for &node_id in self.nodes_to_stylesheet.keys() {
            let node = &self.nodes[node_id];
            let Some(element) = node.element_data() else {
                continue;
            };

            if element.name.local == local_name!("link") {
                if let Some(href) = element.attr(local_name!("href")) {
                    // println!("Node {node_id} {href} {href_to_reload} {} {}", resolved_href.as_str(), resolved_href.as_str() == url_to_reload);
                    if href == href_to_reload {
                        let resolved_href = self.resolve_url(href);
                        self.net_provider.fetch(
                            self.id(),
                            self.build_request(resolved_href.clone())
                                .destination(RequestDestination::Style),
                            ResourceHandler::boxed(
                                self.tx.clone(),
                                self.id,
                                Some(node_id),
                                self.shell_provider.clone(),
                                StylesheetHandler {
                                    source_url: resolved_href,
                                    guard: self.guard.clone(),
                                    net_provider: self.net_provider.clone(),
                                    abort_signal: self.abort_signal.clone(),
                                },
                            ),
                        );
                    }
                }
            }
        }
    }

    pub fn process_style_element(&mut self, target_id: NodeId) {
        let css = self.nodes[target_id].text_content();
        let css = html_escape::decode_html_entities(&css);
        let sheet = self.make_stylesheet(&css, Origin::Author);
        self.add_stylesheet_for_node(sheet, target_id);
    }

    pub fn remove_user_agent_stylesheet(&mut self, contents: &str) {
        if let Some(sheet) = self.ua_stylesheets.remove(contents) {
            self.stylist.remove_stylesheet(sheet, &self.guard.read());
        }
    }

    /// The document's base URL
    pub fn url(&self) -> &url::Url {
        &self.url
    }

    /// Iterate over the author stylesheets (from `<style>` and `<link>` nodes)
    /// currently associated with this document
    pub fn author_stylesheets(&self) -> impl Iterator<Item = &DocumentStyleSheet> {
        self.nodes_to_stylesheet.values()
    }

    /// Iterate over the user-agent stylesheets currently associated with this document
    pub fn useragent_stylesheets(&self) -> impl Iterator<Item = &DocumentStyleSheet> {
        self.ua_stylesheets.values()
    }

    pub fn add_user_agent_stylesheet(&mut self, css: &str) {
        let sheet = self.make_stylesheet(css, Origin::UserAgent);
        self.ua_stylesheets.insert(css.to_string(), sheet.clone());
        self.stylist.append_stylesheet(sheet, &self.guard.read());
    }

    pub fn make_stylesheet(&self, css: impl AsRef<str>, origin: Origin) -> DocumentStyleSheet {
        let data = Stylesheet::from_str(
            css.as_ref(),
            self.url.url_extra_data(),
            origin,
            ServoArc::new(self.guard.wrap(MediaList::empty())),
            self.guard.clone(),
            Some(&StylesheetLoader {
                tx: self.tx.clone(),
                doc_id: self.id,
                net_provider: self.net_provider.clone(),
                shell_provider: self.shell_provider.clone(),
                abort_signal: self.abort_signal.clone(),
            }),
            None,
            QuirksMode::NoQuirks,
            AllowImportRules::Yes,
        );

        DocumentStyleSheet(ServoArc::new(data))
    }

    pub fn upsert_stylesheet_for_node(&mut self, node_id: NodeId) {
        let raw_styles = self.nodes[node_id].text_content();
        let sheet = self.make_stylesheet(raw_styles, Origin::Author);
        self.add_stylesheet_for_node(sheet, node_id);
    }

    pub fn add_stylesheet_for_node(&mut self, stylesheet: DocumentStyleSheet, node_id: NodeId) {
        self.platform_initial_sheet_media(&stylesheet, node_id);
        #[cfg(feature = "shadow-dom")]
        if let Some(root_id) = self.containing_shadow_root(node_id) {
            // A sheet that moved from the document into a shadow tree leaves
            // the document Stylist first.
            if self.document_sheet_nodes.remove(&node_id)
                && let Some(old) = self.nodes_to_stylesheet.get(&node_id).cloned()
            {
                self.stylist.remove_stylesheet(old, &self.guard.read());
            }
            self.install_shadow_stylesheet(root_id, node_id, stylesheet);
            return;
        }

        let old = self.nodes_to_stylesheet.insert(node_id, stylesheet.clone());

        if let Some(old) = old
            && self.document_sheet_nodes.contains(&node_id)
        {
            self.stylist.remove_stylesheet(old, &self.guard.read())
        }
        self.document_sheet_nodes.insert(node_id);

        // Fetch @font-face fonts
        crate::net::fetch_font_face(
            self.tx.clone(),
            self.id,
            Some(node_id),
            &stylesheet.0,
            &self.net_provider,
            &self.shell_provider,
            &self.guard.read(),
            self.abort_signal.as_ref(),
            &mut self.web_fonts,
            self.font_epoch,
        );

        // Store data on element
        let element = &mut self.nodes[node_id].element_data_mut().unwrap();
        element.special_data = SpecialElementData::Stylesheet(stylesheet.clone());

        // TODO: Nodes could potentially get reused so ordering by node_id might be wrong.
        // Only sheets the document Stylist holds can be an insertion point: shadow-root sheets are
        // in `nodes_to_stylesheet` too, and stylo panics on a `before` sheet it does not have.
        let insertion_point = self
            .nodes_to_stylesheet
            .range((Bound::Excluded(node_id), Bound::Unbounded))
            .find(|(id, _)| self.document_sheet_nodes.contains(id))
            .map(|(_, sheet)| sheet);

        if let Some(insertion_point) = insertion_point {
            self.stylist.insert_stylesheet_before(
                stylesheet,
                insertion_point.clone(),
                &self.guard.read(),
            )
        } else {
            self.stylist
                .append_stylesheet(stylesheet, &self.guard.read())
        }
    }

    pub fn handle_messages(&mut self) {
        // Remove event Reciever from the Document so that we can process events
        // without holding a borrow to the Document
        let rx = self.rx.take().unwrap();

        while let Ok(msg) = rx.try_recv() {
            self.handle_message(msg);
        }

        // Put Reciever back
        self.rx = Some(rx);
    }

    pub fn handle_message(&mut self, msg: DocumentEvent) {
        match msg {
            DocumentEvent::ResourceLoad(resource) => self.load_resource(resource),
            DocumentEvent::NavigateIframe { node_id, url } => self.navigate_iframe(node_id, url),
        }
    }

    /// Whether the Document has pending requests for "critical" resources (that should block rendering)
    pub fn has_pending_critical_resources(&self) -> bool {
        !self.pending_critical_resources.is_empty()
    }

    /// How many distinct image URLs are still being fetched.
    ///
    /// Images are deliberately not "critical" resources, so they never block
    /// rendering. An embedder that needs a settled page (a screenshot, a test,
    /// a print) has no other way to tell an image that is still in flight from
    /// one that will never arrive.
    pub fn pending_image_count(&self) -> usize {
        self.pending_images.len()
    }

    pub fn load_resource(&mut self, res: ResourceLoadResponse) {
        self.pending_critical_resources.remove(&res.request_id);

        let resource = match res.result {
            Ok(resource) => resource,
            Err(err) => {
                if let Some(url) = res.resolved_url.as_ref() {
                    let waiting_nodes = self.pending_images.remove(url).unwrap_or_default();
                    #[cfg(feature = "tracing")]
                    tracing::warn!(
                        url = url.as_str(),
                        waiting_nodes = waiting_nodes.len(),
                        error = err.as_str(),
                        "Resource load failed"
                    );
                    #[cfg(not(feature = "tracing"))]
                    let _ = (waiting_nodes, err);
                } else {
                    #[cfg(feature = "tracing")]
                    tracing::warn!(error = err.as_str(), "Resource load failed (no url)");
                    #[cfg(not(feature = "tracing"))]
                    let _ = err;
                }
                return;
            }
        };

        let (resource, font_ticket) = match resource {
            Resource::TrackedFont(bytes, overrides, ticket) => {
                if ticket.css && ticket.epoch != self.font_epoch {
                    ticket.finish(false);
                    return;
                }
                (Resource::Font(bytes, overrides), Some(ticket))
            }
            resource => (resource, None),
        };
        if matches!(&resource, Resource::Css(_) | Resource::Font(_, _))
            && res.node_id.is_some_and(|id| {
                self.get_node(id)
                    .is_none_or(|node| !node.flags.is_in_document())
            })
        {
            if let Some(ticket) = font_ticket {
                ticket.finish(false);
            }
            return;
        }

        match resource {
            Resource::Css(css) => {
                let node_id = res.node_id.unwrap();
                self.add_stylesheet_for_node(css, node_id);
            }
            Resource::ImportSheet(import_rule, sheet) => {
                // The write that used to happen on the network worker. Here it
                // is on the thread that owns styling, so it cannot collide
                // with a concurrent read of the same lock.
                //
                // Scoped, because the `@font-face` scan below needs a read of
                // the same lock and this is an `AtomicRefCell`: holding the
                // write across it would deadlock against itself rather than
                // wait.
                {
                    let mut guard = self.guard.write();
                    import_rule.write_with(&mut guard).stylesheet =
                        style::stylesheets::import_rule::ImportSheet::Sheet(sheet.clone());
                }

                // The same scan `add_stylesheet_for_node` does for a top-level
                // sheet. An imported sheet may declare fonts too, and until now
                // nothing fetched them from a thread allowed to read the lock.
                crate::net::fetch_font_face(
                    self.tx.clone(),
                    self.id,
                    res.node_id,
                    &sheet,
                    &self.net_provider,
                    &self.shell_provider,
                    &self.guard.read(),
                    self.abort_signal.as_ref(),
                    &mut self.web_fonts,
                    self.font_epoch,
                );
            }
            Resource::Image(_kind, width, height, image_data) => {
                // Create the ImageData and cache it
                let image = ImageData::Raster(RasterImageData::new(width, height, image_data));

                let Some(url) = res.resolved_url.as_ref() else {
                    return;
                };

                self.apply_loaded_image(url, image);
            }
            #[cfg(feature = "svg")]
            Resource::Svg(_kind, svg) => {
                // Create the ImageData and cache it
                let image = ImageData::Svg(svg);

                let Some(url) = res.resolved_url.as_ref() else {
                    return;
                };

                self.apply_loaded_image(url, image);
            }
            Resource::DocumentSrc(html) => {
                let Some(node_id) = res.node_id else {
                    return;
                };
                self.apply_iframe_html(node_id, res.request_id, res.resolved_url, &html);
            }
            Resource::Font(bytes, overrides) => {
                let font = Blob::new(Arc::new(bytes));

                // Build a `FontInfoOverride` from the `@font-face` descriptors
                // captured during stylesheet parsing. Without this, parley
                // reads the family name from the TTF's own metadata, which
                // means CSS `font-family: 'Avenir Book'` won't match a font
                // file that internally identifies as `Avenir 45 Book`.
                let weight_override = overrides.weight.map(parley::fontique::FontWeight::new);
                let info_override = parley::fontique::FontInfoOverride {
                    family_name: overrides.family_name.as_deref(),
                    weight: weight_override,
                    style: overrides.style,
                    ..Default::default()
                };

                // TODO: Investigate eliminating double-box
                let mut global_font_ctx = self.font_ctx.lock().unwrap();
                let registered = global_font_ctx
                    .collection
                    .register_fonts(font.clone(), Some(info_override));
                let registered = !registered.is_empty();

                #[cfg(feature = "parallel-construct")]
                {
                    rayon::broadcast(|_ctx| {
                        let mut font_ctx = self
                            .thread_font_contexts
                            .get_or(|| RefCell::new(Box::new(global_font_ctx.clone())))
                            .borrow_mut();
                        font_ctx
                            .collection
                            .register_fonts(font.clone(), Some(info_override));
                    });
                }
                drop(global_font_ctx);

                // TODO: see if we can only invalidate if resolved fonts may have changed
                self.invalidate_inline_contexts();
                if let Some(ticket) = font_ticket {
                    ticket.finish(registered);
                }
            }
            Resource::TrackedFont(..) => unreachable!("tracked font was normalized"),
            Resource::None => {
                // Do nothing
            }
        }
    }

    /// Cache a loaded image and apply it to all nodes waiting on it
    /// (`<img>` elements, `background-image` layers and `mask-image` layers).
    fn apply_loaded_image(&mut self, url: &str, image: ImageData) {
        // Get all nodes waiting for this image
        let waiting_nodes = self.pending_images.remove(url).unwrap_or_default();

        #[cfg(feature = "tracing")]
        tracing::info!(
            "Image {url} loaded, applying to {} nodes",
            waiting_nodes.len()
        );

        // Cache the image
        self.image_cache.insert(url.to_string(), image.clone());

        // Apply to all waiting nodes
        for (node_id, image_type) in waiting_nodes {
            let Some(node) = self.get_node_mut(node_id) else {
                continue;
            };

            match image_type {
                ImageType::Image => {
                    node.element_data_mut().unwrap().special_data =
                        SpecialElementData::Image(Box::new(image.clone()));

                    // Clear layout cache
                    node.cache_mut().clear();
                    node.insert_damage(ALL_DAMAGE);
                }
                ImageType::Background(idx) | ImageType::Mask(idx) => {
                    let layer_image = node.element_data_mut().and_then(|el| {
                        let images = match image_type {
                            ImageType::Background(_) => &mut el.background_images,
                            ImageType::Mask(_) => &mut el.mask_images,
                            ImageType::Image => unreachable!(),
                        };
                        images.get_mut(idx)
                    });
                    if let Some(Some(layer_image)) = layer_image {
                        layer_image.status = Status::Ok;
                        layer_image.image = image.clone();
                    }
                }
            }
        }
    }

    pub fn snapshot_node(&mut self, node_id: NodeId) {
        let node = &mut self.nodes[node_id];

        // Do not snapshot nodes that have never been styled. A snapshot records an element's
        // pre-mutation state so a restyle can diff selector matches then-vs-now. An element
        // that has never been styled has no "then" to diff against. Snapshotting it anyway
        // makes Stylo's invalidation unwrap its (absent) primary style and panic.
        let has_been_styled = node.primary_styles().is_some();
        if !has_been_styled {
            return;
        }

        let opaque_node_id = TNode::opaque(&&*node);
        node.set_has_snapshot(true);
        node.snapshot_handled()
            .store(false, std::sync::atomic::Ordering::SeqCst);

        // TODO: handle invalidations other than hover
        if let Some(_existing_snapshot) = self.snapshots.get_mut(&opaque_node_id) {
            // Do nothing
            // TODO: update snapshot
        } else {
            let attrs: Option<Vec<_>> = node.attrs().map(|attrs| {
                attrs
                    .iter()
                    .map(|attr| {
                        let ident = AttrIdentifier {
                            local_name: GenericAtomIdent(attr.name.local.clone()),
                            name: GenericAtomIdent(attr.name.local.clone()),
                            namespace: GenericAtomIdent(attr.name.ns.clone()),
                            prefix: None,
                        };

                        let value = if attr.name.local == local_name!("id") {
                            AttrValue::Atom(Atom::from(&*attr.value))
                        } else if attr.name.local == local_name!("class") {
                            let classes = attr
                                .value
                                .split_ascii_whitespace()
                                .map(Atom::from)
                                .collect();
                            // Stylo's `AttrValue` owns a `String`, so the atom
                            // is materialised here. This is the one place
                            // interning is paid back out, and it is bounded:
                            // once per snapshotted attribute, not per element
                            // per frame.
                            AttrValue::TokenList(OnceLock::from(attr.value.to_string()), classes)
                        } else {
                            AttrValue::String(attr.value.to_string())
                        };

                        (ident, value)
                    })
                    .collect()
            });

            let changed_attrs = attrs
                .as_ref()
                .map(|attrs| attrs.iter().map(|attr| attr.0.name.clone()).collect())
                .unwrap_or_default();

            self.snapshots.insert(
                opaque_node_id,
                ServoElementSnapshot {
                    state: Some(*node.element_state()),
                    attrs,
                    changed_attrs,
                    class_changed: true,
                    id_changed: true,
                    other_attributes_changed: true,
                },
            );
        }
    }

    /// Preserve the original attributes and accumulate names changed before traversal.
    pub(crate) fn snapshot_attribute(&mut self, node_id: NodeId, name: &markup5ever::LocalName) {
        self.snapshot_node(node_id);
        let opaque_node_id = TNode::opaque(&&self.nodes[node_id]);
        if let Some(snapshot) = self.snapshots.get_mut(&opaque_node_id) {
            let changed_attr = GenericAtomIdent(name.clone());
            if !snapshot.changed_attrs.contains(&changed_attr) {
                snapshot.changed_attrs.extend(std::iter::once(changed_attr));
            }
        }
    }

    /// Snapshot a node and act on it, if it is still there.
    ///
    /// Tolerant of a node that has gone, because the ids reaching this are
    /// remembered across events — focus, hover, the last press — and the node
    /// they name can be removed between one event and the next. Indexing
    /// directly turned that ordinary case into a panic inside an event handler.
    pub fn snapshot_node_and(&mut self, node_id: NodeId, cb: impl FnOnce(&mut Node)) {
        if !self.nodes.contains_key(node_id) {
            return;
        }
        self.snapshot_node(node_id);
        cb(&mut self.nodes[node_id]);
    }

    // Takes (x, y) co-ordinates (relative to the )
    pub fn hit(&self, x: f32, y: f32) -> Option<HitResult> {
        self.hit_with_scrollbar(x, y).0
    }

    /// Walk up the tree to the nearest DOM node whose id is stable across
    /// box-tree reconstruction, so canonicalized interaction state never goes
    /// stale.
    ///
    /// Layout-generated nodes (anonymous blocks and `::before`/`::after`
    /// pseudo-elements, both stored as anonymous blocks) get new ids on every
    /// reconstruction, so we skip any anonymous node *and* a non-anonymous node
    /// whose parent is anonymous (the pseudo's text content). The first
    /// non-anonymous node with a non-anonymous parent is a real DOM node; the
    /// root element's `Document` parent guarantees termination.
    ///
    /// Returns `None` if `node_id` (or an ancestor) no longer exists.
    pub fn nearest_non_anonymous_ancestor(&self, node_id: NodeId) -> Option<NodeId> {
        // Recurse up the tree keeping a window of the current node and its
        // parent, advancing one step per iteration so each node is looked up
        // exactly once.
        let mut node = self.get_node(node_id)?;
        loop {
            let parent = match node.parent {
                Some(parent_id) => self.get_node(parent_id)?,
                None => return Some(node.id),
            };
            if !node.is_anonymous() && !parent.is_anonymous() {
                return Some(node.id);
            }
            node = parent;
        }
    }

    pub fn focus_next_node(&mut self) -> Option<NodeId> {
        let focussed_node_id = self.get_focussed_node_id()?;
        let id = self.next_node(&self.nodes[focussed_node_id], |node| node.is_focussable())?;
        self.set_focus_to(id);
        Some(id)
    }

    /// Move focus to the previous focussable node in the document
    pub fn focus_prev_node(&mut self) -> Option<NodeId> {
        let focussed_node_id = self.get_focussed_node_id()?;
        let id = self.prev_node(&self.nodes[focussed_node_id], |node| node.is_focussable())?;
        self.set_focus_to(id);
        Some(id)
    }

    /// Clear the focussed node
    pub fn clear_focus(&mut self) {
        if let Some(id) = self.focus_node_id {
            let shell_provider = self.shell_provider.clone();
            self.snapshot_node_and(id, |node| node.blur(shell_provider));
            self.focus_node_id = None;
        }
    }

    pub fn set_mousedown_node_id(&mut self, node_id: Option<NodeId>) {
        self.mousedown_node_id = node_id.and_then(|id| self.nearest_non_anonymous_ancestor(id));
    }
    pub fn set_focus_to(&mut self, focus_node_id: NodeId) -> bool {
        let Some(focus_node_id) = self.nearest_non_anonymous_ancestor(focus_node_id) else {
            return false;
        };
        if Some(focus_node_id) == self.focus_node_id {
            return false;
        }

        #[cfg(feature = "tracing")]
        tracing::info!("Focussed node {focus_node_id}");

        let shell_provider = self.shell_provider.clone();

        // Remove focus from the old node
        if let Some(id) = self.focus_node_id {
            self.snapshot_node_and(id, |node| node.blur(shell_provider.clone()));
        }

        // Focus the new node
        self.snapshot_node_and(focus_node_id, |node| node.focus(shell_provider));

        self.focus_node_id = Some(focus_node_id);

        true
    }

    pub fn active_node(&mut self) -> bool {
        let Some(hover_node_id) = self.get_hover_node_id() else {
            return false;
        };

        if let Some(active_node_id) = self.active_node_id {
            if active_node_id == hover_node_id {
                return true;
            }
            self.unactive_node();
        }

        // hover_node_id is canonicalized when stored, so this always holds.
        debug_assert!(
            self.get_node(hover_node_id)
                .is_some_and(|node| !node.is_anonymous()),
            "interaction state must reference DOM nodes, not layout-generated nodes"
        );
        let active_node_id = Some(hover_node_id);

        let node_path = self.maybe_node_layout_ancestors(active_node_id);
        for &id in node_path.iter() {
            self.snapshot_node_and(id, |node| node.active());
        }

        self.active_node_id = active_node_id;

        true
    }

    pub fn unactive_node(&mut self) -> bool {
        let Some(active_node_id) = self.active_node_id.take() else {
            return false;
        };

        let node_path = self.maybe_node_layout_ancestors(Some(active_node_id));
        for &id in node_path.iter() {
            self.snapshot_node_and(id, |node| node.unactive());
        }

        true
    }

    /// The scrollbar thumb currently under the pointer, if any.
    pub fn hovered_scrollbar(&self) -> Option<crate::node::ScrollbarRef> {
        self.hovered_scrollbar
    }

    /// The scrollbar thumb currently being dragged, if any.
    pub fn scrollbar_drag_target(&self) -> Option<crate::node::ScrollbarRef> {
        match &self.drag_mode {
            DragMode::ScrollbarDrag(state) => Some(state.scrollbar),
            _ => None,
        }
    }

    /// The current opacity of `node_id`'s overlay scrollbars. They show at
    /// full opacity on scroll and fade out after a delay (Chromium's overlay
    /// timings); the pointer resting on a thumb, or dragging it, holds them
    /// visible.
    pub fn scrollbar_opacity(&self, node_id: NodeId) -> f32 {
        let interacting = |scrollbar: &crate::node::ScrollbarRef| scrollbar.node_id == node_id;
        if self.hovered_scrollbar.as_ref().is_some_and(interacting)
            || self
                .scrollbar_drag_target()
                .as_ref()
                .is_some_and(interacting)
        {
            return 1.0;
        }
        self.scrollbar_activity.get(&node_id).map_or(1.0, |last| {
            crate::node::scrollbar::opacity_at(last.elapsed())
        })
    }

    /// Show `node_id`'s overlay scrollbars at full opacity and restart their
    /// fade-out delay.
    pub(crate) fn show_scrollbars(&mut self, node_id: NodeId) {
        if cfg!(feature = "scrollbars") {
            self.scrollbar_activity.insert(node_id, Instant::now());
        }
    }

    /// Whether any overlay scrollbars are awaiting or animating their
    /// fade-out (so frames must keep rendering until they finish).
    fn scrollbars_animating(&self) -> bool {
        use crate::node::scrollbar::{FADE_DELAY, FADE_DURATION};
        self.scrollbar_activity
            .values()
            .any(|last| last.elapsed() < FADE_DELAY + FADE_DURATION)
    }

    /// [`hit`](Self::hit), also resolving the innermost overlay scrollbar
    /// thumb under the point (shares the traversal, so it costs nothing
    /// extra).
    pub(crate) fn hit_with_scrollbar(
        &self,
        x: f32,
        y: f32,
    ) -> (Option<HitResult>, Option<crate::node::ScrollbarRef>) {
        if TDocument::as_node(&self.root_node())
            .first_element_child()
            .is_none()
        {
            #[cfg(feature = "tracing")]
            tracing::warn!("No DOM - not resolving hit test");
            return (None, None);
        }
        let mut scrollbar = None;
        let hit = self
            .root_element()
            .hit_inner(x, y, self.viewport().scale_f64(), &mut scrollbar);
        (hit, scrollbar)
    }

    pub fn set_hover_to(&mut self, x: f32, y: f32) -> bool {
        self.semantic_hover_node_id = None;
        // Record the pointer position in client (unscrolled) coordinates so
        // that `refresh_hover` can re-resolve hover state after layout or
        // scroll changes.
        self.last_client_pointer_position = Some(taffy::Point {
            x: x - self.viewport_scroll.x as f32,
            y: y - self.viewport_scroll.y as f32,
        });

        let (hit, hovered_scrollbar) = self.hit_with_scrollbar(x, y);
        // A faded-out thumb is not interactive: pointer moves never fade
        // overlay scrollbars back in (only scrolling shows them).
        let hovered_scrollbar =
            hovered_scrollbar.filter(|scrollbar| self.scrollbar_opacity(scrollbar.node_id) > 0.0);
        // Scrollbar-thumb hover is part of hover state: track it here so a
        // pointer crossing a thumb restyles it even when the hit node (the
        // content under the overlay thumb) is unchanged.
        let scrollbar_changed = hovered_scrollbar != self.hovered_scrollbar;
        if scrollbar_changed {
            // Entering a thumb restores full opacity mid-fade; leaving one
            // restarts the fade-out delay.
            for scrollbar in [self.hovered_scrollbar, hovered_scrollbar]
                .into_iter()
                .flatten()
            {
                self.show_scrollbars(scrollbar.node_id);
            }
        }
        self.hovered_scrollbar = hovered_scrollbar;

        // Store both the precise layout node that was hit (transient: used for
        // cursor/style queries) and its canonical DOM target (persistent: must
        // not reference layout-generated nodes, whose ids die on box-tree
        // reconstruction).
        let hit_node_id = hit.map(|hit| hit.node_id);
        let hover_node_id = hit_node_id.and_then(|id| self.nearest_non_anonymous_ancestor(id));
        let new_is_text = hit.map(|hit| hit.is_text).unwrap_or(false);

        self.apply_hover_target(hit_node_id, hover_node_id, new_is_text, scrollbar_changed)
    }

    /// Move the authored hover state to an already-resolved DOM node.
    ///
    /// Semantic automation has selected a node by identity already. Repeating
    /// hit testing at its centre can choose an overlapping child or overlay,
    /// especially inside nested scrollers, and makes `Hover { node_id }`
    /// target something other than the requested node. Pointer coordinates are
    /// still recorded for event payloads and later layout refreshes.
    pub fn set_hover_to_node(&mut self, node_id: NodeId, x: f32, y: f32) -> bool {
        self.semantic_hover_node_id = Some(node_id);
        self.last_client_pointer_position = Some(taffy::Point {
            x: x - self.viewport_scroll.x as f32,
            y: y - self.viewport_scroll.y as f32,
        });

        let hovered_scrollbar = self.hovered_scrollbar.take();
        let scrollbar_changed = hovered_scrollbar.is_some();
        if let Some(scrollbar) = hovered_scrollbar {
            self.show_scrollbars(scrollbar.node_id);
        }
        let hover_node_id = self.nearest_non_anonymous_ancestor(node_id);
        self.apply_hover_target(Some(node_id), hover_node_id, false, scrollbar_changed)
    }

    fn apply_hover_target(
        &mut self,
        hit_node_id: Option<NodeId>,
        hover_node_id: Option<NodeId>,
        new_is_text: bool,
        scrollbar_changed: bool,
    ) -> bool {
        let hit_changed =
            hit_node_id != self.hover_hit_node_id || new_is_text != self.hover_node_is_text;
        self.hover_hit_node_id = hit_node_id;
        self.hover_node_is_text = new_is_text;

        // Return early if the new node is the same as the already-hovered node
        if hover_node_id == self.hover_node_id {
            if hit_changed {
                // The canonical target is unchanged (so no restyle is needed)
                // but the precise hit node changed, which can change the cursor
                // (e.g. moving between text and non-text within one element).
                self.shell_provider.set_cursor(self.get_cursor());
            }
            return scrollbar_changed;
        }

        let old_node_path = self.maybe_node_layout_ancestors(self.hover_node_id);
        let new_node_path = self.maybe_node_layout_ancestors(hover_node_id);
        let same_count = old_node_path
            .iter()
            .zip(&new_node_path)
            .take_while(|(o, n)| o == n)
            .count();
        for &id in old_node_path.iter().skip(same_count) {
            self.snapshot_node_and(id, |node| node.unhover());
        }
        for &id in new_node_path.iter().skip(same_count) {
            self.snapshot_node_and(id, |node| node.hover());
        }

        self.hover_node_id = hover_node_id;

        // Update the cursor
        self.shell_provider.set_cursor(self.get_cursor());

        // Request redraw
        self.shell_provider.request_redraw();

        true
    }

    pub fn clear_hover(&mut self) -> bool {
        // The pointer is no longer over the document, so stop re-resolving
        // hover state against it.
        self.last_client_pointer_position = None;
        self.semantic_hover_node_id = None;
        self.hover_hit_node_id = None;

        let Some(hover_node_id) = self.hover_node_id else {
            return false;
        };

        let old_node_path = self.maybe_node_layout_ancestors(Some(hover_node_id));
        for &id in old_node_path.iter() {
            self.snapshot_node_and(id, |node| node.unhover());
        }

        self.hover_node_id = None;
        self.hover_node_is_text = false;

        // Update the cursor
        self.shell_provider.set_cursor(self.get_cursor());

        // Request redraw
        self.shell_provider.request_redraw();

        true
    }

    /// Re-resolve hover state against the current layout using the last known
    /// pointer position.
    ///
    /// TODO: synthesizing pointerenter/pointerleave DOM events for
    /// hover changes caused by layout shifts.
    pub fn refresh_hover(&mut self) -> bool {
        if let Some(node_id) = self.semantic_hover_node_id {
            if self.get_node(node_id).is_some() {
                let hover_node_id = self.nearest_non_anonymous_ancestor(node_id);
                return self.apply_hover_target(Some(node_id), hover_node_id, false, false);
            }
            self.semantic_hover_node_id = None;
        }
        let Some(pos) = self.last_client_pointer_position else {
            return false;
        };
        let x = pos.x + self.viewport_scroll.x as f32;
        let y = pos.y + self.viewport_scroll.y as f32;
        self.set_hover_to(x, y)
    }

    pub fn get_hover_node_id(&self) -> Option<NodeId> {
        self.hover_node_id
    }

    pub fn get_mousedown_node_id(&self) -> Option<NodeId> {
        self.mousedown_node_id
    }

    pub fn set_viewport(&mut self, viewport: Viewport) {
        let scale_has_changed = viewport.scale_f64() != self.viewport.scale_f64();
        self.viewport = viewport;
        self.set_stylist_device(make_device(
            &self.viewport,
            self.media_type.clone(),
            self.font_ctx.clone(),
        ));
        self.scroll_viewport_by(0.0, 0.0); // Clamp scroll offset

        if scale_has_changed {
            self.invalidate_inline_contexts();
            self.shell_provider.request_redraw();
        }
    }

    /// Returns the current CSS media type used to evaluate `@media` rules.
    pub fn media_type(&self) -> &MediaType {
        &self.media_type
    }

    /// Sets the CSS media type used to evaluate `@media` rules (e.g. `screen` or `print`)
    /// and rebuilds the stylist device so updated rules apply on the next restyle.
    pub fn set_media_type(&mut self, media_type: MediaType) {
        if self.media_type == media_type {
            return;
        }
        self.media_type = media_type;
        self.set_stylist_device(make_device(
            &self.viewport,
            self.media_type.clone(),
            self.font_ctx.clone(),
        ));
    }

    pub fn viewport(&self) -> &Viewport {
        &self.viewport
    }

    pub fn viewport_mut(&mut self) -> ViewportMut<'_> {
        ViewportMut::new(self)
    }

    pub fn zoom_by(&mut self, increment: f32) {
        let mut viewport = self.viewport.clone();
        viewport.zoom_by(increment);
        self.set_viewport(viewport);
    }

    pub fn zoom_to(&mut self, zoom: f32) {
        let mut viewport = self.viewport.clone();
        viewport.set_zoom(zoom);
        self.set_viewport(viewport);
    }

    pub fn get_viewport(&self) -> Viewport {
        self.viewport.clone()
    }

    /// Returns whether incremental layout is currently enabled for this document.
    pub fn incremental_layout(&self) -> bool {
        self.incremental_layout
    }

    /// Enables or disables incremental layout for this document.
    pub fn set_incremental_layout(&mut self, enabled: bool) {
        self.incremental_layout = enabled;
    }

    pub fn devtools(&self) -> &DevtoolSettings {
        &self.devtool_settings
    }

    pub fn devtools_mut(&mut self) -> &mut DevtoolSettings {
        &mut self.devtool_settings
    }

    pub fn subdoc(&self, node_id: NodeId) -> Option<&dyn Document> {
        self.get_node(node_id)
            .and_then(|node| node.element_data())
            .and_then(|el| el.sub_doc_data())
    }

    pub fn subdoc_mut(&mut self, node_id: NodeId) -> Option<&mut dyn Document> {
        self.get_node_mut(node_id)
            .and_then(|node| node.element_data_mut())
            .and_then(|el| el.sub_doc_data_mut())
    }

    pub fn is_animating(&self) -> bool {
        #[cfg(feature = "custom-widget")]
        let custom_widget_is_animating = self.custom_widget_nodes.iter().any(|&node_id| {
            self.nodes[node_id]
                .element_data()
                .and_then(|el| el.custom_widget_data())
                .is_some_and(|data| data.widget.requires_redraw())
        });
        #[cfg(not(feature = "custom-widget"))]
        let custom_widget_is_animating = false;

        let animating = self.has_canvas
            | self.has_active_animations
            | (self.subdoc_animation_pacing != AnimationPacing::Idle)
            | custom_widget_is_animating
            | (self.scroll_animation != ScrollAnimationState::None)
            | self.scrollbars_animating();

        if animating && crate::debug::animation_reasons_enabled() {
            crate::debug::report_animation_reasons(
                self.id(),
                self.has_canvas,
                self.has_active_animations,
                self.subdoc_animation_pacing != AnimationPacing::Idle,
                custom_widget_is_animating,
                self.scroll_animation != ScrollAnimationState::None,
                self.scrollbars_animating(),
                self.animating_node_names().as_deref(),
            );
        }

        animating
    }

    /// Return the cadence class for the next animation-only frame.
    ///
    /// CSS animations are commonly decorative and can use a lower cadence.
    /// Canvas, scrolling and custom widgets remain at the interactive cadence.
    pub fn animation_pacing(&self) -> AnimationPacing {
        let focused_text_input = self.focus_node_id.is_some_and(|node_id| {
            self.nodes
                .get(node_id)
                .and_then(|node| node.element_data())
                .is_some_and(|element| element.text_input_data().is_some())
        });
        #[cfg(feature = "custom-widget")]
        let custom_widget_is_animating = self.custom_widget_nodes.iter().any(|&node_id| {
            self.nodes[node_id]
                .element_data()
                .and_then(|el| el.custom_widget_data())
                .is_some_and(|data| data.widget.requires_redraw())
        });
        #[cfg(not(feature = "custom-widget"))]
        let custom_widget_is_animating = false;

        if self.has_canvas
            || custom_widget_is_animating
            || self.scroll_animation != ScrollAnimationState::None
            || self.scrollbars_animating()
        {
            AnimationPacing::Interactive
        } else if self.has_active_animations {
            const SLOW_ANIMATION_SECONDS: f64 = 2.0;
            let sets = self.animations.sets.read();
            let has_fast_animation_or_transition = sets.values().any(|set| {
                set.transitions.iter().any(|transition| {
                    matches!(
                        transition.state,
                        AnimationState::Pending | AnimationState::Running
                    )
                }) || set.animations.iter().any(|animation| {
                    matches!(
                        animation.state,
                        AnimationState::Pending | AnimationState::Running
                    ) && animation.duration < SLOW_ANIMATION_SECONDS
                })
            });
            if has_fast_animation_or_transition {
                AnimationPacing::Interactive
            } else {
                AnimationPacing::SlowCss
            }
        } else if focused_text_input {
            AnimationPacing::Caret
        } else if self.subdoc_animation_pacing != AnimationPacing::Idle {
            self.subdoc_animation_pacing
        } else {
            AnimationPacing::Idle
        }
    }

    /// Which elements Stylo currently holds animations or transitions for.
    ///
    /// Only built when the diagnostic is switched on: a frame loop that will
    /// not settle is otherwise very hard to attribute, because
    /// `has_active_animations` is one bool for the whole document and says
    /// nothing about which element is keeping it true.
    fn animating_node_names(&self) -> Option<String> {
        if !self.has_active_animations {
            return None;
        }
        let sets = self.animations.sets.read();
        let mut described: Vec<String> = sets
            .iter()
            .filter(|(_, state)| state.needs_animation_ticks())
            .filter_map(|(key, state)| {
                let node_id = NodeId::from_u64(key.node.id() as u64);
                let node = self.nodes.get(node_id)?;
                let element = node.element_data()?;
                let name = element
                    .attr(local_name!("id"))
                    .map(|id| format!("#{id}"))
                    .or_else(|| {
                        element
                            .attr(local_name!("class"))
                            .and_then(|c| c.split_ascii_whitespace().next())
                            .map(|c| format!(".{c}"))
                    })
                    .unwrap_or_else(|| element.name.local.to_string());
                Some(format!(
                    "{name}(anim={},trans={},in_doc={})",
                    state.animations.len(),
                    state.transitions.len(),
                    node.flags.is_in_document(),
                ))
            })
            .collect();
        described.sort();
        described.truncate(12);
        Some(described.join(" "))
    }

    /// Update the device and reset the stylist to process the new size
    pub fn set_stylist_device(&mut self, device: Device) {
        self.viewport_generation = self.viewport_generation.wrapping_add(1);
        // Viewport units become pixels at cascade time, from this device.
        // Compare before `device` is moved into the stylist.
        let previous_viewport = self.stylist.device().au_viewport_size();
        let next_viewport = device.au_viewport_size();

        // Seed the new device with the root element's current style and font-relative
        // unit state (used to resolve rem/rlh/rex/rch/rcap/ric units). Stylo only
        // updates this state when the root element's style *changes* during a restyle,
        // so a freshly-built device would otherwise resolve these units against the
        // default font-size (16px) until the root's font-size next changes.
        let root_styles = self
            .try_root_element()
            .and_then(|root| root.primary_styles());
        if let Some(root_style) = root_styles.as_deref() {
            device.set_root_style(root_style);

            let font = root_style.get_font();
            let font_size = font.clone_font_size().computed_size();
            device.set_root_font_size(root_style.effective_zoom.unzoom(font_size.px()));

            let line_height = device
                .calc_line_height(font, root_style.writing_mode, None)
                .0;
            device.set_root_line_height(root_style.effective_zoom.unzoom(line_height.px()));
        }
        drop(root_styles);

        let origins = {
            let guard = &self.guard;
            let guards = StylesheetGuards {
                author: &guard.read(),
                ua_or_user: &guard.read(),
            };
            self.stylist.set_device(device, &guards)
        };
        self.stylist.force_stylesheet_origins_dirty(origins);
        #[cfg(feature = "shadow-dom")]
        for host_id in self.shadow_host_node_ids() {
            if let Some(root_id) = self.shadow_root_id(host_id) {
                self.invalidate_shadow_styles(root_id);
            }
        }

        // Recascade through normal style traversal, which skips hidden subtrees.
        // Allocated element data does not guarantee a computed primary style.
        if let Some(root_id) = self.try_root_element().map(|root| root.id) {
            self.nodes[root_id].set_restyle_hint(RestyleHint::recascade_subtree());
            self.shell_provider.request_redraw();
        }
        if previous_viewport != next_viewport {
            self.abspos_layout_dirty = true;
        }
    }

    pub fn stylist_device(&mut self) -> &Device {
        self.stylist.device()
    }

    /// The cursor to show, where `None` means `cursor: none` — hide it.
    ///
    /// `None` is an answer, not the absence of one. The shell hides the pointer
    /// when it sees `None`, so every path that means "nothing to say here" must
    /// return `Default` instead. Returning `None` from those made the pointer
    /// vanish as it crossed into page content, which is the shape this used to
    /// have: three `?`s that each meant "no opinion" and all read as "hide".
    pub fn get_cursor(&self) -> Option<CursorIcon> {
        // Prefer the precise hit node: `cursor` and `user-select` may be set on
        // a pseudo-element or resolved on an anonymous box, and text hits carry
        // is_text via the hit node. Fall back to the canonical hover node if
        // the hit node has been removed (it is transient across resolves).
        let node_id = self
            .hover_hit_node_id
            .filter(|&id| self.nodes.contains_key(id))
            .or(self.get_hover_node_id());
        let Some(node_id) = node_id else {
            return Some(CursorIcon::Default);
        };
        let node = &self.nodes[node_id];

        if let Some(subdoc) = node.subdoc().map(|doc| doc.inner()) {
            // Only delegate when the sub-document has hover state of its own.
            // Without this check an embedded document that has not been hovered
            // yet answers `None` — meaning "I have no hover node" — and the
            // pointer disappears the moment it enters the page area, which is
            // every page in a browser built on sub-documents.
            if subdoc.hover_hit_node_id.is_some() || subdoc.get_hover_node_id().is_some() {
                return subdoc.get_cursor();
            }
            return Some(CursorIcon::Default);
        }

        let Some(style) = node.primary_styles() else {
            return Some(CursorIcon::Default);
        };
        let user_select = style.clone_user_select();
        let keyword = style.clone_cursor().keyword;

        // Return cursor from style if it is non-auto
        if keyword != CursorKind::Auto {
            return stylo_to_cursor_icon(keyword);
        }

        // Return text cursor for text inputs
        if node
            .element_data()
            .is_some_and(|e| e.text_input_data().is_some())
        {
            return Some(CursorIcon::Text);
        }

        // Use "pointer" cursor if any ancestor is a link
        let mut maybe_node = Some(node);
        while let Some(node) = maybe_node {
            if node.is_link() {
                return Some(CursorIcon::Pointer);
            }

            maybe_node = node.layout_parent.get().map(|node_id| node.with(node_id));
        }

        // Return text cursor for text nodes
        if self.hover_node_is_text {
            return Some(match user_select {
                UserSelect::Text | UserSelect::All | UserSelect::Auto => CursorIcon::Text,
                UserSelect::None => CursorIcon::Default,
            });
        }

        // Else fallback to default cursor
        Some(CursorIcon::Default)
    }

    pub fn scroll_node_by<F: FnMut(DomEvent)>(
        &mut self,
        node_id: NodeId,
        x: f64,
        y: f64,
        dispatch_event: F,
    ) {
        self.scroll_node_by_has_changed(node_id, x, y, dispatch_event);
    }

    /// Scroll a node by given x and y
    /// Will bubble scrolling up to parent node once it can no longer scroll further
    /// If we're already at the root node, bubbles scrolling up to the viewport
    ///
    /// A `position: sticky` box is held against the edge of the scrollport it
    /// lives in, so the boxes have to be re-adjusted here rather than only in
    /// `resolve`: a wheel event does not necessarily produce a style and layout
    /// pass, and a header that only unstuck on the next restyle is a header
    /// that visibly lags the scroll.
    pub fn scroll_node_by_has_changed<F: FnMut(DomEvent)>(
        &mut self,
        node_id: NodeId,
        x: f64,
        y: f64,
        dispatch_event: F,
    ) -> bool {
        let has_changed = self.scroll_node_by_inner(node_id, x, y, dispatch_event);
        if has_changed {
            self.resolve_positioned_scroll();
        }
        has_changed
    }

    fn scroll_node_by_inner<F: FnMut(DomEvent)>(
        &mut self,
        node_id: NodeId,
        x: f64,
        y: f64,
        mut dispatch_event: F,
    ) -> bool {
        // Per the CSS overflow propagation rules, the root element's overflow (and usually
        // the <body>'s) is applied to the viewport, and the element itself must not have
        // a scrolling mechanism of its own. So scrolls that reach the root element are
        // forwarded to the viewport rather than scrolling the root element itself.
        if self.try_root_element().is_some_and(|el| el.id == node_id) {
            let has_changed = self.scroll_viewport_by_has_changed(x, y);
            if has_changed {
                let layout = *self.root_element().final_layout();
                let scale = self.viewport.scale() as f64;
                let event = BlitzScrollEvent {
                    scroll_top: self.viewport_scroll.y,
                    scroll_left: self.viewport_scroll.x,
                    scroll_width: layout.size.width.max(layout.content_size.width) as i32,
                    scroll_height: layout.size.height.max(layout.content_size.height) as i32,
                    client_width: (self.viewport.window_size.0 as f64 / scale) as i32,
                    client_height: (self.viewport.window_size.1 as f64 / scale) as i32,
                };
                dispatch_event(DomEvent::new(node_id, DomEventData::Scroll(event)));
            }
            return has_changed;
        }

        let Some(node) = self.nodes.get_mut(node_id) else {
            return false;
        };

        // Text inputs scroll their own internal text content rather than using the generic
        // overflow mechanism: single-line inputs scroll horizontally, multi-line inputs scroll
        // vertically. Any delta the input cannot consume is bubbled up to an ancestor scroller.
        if node
            .element_data()
            .is_some_and(|el| el.text_input_data().is_some())
        {
            let parent = node.parent;
            let content_box_width = node.final_layout().content_box_width();
            let content_box_height = node.final_layout().content_box_height();
            let input = node
                .element_data_mut()
                .and_then(|el| el.text_input_data_mut())
                .unwrap();

            let (bubble_x, bubble_y) = if input.is_multiline {
                (
                    x,
                    input.scroll_by(y as f32, content_box_width, content_box_height) as f64,
                )
            } else {
                (
                    input.scroll_by(x as f32, content_box_width, content_box_height) as f64,
                    y,
                )
            };

            let has_changed = bubble_x != x || bubble_y != y;

            if bubble_x != 0.0 || bubble_y != 0.0 {
                let bubbled = if let Some(parent) = parent {
                    self.scroll_node_by_inner(parent, bubble_x, bubble_y, dispatch_event)
                } else {
                    self.scroll_viewport_by_has_changed(bubble_x, bubble_y)
                };
                return bubbled | has_changed;
            }

            return has_changed;
        }

        let (can_x_scroll, can_y_scroll) = node
            .primary_styles()
            .map(|styles| {
                (
                    matches!(styles.clone_overflow_x(), Overflow::Scroll | Overflow::Auto),
                    matches!(styles.clone_overflow_y(), Overflow::Scroll | Overflow::Auto),
                )
            })
            .unwrap_or((false, false));

        let initial = *node.scroll_offset();
        let new_x = node.scroll_offset().x - x;
        let new_y = node.scroll_offset().y - y;

        let mut bubble_x = 0.0;
        let mut bubble_y = 0.0;

        let scroll_width = node.final_layout().scroll_width() as f64;
        let scroll_height = node.final_layout().scroll_height() as f64;

        // Handle sub document case
        if let Some(mut sub_doc) = node.subdoc_mut().map(|doc| doc.inner_mut()) {
            let has_changed = if let Some(hover_node_id) = sub_doc.get_hover_node_id() {
                sub_doc.scroll_node_by_has_changed(hover_node_id, x, y, dispatch_event)
            } else {
                sub_doc.scroll_viewport_by_has_changed(x, y)
            };

            // TODO: propagate remaining scroll to parent
            return has_changed;
        }

        // If we're past our scroll bounds, transfer remainder of scrolling to parent/viewport
        if !can_x_scroll {
            bubble_x = x
        } else if new_x < 0.0 {
            bubble_x = -new_x;
            node.scroll_offset_mut().x = 0.0;
        } else if new_x > scroll_width {
            bubble_x = scroll_width - new_x;
            node.scroll_offset_mut().x = scroll_width;
        } else {
            node.scroll_offset_mut().x = new_x;
        }

        if !can_y_scroll {
            bubble_y = y
        } else if new_y < 0.0 {
            bubble_y = -new_y;
            node.scroll_offset_mut().y = 0.0;
        } else if new_y > scroll_height {
            bubble_y = scroll_height - new_y;
            node.scroll_offset_mut().y = scroll_height;
        } else {
            node.scroll_offset_mut().y = new_y;
        }

        let has_changed = *node.scroll_offset() != initial;

        if has_changed {
            let layout = *node.final_layout();
            let event = BlitzScrollEvent {
                scroll_top: node.scroll_offset().y,
                scroll_left: node.scroll_offset().x,
                scroll_width: layout.scroll_width() as i32,
                scroll_height: layout.scroll_height() as i32,
                client_width: layout.size.width as i32,
                client_height: layout.size.height as i32,
            };

            dispatch_event(DomEvent::new(node_id, DomEventData::Scroll(event)));
        }

        let parent = node.parent;
        if has_changed {
            self.show_scrollbars(node_id);
        }

        if bubble_x != 0.0 || bubble_y != 0.0 {
            if let Some(parent) = parent {
                return self.scroll_node_by_inner(parent, bubble_x, bubble_y, dispatch_event)
                    | has_changed;
            } else {
                return self.scroll_viewport_by_has_changed(bubble_x, bubble_y) | has_changed;
            }
        }

        has_changed
    }

    pub fn scroll_viewport_by(&mut self, x: f64, y: f64) {
        self.scroll_viewport_by_has_changed(x, y);
    }

    /// Scroll the viewport by the given values
    pub fn scroll_viewport_by_has_changed(&mut self, x: f64, y: f64) -> bool {
        // The viewport scrolls the root element's scrollable overflow, which includes both
        // the root element itself and any content which overflows it (e.g. when the root
        // element has a fixed height but its content is taller). A document without a root
        // element has no scrollable content, so its content size is zero.
        let (content_width, content_height) = match self.try_root_element() {
            Some(root) => {
                let root_layout = root.final_layout();
                (
                    root_layout.size.width.max(root_layout.content_size.width) as f64,
                    root_layout.size.height.max(root_layout.content_size.height) as f64,
                )
            }
            None => (0.0, 0.0),
        };
        let new_scroll = (self.viewport_scroll.x - x, self.viewport_scroll.y - y);
        let window_width = self.viewport.window_size.0 as f64 / self.viewport.scale() as f64;
        let window_height = self.viewport.window_size.1 as f64 / self.viewport.scale() as f64;

        let initial = self.viewport_scroll;
        self.viewport_scroll.x =
            f64::max(0.0, f64::min(new_scroll.0, content_width - window_width));
        self.viewport_scroll.y =
            f64::max(0.0, f64::min(new_scroll.1, content_height - window_height));

        let has_changed = self.viewport_scroll != initial;
        if has_changed {
            // The viewport is the scrollport a page-level sticky box is held
            // against, and the containing block a fixed box is pinned to, so
            // both move with this and not with the next relayout. See
            // `resolve_sticky_positions` and `resolve_fixed_positions`.
            self.resolve_positioned_scroll();
        }
        has_changed
    }

    pub fn scroll_by(
        &mut self,
        anchor_node_id: Option<NodeId>,
        scroll_x: f64,
        scroll_y: f64,
        dispatch_event: &mut dyn FnMut(DomEvent),
    ) -> bool {
        if let Some(anchor_node_id) = anchor_node_id {
            self.scroll_node_by_has_changed(anchor_node_id, scroll_x, scroll_y, dispatch_event)
        } else {
            self.scroll_viewport_by_has_changed(scroll_x, scroll_y)
        }
    }

    pub fn viewport_scroll(&self) -> crate::Point<f64> {
        self.viewport_scroll
    }

    pub fn set_viewport_scroll(&mut self, scroll: crate::Point<f64>) {
        self.viewport_scroll = scroll;
    }

    /// Find the node targeted by a URL fragment (the `#...` part of a URL).
    ///
    /// Per the HTML spec, this is the element whose `id` matches the fragment, falling
    /// back to the first `<a>` element whose `name` attribute matches.
    pub fn get_fragment_target(&self, fragment: &str) -> Option<NodeId> {
        if let Some(node_id) = self.get_element_by_id(fragment) {
            return Some(node_id);
        }

        // Fall back to a named anchor: `<a name="...">`
        self.nodes.iter().find_map(|(id, node)| {
            let el = node.element_data()?;
            (el.name.local == local_name!("a") && el.attr(local_name!("name")) == Some(fragment))
                .then_some(id)
        })
    }

    /// Scroll the viewport so that the given node is aligned with the top of the viewport.
    /// Scroll the nearest scroll container at or above `node_id`.
    ///
    /// "Scroll this panel" is the operation callers actually want, and
    /// `scroll_node_by` only moves the node itself, so naming any inner element
    /// silently did nothing. Wheel events are no help either: they are
    /// delivered to whatever the document last saw hovered, which an injected
    /// pointer move does not set, so an automated caller had no way to scroll
    /// anything at all.
    /// The nearest scroll container at or above `node_id`, if there is one.
    pub fn nearest_scroll_container(&self, node_id: NodeId) -> Option<NodeId> {
        let mut current = Some(node_id);
        for _ in 0..64 {
            let id = current?;
            let node = self.nodes.get(id)?;
            if node.style().overflow.x.is_scroll_container()
                || node.style().overflow.y.is_scroll_container()
            {
                return Some(id);
            }
            current = node.parent;
        }
        None
    }

    pub fn scroll_nearest_container_by(&mut self, node_id: NodeId, x: f64, y: f64) -> bool {
        self.scroll_nearest_container_by_with_events(node_id, x, y, |_| {})
    }

    pub fn scroll_nearest_container_by_with_events<F: FnMut(DomEvent)>(
        &mut self,
        node_id: NodeId,
        x: f64,
        y: f64,
        mut dispatch_event: F,
    ) -> bool {
        let mut current = Some(node_id);
        for _ in 0..64 {
            let Some(id) = current else { break };
            let Some(node) = self.nodes.get(id) else {
                break;
            };
            let scrolls = node.style().overflow.x.is_scroll_container()
                || node.style().overflow.y.is_scroll_container();
            if scrolls {
                self.scroll_node_by(id, x, y, &mut dispatch_event);
                return true;
            }
            current = node.parent;
        }
        self.scroll_viewport_by(x, y);
        false
    }

    pub fn scroll_to_node(&mut self, node_id: NodeId) {
        self.scroll_to_node_with_events(node_id, |_| {});
    }

    pub fn scroll_to_node_with_events<F: FnMut(DomEvent)>(
        &mut self,
        node_id: NodeId,
        dispatch_event: F,
    ) {
        self.scroll_to_node_aligned_with_events(node_id, false, dispatch_event);
    }

    /// Reveal a node near the centre of each scrollport and the viewport.
    ///
    /// Semantic input uses this placement so fixed or sticky chrome cannot
    /// cover the point an automation client will drive. Ordinary DOM
    /// `scrollIntoView` and fragment navigation retain their start alignment.
    pub fn scroll_to_node_centered_with_events<F: FnMut(DomEvent)>(
        &mut self,
        node_id: NodeId,
        dispatch_event: F,
    ) {
        self.scroll_to_node_aligned_with_events(node_id, true, dispatch_event);
    }

    fn scroll_to_node_aligned_with_events<F: FnMut(DomEvent)>(
        &mut self,
        node_id: NodeId,
        centered: bool,
        mut dispatch_event: F,
    ) {
        // Semantic snapshots expose visible text as addressable nodes, but a
        // text node does not own a Taffy layout box. `absolute_position` and
        // the scrolling calculations below require one, so resolve such a
        // target to its nearest layout ancestor first. Without this, asking an
        // automation client to reveal a label panics the entire host at
        // `Node::final_layout` instead of scrolling the label's box into view.
        let mut scroll_target = Some(node_id);
        let node_id = loop {
            let Some(candidate) = scroll_target else {
                return;
            };
            let Some(node) = self.nodes.get(candidate) else {
                return;
            };
            if matches!(
                node.data,
                NodeData::Element(_) | NodeData::AnonymousBlock(_) | NodeData::Document(_)
            ) {
                break candidate;
            }
            scroll_target = node.layout_parent.get().or(node.parent);
        };

        // Every scroll container between the node and the root, innermost
        // first. Scrolling only the viewport is not `scrollIntoView`: it does
        // nothing at all for a node inside a nested scroller, which is what an
        // application's own scrolling panes are.
        //
        // This was not academic. A transcript pane held its "Show 12 earlier
        // messages" button at y=-9463 and neither wheel events, Page Up nor
        // this call moved it by a single pixel, so a layout bug that only
        // appears further up the thread could not be reached from outside the
        // app at all. Every measurement of it had to come from a human
        // scrolling by hand and saying "now".
        let mut chain = Vec::new();
        let mut current = self.nodes.get(node_id).and_then(|node| node.parent);
        while let Some(id) = current {
            let Some(node) = self.nodes.get(id) else {
                break;
            };
            let scrolls = node.style().overflow.x.is_scroll_container()
                || node.style().overflow.y.is_scroll_container();
            if scrolls {
                chain.push(id);
            }
            current = node.parent;
        }

        // Innermost first: scrolling an outer container moves the inner one, so
        // the inner offsets have to be settled before the outer ones are
        // measured, and each step re-reads the node's position.
        for container in chain {
            let Some(node) = self.nodes.get(node_id) else {
                return;
            };
            let target = node.absolute_position(0.0, 0.0);
            let Some(scroller) = self.nodes.get(container) else {
                continue;
            };
            let box_ = scroller.absolute_position(0.0, 0.0);
            let layout = scroller.final_layout();
            let target_layout = node.final_layout();
            // `scroll_node_by` subtracts its delta from the offset. Semantic
            // automation centres the target to avoid chrome; DOM behavior
            // keeps its historical start alignment.
            let (dx, dy) = if centered {
                (
                    f64::from(
                        box_.x + layout.size.width / 2.0
                            - (target.x + target_layout.size.width / 2.0),
                    ),
                    f64::from(
                        box_.y + layout.size.height / 2.0
                            - (target.y + target_layout.size.height / 2.0),
                    ),
                )
            } else {
                (f64::from(box_.x - target.x), f64::from(box_.y - target.y))
            };
            self.scroll_node_by(container, dx, dy, &mut dispatch_event);
        }

        // `absolute_position` gives the node's position in document space (it does not
        // account for the viewport scroll), so it is the scroll offset we want to land on.
        let Some(node) = self.nodes.get(node_id) else {
            return;
        };
        let target = node.absolute_position(0.0, 0.0);
        let current = self.viewport_scroll;
        let (desired_x, desired_y) = if centered {
            let target_layout = node.final_layout();
            let scale = self.viewport.scale();
            let viewport_width = self.viewport.window_size.0 as f32 / scale;
            let viewport_height = self.viewport.window_size.1 as f32 / scale;
            (
                f64::from(target.x + target_layout.size.width / 2.0 - viewport_width / 2.0)
                    .max(0.0),
                f64::from(target.y + target_layout.size.height / 2.0 - viewport_height / 2.0)
                    .max(0.0),
            )
        } else {
            (f64::from(target.x), f64::from(target.y))
        };

        // `scroll_viewport_by` subtracts the delta from the current scroll
        // offset, so pass current minus the centred destination.
        let dx = current.x - desired_x;
        let dy = current.y - desired_y;
        if let Some(root) = self.try_root_element().map(|element| element.id) {
            self.scroll_node_by(root, dx, dy, dispatch_event);
        } else {
            self.scroll_viewport_by(dx, dy);
        }
    }

    /// Scroll to the element targeted by the given URL fragment (the `#...` part of a URL).
    ///
    /// An empty fragment (or a `top` fragment that matches no element) scrolls to the top
    /// of the document, matching browser behaviour. Returns `true` if a scroll target was
    /// found.
    pub fn scroll_to_fragment(&mut self, fragment: &str) -> bool {
        // Fragments are percent-encoded in URLs (e.g. `%20`); decode before matching.
        let decoded = percent_encoding::percent_decode_str(fragment)
            .decode_utf8_lossy()
            .into_owned();

        if !decoded.is_empty() {
            if let Some(node_id) = self.get_fragment_target(&decoded) {
                self.scroll_to_node(node_id);
                return true;
            }
        }

        // An empty fragment, or the special "top" fragment when no matching element exists,
        // scrolls to the top of the document.
        if decoded.is_empty() || decoded.eq_ignore_ascii_case("top") {
            let current = self.viewport_scroll;
            self.scroll_viewport_by(current.x, current.y);
            return true;
        }

        false
    }

    /// SVG graphics bounds in the element's user coordinate system.
    /// Callers must flush layout before reading, as for client rectangles.
    pub fn get_svg_bbox(&self, node_id: NodeId) -> Option<BoundingRect> {
        #[cfg(feature = "svg")]
        {
            self.svg_user_bbox(node_id)
        }
        #[cfg(not(feature = "svg"))]
        {
            let _ = node_id;
            None
        }
    }

    /// Computes the size and position of the `Node` relative to the viewport
    pub fn get_client_bounding_rect(&self, node_id: NodeId) -> Option<BoundingRect> {
        #[cfg(feature = "svg")]
        if let Some(root) = self.svg_geometry_root(node_id) {
            return self.svg_client_rect(root, node_id);
        }

        // Non-atomic inline elements have no layout box of their own: return
        // the union of their per-line-box fragment rects.
        if let Some(rects) = self.inline_fragment_rects(node_id) {
            let rects: Vec<_> = rects
                .into_iter()
                .map(|rect| self.transformed_client_rect(node_id, rect))
                .collect();
            let x0 = rects.iter().map(|r| r.x).fold(f64::INFINITY, f64::min);
            let y0 = rects.iter().map(|r| r.y).fold(f64::INFINITY, f64::min);
            let x1 = rects
                .iter()
                .map(|r| r.x + r.width)
                .fold(f64::NEG_INFINITY, f64::max);
            let y1 = rects
                .iter()
                .map(|r| r.y + r.height)
                .fold(f64::NEG_INFINITY, f64::max);
            return match rects.is_empty() {
                true => None,
                false => Some(BoundingRect {
                    x: x0,
                    y: y0,
                    width: x1 - x0,
                    height: y1 - y0,
                }),
            };
        }

        let node = self.get_node(node_id)?;
        if !matches!(
            node.data,
            NodeData::Element(_) | NodeData::AnonymousBlock(_) | NodeData::Document(_)
        ) {
            return None;
        }
        let pos = node.absolute_position(0.0, 0.0);

        Some(self.transformed_client_rect(
            node_id,
            BoundingRect {
                x: pos.x as f64 - self.viewport_scroll.x,
                y: pos.y as f64 - self.viewport_scroll.y,
                width: node.unrounded_layout().size.width as f64,
                height: node.unrounded_layout().size.height as f64,
            },
        ))
    }

    /// Map the layout rectangle through the same two-dimensional transforms as paint.
    /// Layout coordinates deliberately exclude transforms; CSSOM client rectangles do not.
    pub(crate) fn transformed_client_rect(
        &self,
        node_id: NodeId,
        rect: BoundingRect,
    ) -> BoundingRect {
        let mut matrix = kurbo::Affine::IDENTITY;
        let mut current = self.get_node(node_id);
        let scale = self.viewport.scale_f64();
        while let Some(node) = current {
            if matches!(
                node.data,
                NodeData::Element(_) | NodeData::AnonymousBlock(_) | NodeData::Document(_)
            ) && let Some(transform) = *node.transform()
            {
                let [a, b, c, d, e, f] = transform.as_coeffs();
                let css_transform = kurbo::Affine::new([a, b, c, d, e / scale, f / scale]);
                let origin = node.absolute_position(0.0, 0.0);
                let translate = kurbo::Affine::translate((
                    origin.x as f64 - self.viewport_scroll.x,
                    origin.y as f64 - self.viewport_scroll.y,
                ));
                matrix = translate * css_transform * translate.inverse() * matrix;
            }
            current = node
                .layout_parent
                .get()
                .or(node.parent)
                .and_then(|id| self.get_node(id));
        }
        let transformed = matrix.transform_rect_bbox(kurbo::Rect::new(
            rect.x,
            rect.y,
            rect.x + rect.width,
            rect.y + rect.height,
        ));
        BoundingRect {
            x: transformed.x0,
            y: transformed.y0,
            width: transformed.width(),
            height: transformed.height(),
        }
    }

    /// Computes the sizes and positions of the `Node`'s box fragments relative to the
    /// viewport (CSSOM `getClientRects()` semantics). Nodes with their own layout box
    /// return a single rect. Non-atomic inline elements (which are laid out as style
    /// spans within an inline root's text layout) return one rect per line box.
    pub fn node_client_rects(&self, node_id: NodeId) -> Vec<BoundingRect> {
        #[cfg(feature = "svg")]
        if self.svg_geometry_root(node_id).is_some() {
            return self.get_client_bounding_rect(node_id).into_iter().collect();
        }
        match self.inline_fragment_rects(node_id) {
            Some(rects) => rects
                .into_iter()
                .map(|rect| self.transformed_client_rect(node_id, rect))
                .collect(),
            None => self.get_client_bounding_rect(node_id).into_iter().collect(),
        }
    }

    /// Computes per-line-box fragment rects for a non-atomic inline element by walking
    /// the containing inline root's text layout. Returns `None` for nodes that have
    /// their own layout box (which should use `get_client_bounding_rect` instead).
    /// Report inline elements whose fragment rects lie outside the inline root
    /// that owns them. `BLITZ_TRACE_INLINE=1`, once per resolve.
    ///
    /// A non-atomic inline element has no layout box of its own: its geometry
    /// is read back out of the containing inline root's text layout on demand.
    /// So "the chip is 900px to the right of its block" is a statement about
    /// that text layout, and the only way to see it is from in here, with both
    /// the fragment and the root in hand. Every earlier attempt to chase this
    /// from outside was reading a number the engine computes on the fly and
    /// could not say where it came from.
    pub(crate) fn trace_escaped_inline_fragments(&self) {
        static TRACE: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
        if !*TRACE.get_or_init(|| std::env::var_os("BLITZ_TRACE_INLINE").is_some()) {
            return;
        }
        let mut reported = 0;
        for (id, node) in self.nodes.iter() {
            if !node.is_element() {
                continue;
            }
            let Some(rects) = self.inline_fragment_rects(id) else {
                continue;
            };
            let Some(root) = node.inline_root_ancestor() else {
                continue;
            };
            let root_layout = root.final_layout();
            let root_pos = root.absolute_position(0.0, 0.0);
            let root_right =
                root_pos.x as f64 + root_layout.size.width as f64 - self.viewport_scroll.x;
            for rect in &rects {
                if rect.x + rect.width > root_right + 1.0 {
                    reported += 1;
                    if reported <= 12 {
                        eprintln!(
                            "escaped-fragment node={id:?} rect=[{:.1},{:.1} {:.1}x{:.1}] \
root={:?} root_right={root_right:.1} root_w={:.1} lines={} layout_scale={:.2} vp_scale={:.2} layout_w={:.1}",
                            rect.x,
                            rect.y,
                            rect.width,
                            rect.height,
                            root.id,
                            root_layout.size.width,
                            root.element_data()
                                .and_then(|e| e.inline_layout_data.as_ref())
                                .map(|i| i.layout.len())
                                .unwrap_or(0),
                            root.element_data()
                                .and_then(|e| e.inline_layout_data.as_ref())
                                .map(|i| i.layout.scale())
                                .unwrap_or(0.0),
                            self.viewport.scale(),
                            root.element_data()
                                .and_then(|e| e.inline_layout_data.as_ref())
                                .map(|i| i.layout.width())
                                .unwrap_or(0.0),
                        );
                    }
                    break;
                }
            }
        }
        if reported > 0 {
            eprintln!("escaped-fragment total={reported}");
        }

        // The opposite failure, and the one that reads as "first load is
        // broken": lines broken far narrower than the box they sit in, so a
        // paragraph comes out as a column of one or two words inside a
        // full-width bubble. Nothing escapes, so the check above never sees it.
        let mut narrow = 0;
        for (id, node) in self.nodes.iter() {
            let Some(inline) = node
                .data
                .downcast_element()
                .and_then(|element| element.inline_layout_data.as_ref())
            else {
                continue;
            };
            let box_width = node.final_layout().size.width as f64 * self.viewport.scale() as f64;
            let broken_at = inline.layout.width() as f64;
            // Only interesting when the text had more to give: a short string
            // legitimately measures narrower than its box.
            let full = inline.layout.calculate_content_widths().max as f64;
            if box_width > 40.0 && broken_at < box_width * 0.6 && full > box_width * 0.9 {
                narrow += 1;
                if narrow <= 12 {
                    eprintln!(
                        "narrow-break node={id:?} broken_at={broken_at:.1} box={box_width:.1} \
                         max_content={full:.1} lines={} text={:?}",
                        inline.layout.len(),
                        inline.text.chars().take(40).collect::<String>(),
                    );
                }
            }
        }
        if narrow > 0 {
            eprintln!("narrow-break total={narrow}");
        }
    }

    pub fn inline_fragment_rects(&self, node_id: NodeId) -> Option<Vec<BoundingRect>> {
        use parley::PositionedLayoutItem;

        let node = self.get_node(node_id)?;

        // Text and non-atomic inline elements live in the inline root's glyph
        // runs rather than owning layout boxes.
        let is_text = node.is_text_node();
        if !is_text {
            if !node.is_element() || node.flags.is_inline_root() {
                return None;
            }
            let display = node.primary_styles()?.clone_display();
            if !(display.outside() == DisplayOutside::Inline
                && display.inside() == DisplayInside::Flow)
            {
                return None;
            }
        }

        let inline_root = node.inline_root_ancestor()?;
        let inline_layout = inline_root.element_data()?.inline_layout_data.as_ref()?;
        let layout = &inline_layout.layout;
        let scale = layout.scale() as f64;

        // Walk up the DOM parent chain from `id` to check whether it is (or is
        // inside) the target node, stopping at the inline root.
        let is_in_target = |mut id: NodeId| -> bool {
            loop {
                if id == node_id {
                    return true;
                }
                if id == inline_root.id {
                    return false;
                }
                match self.get_node(id).and_then(|n| n.parent) {
                    Some(parent) => id = parent,
                    None => return false,
                }
            }
        };

        // Fragment rects are relative to the inline root's content box.
        let root_layout = inline_root.final_layout();
        let root_pos = inline_root.absolute_position(0.0, 0.0);
        let origin_x = root_pos.x as f64
            + (root_layout.padding.left + root_layout.border.left) as f64
            - self.viewport_scroll.x;
        let origin_y = root_pos.y as f64
            + (root_layout.padding.top + root_layout.border.top) as f64
            - self.viewport_scroll.y;

        let mut rects: Vec<BoundingRect> = Vec::new();
        for line in layout.lines() {
            let line_metrics = line.metrics();
            // Union all of the target's fragments on this line into a single rect
            let mut line_rect: Option<(f64, f64, f64, f64)> = None;
            let mut add = |x0: f64, y0: f64, x1: f64, y1: f64| {
                line_rect = Some(match line_rect {
                    Some((lx0, ly0, lx1, ly1)) => {
                        (lx0.min(x0), ly0.min(y0), lx1.max(x1), ly1.max(y1))
                    }
                    None => (x0, y0, x1, y1),
                });
            };

            for item in line.items() {
                match item {
                    PositionedLayoutItem::GlyphRun(glyph_run) => {
                        let brush = glyph_run.style().brush;
                        let matches = if is_text {
                            brush.text_node == Some(node_id)
                        } else {
                            is_in_target(brush.id)
                        };
                        if !matches {
                            continue;
                        }
                        let x0 = glyph_run.offset() as f64;
                        let x1 = x0 + glyph_run.advance() as f64;
                        // Use the line box's block extent rather than the
                        // run's font ascent/descent: fonts with small
                        // typographic metrics would otherwise produce rects
                        // that clip the rendered glyphs. This matches the
                        // geometry used for text selection highlights.
                        let y0 = line_metrics.block_min_coord as f64;
                        let y1 = line_metrics.block_max_coord as f64;
                        add(x0, y0, x1, y1);
                    }
                    PositionedLayoutItem::InlineBox(inline_box) => {
                        if is_text || !is_in_target(NodeId::from_u64(inline_box.id)) {
                            continue;
                        }
                        let x0 = inline_box.x as f64;
                        let y0 = inline_box.y as f64;
                        add(
                            x0,
                            y0,
                            x0 + inline_box.width as f64,
                            y0 + inline_box.height as f64,
                        );
                    }
                }
            }

            if let Some((x0, y0, x1, y1)) = line_rect {
                rects.push(BoundingRect {
                    x: origin_x + x0 / scale,
                    y: origin_y + y0 / scale,
                    width: (x1 - x0) / scale,
                    height: (y1 - y0) / scale,
                });
            }
        }

        Some(rects)
    }

    pub fn find_title_node(&self) -> Option<&Node> {
        TreeTraverser::new(self)
            .find(|node_id| {
                let node = &self.nodes[*node_id];
                let Some(element) = node.element_data() else {
                    return false;
                };
                if element.name.ns != ns!(html) || element.name.local != local_name!("title") {
                    return false;
                }
                node.parent
                    .and_then(|parent_id| self.nodes.get(parent_id))
                    .and_then(Node::element_data)
                    .is_some_and(|parent| {
                        parent.name.ns == ns!(html) && parent.name.local == local_name!("head")
                    })
            })
            .map(|node_id| &self.nodes[node_id])
    }

    pub fn with_text_input(
        &mut self,
        node_id: NodeId,
        cb: impl FnOnce(PlainEditorDriver<TextBrush>),
    ) {
        let Some(node) = self.nodes.get_mut(node_id) else {
            return;
        };

        if let Some(text_input) = node
            .element_data_mut()
            .and_then(|el| el.text_input_data_mut())
        {
            let mut font_ctx = self.font_ctx.lock().unwrap();
            let layout_ctx = &mut self.layout_ctx;
            let driver = text_input.editor.driver(&mut font_ctx, layout_ctx);
            cb(driver)
        }
    }

    /// Recompute the scroll offset of the text input at `node_id` (if any) so that its caret
    /// remains visible within the input's content box.
    pub(crate) fn clamp_text_input_scroll(&mut self, node_id: NodeId) {
        let Some(node) = self.nodes.get_mut(node_id) else {
            return;
        };

        let content_box_width = node.final_layout().content_box_width();
        let content_box_height = node.final_layout().content_box_height();

        if let Some(text_input) = node
            .element_data_mut()
            .and_then(|el| el.text_input_data_mut())
        {
            text_input.clamp_scroll_offset(content_box_width, content_box_height);
        }
    }

    pub(crate) fn compute_has_canvas(&self) -> bool {
        TreeTraverser::new(self).any(|node_id| {
            let node = &self.nodes[node_id];
            let Some(element) = node.element_data() else {
                return false;
            };
            if element.name.local == local_name!("canvas") && element.has_attr(local_name!("src")) {
                return true;
            }

            false
        })
    }

    // Text selection methods

    /// Find the text position (inline_root_id, byte_offset) at a given point.
    /// Uses hit() for proper coordinate transformation, then finds the inline root
    /// and byte offset.
    pub fn find_text_position(&self, x: f32, y: f32) -> Option<(NodeId, usize)> {
        let hit = self.hit(x, y)?;
        let hit_node = self.get_node(hit.node_id)?;
        let inline_root = hit_node.inline_root_ancestor()?;
        let byte_offset = inline_root.text_offset_at_point(hit.x, hit.y)?;
        Some((inline_root.id, byte_offset))
    }

    /// Find the word or line at a point, as `(inline_root_id, start, end)`.
    ///
    /// The multi-click counterpart of
    /// [`find_text_position`](Self::find_text_position): that one answers where
    /// a caret goes, this one answers what a double or triple click selects.
    pub fn find_text_range(
        &self,
        x: f32,
        y: f32,
        granularity: TextGranularity,
    ) -> Option<(NodeId, usize, usize)> {
        let hit = self.hit(x, y)?;
        let hit_node = self.get_node(hit.node_id)?;
        let inline_root = hit_node.inline_root_ancestor()?;
        let range = inline_root.text_range_at_point(hit.x, hit.y, granularity)?;
        Some((inline_root.id, range.start, range.end))
    }

    /// Set the text selection range (creates a new selection from anchor to focus)
    pub fn set_text_selection(
        &mut self,
        anchor_node: NodeId,
        anchor_offset: usize,
        focus_node: NodeId,
        focus_offset: usize,
    ) {
        self.dom_selection = None;
        self.text_selection =
            TextSelection::new(anchor_node, anchor_offset, focus_node, focus_offset);

        // For anonymous blocks, switch to storing parent+sibling_index (stable reference)
        if let (Some(parent), Some(idx)) = self.anonymous_block_location(anchor_node) {
            self.text_selection
                .anchor
                .set_anonymous(parent, idx, anchor_offset);
        }
        if let (Some(parent), Some(idx)) = self.anonymous_block_location(focus_node) {
            self.text_selection
                .focus
                .set_anonymous(parent, idx, focus_offset);
        }
    }

    /// Get the parent ID and sibling index for a node if it's an anonymous block.
    /// Returns (None, None) for non-anonymous blocks.
    fn anonymous_block_location(&self, node_id: NodeId) -> (Option<NodeId>, Option<usize>) {
        let Some(node) = self.get_node(node_id) else {
            return (None, None);
        };

        if !node.is_anonymous() {
            return (None, None);
        }

        let Some(parent_id) = node.parent else {
            return (None, None);
        };

        let Some(parent) = self.get_node(parent_id) else {
            return (Some(parent_id), None);
        };

        let layout_children = parent.layout_children.borrow();
        let Some(children) = layout_children.as_ref() else {
            return (Some(parent_id), None);
        };

        // Find the index of this anonymous block among siblings
        let mut anon_index = 0;
        for &child_id in children.iter() {
            if child_id == node_id {
                return (Some(parent_id), Some(anon_index));
            }
            if self.get_node(child_id).is_some_and(|n| n.is_anonymous()) {
                anon_index += 1;
            }
        }

        (Some(parent_id), None)
    }

    /// Clear the text selection
    pub fn clear_text_selection(&mut self) {
        self.dom_selection = None;
        self.text_selection.clear();
    }

    /// Update the selection focus point (used during mouse drag to extend selection).
    pub fn update_selection_focus(&mut self, focus_node: NodeId, focus_offset: usize) {
        self.dom_selection = None;
        // For anonymous blocks, store parent+sibling_index; otherwise store node directly
        if let (Some(parent), Some(idx)) = self.anonymous_block_location(focus_node) {
            self.text_selection
                .focus
                .set_anonymous(parent, idx, focus_offset);
        } else {
            self.text_selection.set_focus(focus_node, focus_offset);
        }
    }

    /// Extend text selection to the given point. Returns true if selection was updated.
    /// This is a convenience method that combines find_text_position and update_selection_focus.
    pub fn extend_text_selection_to_point(&mut self, x: f32, y: f32) -> bool {
        if !self.text_selection.anchor.is_some() {
            return false;
        }

        if let Some((node, offset)) = self.find_text_position(x, y) {
            self.update_selection_focus(node, offset);
            self.shell_provider.request_redraw();
            true
        } else {
            false
        }
    }

    /// Find the Nth anonymous block under a parent.
    fn find_anonymous_block_by_index(
        &self,
        parent_id: NodeId,
        target_index: usize,
    ) -> Option<NodeId> {
        let parent = self.get_node(parent_id)?;
        let layout_children = parent.layout_children.borrow();
        let children = layout_children.as_ref()?;

        children
            .iter()
            .filter(|&&child_id| self.get_node(child_id).is_some_and(|n| n.is_anonymous()))
            .nth(target_index)
            .copied()
    }

    /// Check if there is an active (non-empty) text selection
    pub fn has_text_selection(&self) -> bool {
        self.dom_selection.as_ref().map_or_else(
            || self.text_selection.is_active(),
            |range| !range.bounds().collapsed(),
        )
    }

    /// Get the selected text content, supporting selection across multiple inline roots.
    pub fn get_selected_text(&self) -> Option<String> {
        if let Some(range) = &self.dom_selection {
            let text = self.range_string(range.bounds());
            return (!text.is_empty()).then_some(text);
        }
        let ranges = self.get_text_selection_ranges();
        if ranges.is_empty() {
            return None;
        }

        let mut result = String::new();
        for (node_id, start, end) in &ranges {
            let node = self.get_node(*node_id)?;
            let element_data = node.element_data()?;
            let inline_layout = element_data.inline_layout_data.as_ref()?;

            if *end > inline_layout.text.len() {
                continue;
            }

            if !result.is_empty() {
                result.push(' ');
            }
            result.push_str(&inline_layout.text[*start..*end]);
        }

        if result.is_empty() {
            None
        } else {
            Some(result)
        }
    }

    /// The selection as HTML, for a clipboard that can carry formatting.
    ///
    /// The same ranges [`Self::get_selected_text`] walks, with each one wrapped
    /// in the tag of the element it came from, so bold stays bold and a code
    /// span stays a code span when it lands in another application. Pasting
    /// formatted text out of a Blitz window was impossible before this: plain
    /// text was the only payload ever written.
    ///
    /// Only the element's own tag is reproduced, not its ancestors or its
    /// styles. That is deliberate: a paste should carry the structure the author
    /// wrote, not this window's theme, and dragging a `class` into another
    /// application's document would reference styles that do not exist there.
    pub fn get_selected_html(&self) -> Option<String> {
        let ranges = self.get_text_selection_ranges();
        if ranges.is_empty() {
            return None;
        }

        let mut result = String::new();
        for (node_id, start, end) in &ranges {
            let Some(node) = self.get_node(*node_id) else {
                continue;
            };
            let Some(element_data) = node.element_data() else {
                continue;
            };
            let Some(inline_layout) = element_data.inline_layout_data.as_ref() else {
                continue;
            };
            if *end > inline_layout.text.len() {
                continue;
            }

            if !result.is_empty() {
                result.push(' ');
            }

            let tag = element_data.name.local.as_ref();
            let fragment = escape_html(&inline_layout.text[*start..*end]);
            // A block tag around a fragment of a paragraph would be wrong: the
            // range is a run of text, and the element it belongs to may be only
            // partly selected. Inline tags carry meaning a paste should keep;
            // anything else contributes its text and nothing more.
            if matches!(
                tag,
                "b" | "strong" | "i" | "em" | "code" | "kbd" | "mark" | "s" | "u" | "sub" | "sup"
            ) {
                result.push_str(&format!("<{tag}>{fragment}</{tag}>"));
            } else {
                result.push_str(&fragment);
            }
        }

        if result.is_empty() {
            None
        } else {
            Some(result)
        }
    }

    /// Get all selection ranges as Vec<(node_id, start_offset, end_offset)>.
    /// Returns empty vec if no selection.
    pub fn get_text_selection_ranges(&self) -> Vec<(NodeId, usize, usize)> {
        if let Some(range) = &self.dom_selection {
            return self.range_layout_ranges(range.bounds());
        }
        let lookup = |parent_id, idx| self.find_anonymous_block_by_index(parent_id, idx);

        let anchor_node = match self.text_selection.anchor.resolve_node_id(lookup) {
            Some(id) => id,
            None => return Vec::new(),
        };
        let focus_node = match self.text_selection.focus.resolve_node_id(lookup) {
            Some(id) => id,
            None => return Vec::new(),
        };

        // Guard against stale selection endpoints: nodes may have been removed from
        // the document (e.g. by script) since the selection was made.
        let node_is_in_doc = |node_id: NodeId| {
            self.nodes
                .get(node_id)
                .is_some_and(|node| node.flags.is_in_document())
        };
        if !node_is_in_doc(anchor_node) || !node_is_in_doc(focus_node) {
            return Vec::new();
        }

        // Single node selection
        if anchor_node == focus_node {
            let start = self
                .text_selection
                .anchor
                .offset
                .min(self.text_selection.focus.offset);
            let end = self
                .text_selection
                .anchor
                .offset
                .max(self.text_selection.focus.offset);

            if start == end {
                return Vec::new();
            }
            return vec![(anchor_node, start, end)];
        }

        // Multi-node selection: collect all inline roots between anchor and focus
        let inline_roots = self.collect_inline_roots_in_range(anchor_node, focus_node);
        if inline_roots.is_empty() {
            return Vec::new();
        }

        // Determine document order using the collected inline_roots order
        // (inline_roots is already in document order from first to last)
        let first_in_roots = inline_roots[0];

        let (first_node, first_offset, last_node, last_offset) =
            if first_in_roots == anchor_node || (first_in_roots != focus_node) {
                // anchor is first (or neither endpoint is in roots, which shouldn't happen)
                (
                    anchor_node,
                    self.text_selection.anchor.offset,
                    focus_node,
                    self.text_selection.focus.offset,
                )
            } else {
                // focus is first
                (
                    focus_node,
                    self.text_selection.focus.offset,
                    anchor_node,
                    self.text_selection.anchor.offset,
                )
            };

        let mut ranges = Vec::with_capacity(inline_roots.len());

        for &node_id in &inline_roots {
            let Some(node) = self.get_node(node_id) else {
                continue;
            };
            let Some(element_data) = node.element_data() else {
                continue;
            };
            let Some(inline_layout) = element_data.inline_layout_data.as_ref() else {
                continue;
            };

            let text_len = inline_layout.text.len();

            if node_id == first_node && node_id == last_node {
                let start = first_offset.min(last_offset);
                let end = first_offset.max(last_offset);
                if start < end && end <= text_len {
                    ranges.push((node_id, start, end));
                }
            } else if node_id == first_node {
                if first_offset < text_len {
                    ranges.push((node_id, first_offset, text_len));
                }
            } else if node_id == last_node {
                if last_offset > 0 && last_offset <= text_len {
                    ranges.push((node_id, 0, last_offset));
                }
            } else if text_len > 0 {
                ranges.push((node_id, 0, text_len));
            }
        }

        ranges
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct BoundingRect {
    pub x: f64,
    pub y: f64,
    pub width: f64,
    pub height: f64,
}

/// The record of changes a script's `MutationObserver` reads. See
/// [`crate::DomMutation`] for what is recorded and why.
impl BaseDocument {
    /// Note a `<details open>` presence change for the toggle event. `present` is whether the
    /// attribute exists after this write.
    pub(crate) fn record_details_open(
        &mut self,
        node_id: NodeId,
        name: &markup5ever::QualName,
        present: bool,
    ) {
        if name.local != local_name!("open") || !name.ns.is_empty() {
            return;
        }
        let Some(element) = self.nodes[node_id].element_data() else {
            return;
        };
        if element.name.local != local_name!("details") || element.name.ns != ns!(html) {
            return;
        }
        let was_open = element.attr(local_name!("open")).is_some();
        if was_open != present && !self.details_toggles.iter().any(|(id, _)| *id == node_id) {
            self.details_toggles.push((node_id, was_open));
        }
    }

    /// The inert document template contents belong to.
    pub(crate) fn template_contents_owner(&mut self) -> NodeId {
        if let Some(owner) = self.template_contents_owner {
            return owner;
        }
        let mut data = crate::node::DocumentData::default();
        data.content_type = "text/html";
        let owner = self.create_node(NodeData::Document(Box::new(data)));
        self.template_contents_owner = Some(owner);
        owner
    }

    /// Changes whenever the device media queries are evaluated against changes.
    pub fn viewport_generation(&self) -> u64 {
        self.viewport_generation
    }

    /// The `<details>` toggles recorded since the last call, each with its old open state.
    pub fn take_details_toggles(&mut self) -> Vec<(NodeId, bool)> {
        std::mem::take(&mut self.details_toggles)
    }

    /// Update the raw content handler state at the attribute mutation boundary.
    /// Equal-value writes still replace a compiled or script-assigned handler.
    pub(crate) fn record_inline_handler_attribute(
        &mut self,
        node_id: NodeId,
        name: &crate::QualName,
        value: Option<&str>,
    ) {
        if name.ns != markup5ever::ns!() || !name.local.as_ref().starts_with("on") {
            return;
        }
        let Some(element) = self
            .nodes
            .get_mut(node_id)
            .and_then(|node| node.element_data_mut())
        else {
            return;
        };
        let value = value.map(crate::node::AttrAtom::from);
        if let Some(value) = &value {
            let attributes = element
                .inline_event_attributes
                .get_or_insert_with(|| Box::new(Vec::new()));
            if let Some(attribute) = attributes
                .iter_mut()
                .find(|attribute| attribute.name.local == name.local)
            {
                attribute.name = name.clone();
                attribute.value = value.clone();
            } else {
                attributes.push(crate::node::Attribute {
                    name: name.clone(),
                    value: value.clone(),
                });
            }
        } else {
            let Some(attributes) = element.inline_event_attributes.as_mut() else {
                return;
            };
            let Some(index) = attributes
                .iter()
                .position(|attribute| attribute.name.local == name.local)
            else {
                return;
            };
            attributes.remove(index);
            if attributes.is_empty() {
                element.inline_event_attributes = None;
            }
        }
        self.inline_handler_changes
            .push((node_id, name.clone(), value));
    }

    /// Take content handler changes in mutation order.
    pub fn take_inline_handler_changes(
        &mut self,
    ) -> Vec<(NodeId, crate::QualName, Option<crate::node::AttrAtom>)> {
        std::mem::take(&mut self.inline_handler_changes)
    }

    /// Start or stop recording changes. Stopping discards what was recorded
    /// and not yet taken.
    pub fn set_recording_mutations(&mut self, recording: bool) {
        match (recording, self.mutation_log.is_some()) {
            (true, false) => self.mutation_log = Some(Vec::new()),
            (false, true) => self.mutation_log = None,
            _ => {}
        }
    }

    /// Whether changes are being recorded.
    pub fn is_recording_mutations(&self) -> bool {
        self.mutation_log.is_some()
    }

    /// Take every change recorded since the last call, oldest first.
    pub fn take_mutations(&mut self) -> Vec<crate::DomMutation> {
        self.mutation_log
            .as_mut()
            .map(std::mem::take)
            .unwrap_or_default()
    }

    pub(crate) fn record_mutation(&mut self, mutation: crate::DomMutation) {
        if let Some(log) = self.mutation_log.as_mut() {
            if log.len() < crate::mutation_record::MUTATION_LOG_CAP {
                log.push(mutation);
            }
        }
    }

    /// Where `node_id` sits among its siblings: its parent and the siblings on
    /// either side, as a child-list record reports them.
    pub(crate) fn sibling_context(
        &self,
        node_id: NodeId,
    ) -> Option<(NodeId, Option<NodeId>, Option<NodeId>)> {
        let parent_id = self.nodes.get(node_id)?.parent?;
        let siblings = &self.nodes.get(parent_id)?.children;
        let index = siblings.iter().position(|id| *id == node_id)?;
        let previous = index.checked_sub(1).map(|i| siblings[i]);
        let next = siblings.get(index + 1).copied();
        Some((parent_id, previous, next))
    }
}

impl AsRef<BaseDocument> for BaseDocument {
    fn as_ref(&self) -> &BaseDocument {
        self
    }
}

impl AsMut<BaseDocument> for BaseDocument {
    fn as_mut(&mut self) -> &mut BaseDocument {
        self
    }
}

#[cfg(test)]
mod hover_state_tests {
    use super::*;
    use crate::{Attribute, qual_name};
    use blitz_traits::shell::ColorScheme;

    /// Build `<html><body style="margin:0"><div style="width:300px">some text
    /// <div style="height:50px"></div></div></body></html>` manually (the HTML
    /// parser lives in blitz-html, which would be a circular dev-dependency).
    /// The bare text next to a block sibling gets wrapped in an anonymous
    /// block, which becomes the inline root: text hits report the anonymous
    /// block as the hit node.
    fn make_doc() -> (BaseDocument, NodeId) {
        let mut doc = BaseDocument::new(DocumentConfig {
            viewport: Some(Viewport::new(400, 300, 1.0, ColorScheme::Light)),
            ..Default::default()
        });
        let root_id = doc.root_node().id;
        let style = |value: &str| Attribute {
            name: qual_name!("style"),
            value: value.into(),
        };

        let mut mutator = doc.mutate();
        let html = mutator.create_element(qual_name!("html"), vec![]);
        let body = mutator.create_element(qual_name!("body"), vec![style("margin:0")]);
        let container = mutator.create_element(qual_name!("div"), vec![style("width:300px")]);
        let text = mutator.create_text_node("some text");
        let block = mutator.create_element(qual_name!("div"), vec![style("height:50px")]);
        mutator.append_children(container, &[text, block]);
        mutator.append_children(body, &[container]);
        mutator.append_children(html, &[body]);
        mutator.append_children(root_id, &[html]);
        drop(mutator);

        doc.resolve(0.0);
        (doc, container)
    }

    /// Whether text laid out with a real (non-zero-metric) font. Without the
    /// `system-fonts` feature text measures 0x0 and text hits are impossible,
    /// making these tests vacuous.
    fn text_has_size(doc: &BaseDocument, container: NodeId) -> bool {
        doc.nodes[container].final_layout().size.height > 50.0
    }

    /// Regression test: hovering bare text wrapped in an anonymous block must
    /// report a text cursor. The hit node for such text is the anonymous
    /// inline root itself, while the *stored* hover target is canonicalized to
    /// the containing element — the cursor must be derived from the precise
    /// hit node, not the canonical target.
    #[test]
    fn hovering_text_in_anonymous_block_reports_text_cursor() {
        let (mut doc, container) = make_doc();
        if !text_has_size(&doc, container) {
            eprintln!("skipping: no usable font (text measures 0x0)");
            return;
        }

        doc.set_hover_to(5.0, 8.0);
        assert!(doc.hover_node_is_text, "expected a text hit");
        let hit_id = doc.hover_hit_node_id.expect("expected a hit node");
        assert!(
            doc.nodes[hit_id].is_anonymous(),
            "expected the hit node to be the anonymous inline root"
        );
        assert_eq!(
            doc.get_hover_node_id(),
            Some(container),
            "expected the stored hover target to be the containing element"
        );
        assert_eq!(doc.get_cursor(), Some(CursorIcon::Text));
    }

    #[test]
    fn semantic_hover_keeps_the_resolved_node_instead_of_hit_testing_again() {
        let (mut doc, container) = make_doc();

        // This coordinate is outside the 300px-wide container. A coordinate
        // hit test therefore cannot select it, but semantic automation has
        // already selected the container by id and must preserve that target.
        doc.set_hover_to_node(container, 350.0, 250.0);

        assert_eq!(doc.get_hover_node_id(), Some(container));
        assert_eq!(doc.hover_hit_node_id, Some(container));

        doc.resolve(0.0);
        assert_eq!(
            doc.get_hover_node_id(),
            Some(container),
            "a resolve must not turn semantic identity back into a coordinate hit"
        );
    }

    /// Hovering the empty region of the anonymous block (right of the text) is
    /// not a text hit: default cursor, same canonical hover target.
    #[test]
    fn hovering_anonymous_block_whitespace_reports_default_cursor() {
        let (mut doc, container) = make_doc();
        if !text_has_size(&doc, container) {
            eprintln!("skipping: no usable font (text measures 0x0)");
            return;
        }

        doc.set_hover_to(250.0, 8.0);
        assert!(!doc.hover_node_is_text);
        assert_eq!(doc.get_hover_node_id(), Some(container));
        assert_eq!(doc.get_cursor(), Some(CursorIcon::Default));
    }
}

#[cfg(test)]
mod control_scroll_tests {
    use super::*;
    use crate::{Attribute, qual_name};
    use blitz_traits::shell::ColorScheme;

    #[test]
    fn controlled_scroll_dispatches_the_dom_scroll_event() {
        let mut doc = BaseDocument::new(DocumentConfig {
            viewport: Some(Viewport::new(400, 300, 1.0, ColorScheme::Light)),
            ..Default::default()
        });
        let root_id = doc.root_node().id;
        let style = |value: &str| Attribute {
            name: qual_name!("style"),
            value: value.into(),
        };

        let mut mutator = doc.mutate();
        let html = mutator.create_element(qual_name!("html"), vec![]);
        let body = mutator.create_element(qual_name!("body"), vec![style("margin:0")]);
        let scroller = mutator.create_element(
            qual_name!("div"),
            vec![style("width:200px;height:100px;overflow-y:scroll")],
        );
        let spacer = mutator.create_element(qual_name!("div"), vec![style("height:400px")]);
        let target = mutator.create_element(qual_name!("button"), vec![style("height:40px")]);
        let target_text = mutator.create_text_node("Reveal me");
        mutator.append_children(target, &[target_text]);
        mutator.append_children(scroller, &[spacer, target]);
        mutator.append_children(body, &[scroller]);
        mutator.append_children(html, &[body]);
        mutator.append_children(root_id, &[html]);
        drop(mutator);
        doc.resolve(0.0);

        // The manual mutator deliberately bypasses the HTML/style parser used
        // by loaded documents. Give the fixture explicit post-layout geometry
        // so this unit test isolates event forwarding rather than CSS parsing.
        doc.nodes[html].final_layout_mut().size.height = 300.0;
        doc.nodes[html].final_layout_mut().content_size.height = 600.0;
        doc.nodes[target].final_layout_mut().location.y = 400.0;

        let mut events = Vec::new();
        // A semantic client may target the exposed text rather than its
        // element. Text has no `final_layout`, so this also pins the host-crash
        // regression from revealing a named label.
        doc.scroll_to_node_centered_with_events(target_text, |event| events.push(event));

        assert!(
            (doc.viewport_scroll.y - 270.0).abs() < 0.1,
            "the 40px target should be centred in the 300px viewport"
        );
        assert!(
            events
                .iter()
                .any(|event| { event.target == html && event.name() == "scroll" })
        );
    }
}

#[cfg(test)]
mod font_face_override_tests {
    use super::*;
    use crate::net::{FontFaceOverrides, Resource, ResourceLoadResponse};

    /// Regression-pin for the `@font-face` descriptor-honouring fix.
    ///
    /// The bug was that `Resource::Font` carried only the raw font bytes,
    /// so `load_resource` registered fonts with `info_override = None` and
    /// parley fell back to the TTF's internal `name` table. After the fix,
    /// `Resource::Font` carries `FontFaceOverrides` and `load_resource`
    /// builds a `FontInfoOverride` from them — meaning a CSS-declared
    /// `font-family` alias wins over the file's own metadata.
    ///
    /// We drive `load_resource` directly with a fabricated response rather
    /// than go through HTML parsing → `fetch_font_face`, because the
    /// downstream HTML parser lives in `blitz-html` (would be a circular
    /// crate dependency). The mapping from `@font-face` descriptors into
    /// `FontFaceOverrides` is covered by the unit tests in `net.rs`; this
    /// test pins the load-side of the pipeline.
    #[test]
    fn font_face_overrides_alias_family_name() {
        const ALIAS: &str = "AliasedFamily";

        let mut document = BaseDocument::new(DocumentConfig::default());

        // Sanity: the alias name is not registered before we feed the font.
        {
            let mut ctx = document.font_ctx.lock().unwrap();
            assert!(
                ctx.collection.family_id(ALIAS).is_none(),
                "alias must not exist before registration",
            );
        }

        // Drive `load_resource` with a `Resource::Font` whose overrides
        // assert the CSS-side family name. We use the bullet font as a
        // valid font payload — its internal `name` table is irrelevant to
        // the assertion; what matters is whether the override wins.
        let response = ResourceLoadResponse {
            request_id: 0,
            node_id: None,
            resolved_url: Some(String::from("test://aliased-family")),
            result: Ok(Resource::Font(
                blitz_traits::net::Bytes::from_static(crate::BULLET_FONT),
                FontFaceOverrides {
                    family_name: Some(String::from(ALIAS)),
                    weight: Some(800.0),
                    style: Some(parley::fontique::FontStyle::Italic),
                },
            )),
        };
        document.load_resource(response);

        // The override must have taken effect: parley's `Collection` now
        // resolves the CSS-declared alias to a registered family.
        let mut ctx = document.font_ctx.lock().unwrap();
        let family_id = ctx
            .collection
            .family_id(ALIAS)
            .expect("CSS-declared family name should be registered as a family alias");
        let resolved_name = ctx
            .collection
            .family_name(family_id)
            .expect("family id should resolve back to a name");
        assert_eq!(
            resolved_name, ALIAS,
            "registered family should report the CSS-declared name, \
             not the font file's internal `name` table entry",
        );
    }
}

#[cfg(test)]
mod clipboard_html_tests {
    use super::escape_html;

    /// A selection is document text, so markup characters in it are content.
    /// Unescaped, `a < b` opens a tag in whatever receives the paste.
    #[test]
    fn markup_characters_in_a_selection_are_escaped() {
        assert_eq!(
            escape_html("a < b && c > d"),
            "a &lt; b &amp;&amp; c &gt; d"
        );
    }

    /// The ampersand has to go first, or escaping the others re-escapes the
    /// entities just written and `<` arrives as `&amp;lt;`.
    #[test]
    fn an_ampersand_is_not_double_escaped() {
        assert_eq!(escape_html("&lt;"), "&amp;lt;");
    }

    /// Ordinary prose is left exactly as it is, including the apostrophes and
    /// quotes that a paste should carry through unchanged.
    #[test]
    fn prose_is_untouched() {
        assert_eq!(escape_html("it's \"fine\""), "it's &quot;fine&quot;");
    }
}