blitz_dom/

resolve.rs

//! Resolve style and layout

use blitz_traits::node_id::NodeId;
use std::{
    cell::RefCell,
    collections::HashSet,
    time::{SystemTime, UNIX_EPOCH},
};

use kurbo::{Affine, Rect};
use parley::LayoutContext;
use selectors::Element as _;
use style::dom::TDocument;

#[cfg(feature = "parallel-construct")]
use rayon::prelude::*;

// FIXME: static thread_local FontCtx isn't necessarily correct in multi-document context.
// Should use thread_local crate with ThreadLocal value store in the Document.
thread_local! {
    pub(crate) static LAYOUT_CTX: RefCell<Option<Box<LayoutContext<TextBrush>>>> = const { RefCell::new(None) };
}

use style::properties::ComputedValues;
use style::properties::generated::longhands::position::computed_value::T as Position;
use style::selector_parser::RestyleDamage;
use taffy::AvailableSpace;

use crate::{
    BaseDocument,
    events::ScrollAnimationState,
    layout::{
        construct::{
            ConstructionTask, ConstructionTaskData, ConstructionTaskResult,
            ConstructionTaskResultData, LayoutChildren, build_inline_layout_into,
            collect_layout_children,
        },
        damage::{ALL_DAMAGE, CONSTRUCT_BOX, CONSTRUCT_DESCENDENT, CONSTRUCT_FC},
    },
    node::TextBrush,
};

impl BaseDocument {
    /// Pull every scroll offset back inside the content it scrolls.
    ///
    /// Scrolling clamps against the extent at the time of the gesture, and
    /// nothing re-checked it afterwards. So any layout that made a scroller's
    /// content *shorter* left the offset beyond the new end, and the view
    /// stayed parked in space the content no longer reaches: dismiss a panel
    /// while scrolled to the bottom and its height is simply gone from under
    /// you, leaving a band of nothing between the last content and the edge.
    /// Far enough past the end and there is nothing left to see at all.
    ///
    /// Done after layout, which is the only point at which the new extents are
    /// known, and cheap: offsets are almost always zero.
    fn clamp_scroll_offsets(&mut self) {
        for (_, node) in self.nodes.iter_mut() {
            // The accessor panics on node kinds that have no scroll offset, so
            // ask the data first rather than every node in the tree.
            let Some(offset) = node
                .data
                .downcast_element()
                .map(|element| element.scroll_offset)
            else {
                continue;
            };
            if offset.x == 0.0 && offset.y == 0.0 {
                continue;
            }
            let max_x = f64::from(node.final_layout().scroll_width()).max(0.0);
            let max_y = f64::from(node.final_layout().scroll_height()).max(0.0);
            let clamped = node.scroll_offset_mut();
            clamped.x = offset.x.clamp(0.0, max_x);
            clamped.y = offset.y.clamp(0.0, max_y);
        }
    }

    /// Re-break any inline layout whose lines belong to a pass other than the
    /// one that decided its box.
    ///
    /// Taffy performs layout under min-content and max-content constraints
    /// while sizing a box, and every one of those passes breaks the same parley
    /// layout the screen reads from. Whichever ran last is what gets painted.
    /// That is usually the real layout, and when the final pass is answered
    /// from the taffy cache it is not: `compute_inline_layout` never runs
    /// again, and the trial break stays. Reported as "1st load is fucked" and
    /// measured on a live transcript as paragraphs broken at 164px inside a
    /// 1,426px box, 39 lines of one or two words each.
    ///
    /// Cheap by construction: it compares two floats per inline root and
    /// re-breaks only the ones that disagree, which in a settled document is
    /// none of them.
    /// Returns whether any repair changed a layout's height, which means the
    /// boxes taffy sized are now wrong and layout has to run again.
    fn repair_inline_line_breaks(&mut self) -> bool {
        let scale = self.viewport.scale();

        let mut wrong = Vec::new();
        for (node_id, node) in self.nodes.iter() {
            let Some(inline) = node
                .data
                .downcast_element()
                .and_then(|element| element.inline_layout_data.as_ref())
            else {
                continue;
            };
            // The *unrounded* layout, which is the width the layout pass
            // broke at. `final_layout` is rounded to whole pixels, and half a
            // pixel of rounding-down is enough to wrap a label that exactly
            // fit: "125.1k / 200.0k ctx · 63%" came back on two lines.
            let layout = node.unrounded_layout();
            let content_width = (layout.size.width
                - layout.padding.left
                - layout.padding.right
                - layout.border.left
                - layout.border.right)
                .max(0.0)
                * scale;
            // Half a device pixel: below that the break is identical and
            // re-running it would cost a frame to change nothing.
            if inline
                .laid_out_at
                .is_none_or(|broken_at| (broken_at - content_width).abs() > 0.5)
            {
                wrong.push((node_id, content_width));
            }
        }

        let mut changed_height = false;
        for (node_id, content_width) in wrong {
            // Breaking discards the alignment the layout pass applied, so it
            // has to go back on: without it every centred or right-aligned
            // paragraph this touches would silently come back left-aligned.
            let alignment = self.nodes[node_id]
                .primary_styles()
                .map(|style| {
                    use parley::layout::Alignment;
                    use style::values::specified::TextAlignKeyword;
                    match style.clone_text_align() {
                        TextAlignKeyword::Start => Alignment::Start,
                        TextAlignKeyword::Left | TextAlignKeyword::MozLeft => Alignment::Left,
                        TextAlignKeyword::Right | TextAlignKeyword::MozRight => Alignment::Right,
                        TextAlignKeyword::Center | TextAlignKeyword::MozCenter => Alignment::Center,
                        TextAlignKeyword::Justify => Alignment::Justify,
                        TextAlignKeyword::End => Alignment::End,
                    }
                })
                .unwrap_or(parley::layout::Alignment::Start);

            let Some(inline) = self.nodes[node_id]
                .data
                .downcast_element_mut()
                .and_then(|element| element.inline_layout_data.as_mut())
            else {
                continue;
            };
            inline.layout.break_all_lines(Some(content_width));
            inline.layout.align(
                alignment,
                parley::layout::AlignmentOptions {
                    align_when_overflowing: false,
                },
            );
            inline.laid_out_at = Some(content_width);

            // Any repair at all invalidates the boxes around it, not just one
            // whose parley height moved. The box was sized by a pass that broke
            // these lines differently, and its height was accumulated into
            // every ancestor's content size on the way up. Comparing parley
            // heights before and after missed that: the layout being repaired
            // is not the one the box was sized from, so it can come out the
            // same height while the box is still wrong. Measured live as a
            // transcript whose content ran 1,062px past the extent it reported,
            // so it could not scroll to its own last message.
            changed_height = true;
            self.nodes[node_id].insert_damage(RestyleDamage::RELAYOUT);
        }

        changed_height
    }

    /// Restyle the tree and then relayout it
    pub fn resolve(&mut self, current_time_for_animations: f64) {
        if current_time_for_animations.is_finite() {
            self.last_resolve_animation_time = self
                .last_resolve_animation_time
                .max(current_time_for_animations);
        }
        let current_time_for_animations = self.last_resolve_animation_time;

        if TDocument::as_node(&self.root_node())
            .first_element_child()
            .is_none()
        {
            #[cfg(feature = "tracing")]
            tracing::warn!("No DOM - not resolving");
            return;
        }

        // Process messages that have been sent to our message channel (e.g. loaded resource)
        self.handle_messages();

        self.resolve_scroll_animation();

        // Retain completed activity entries so an initially visible scrollbar
        // stays faded after its first interaction. Only removed nodes need to
        // shed their entry.
        let nodes = &self.nodes;
        self.scrollbar_activity
            .retain(|node_id, _| nodes.contains_key(*node_id));

        let root_node_id = self.root_element().id;
        #[cfg(feature = "log-phase-times")]
        let mut timer =
            debug_timer::RealDebugTimer::init_if(blitz_traits::profiling::deep_profiling_enabled());
        #[cfg(not(feature = "log-phase-times"))]
        let mut timer = debug_timer::DummyDebugTimer::init();
        #[cfg(feature = "log-phase-times")]
        crate::layout::layout_counters::begin(blitz_traits::profiling::deep_profiling_enabled());

        // Compute the shadow DOM flattened tree (shadow-root composition and
        // <slot> distribution). This must happen *before* style resolution so
        // that Stylo traverses the composed (flattened) tree and styles shadow
        // content, and before box construction consumes it.
        #[cfg(feature = "shadow-dom")]
        {
            self.compute_flattened_trees();
            timer.record_time("shadow");
        }

        // we need to resolve stylist first since it will need to drive our layout bits
        self.resolve_stylist(current_time_for_animations);
        timer.record_time("style");

        self.paint_damage.begin_resolve();

        // Propagate damage flags (from mutation and restyles) up and down the tree
        if self.incremental_layout {
            self.propagate_damage_flags(root_node_id, RestyleDamage::empty());
            timer.record_time("damage");
        }
        // Anything after this point sees propagated damage, in which every
        // ancestor up to the root is marked. Recording repaints from there
        // would describe every frame as a full-frame repaint.
        self.paint_damage.end_propagation();

        // Fix up tree for layout (insert anonymous blocks as necessary, etc)
        self.resolve_layout_children();
        timer.record_time("construct");

        self.resolve_deferred_tasks();
        timer.record_time("pconstruct");

        self.hoist_fixed_position_nodes();
        timer.record_time("hoist");

        // Merge stylo into taffy
        self.flush_styles_to_layout(root_node_id);
        timer.record_time("flush");

        // Next we resolve layout with the data resolved by stlist
        //
        // Caught, under `BLITZ_TRACE_LAYOUT_PANIC=1` only, so the markup that
        // killed layout can be printed before the process goes. The panic hook
        // that names the element runs without the document and can only give an
        // id and a class list; the id is worthless once the process is gone,
        // and a class list is not markup you can put in a test. This is the one
        // place that still holds `&mut self` when layout fails, so it is the
        // only place the subtree can be serialized. The panic is resumed
        // immediately: nothing here makes a failed layout survivable.
        #[cfg(not(target_arch = "wasm32"))]
        if crate::layout::layout_panic_probe::enabled() {
            let attempt =
                std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| self.resolve_layout()));
            if let Err(payload) = attempt {
                if let Some(node_id) = crate::layout::layout_panic_probe::innermost_node() {
                    if let Some(node) = self.nodes.get(node_id) {
                        eprintln!(
                            "[blitz-layout-panic] markup of node {node_id}:\n{}",
                            node.outer_html_pretty()
                        );
                    }
                }
                std::panic::resume_unwind(payload);
            }
        } else {
            self.resolve_layout();
        }
        #[cfg(target_arch = "wasm32")]
        self.resolve_layout();
        self.resolve_sticky_positions();
        self.resolve_fixed_positions();
        self.resolve_hoisted_positions();
        self.correct_hoisted_fixed_positions();
        self.resolve_hoisted_clips();
        timer.record_time("layout");

        // One extra pass, only when a repair moved a box. Bounded deliberately:
        // the second layout runs against lines that already agree with their
        // widths, so a third could not find anything new, and an unbounded loop
        // here would be a hang rather than a slow frame.
        if self.repair_inline_line_breaks() {
            // Damage first. The repair marks the nodes it touched, but a box's
            // height is accumulated into every ancestor's content size on the
            // way up, and those ancestors answer from the taffy cache until
            // damage propagation clears it. Without this the second pass runs
            // and changes nothing: measured live as a scroller still reporting
            // an extent 1,062px short of its own content.
            if self.incremental_layout {
                self.propagate_damage_flags(root_node_id, RestyleDamage::empty());
            }
            self.flush_styles_to_layout(root_node_id);
            self.resolve_layout();
            self.resolve_sticky_positions();
            self.resolve_fixed_positions();
            self.resolve_hoisted_positions();
            self.correct_hoisted_fixed_positions();
            self.resolve_hoisted_clips();
            self.repair_inline_line_breaks();
            self.resolve_transforms(root_node_id);
        }

        self.clamp_scroll_offsets();
        self.resolve_hoisted_positions();
        self.correct_hoisted_fixed_positions();
        self.resolve_hoisted_clips();
        self.trace_escaped_inline_fragments();

        // Resolve transforms
        self.resolve_transforms(root_node_id);
        timer.record_time("transform");

        // Boxes are final here, which is what the geometry half compares. It
        // runs before the clearing loop below only because both walk the node
        // list and doing them together saves nothing: this one needs `&nodes`
        // while that one needs `&mut`.
        if self.paint_damage.is_enabled() {
            let mut tracker = std::mem::take(&mut self.paint_damage);
            tracker.capture(&self.nodes);
            self.paint_damage = tracker;
            timer.record_time("paint_damage");
        }

        // Clear all damage and dirty flags
        if self.incremental_layout {
            for (_, node) in self.nodes.iter_mut() {
                node.clear_damage_mut();
                node.unset_dirty_descendants();
            }
            timer.record_time("c_damage");
        }

        // Re-resolve the hover node from the pointer position against the fresh
        // layout. This must run *after* the damage/dirty flags are cleared
        // above, so that the restyle hint and ancestor `dirty_descendants`
        // flags set by any resulting hover change survive into the next resolve
        // pass (the clearing loop would otherwise wipe them). Any resulting
        // restyle is picked up on the next resolve pass; a redraw is requested
        // if the hovered node actually changes.
        self.refresh_hover();

        let mut subdoc_animation_pacing = crate::document::AnimationPacing::Idle;
        for &node_id in &self.sub_document_nodes {
            let node = &mut self.nodes[node_id];
            let size = node.final_layout().size;
            if let Some(mut sub_doc) = node.subdoc_mut().map(|doc| doc.inner_mut()) {
                // Set viewport
                // viewport_mut handles change detection. So we just unconditionally set the values;
                let mut sub_viewport = sub_doc.viewport_mut();
                sub_viewport.hidpi_scale = self.viewport.hidpi_scale;
                sub_viewport.zoom = self.viewport.zoom;
                sub_viewport.color_scheme = self.viewport.color_scheme;

                let viewport_scale = self.viewport.scale();
                sub_viewport.window_size = (
                    (size.width * viewport_scale) as u32,
                    (size.height * viewport_scale) as u32,
                );
                drop(sub_viewport);

                sub_doc.resolve(current_time_for_animations);

                subdoc_animation_pacing = subdoc_animation_pacing.max(sub_doc.animation_pacing());
            }
        }
        self.subdoc_animation_pacing = subdoc_animation_pacing;
        timer.record_time("subdocs");

        // Printed with the phases so a single line says both how long layout
        // took and how much of the tree it touched. Without the counts the
        // timings cannot distinguish a few slow nodes from a cache miss across
        // the document, and those need opposite fixes.
        #[cfg(feature = "log-phase-times")]
        {
            // The offenders are read, and the message built, only when a sink
            // is configured: the counters are cheap to keep and expensive to
            // describe, and this feature now travels with a shipped binary.
            // Draining, though, is unconditional — `layout_counters::last()` is
            // what the benchmarks read, and counts that are never taken keep
            // accumulating across resolves.
            let describe = timer.is_logging();
            if describe {
                // Named before the counters are drained, and only when the pass
                // was expensive enough to be worth looking at.
                let offenders = crate::layout::layout_counters::worst_offenders(6);
                if offenders.first().is_some_and(|(_, count)| *count > 8) {
                    let described: Vec<String> = offenders
                        .iter()
                        .map(|(id, count)| {
                            let tag = self
                                .nodes
                                .get(*id)
                                .and_then(|node| node.element_data())
                                .map(|element| element.name.local.to_string())
                                .unwrap_or_else(|| "?".to_string());
                            let display = self
                                .nodes
                                .get(*id)
                                .map(|node| format!("{:?}", node.style().display))
                                .unwrap_or_default();
                            format!("{id:?}:{tag}({display})x{count}")
                        })
                        .collect();
                    debug_timer::log_line(&format!("  layout hotspots: {}\n", described.join(" ")));
                }
            }
            let counts = crate::layout::layout_counters::take();
            if describe {
                let total_nodes = self.nodes.len();
                let hit_rate = if counts.lookups > 0 {
                    (counts.hits as f64 / counts.lookups as f64) * 100.0
                } else {
                    0.0
                };
                timer.print_times(&format!(
                    "Resolve({}) [computed {} over {} distinct of {total_nodes} nodes, \
                     cache {}/{} hits {hit_rate:.0}%, {} cleared]: ",
                    self.id(),
                    counts.computed,
                    counts.distinct,
                    counts.hits,
                    counts.lookups,
                    counts.caches_cleared,
                ));
            }
        }
        #[cfg(not(feature = "log-phase-times"))]
        timer.print_times(&format!("Resolve({}): ", self.id()));
    }

    fn resolve_transforms(&mut self, node_id: NodeId) -> Rect {
        if !self.nodes.contains_key(node_id) {
            return Rect::ZERO;
        }

        if !self.nodes[node_id]
            .damage()
            .map(|d| d.contains(style::selector_parser::RestyleDamage::RECALCULATE_OVERFLOW))
            .unwrap_or(false)
        {
            return *self.nodes[node_id].scrollable_overflow();
        }

        let scale = self.viewport.scale_f64();

        let transform = self.nodes[node_id].set_transform(scale as f32);

        let w = self.nodes[node_id].final_layout().size.width as f64 * scale;
        let h = self.nodes[node_id].final_layout().size.height as f64 * scale;
        let mut overflow = Rect::new(0.0, 0.0, w, h);

        let layout_children = std::mem::take(self.nodes[node_id].layout_children.get_mut());

        if let Some(ref children) = layout_children {
            for &child_id in children {
                let child_rect_in_self = self.resolve_transforms(child_id);
                overflow = overflow.union(child_rect_in_self);
            }
        }
        if let Some(before) = self.nodes[node_id].before() {
            let child_rect_in_self = self.resolve_transforms(before);
            overflow = overflow.union(child_rect_in_self);
        }
        if let Some(after) = self.nodes[node_id].after() {
            let child_rect_in_self = self.resolve_transforms(after);
            overflow = overflow.union(child_rect_in_self);
        }

        // Text overflows too, and only layout *children* were counted above.
        //
        // Glyph runs are not nodes, so a `white-space: nowrap` line wider than
        // its box left `scrollable_overflow` exactly equal to that box. Paint
        // skips its clip layer when the overflow rect fits the border box —
        // most `overflow-hidden` wrappers really do clip nothing, and a layer
        // is the most expensive thing in a frame — so the one case that needed
        // the clip was the one case that reported it was unnecessary. A
        // truncated tab title painted straight through the close button beside
        // it, a branch name through the chip after it, and a transcript line
        // under the cost readout: measured here as a 150px box painting its
        // text out to x=354.
        if let Some(inline_layout) = self.nodes[node_id]
            .data
            .downcast_element()
            .and_then(|element| element.inline_layout_data.as_ref())
        {
            // Already device pixels: parley is handed the scaled size, so
            // scaling again doubled every inline root's overflow at 2x and
            // inflated its hit area with it.
            let text_width = inline_layout.layout.width() as f64;
            let text_height = inline_layout.layout.height() as f64;
            overflow = overflow.union(Rect::new(0.0, 0.0, text_width, text_height));
        }

        *self.nodes[node_id].scrollable_overflow_mut() = overflow;
        *self.nodes[node_id].layout_children.get_mut() = layout_children;

        let scaled_x = self.nodes[node_id].final_layout().location.x as f64 * scale;
        let scaled_y = self.nodes[node_id].final_layout().location.y as f64 * scale;

        let full = if let Some(t) = transform {
            Affine::translate((scaled_x, scaled_y)) * t
        } else {
            Affine::translate((scaled_x, scaled_y))
        };

        full.transform_rect_bbox(overflow)
    }

    pub fn resolve_scroll_animation(&mut self) {
        match &mut self.scroll_animation {
            ScrollAnimationState::Fling(fling_state) => {
                let time_ms = SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .unwrap()
                    .as_millis() as u64 as f64;

                let time_diff_ms = time_ms - fling_state.last_seen_time;

                // 0.95 @ 60fps normalized to actual frame times
                let deceleration = 1.0 - ((0.05 / 16.66666) * time_diff_ms);

                fling_state.x_velocity *= deceleration;
                fling_state.y_velocity *= deceleration;
                fling_state.last_seen_time = time_ms;
                let fling_state = fling_state.clone();

                let dx = fling_state.x_velocity * time_diff_ms;
                let dy = fling_state.y_velocity * time_diff_ms;

                self.scroll_by(Some(fling_state.target), dx, dy, &mut |_| {});
                if fling_state.x_velocity.abs() < 0.1 && fling_state.y_velocity.abs() < 0.1 {
                    self.scroll_animation = ScrollAnimationState::None;
                }
            }
            ScrollAnimationState::None => {
                // Do nothing
            }
        }
    }

    /// Restore authored fixed-node slots before reconstructing the box tree.
    ///
    /// Hoisting removes these children from their original parents and appends
    /// them to the root. Rebuilding the root while retaining an original
    /// parent's cache would otherwise discard the only remaining tree edge.
    /// The next hoisting walk could not find the node, even though its DOM,
    /// styles and previously computed geometry were still present.
    fn restore_fixed_children_for_construction(&mut self) {
        if self.hoisted_fixed_parents.is_empty() {
            return;
        }

        let root_id = self.root_element().id;
        let mut restored: Vec<_> = self
            .hoisted_fixed_parents
            .iter()
            .filter_map(|(&node_id, &parent_id)| {
                let node = self.nodes.get(node_id)?;
                if !node.flags.is_in_document()
                    || node.layout_parent.get() != Some(root_id)
                    || !self.nodes.contains_key(parent_id)
                {
                    return None;
                }
                let index = self.hoisted_fixed_indices.get(&node_id).copied()?;
                Some((node_id, parent_id, index))
            })
            .collect();
        restored.sort_by_key(|entry| entry.2);

        // Remove obsolete root edges as well as the live edges restored below.
        if let Some(children) = self.nodes[root_id].layout_children.get_mut().as_mut() {
            children.retain(|id| !self.hoisted_fixed_parents.contains_key(id));
        }
        self.hoisted_fixed_parents.clear();
        self.hoisted_fixed_indices.clear();

        for (node_id, parent_id, index) in restored {
            if let Some(children) = self.nodes[parent_id].layout_children.get_mut().as_mut() {
                children.retain(|id| *id != node_id);
                children.insert(index.min(children.len()), node_id);
            }
            // A missing parent cache must be reconstructed from current DOM,
            // rather than replaced with a partial list of old fixed children.
            self.nodes[node_id].layout_parent.set(Some(parent_id));
        }

        // This changes only the representation used during construction.
        // Hoisting runs again before style flushing and layout, so an unchanged
        // tree retains its layout caches. The hypothetical-position pass has a
        // separate restore/finish pair that invalidates its layout inputs.
    }

    /// Ensure that the layout_children field is populated for all nodes
    pub fn resolve_layout_children(&mut self) {
        self.restore_fixed_children_for_construction();
        resolve_layout_children_recursive(self, self.root_node().id);

        fn resolve_layout_children_recursive(doc: &mut BaseDocument, node_id: NodeId) {
            // Anonymous blocks and pseudo-elements can be removed from the slab
            // between render passes. Bail out rather than panicking on a stale key.
            if doc.nodes.get(node_id).is_none() {
                return;
            }

            let mut damage = doc.nodes[node_id].damage().unwrap_or(ALL_DAMAGE);
            let _flags = doc.nodes[node_id].flags;

            // A hidden subtree keeps the boxes it already has.
            //
            // `display: none` means "do not lay this out", not "forget what you
            // know about it". Collecting layout children for a hidden container
            // yields an empty list, so hiding a pane used to discard every box
            // and every shaped inline layout beneath it, and revealing it built
            // all of them again from the DOM. In an application that retains
            // its tabs and toggles them by class, that is the entire cost of a
            // tab switch, paid again on every switch: measured on six retained
            // panes of a real project tab, a *re-reveal* cost exactly what the
            // first reveal cost, 46,526 layout computations either way.
            //
            // Damage is deliberately left in place rather than cleared. Content
            // that changes while hidden still carries its damage to the reveal,
            // where the normal path reconstructs precisely what changed.
            if doc.incremental_layout
                && doc.nodes[node_id].is_display_none()
                && doc.nodes[node_id].layout_children.borrow().is_some()
            {
                return;
            }

            // A node that has never been constructed has no boxes to keep, and
            // no damage either once its styles survive being hidden: a pane
            // that was hidden before it was ever shown reaches its reveal with
            // valid styles, nothing marked dirty, and nothing to lay out. It
            // used to be rescued by stylo discarding those styles. Ask the
            // boxes instead of the damage.
            let never_constructed = doc.nodes[node_id].layout_children.borrow().is_none();

            if !doc.incremental_layout
                || never_constructed
                || damage.intersects(CONSTRUCT_FC | CONSTRUCT_BOX)
            {
                //} || flags.contains(NodeFlags::IS_INLINE_ROOT) {

                // Deallocate the anonymous blocks created for this node in the
                // previous construction round. They live only in the slab, so
                // reconstructing without freeing them would leak a slab entry per
                // anonymous block per reconstruction.
                let old_anonymous_blocks = std::mem::take(&mut doc.nodes[node_id].anonymous_blocks);
                for anon_id in old_anonymous_blocks {
                    doc.deallocate_anonymous_block(anon_id);
                }

                let mut collected = LayoutChildren::default();
                collect_layout_children(doc, node_id, &mut collected);
                let layout_children = collected.children;
                doc.nodes[node_id].anonymous_blocks = collected.anonymous_blocks;

                // Recurse into newly collected layout children
                for child_id in layout_children.iter().copied() {
                    resolve_layout_children_recursive(doc, child_id);
                    doc.nodes[child_id].layout_parent.set(Some(node_id));
                    if let Some(mut data) = doc.nodes[child_id]
                        .stylo_element_data_opt_mut()
                        .and_then(|s| s.get_mut())
                    {
                        data.damage
                            .remove(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
                    }
                }

                *doc.nodes[node_id].layout_children.borrow_mut() = Some(layout_children.clone());
                // *doc.nodes[node_id].paint_children.borrow_mut() = Some(layout_children);

                damage.remove(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
                // damage.insert(RestyleDamage::RELAYOUT | RestyleDamage::REPAINT);
            } else {
                //if damage.contains(CONSTRUCT_DESCENDENT) {
                let layout_children = doc.nodes[node_id].layout_children.borrow_mut().take();
                if let Some(layout_children) = layout_children {
                    for child_id in layout_children.iter().copied() {
                        // Anonymous blocks and pseudo-elements can be removed from the
                        // slab between render passes; skip stale IDs.
                        if !doc.nodes.contains_key(child_id) {
                            continue;
                        }
                        resolve_layout_children_recursive(doc, child_id);
                        doc.nodes[child_id].layout_parent.set(Some(node_id));
                    }

                    *doc.nodes[node_id].layout_children.borrow_mut() = Some(layout_children);
                }

                // damage.remove(CONSTRUCT_DESCENDENT);
                // damage.insert(RestyleDamage::RELAYOUT | RestyleDamage::REPAINT);
            }

            doc.nodes[node_id].set_damage(damage);
        }
    }

    /// Reparent `position: fixed` nodes onto the root element for layout.
    ///
    /// Taffy has no `Fixed` position, so `stylo_taffy` maps it to `Absolute`. An
    /// absolutely positioned node resolves its insets against its containing
    /// block, which for a fixed node must be the viewport. Laid out in place it
    /// would instead resolve against the nearest positioned ancestor, so both its
    /// offset and — when opposite insets are set — its size come out wrong.
    ///
    /// Reparenting them onto the root element takes the positioned ancestor out
    /// of the picture. This runs after `resolve_layout_children` and before
    /// `flush_styles_to_layout`, which derives `paint_children` from
    /// `layout_children`, so painting and hit testing follow the hoist without
    /// further work.
    ///
    /// The containing-block pass uses viewport dimensions independently of
    /// the root element's content height. It temporarily restores authored
    /// child slots to obtain static positions before returning these boxes
    /// to the root for painting and viewport scrolling.
    ///
    /// A transformed ancestor becomes the containing block for its fixed
    /// descendants, so those are left where they are.
    ///
    /// <https://drafts.csswg.org/css-position/#fixed-pos>
    /// <https://drafts.csswg.org/css-transforms-1/#propdef-transform>
    ///
    /// The same walk collects `position: sticky` nodes into
    /// [`Self::sticky_nodes`]. Nothing about the two is related, but both need
    /// one pre-order pass over the box tree, and a second walk would be paid on
    /// every frame of every document whether or not it has a sticky box in it.
    pub fn hoist_fixed_position_nodes(&mut self) {
        let root_id = self.root_element().id;

        let mut hoisted: Vec<NodeId> = Vec::new();
        let mut sticky: Vec<NodeId> = Vec::new();
        let root_transformed = self.nodes[root_id]
            .primary_styles()
            .is_some_and(|styles| establishes_containing_block(&styles));
        let mut escaped = if self.abspos_candidates_dirty || !self.incremental_layout {
            Some(Vec::new())
        } else {
            None
        };
        collect_fixed(
            self,
            root_id,
            root_transformed,
            &mut hoisted,
            &mut sticky,
            &mut escaped,
        );
        if let Some(candidates) = escaped {
            self.abspos_candidate_ids = candidates
                .iter()
                .map(|candidate| candidate.node_id)
                .collect();
            let ids = &self.abspos_candidate_ids;
            self.abspos_inputs.retain(|id, _| ids.contains(id));
            self.abspos_written.retain(|id| ids.contains(id));
            self.abspos_candidates = candidates;
            self.abspos_candidates_dirty = false;
            self.abspos_layout_dirty = true;
        }
        self.sticky_nodes = sticky;
        self.fixed_nodes = hoisted.clone();

        // Drop nodes that are no longer fixed, and keep the rest.
        //
        // This used to `clear()` and rebuild, which worked exactly once. The
        // loop below reads `layout_parent` to learn where a node came from, but
        // the hoist itself sets that to the root, so on the second pass every
        // already-hoisted node takes the `parent_id == root_id` branch and is
        // never re-recorded. Combined with the clear, the map came back empty
        // and `flush_styles_to_layout` put the layer in the root's stacking
        // context instead of the one its box tree gives it.
        //
        // The symptom was a full-bleed background that painted correctly on the
        // first frame and disappeared on the next relayout, which on a real
        // page means as soon as an image finishes loading.
        let still_fixed: HashSet<NodeId> = hoisted.iter().copied().collect();
        self.hoisted_fixed_parents
            .retain(|node_id, _| still_fixed.contains(node_id));
        self.hoisted_fixed_indices
            .retain(|node_id, _| still_fixed.contains(node_id));

        for node_id in hoisted {
            let Some(parent_id) = self.nodes[node_id].layout_parent.get() else {
                continue;
            };
            if parent_id == root_id {
                continue;
            }

            // Remember where it came from. The hoist decides the containing
            // block; the box tree still decides the stacking context, and
            // `flush_styles_to_layout` reads this to keep them apart.
            self.hoisted_fixed_parents.insert(node_id, parent_id);

            if let Some(children) = self.nodes[parent_id].layout_children.borrow_mut().as_mut() {
                if let Some(index) = children.iter().position(|id| *id == node_id) {
                    self.hoisted_fixed_indices.insert(node_id, index);
                }
                children.retain(|id| *id != node_id);
            }
            if let Some(children) = self.nodes[root_id].layout_children.borrow_mut().as_mut() {
                children.push(node_id);
            }
            self.nodes[node_id].layout_parent.set(Some(root_id));
        }

        fn collect_fixed(
            doc: &BaseDocument,
            node_id: NodeId,
            under_transform: bool,
            out: &mut Vec<NodeId>,
            sticky: &mut Vec<NodeId>,
            escaped: &mut Option<Vec<crate::layout::abspos::AbsposCandidate>>,
        ) {
            let children = doc.nodes[node_id].layout_children.borrow().clone();
            let Some(children) = children else {
                return;
            };

            for child_id in children {
                let Some(child) = doc.nodes.get(child_id) else {
                    continue;
                };
                let Some(styles) = child.primary_styles() else {
                    continue;
                };

                // A hidden subtree generates no boxes, so nothing in it may be
                // hoisted. This walk had no display check because it could not
                // reach a hidden subtree: hiding a pane emptied its layout
                // children and stylo discarded its styles, so the recursion
                // stopped and `primary_styles` returned None. Now that a hidden
                // pane keeps both, every `position: fixed` element in every
                // background tab was hoisted onto the root and painted over the
                // tab in front, one ghost per retained tab.
                if styles.clone_display().is_none() {
                    continue;
                }

                let position = styles.clone_position();
                match position {
                    Position::Fixed if !under_transform => out.push(child_id),
                    Position::Sticky => sticky.push(child_id),
                    _ => {}
                }

                if let Some(escaped) = escaped.as_mut() {
                    if position.is_absolutely_positioned() {
                        let cb = doc.abspos_containing_block(child_id, position == Position::Fixed);
                        if cb != child.layout_parent.get() {
                            escaped.push(crate::layout::abspos::AbsposCandidate {
                                node_id: child_id,
                                containing_block: cb,
                            });
                        }
                    }
                }

                collect_fixed(
                    doc,
                    child_id,
                    under_transform || establishes_containing_block(&styles),
                    out,
                    sticky,
                    escaped,
                );
            }
        }

        /// Whether a node becomes the containing block for fixed descendants.
        ///
        /// TODO: `filter`, `backdrop-filter`, `will-change`, `contain` and
        /// `perspective` also do this.
        fn establishes_containing_block(styles: &ComputedValues) -> bool {
            crate::layout::abspos::establishes_transform_containing_block(styles)
        }
    }

    /// Hold every viewport-anchored `position: fixed` box still while the page
    /// scrolls under it.
    ///
    /// Paint translates the whole tree by the negated viewport scroll, and a
    /// hoisted fixed layer is in that tree like everything else, so a fixed box
    /// held its document position and left the screen exactly like flow
    /// content: an overlay authored `top: 0` painted at screen y=-800 on a page
    /// scrolled 800px down. Its document position has to track the scroll for
    /// its screen position to hold still, which is the whole of the correction.
    ///
    /// Boxes under a transformed ancestor are left alone: that ancestor is
    /// their containing block, so they are not viewport-anchored at all and
    /// `hoist_fixed_position_nodes` does not collect them.
    ///
    /// Sizing and insets are resolved against the viewport by the
    /// containing-block layout pass. This method applies scrolling only.
    pub(crate) fn resolve_fixed_positions(&mut self) {
        let scroll = self.viewport_scroll;
        if scroll == self.fixed_scroll_offset {
            return;
        }
        let delta_x = (scroll.x - self.fixed_scroll_offset.x) as f32;
        let delta_y = (scroll.y - self.fixed_scroll_offset.y) as f32;

        for &node_id in self.fixed_nodes.iter() {
            let Some(node) = self.nodes.get_mut(node_id) else {
                continue;
            };
            let location = &mut node.final_layout_mut().location;
            location.x += delta_x;
            location.y += delta_y;
        }
        self.fixed_scroll_offset = scroll;
    }

    /// Hold every `position: sticky` box against the edge of its scrollport.
    ///
    /// A sticky box lays out in flow, reserving its space there, and is then
    /// displaced so that it stays between its own flow position and the far
    /// edge of its containing block. `stylo_taffy` maps `Position::Sticky` onto
    /// `taffy::Position::Relative`, which gets the first half right and does
    /// nothing at all about the second, so every sticky navbar and document
    /// sidebar on the fleet simply scrolled away, on documents 5,000 to
    /// 16,700px tall.
    ///
    /// The displacement is written straight into the box's
    /// `final_layout().location` rather than kept beside it. Paint, hit testing
    /// and `absolute_position` all read that one field, so writing it is what
    /// makes them agree; a parallel offset would have to be threaded through
    /// each of them and would disagree the moment one was missed. The cost is
    /// that this pass has to be able to recover the flow position it started
    /// from, which is what [`Self::sticky_offsets`] records.
    ///
    /// Runs after layout, which is the only point at which the boxes it reads
    /// exist, and again after a scroll, because a wheel event does not
    /// necessarily produce a style and layout pass.
    ///
    /// <https://drafts.csswg.org/css-position/#stickypos-insets>
    pub(crate) fn resolve_sticky_positions(&mut self) {
        if self.sticky_nodes.is_empty() && self.sticky_offsets.is_empty() {
            return;
        }

        // Put every box back at its flow position first. Recomputing from an
        // already-displaced box would compound the offset, walking a header
        // down the page one scroll at a time, and a node that stopped being
        // sticky since the last pass is not in `sticky_nodes` to be corrected
        // any other way.
        for (&node_id, offset) in self.sticky_offsets.iter() {
            let Some(node) = self.nodes.get_mut(node_id) else {
                continue;
            };
            let location = &mut node.final_layout_mut().location;
            location.x -= offset.x;
            location.y -= offset.y;
        }
        self.sticky_offsets.clear();

        let nodes = std::mem::take(&mut self.sticky_nodes);
        for &node_id in nodes.iter() {
            let Some(offset) = self.sticky_offset_of(node_id) else {
                continue;
            };
            if offset.x == 0.0 && offset.y == 0.0 {
                continue;
            }
            let location = &mut self.nodes[node_id].final_layout_mut().location;
            location.x += offset.x;
            location.y += offset.y;
            self.sticky_offsets.insert(node_id, offset);
        }
        self.sticky_nodes = nodes;
    }

    /// The displacement `node_id` needs to stay inside its sticky view
    /// rectangle, given the boxes and scroll offsets as they stand.
    ///
    /// Every coordinate here is a painted document coordinate:
    /// `absolute_position` has already applied each ancestor scroll offset, so
    /// a box and the scrollport it is measured against are directly comparable.
    /// The one scroll offset it does not apply is the viewport's, which paint
    /// subtracts from the whole document, so a box that holds still on screen
    /// is one whose document coordinate tracks the viewport scroll.
    fn sticky_offset_of(&self, node_id: NodeId) -> Option<taffy::Point<f32>> {
        let node = self.nodes.get(node_id)?;
        let styles = node.primary_styles()?;
        if styles.clone_position() != Position::Sticky {
            return None;
        }

        let size = node.final_layout().size;
        let base = node.absolute_position(0.0, 0.0);

        // The sticky view rectangle: the padding box of the nearest scroll
        // container, or the viewport when there is none above it.
        let (port_x, port_y, port_width, port_height) = match self.nearest_scrollport(node_id) {
            Some(scroller_id) => {
                let scroller = &self.nodes[scroller_id];
                let layout = *scroller.final_layout();
                let origin = scroller.absolute_position(0.0, 0.0);
                (
                    origin.x + layout.border.left,
                    origin.y + layout.border.top,
                    layout.size.width - layout.border.left - layout.border.right,
                    layout.size.height - layout.border.top - layout.border.bottom,
                )
            }
            None => {
                let scale = self.viewport.scale();
                (
                    self.viewport_scroll.x as f32,
                    self.viewport_scroll.y as f32,
                    self.viewport.window_size.0 as f32 / scale,
                    self.viewport.window_size.1 as f32 / scale,
                )
            }
        };

        let insets = styles.get_position();
        // Percentages resolve against the sticky view rectangle, which is the
        // rectangle the inset is measured inside.
        let inset = |value: &style::values::computed::Inset, basis: f32| {
            use style::values::generics::position::GenericInset as Inset;
            match value {
                Inset::LengthPercentage(value) => Some(
                    value
                        .resolve(style::values::computed::Length::new(basis))
                        .px(),
                ),
                _ => None,
            }
        };

        // Where the box may travel: its containing block, which is its layout
        // parent's padding box, taken in the same painted coordinates. The
        // parent's own scroll offset is subtracted because the region scrolls
        // with the content, and the extent is widened to the scrollable content
        // so that a sticky box whose parent *is* the scroller stays held for
        // the whole scroll rather than only across one scrollport.
        let parent = node
            .layout_parent
            .get()
            .and_then(|parent_id| self.nodes.get(parent_id))?;
        let (block_x, block_y, block_width, block_height) = {
            let layout = *parent.final_layout();
            let origin = parent.absolute_position(0.0, 0.0);
            let scroll = *parent.scroll_offset();
            (
                origin.x + layout.border.left - scroll.x as f32,
                origin.y + layout.border.top - scroll.y as f32,
                (layout.size.width - layout.border.left - layout.border.right)
                    .max(layout.content_size.width),
                (layout.size.height - layout.border.top - layout.border.bottom)
                    .max(layout.content_size.height),
            )
        };

        let axis = |start: Option<f32>,
                    end: Option<f32>,
                    base: f32,
                    extent: f32,
                    port_start: f32,
                    port_extent: f32,
                    block_start: f32,
                    block_extent: f32| {
            // `start` (top/left) pushes the box away from the near edge of the
            // scrollport; `end` (bottom/right) pulls it back from the far one.
            // A box can satisfy both at once when it is smaller than the
            // rectangle between them; when it cannot, the near edge wins, so
            // that constraint is applied second.
            let mut offset = 0.0f32;
            if let Some(end) = end {
                offset = (port_start + port_extent - end - extent - base).min(0.0);
            }
            if let Some(start) = start {
                let shift = (port_start + start - base).max(0.0);
                if shift > 0.0 {
                    offset = shift;
                }
            }

            // Stickiness ends where the containing block does: a box pinned for
            // ever would escape its own section and float over the next one.
            let furthest = (block_start + block_extent - extent - base).max(0.0);
            let nearest = (block_start - base).min(0.0);
            offset.clamp(nearest, furthest)
        };

        Some(taffy::Point {
            x: axis(
                inset(&insets.left, port_width),
                inset(&insets.right, port_width),
                base.x,
                size.width,
                port_x,
                port_width,
                block_x,
                block_width,
            ),
            y: axis(
                inset(&insets.top, port_height),
                inset(&insets.bottom, port_height),
                base.y,
                size.height,
                port_y,
                port_height,
                block_y,
                block_height,
            ),
        })
    }

    /// The nearest ancestor of `node_id` that scrolls its content, or `None`
    /// when nothing between it and the root does and the viewport is the
    /// scrollport.
    ///
    /// The root element is excluded deliberately: per the CSS overflow
    /// propagation rules its overflow belongs to the viewport, which is also
    /// why `scroll_node_by_has_changed` forwards a scroll that reaches it.
    fn nearest_scrollport(&self, node_id: NodeId) -> Option<NodeId> {
        use style::computed_values::overflow_x::T as Overflow;

        let root_id = self.try_root_element()?.id;
        let mut current = self.nodes.get(node_id)?.layout_parent.get();
        while let Some(id) = current {
            if id == root_id {
                return None;
            }
            let ancestor = self.nodes.get(id)?;
            if let Some(styles) = ancestor.primary_styles() {
                let scrolls = |overflow| {
                    matches!(
                        overflow,
                        Overflow::Scroll | Overflow::Auto | Overflow::Hidden
                    )
                };
                if scrolls(styles.clone_overflow_x()) || scrolls(styles.clone_overflow_y()) {
                    return Some(id);
                }
            }
            current = ancestor.layout_parent.get();
        }
        None
    }

    /// Give each held fixed layer the offset that cancels its hoist.
    ///
    /// Paint draws a hoisted child at its stacking context root's origin, plus
    /// the recorded offset, plus the node's own layout location — and that
    /// location is relative to the root element, because the hoist made the
    /// root its layout parent. So the offset has to carry the difference
    /// between the two origins, or a background mounted with `inset: 0` lands
    /// wherever its isolate happens to sit rather than over the viewport.
    ///
    /// Separate from `flush_styles_to_layout`, which decides *which* context
    /// holds the layer: that runs before taffy, when every absolute position is
    /// still zero.
    pub(crate) fn correct_hoisted_fixed_positions(&mut self) {
        if self.hoisted_fixed_parents.is_empty() {
            return;
        }
        let root_id = self.root_element().id;
        let root_abs = self.nodes[root_id].absolute_position(0.0, 0.0);

        let placements: Vec<(NodeId, NodeId)> = self
            .hoisted_fixed_parents
            .iter()
            .filter_map(|(&node_id, &origin)| {
                let host = self.nearest_stacking_context_ancestor(origin)?;
                (host != root_id).then_some((node_id, host))
            })
            .collect();

        for (node_id, host) in placements {
            let host_abs = self.nodes[host].absolute_position(0.0, 0.0);
            let host_scroll = *self.nodes[host].scroll_offset();
            let Some(mut context) = self.nodes[host].stacking_context.take() else {
                continue;
            };
            for child in context.children.iter_mut() {
                if child.node_id == node_id {
                    child.position = taffy::Point {
                        x: root_abs.x - host_abs.x + host_scroll.x as f32,
                        y: root_abs.y - host_abs.y + host_scroll.y as f32,
                    };
                }
            }
            context.compute_content_size(self);
            self.nodes[host].stacking_context = Some(context);
        }
    }

    /// Recompute hoisted paint offsets from the layout that just finished.
    ///
    /// Stacking contexts are assembled while styles are flushed into Taffy,
    /// before Taffy computes this frame's boxes. Accumulating ancestor
    /// locations during that flush therefore reads zeroes on the first frame
    /// and previous-frame positions after relayout. The next unrelated
    /// restyle rebuilds the same context from current boxes, which made a
    /// transformed flower repair itself on its first hover.
    ///
    /// A hoisted child is painted from the context host, then by this offset,
    /// then by its own layout location. Its layout parent's document position
    /// relative to the host is therefore the exact offset needed here. Fixed
    /// children are the exception: their box tree was deliberately reparented
    /// to the root and [`Self::correct_hoisted_fixed_positions`] restores their
    /// authored stacking-context offset separately.
    pub(crate) fn resolve_hoisted_positions(&mut self) {
        self.resolve_abspos_positions();
        let nodes = &self.nodes;
        self.hoisted_position_hosts
            .retain(|id| nodes.contains_key(*id));
        let hosts: Vec<NodeId> = self.hoisted_position_hosts.iter().copied().collect();

        for host in hosts {
            let host_position = self.nodes[host].absolute_position(0.0, 0.0);
            let Some(mut context) = self.nodes[host].stacking_context.take() else {
                continue;
            };

            // A stacking context is assembled during a style flush and then
            // outlives it. `flush_styles_to_layout` returns early on a
            // `display: none` subtree, so a host hidden after its list was
            // built never rebuilds that list, while this pass walks every node
            // that has a context, hidden or not. Removing one of the listed
            // children left a freed key behind, and the next resolve panicked
            // with "invalid SlotMap key used" rather than painting one frame
            // stale. Prune here, where the whole list is already in hand.
            if context
                .children
                .iter()
                .any(|child| !self.nodes.contains_key(child.node_id))
            {
                context
                    .children
                    .retain(|child| self.nodes.contains_key(child.node_id));
                context.negative_z_count = context
                    .children
                    .iter()
                    .take_while(|child| child.z_index < 0)
                    .count() as u32;
            }

            for child in context.children.iter_mut() {
                let node = &self.nodes[child.node_id];
                if self.fixed_nodes.contains(&child.node_id) {
                    continue;
                }
                let child_position = node.absolute_position(0.0, 0.0);
                let child_layout_position = node.final_layout().location;
                let host_scroll = self.nodes[host].scroll_offset();
                child.position = taffy::Point {
                    x: child_position.x - host_position.x - child_layout_position.x
                        + host_scroll.x as f32,
                    y: child_position.y - host_position.y - child_layout_position.y
                        + host_scroll.y as f32,
                };
            }

            context.compute_content_size(self);
            self.nodes[host].stacking_context = Some(context);
        }
    }

    /// Turn each hoisted child's clipping ancestors into rectangles paint can
    /// use, relative to the origin of the stacking context it paints in.
    ///
    /// Separate from `flush_styles_to_layout`, which decides *which* ancestors
    /// clip: that runs before taffy, when every box is still zero-sized, so
    /// reading a size there produced an empty clip and made hoisted content
    /// disappear entirely rather than merely escape.
    pub(crate) fn resolve_hoisted_clips(&mut self) {
        if self.hoisted_clip_hosts.is_empty() {
            return;
        }

        // Retain registrations from skipped subtrees across style flushes.
        let nodes = &self.nodes;
        self.hoisted_clip_hosts.retain(|id| nodes.contains_key(*id));
        let hosts: Vec<NodeId> = self.hoisted_clip_hosts.iter().copied().collect();
        for host in hosts {
            let Some(mut context) = self.nodes[host].stacking_context.take() else {
                continue;
            };
            let host_position = self.nodes[host].absolute_position(0.0, 0.0);

            for child in context.children.iter_mut() {
                child.clips.clear();
                child.clips.reserve(child.clip_ancestors.len());
                for &clipper in child.clip_ancestors.iter() {
                    let node = &self.nodes[clipper];
                    // The clip is the clipping box's own border box, so its
                    // own scroll offset does not enter into it. Ancestor
                    // scrolling does, and `absolute_position` applies that.
                    let position = node.absolute_position(0.0, 0.0);
                    let layout = node.final_layout();
                    // Paint and hit testing use the host's unscrolled content
                    // coordinates, applying its scroll offset once afterwards.
                    let host_scroll = self.nodes[host].scroll_offset();
                    let left = position.x - host_position.x + host_scroll.x as f32;
                    let top = position.y - host_position.y + host_scroll.y as f32;
                    // The padding box, matching what paint clips content to.
                    child.clips.push(taffy::Rect {
                        left: left + layout.border.left,
                        top: top + layout.border.top,
                        right: left + layout.size.width - layout.border.right,
                        bottom: top + layout.size.height - layout.border.bottom,
                    });
                }
            }

            self.nodes[host].stacking_context = Some(context);
        }
    }

    /// Scrolling can move containing blocks without a style or layout pass.
    /// Update shared box locations before refreshing paint offsets and clips.
    pub(crate) fn resolve_positioned_scroll(&mut self) {
        self.resolve_sticky_positions();
        self.resolve_fixed_positions();
        self.resolve_hoisted_positions();
        self.correct_hoisted_fixed_positions();
        self.resolve_hoisted_clips();
        if let Some(root) = self.try_root_element().map(|node| node.id) {
            self.resolve_transforms(root);
        }
    }

    pub fn resolve_deferred_tasks(&mut self) {
        let mut deferred_construction_nodes = std::mem::take(&mut self.deferred_construction_nodes);

        // Deduplicate deferred tasks by node_id to avoid redundant work
        deferred_construction_nodes.sort_unstable_by_key(|task| task.node_id);
        deferred_construction_nodes.dedup_by_key(|task| task.node_id);

        #[cfg(feature = "parallel-construct")]
        let iter = deferred_construction_nodes.into_par_iter();
        #[cfg(not(feature = "parallel-construct"))]
        let iter = deferred_construction_nodes.into_iter();

        let results: Vec<ConstructionTaskResult> = iter
            .map(|task: ConstructionTask| match task.data {
                ConstructionTaskData::InlineLayout(mut layout) => {
                    #[cfg(feature = "parallel-construct")]
                    let mut layout_ctx = LAYOUT_CTX
                        .take()
                        .unwrap_or_else(|| Box::new(LayoutContext::new()));
                    #[cfg(feature = "parallel-construct")]
                    let layout_ctx_mut = &mut layout_ctx;

                    #[cfg(feature = "parallel-construct")]
                    let mut font_ctx = self
                        .thread_font_contexts
                        .get_or(|| RefCell::new(Box::new(self.font_ctx.lock().unwrap().clone())))
                        .borrow_mut();
                    #[cfg(feature = "parallel-construct")]
                    let font_ctx_mut = &mut *font_ctx;

                    #[cfg(not(feature = "parallel-construct"))]
                    let layout_ctx_mut = &mut self.layout_ctx;
                    #[cfg(not(feature = "parallel-construct"))]
                    let font_ctx_mut = &mut *self.font_ctx.lock().unwrap();

                    layout.content_widths = None;
                    build_inline_layout_into(
                        &self.nodes,
                        layout_ctx_mut,
                        font_ctx_mut,
                        &mut layout,
                        self.viewport.scale(),
                        task.node_id,
                    );

                    #[cfg(feature = "parallel-construct")]
                    {
                        LAYOUT_CTX.set(Some(layout_ctx));
                    }

                    // If layout doesn't contain any inline boxes, then it is safe to populate the content_widths
                    // cache during this parallelized stage.
                    // if layout.layout.inline_boxes().is_empty() {
                    //     layout.content_widths();
                    // }

                    ConstructionTaskResult {
                        node_id: task.node_id,
                        data: ConstructionTaskResultData::InlineLayout(layout),
                    }
                }
            })
            .collect();

        for result in results {
            match result.data {
                ConstructionTaskResultData::InlineLayout(layout) => {
                    self.abspos_layout_dirty = true;
                    // The node and every layout ancestor. The shaped layout
                    // that lands here has not been broken into lines yet, and
                    // an ancestor still holding a cached layout never descends,
                    // so clearing this node alone leaves the fresh unbroken
                    // layout in place with nothing to break it. Non-atomic
                    // inline elements then report geometry from a single line
                    // as wide as the whole paragraph.
                    //
                    // `layout_parent`, not `parent`: taffy walks the layout
                    // tree, and anonymous blocks make the two chains differ.
                    self.nodes[result.node_id].cache_mut().clear();
                    self.nodes[result.node_id]
                        .element_data_mut()
                        .unwrap()
                        .inline_layout_data = Some(layout);
                }
            }
        }

        self.deferred_construction_nodes.clear();
    }

    /// Walk the nodes now that they're properly styled and transfer their styles to the taffy style system
    ///
    /// TODO: update taffy to use an associated type instead of slab key
    /// TODO: update taffy to support traited styles so we don't even need to rely on taffy for storage
    pub fn resolve_layout(&mut self) {
        // Preserve corrected boxes, fixed parent slots, caches and positional
        // offsets when neither style/tree changes nor layout damage occurred.
        if self.incremental_layout && !self.abspos_layout_dirty && !self.abspos_candidates_dirty {
            return;
        }
        let size = self.stylist.device().au_viewport_size();

        let available_space = taffy::Size {
            width: AvailableSpace::Definite(size.width.to_f32_px()),
            height: AvailableSpace::Definite(size.height.to_f32_px()),
        };

        let root_element_id = crate::taffy_node_id(self.root_element().id);

        // println!("\n\nRESOLVE LAYOUT\n===========\n");

        let root_id = crate::dom_node_id(root_element_id);
        let previous_content_size = self.nodes[root_id].unrounded_layout().content_size;
        self.abspos_normal_layout = false;
        let fixed_parents = self.restore_fixed_layout_parents();
        taffy::compute_root_layout(self, root_element_id, available_space);
        // A cached root output predates the correction of descendant extents.
        // Its descendant boxes remain corrected; preserve the root's extent too.
        if !self.abspos_normal_layout {
            self.nodes[root_id].unrounded_layout_mut().content_size = previous_content_size;
        }
        let placements = self.resolve_abspos_layout(
            crate::dom_node_id(root_element_id),
            taffy::Size {
                width: size.width.to_f32_px(),
                height: size.height.to_f32_px(),
            },
        );
        self.finish_fixed_layout_parents(fixed_parents);
        taffy::round_layout(self, root_element_id);
        self.finish_abspos_placements(placements);
        self.abspos_layout_dirty = false;

        // Rounding rewrites every location from taffy's own output, discarding
        // the sticky and fixed displacements written into them along with
        // everything else. Forgetting them here is what keeps
        // `resolve_sticky_positions` and `resolve_fixed_positions` able to
        // treat what they hold as "what is currently baked into a box".
        self.sticky_offsets.clear();
        self.fixed_scroll_offset = crate::Point::ZERO;

        // Table rows and row groups are flattened into a grid of cells and
        // never reach Taffy, so nothing wrote a layout for them at all. Describe
        // each from the cells it holds, after rounding: `final_layout` is what
        // every geometry query reads and the rounding pass is what fills it, so
        // doing this any earlier reads cells that are still zero.
        self.assign_table_row_layouts();

        // Fixed locations already use the viewport, or their transformed
        // containing block. No document-origin cancellation is needed here.

        // println!("\n\n");
        // taffy::print_tree(self, root_node_id)
    }
}

#[cfg(test)]
mod tests {
    use crate::{BaseDocument, DocumentConfig};

    #[test]
    fn resolving_for_inspection_cannot_rewind_the_animation_clock() {
        let mut document = BaseDocument::new(DocumentConfig::default());
        document.resolve(2.5);
        document.resolve(0.0);
        assert_eq!(document.last_resolve_animation_time, 2.5);
    }
}