sequoia_view/

runtime.rs

use std::any::Any;
use std::cell::{Cell, RefCell};
use std::collections::{HashMap, HashSet};
use std::panic::AssertUnwindSafe;
use std::rc::{Rc, Weak};
use std::time::Instant;

use crate::dnd::{
    ActiveDrag, DragEnd, DragId, DragOptions, DragPayload, DragSession, DropPosition, PendingDrag,
    exceeded_threshold, grab_offset, preview_origin,
};
use crate::overlay::{
    Anchor, InputMode, OverlayEntry, OverlayId, OverlayLayer, OverlayStore, compute_position,
};
use sequoia_core::{
    Constraints, Dirty, Edges, Length, Point, Rect, RenderList, ShaderId, Size, Transform, Vec2,
    WindowId,
};
use sequoia_input::{
    CursorIcon, Event, EventPhase, ImeEvent, Key, KeyEvent, Modifiers, PenTool, PointerButton,
    PointerEvent,
};
use sequoia_layout::{
    Align, Axis, ContainerStyle, Dock, DockStyle, FlexItem, GridPlacement, GridStyle, LayoutCtx,
    LayoutStyle, MasonryStyle, Overflow, Track, WrapStyle, clamp_to, distribute_flex,
    dock_layout_order, dock_thickness, masonry_assign, masonry_column_width, resolve_cross,
    resolve_dock, resolve_flex_basis, resolve_main, resolve_tracks, sanitize_gap, track_offsets,
    wrap_lines,
};
use sequoia_reactive::{Environment, ReadSet, Signal, Watcher, capture_reads, flush_effects};
use sequoia_style::{Theme, VisualState};
use sequoia_text::TextSystem;

use crate::any::{AnyView, ErasedView};
use crate::cache::{LayerCache, LayerKey, LayerStamp};
use crate::clock::FrameClock;
use crate::live::{AnimSpec, AnimState, Live, Prop, SpringSpec};
use crate::paint_region::CullCtx;
use crate::surface::SurfaceDraw;
use crate::view::{EventCtx, PaintCtx, View};

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub struct ElementId {
    pub(crate) index: u32,
    pub(crate) generation: u32,
}

impl ElementId {
    /// Stable key that includes the arena generation, for cache invalidation.
    pub fn key(self) -> u64 {
        (u64::from(self.generation) << 32) | u64::from(self.index)
    }
}

#[derive(Clone, Copy)]
struct PaintPass<'a> {
    env: &'a Environment,
    hover_chain: &'a [ElementId],
    session: &'a RefCell<PaintSession>,
}

/// Layer-cache side effects of one paint pass.
///
/// The prefetch pass paints placeholder shapes, so its captures and counters
/// are kept only when no shape was missing; committing them otherwise would
/// cache incomplete layers.
#[derive(Default)]
struct PaintSession {
    layer_hits: u64,
    layer_misses: u64,
    captures: Vec<(LayerKey, LayerStamp, RenderList)>,
}

impl PaintPass<'_> {
    fn hovered_subtree(&self, id: ElementId) -> bool {
        self.hover_chain.contains(&id)
    }
}

pub trait ViewState: 'static + Default {}
impl<T: Default + 'static> ViewState for T {}

const MAX_ERRORS: usize = 64;

#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct Stats {
    pub mounts: u64,

    pub unmounts: u64,

    pub rebuilds: u64,

    pub measure_invalidations: u64,

    pub errors: u64,
}

#[derive(Clone, Debug, PartialEq)]
pub struct RuntimeError {
    pub element: ElementId,

    pub type_name: String,

    pub message: String,
}

#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct InteractState {
    pub hovered: Option<ElementId>,

    pub pressed: Option<ElementId>,

    pub captured: Option<ElementId>,

    pub focus: Option<ElementId>,

    pub cursor: Point,

    pub pointer_seen: bool,
}

struct Element {
    parent: Option<ElementId>,
    key: u64,
    children: Vec<ElementId>,
    view: Option<Rc<dyn ErasedView>>,
    watcher: Option<Watcher>,
    reads: ReadSet,
    dirty: Dirty,
    revision: u64,
    rect: Cell<Rect>,
    /// False while layout culls this subtree past the visible main axis.
    laid_out: Cell<bool>,
}

#[derive(Default)]
struct Arena {
    slots: Vec<Option<Element>>,
    generations: Vec<u32>,
    free: Vec<u32>,
}

impl Arena {
    fn get(&self, id: ElementId) -> Option<&Element> {
        let i = id.index as usize;
        if self.generations.get(i)? != &id.generation {
            return None;
        }
        self.slots.get(i)?.as_ref()
    }
    fn get_mut(&mut self, id: ElementId) -> Option<&mut Element> {
        let i = id.index as usize;
        if self.generations.get(i)? != &id.generation {
            return None;
        }
        self.slots.get_mut(i)?.as_mut()
    }
    fn alloc_slot(&mut self) -> (u32, u32) {
        match self.free.pop() {
            Some(i) => (i, self.generations[i as usize]),
            None => {
                let i = self.slots.len() as u32;
                self.slots.push(None);
                self.generations.push(0);
                (i, 0)
            }
        }
    }
    fn free_slot(&mut self, slot: u32) {
        self.slots[slot as usize] = None;
        self.generations[slot as usize] = self.generations[slot as usize].wrapping_add(1);
        self.free.push(slot);
    }
    fn alive(&self) -> usize {
        self.slots.iter().filter(|s| s.is_some()).count()
    }
}

/// Constraint variants kept per element. Layout probes children with both a
/// bounded and an unbounded max size; a single entry would be overwritten by
/// the second probe and force a full re-measure on every frame.
const MAX_MEASURE_VARIANTS: usize = 4;

#[derive(Clone)]
struct MeasureEntry {
    constraints: Constraints,
    style: LayoutStyle,
    container: Option<ContainerStyle>,

    grid: Option<GridStyle>,
    placements: Vec<GridPlacement>,

    dock: Option<DockStyle>,

    wrap: Option<WrapStyle>,
    masonry: Option<MasonryStyle>,
    children_len: usize,
    size: Size,
}

struct DispatchCells {
    stopped: Cell<bool>,
    handled: Cell<bool>,
    capture_req: Cell<Option<ElementId>>,
    release_req: Cell<bool>,
    focus_req: Cell<bool>,
}

impl DispatchCells {
    fn new() -> Self {
        Self {
            stopped: Cell::new(false),
            handled: Cell::new(false),
            capture_req: Cell::new(None),
            release_req: Cell::new(false),
            focus_req: Cell::new(false),
        }
    }
}

struct Inner {
    arena: RefCell<Arena>,
    queue: RefCell<Vec<ElementId>>,
    root: Cell<Option<ElementId>>,
    stats: Cell<Stats>,
    measures: RefCell<HashMap<ElementId, Vec<MeasureEntry>>>,
    interact: Cell<InteractState>,
    environment: RefCell<Environment>,

    env_listener: RefCell<Option<sequoia_reactive::Listener>>,

    redraw: RefCell<Option<Box<dyn Fn()>>>,
    redraw_armed: Cell<bool>,
    surfaces: RefCell<Vec<SurfaceDraw>>,
    overlays: RefCell<OverlayStore>,

    pending_drag: RefCell<Option<PendingDrag>>,

    active_drag: RefCell<Option<ActiveDrag>>,

    next_drag_id: Cell<u64>,

    viewport: Cell<Rect>,

    root_fill: Cell<bool>,

    window_size: Signal<Size>,

    scale: Cell<f32>,

    safe_insets: Cell<Edges>,

    errors: RefCell<Vec<RuntimeError>>,

    errors_seq: Signal<u64>,

    stylus_pressure: Cell<f32>,

    stylus_tool: Cell<PenTool>,

    touches: RefCell<HashMap<u64, Point>>,

    shapes: sequoia_draw::ShapeCache,

    window: Cell<WindowId>,

    wrap_cache: RefCell<HashMap<(u32, u32, u8), bool>>,

    live_anims: RefCell<HashMap<(ElementId, u64), AnimState>>,

    clock: Cell<FrameClock>,

    damage: RefCell<crate::damage::DamageTracker>,

    layers: RefCell<LayerCache>,
    layer_hits: Cell<u64>,
    layer_misses: Cell<u64>,

    states: RefCell<HashMap<ElementId, Box<dyn Any>>>,

    layout_epoch: Cell<u64>,

    layout_dirty: Cell<bool>,

    measure_calls: Cell<u64>,
    measure_hits: Cell<u64>,
    measure_ns: Cell<u64>,
    arrange_ns: Cell<u64>,

    scoped_cancels: RefCell<HashMap<ElementId, Vec<Box<dyn FnOnce()>>>>,

    shader_ids: RefCell<HashMap<String, ShaderId>>,

    next_shader_id: Cell<u32>,
}

impl Inner {
    fn schedule(&self, id: ElementId) {
        let view = self.arena.borrow().get(id).and_then(|e| e.view.clone());
        if let Some(v) = &view {
            // A tracked signal changed, so anything the view cached while
            // building is stale. The rebuild below refills it.
            v.invalidate_cache_erased();
        }
        let dirty = view
            .as_ref()
            .map(|v| v.signal_dirty_erased())
            .unwrap_or(Dirty::LAYOUT | Dirty::CHILDREN);
        self.mark(id, dirty);
    }

    fn mark(&self, id: ElementId, flags: Dirty) {
        if flags.is_empty() {
            return;
        }
        if flags.needs_repaint() {
            self.bump_revision(id);
        }
        let (newly, rect) = {
            let mut arena = self.arena.borrow_mut();
            match arena.get_mut(id) {
                Some(e) => {
                    let was = e.dirty;
                    e.dirty |= flags;
                    (was.is_empty(), e.rect.get())
                }
                None => return,
            }
        };
        if newly {
            self.queue.borrow_mut().push(id);
        }

        let repaint = flags.needs_repaint();
        {
            let mut damage = self.damage.borrow_mut();
            damage.mark(flags);
            if repaint {
                damage.mark_rect(rect);
            }
        }

        // A coarse update marks thousands of elements in one frame; the host
        // only needs one wake-up, not one per element. Painting re-arms this.
        if repaint
            && !self.redraw_armed.replace(true)
            && let Some(h) = self.redraw.borrow().as_ref()
        {
            h();
        }
    }

    fn bump_revision(&self, id: ElementId) {
        let mut arena = self.arena.borrow_mut();
        let mut cur = Some(id);
        let mut walked = 0u32;
        while let Some(c) = cur {
            let Some(e) = arena.get_mut(c) else {
                break;
            };
            e.revision = e.revision.wrapping_add(1);
            cur = e.parent;
            walked += 1;
            if walked > 4096 {
                break;
            }
        }
    }
}

#[derive(Clone)]
pub struct Runtime {
    inner: Rc<Inner>,
}

impl Default for Runtime {
    fn default() -> Self {
        Self::new()
    }
}

impl Runtime {
    pub fn new() -> Self {
        Self {
            inner: Rc::new(Inner {
                arena: RefCell::default(),
                queue: RefCell::default(),
                root: Cell::new(None),
                stats: Cell::new(Stats::default()),
                measures: RefCell::new(HashMap::new()),
                interact: Cell::new(InteractState::default()),
                environment: RefCell::new(Environment::new()),
                env_listener: RefCell::new(None),
                shapes: sequoia_draw::ShapeCache::default(),
                redraw: RefCell::new(None),
                redraw_armed: Cell::new(false),
                surfaces: RefCell::new(Vec::new()),
                overlays: RefCell::default(),
                pending_drag: RefCell::new(None),
                active_drag: RefCell::new(None),
                next_drag_id: Cell::new(0),
                viewport: Cell::new(Rect::ZERO),
                root_fill: Cell::new(false),
                window_size: Signal::new(Size::ZERO),
                scale: Cell::new(1.0),
                safe_insets: Cell::new(Edges::ZERO),
                errors: RefCell::new(Vec::new()),
                errors_seq: Signal::new(0),
                stylus_pressure: Cell::new(1.0),
                stylus_tool: Cell::new(PenTool::Mouse),
                touches: RefCell::new(HashMap::new()),
                window: Cell::new(WindowId::PRIMARY),
                wrap_cache: RefCell::new(HashMap::new()),
                live_anims: RefCell::new(HashMap::new()),
                clock: Cell::new(FrameClock::new()),
                damage: RefCell::new(crate::damage::DamageTracker::new()),
                layers: RefCell::new(LayerCache::new(128)),
                layer_hits: Cell::new(0),
                layer_misses: Cell::new(0),
                states: RefCell::new(HashMap::new()),
                layout_epoch: Cell::new(0),
                layout_dirty: Cell::new(true),
                measure_calls: Cell::new(0),
                measure_hits: Cell::new(0),
                measure_ns: Cell::new(0),
                arrange_ns: Cell::new(0),
                scoped_cancels: RefCell::new(HashMap::new()),
                shader_ids: RefCell::new(HashMap::new()),
                next_shader_id: Cell::new(0),
            }),
        }
    }

    /// Associates a shader name with a backend [`ShaderId`].
    pub fn register_shader_id_with(&self, name: impl Into<String>, id: ShaderId) {
        self.inner.shader_ids.borrow_mut().insert(name.into(), id);
    }

    /// Registers a shader name and returns a stable headless [`ShaderId`].
    pub fn register_shader_id(&self, name: impl Into<String>) -> ShaderId {
        let name = name.into();
        if let Some(id) = self.inner.shader_ids.borrow().get(&name).copied() {
            return id;
        }
        let id = ShaderId::new(self.inner.next_shader_id.get());
        self.inner
            .next_shader_id
            .set(self.inner.next_shader_id.get() + 1);
        self.inner.shader_ids.borrow_mut().insert(name, id);
        id
    }

    /// Looks up a registered shader name.
    pub fn shader_id(&self, name: &str) -> Option<ShaderId> {
        self.inner.shader_ids.borrow().get(name).copied()
    }

    /// Names of every shader registered on this runtime, sorted.
    pub fn shader_names(&self) -> Vec<String> {
        let mut names: Vec<String> = self.inner.shader_ids.borrow().keys().cloned().collect();
        names.sort();
        names
    }

    /// Whether a shader with `name` is registered.
    pub fn has_shader(&self, name: &str) -> bool {
        self.inner.shader_ids.borrow().contains_key(name)
    }

    pub fn window_id(&self) -> WindowId {
        self.inner.window.get()
    }

    pub fn set_window_id(&self, id: WindowId) {
        self.inner.window.set(id);
    }

    pub fn window_size(&self) -> Signal<Size> {
        self.inner.window_size.clone()
    }

    pub fn window_size_value(&self) -> Size {
        self.inner.window_size.get_untracked()
    }

    pub fn window_rect(&self) -> Rect {
        self.inner.viewport.get()
    }

    pub fn viewport_rect(&self) -> Rect {
        self.inner.viewport.get()
    }

    pub fn set_root_fill(&self, enabled: bool) {
        if self.inner.root_fill.get() == enabled {
            return;
        }
        self.inner.root_fill.set(enabled);
        self.inner.layout_dirty.set(true);
        self.mark_full_damage();
    }

    pub fn scale(&self) -> f32 {
        self.inner.scale.get()
    }

    pub fn set_scale(&self, scale: f32) {
        let s = if scale.is_finite() && scale > 0.0 {
            scale
        } else {
            1.0
        };
        if self.inner.scale.get() == s {
            return;
        }
        self.inner.scale.set(s);
        self.mark_full_damage();
    }

    pub fn safe_insets(&self) -> Edges {
        self.inner.safe_insets.get()
    }

    pub fn set_safe_insets(&self, insets: Edges) {
        if self.inner.safe_insets.get() == insets {
            return;
        }
        self.inner.safe_insets.set(insets);
        self.inner.layout_dirty.set(true);
        self.mark_full_damage();
    }

    pub fn set_environment(&self, env: Environment) {
        *self.inner.environment.borrow_mut() = env.clone();
        self.inner.layout_dirty.set(true);
        self.mark_full_damage();
        let weak = Rc::downgrade(&self.inner);
        *self.inner.env_listener.borrow_mut() = Some(env.on_change(move || {
            if let Some(inner) = weak.upgrade() {
                inner.layout_dirty.set(true);
                inner.layers.borrow_mut().invalidate_all();
                inner.damage.borrow_mut().mark_full();
                if let Some(h) = inner.redraw.borrow().as_ref() {
                    h();
                }
            }
        }));
    }

    pub fn set_redraw_hook(&self, hook: impl Fn() + 'static) {
        *self.inner.redraw.borrow_mut() = Some(Box::new(hook));
    }

    fn request_redraw(&self) {
        self.inner.damage.borrow_mut().mark(Dirty::PAINT);
        if let Some(h) = self.inner.redraw.borrow().as_ref() {
            h();
        }
    }

    pub fn request_frame(&self) {
        self.inner.damage.borrow_mut().request_frame();
        self.request_redraw();
    }

    /// Mark an element as damaged. Uses its current bounds for partial repaint.
    pub(crate) fn mark_damage(&self, el: ElementId, flags: Dirty) {
        let repaint = flags.needs_repaint();
        if repaint {
            self.inner.bump_revision(el);
        }
        let rect = if repaint { self.rect_of(el) } else { None };
        let mut damage = self.inner.damage.borrow_mut();
        damage.mark(flags);
        if let Some(rect) = rect {
            damage.mark_rect(rect);
        }
    }

    /// Mark the whole viewport as damaged (resize, DPI, theme, root swap).
    pub fn mark_full_damage(&self) {
        self.inner.layers.borrow_mut().invalidate_all();
        self.inner.damage.borrow_mut().mark_full();
    }

    /// Drops all cached layer snapshots.
    pub fn clear_layer_cache(&self) {
        self.inner.layers.borrow_mut().invalidate_all();
    }

    /// Returns `(hits, misses)` for the layer cache.
    pub fn layer_cache_stats(&self) -> (u64, u64) {
        (self.inner.layer_hits.get(), self.inner.layer_misses.get())
    }

    pub fn needs_frame(&self) -> bool {
        self.inner.damage.borrow().needs_frame()
    }

    pub fn damage_flags(&self) -> Dirty {
        self.inner.damage.borrow().flags()
    }

    pub fn damage_rect(&self) -> Option<Rect> {
        self.inner.damage.borrow().paint_region()
    }

    /// Returns the disjoint damage regions for the next frame.
    ///
    /// `None` means a full repaint. Overlapping marks are merged, and a
    /// bounded set of regions is kept so a backend can scissor each one
    /// without unbounded work.
    pub fn damage_regions(&self) -> Option<Vec<Rect>> {
        self.inner.damage.borrow().paint_regions()
    }

    pub fn damage_stats(&self) -> (u64, u64) {
        let damage = self.inner.damage.borrow();
        (damage.frames_painted(), damage.frames_skipped())
    }

    /// Paint only when something changed since the previous frame.
    ///
    /// A frame is skipped when there is no pending animation request and the
    /// accumulated flags do not require pixels (`Dirty::needs_repaint`).
    /// Bookkeeping-only flags (`HIT_TEST`, `DATA`) are discarded by the skip.
    /// Returns [`crate::FrameOutcome::Skipped`] without building a render list.
    pub fn paint_if_dirty(
        &self,
        list: &mut RenderList,
        text: &mut TextSystem,
    ) -> crate::damage::FrameOutcome {
        let had_motion = self.inner.damage.borrow_mut().take_motion();
        if !had_motion && self.inner.damage.borrow().is_empty() {
            self.inner.damage.borrow_mut().record_skipped();
            return crate::damage::FrameOutcome::Skipped;
        }
        if had_motion {
            self.inner.layers.borrow_mut().invalidate_all();
        }
        self.paint_region(list, text, CullCtx::ENABLED);
        self.inner.damage.borrow_mut().after_paint();
        crate::damage::FrameOutcome::Painted
    }

    /// Snapshot of the frame clock used by every view animation.
    pub fn clock(&self) -> FrameClock {
        self.inner.clock.get()
    }

    pub fn now(&self) -> std::time::Instant {
        self.inner.clock.get().now()
    }

    pub fn elapsed_secs(&self) -> f32 {
        self.inner.clock.get().elapsed_secs()
    }

    pub fn frame_dt_secs(&self) -> f32 {
        self.inner.clock.get().dt_secs()
    }

    pub fn reduced_motion(&self) -> bool {
        self.inner.clock.get().reduced_motion()
    }

    pub fn set_reduced_motion(&self, reduced: bool) {
        let mut c = self.inner.clock.get();
        if c.reduced_motion() == reduced {
            return;
        }
        c.set_reduced_motion(reduced);
        self.inner.clock.set(c);
        self.inner.layout_dirty.set(true);
        self.request_redraw();
    }

    pub fn set_animation_speed(&self, speed: f32) {
        let mut c = self.inner.clock.get();
        c.set_speed(speed);
        self.inner.clock.set(c);
        self.request_redraw();
    }

    pub fn animation_speed(&self) -> f32 {
        self.inner.clock.get().speed()
    }

    /// Switch to explicit time control. Hosts and tests can then call
    /// [`Runtime::advance_for_test`] without coupling to wall time.
    pub fn set_manual_clock(&self, manual: bool) {
        let mut c = self.inner.clock.get();
        c.set_manual(manual);
        self.inner.clock.set(c);
    }

    /// Advance the shared clock by an exact duration.
    ///
    /// This also flips the clock into manual mode, so subsequent `tick` calls
    /// do not advance it from the wall clock.
    pub fn advance_for_test(&self, dt: std::time::Duration) {
        let mut c = self.inner.clock.get();
        c.set_manual(true);
        c.advance_by(dt);
        self.inner.clock.set(c);
        self.invalidate_animated_layout();
    }

    pub fn reset_clock(&self) {
        let mut c = self.inner.clock.get();
        c.reset();
        self.inner.clock.set(c);
        self.invalidate_animated_layout();
    }

    fn has_layout_animation(&self) -> bool {
        self.inner
            .live_anims
            .borrow()
            .keys()
            .any(|(_, prop)| *prop == Prop::WIDTH.0 || *prop == Prop::HEIGHT.0)
    }

    fn invalidate_animated_layout(&self) {
        if self.has_layout_animation() {
            self.inner.layout_dirty.set(true);
        }
    }

    fn advance_clock(&self) {
        let mut c = self.inner.clock.get();
        c.advance();
        self.inner.clock.set(c);
        self.invalidate_animated_layout();
    }

    pub fn live_f32(
        &self,
        el: ElementId,
        prop: Prop,
        target: f32,
        tween: Option<&AnimSpec>,
        spring: Option<&SpringSpec>,
    ) -> (f32, bool) {
        let key = (el, prop.0);
        if self.reduced_motion() || (tween.is_none() && spring.is_none()) {
            self.inner.live_anims.borrow_mut().remove(&key);
            return (target, false);
        }
        let now = self.now();
        let mut map = self.inner.live_anims.borrow_mut();
        let entry = map.entry(key).or_insert_with(|| {
            AnimState::F32(crate::live::F32State {
                current: target,
                from: target,
                start: now,
                last_target: target,
                tween: tween.copied(),
                spring: spring.copied(),
                velocity: 0.0,
                last_tick: now,
                initialized: false,
            })
        });

        if !matches!(entry, AnimState::F32(_)) {
            *entry = AnimState::F32(crate::live::F32State {
                current: target,
                from: target,
                start: now,
                last_target: target,
                tween: tween.copied(),
                spring: spring.copied(),
                velocity: 0.0,
                last_tick: now,
                initialized: false,
            });
        }
        let AnimState::F32(st) = entry else {
            return (target, false);
        };
        let (v, running) = AnimState::sample_f32(st, target, tween, spring, now);
        drop(map);
        if running {
            self.request_frame();
        }
        (v, running)
    }

    pub fn live_color(
        &self,
        el: ElementId,
        prop: Prop,
        target: sequoia_core::Color,
        tween: Option<&AnimSpec>,
    ) -> (sequoia_core::Color, bool) {
        let key = (el, prop.0);
        if self.reduced_motion() || tween.is_none() {
            self.inner.live_anims.borrow_mut().remove(&key);
            return (target, false);
        }
        let now = self.now();
        let mut map = self.inner.live_anims.borrow_mut();
        let entry = map.entry(key).or_insert_with(|| {
            AnimState::Color(crate::live::ColorState {
                current: target,
                from: target,
                start: now,
                last_target: target,
                tween: tween.copied(),
                smooth_rate: None,
                last_tick: now,
                initialized: false,
            })
        });
        if !matches!(entry, AnimState::Color(_)) {
            *entry = AnimState::Color(crate::live::ColorState {
                current: target,
                from: target,
                start: now,
                last_target: target,
                tween: tween.copied(),
                smooth_rate: None,
                last_tick: now,
                initialized: false,
            });
        }
        let AnimState::Color(st) = entry else {
            return (target, false);
        };
        let (v, running) = AnimState::sample_color(st, target, tween, None, now);
        drop(map);
        if running {
            self.request_frame();
        }
        (v, running)
    }

    pub fn live_color_exp(
        &self,
        el: ElementId,
        prop: Prop,
        target: sequoia_core::Color,
        rate: f32,
    ) -> (sequoia_core::Color, bool) {
        let key = (el, prop.0);
        if self.reduced_motion() || !(rate > 0.0) {
            self.inner.live_anims.borrow_mut().remove(&key);
            return (target, false);
        }
        let now = self.now();
        let mut map = self.inner.live_anims.borrow_mut();
        let entry = map.entry(key).or_insert_with(|| {
            AnimState::Color(crate::live::ColorState {
                current: target,
                from: target,
                start: now,
                last_target: target,
                tween: None,
                smooth_rate: Some(rate),
                last_tick: now,
                initialized: false,
            })
        });
        if !matches!(entry, AnimState::Color(_)) {
            *entry = AnimState::Color(crate::live::ColorState {
                current: target,
                from: target,
                start: now,
                last_target: target,
                tween: None,
                smooth_rate: Some(rate),
                last_tick: now,
                initialized: false,
            });
        }
        let AnimState::Color(st) = entry else {
            return (target, false);
        };
        let (v, running) = AnimState::sample_color(st, target, None, Some(rate), now);
        drop(map);
        if running {
            self.request_frame();
        }
        (v, running)
    }

    pub fn live_vec2(
        &self,
        el: ElementId,
        prop: Prop,
        target: sequoia_core::Vec2,
        tween: Option<&AnimSpec>,
        spring: Option<&SpringSpec>,
    ) -> (sequoia_core::Vec2, bool) {
        let key = (el, prop.0);
        if self.reduced_motion() || (tween.is_none() && spring.is_none()) {
            self.inner.live_anims.borrow_mut().remove(&key);
            return (target, false);
        }
        let now = self.now();
        let mut map = self.inner.live_anims.borrow_mut();
        let entry = map.entry(key).or_insert_with(|| {
            AnimState::Vec2(crate::live::Vec2State {
                current: target,
                from: target,
                start: now,
                last_target: target,
                tween: tween.copied(),
                spring: spring.copied(),
                velocity: sequoia_core::Vec2::ZERO,
                last_tick: now,
                initialized: false,
            })
        });
        if !matches!(entry, AnimState::Vec2(_)) {
            *entry = AnimState::Vec2(crate::live::Vec2State {
                current: target,
                from: target,
                start: now,
                last_target: target,
                tween: tween.copied(),
                spring: spring.copied(),
                velocity: sequoia_core::Vec2::ZERO,
                last_tick: now,
                initialized: false,
            });
        }
        let AnimState::Vec2(st) = entry else {
            return (target, false);
        };
        let (v, running) = AnimState::sample_vec2(st, target, tween, spring, now);
        drop(map);
        if running {
            self.request_frame();
        }
        (v, running)
    }

    pub fn resolve_live_f32(&self, el: ElementId, prop: Prop, live: &Live<f32>) -> f32 {
        let target = live.target_untracked();
        let (v, _) = self.live_f32(
            el,
            prop,
            target,
            live.tween_spec().as_ref(),
            live.spring_spec().as_ref(),
        );
        v
    }

    pub fn resolve_live_vec2(
        &self,
        el: ElementId,
        prop: Prop,
        live: &Live<sequoia_core::Vec2>,
    ) -> sequoia_core::Vec2 {
        let target = live.target_untracked();
        let (v, _) = self.live_vec2(
            el,
            prop,
            target,
            live.tween_spec().as_ref(),
            live.spring_spec().as_ref(),
        );
        v
    }

    pub fn live_anim_count(&self) -> usize {
        self.inner.live_anims.borrow().len()
    }

    pub fn shapes(&self) -> &sequoia_draw::ShapeCache {
        &self.inner.shapes
    }

    pub fn mount(&self, root: impl View + 'static) {
        self.mount_any(AnyView::new(root));
    }

    pub fn mount_any(&self, root: AnyView) {
        if let Some(old) = self.inner.root.get() {
            self.unmount_subtree(old);
        }
        let value = unwrap_any(root.into_inner());
        let id = self.alloc(value, None, 0, 0);
        if let Some(v) = self.view_rc(id) {
            self.build_with(id, v);
        }
        if let Some(v) = self.view_rc(id) {
            let type_name = v.type_name().to_string();
            if std::panic::catch_unwind(AssertUnwindSafe(|| {
                v.on_mount();
            }))
            .is_err()
            {
                self.record_error(id, type_name, "on_mount panicked".to_string());
            }
        }
        self.inner.root.set(Some(id));
        self.mark_full_damage();
    }

    pub fn with_state<S: Default + 'static, R>(
        &self,
        el: ElementId,
        f: impl FnOnce(&mut S) -> R,
    ) -> R {
        struct Reinsert<'a> {
            map: &'a RefCell<HashMap<ElementId, Box<dyn Any>>>,
            el: ElementId,
            slot: Option<Box<dyn Any>>,
        }
        impl Drop for Reinsert<'_> {
            fn drop(&mut self) {
                if let Some(slot) = self.slot.take() {
                    self.map.borrow_mut().insert(self.el, slot);
                }
            }
        }

        let slot = match self.inner.states.borrow_mut().remove(&el) {
            Some(b) if b.is::<S>() => b,

            Some(_) | None => Box::new(S::default()),
        };
        let mut guard = Reinsert {
            map: &self.inner.states,
            el,
            slot: Some(slot),
        };
        let s = guard
            .slot
            .as_mut()
            .and_then(|b| b.downcast_mut::<S>())
            .expect("slot ma typ S po sprawdzeniu is::<S>()");
        f(s)
    }

    pub fn read_state<S: Default + 'static, R>(&self, el: ElementId, f: impl FnOnce(&S) -> R) -> R {
        self.with_state::<S, R>(el, |s| f(s))
    }

    pub fn state_count(&self) -> usize {
        self.inner.states.borrow().len()
    }

    pub fn has_state(&self, el: ElementId) -> bool {
        self.inner.states.borrow().contains_key(&el)
    }

    pub fn track_scoped(&self, el: ElementId, cancel: impl FnOnce() + 'static) {
        if !self.is_alive(el) {
            cancel();
            return;
        }
        self.inner
            .scoped_cancels
            .borrow_mut()
            .entry(el)
            .or_default()
            .push(Box::new(cancel));
    }

    pub fn scoped_count(&self) -> usize {
        self.inner
            .scoped_cancels
            .borrow()
            .values()
            .map(|v| v.len())
            .sum()
    }

    pub fn request_rebuild(&self, el: ElementId) {
        self.inner.schedule(el);
    }

    pub fn tick(&self) {
        self.advance_clock();
        self.settle();
    }

    fn settle(&self) {
        flush_effects();
        // Rects describe the previous layout, so they can only be trusted when
        // no structural change is waiting for the next layout pass.
        let rects_valid = !self.inner.layout_dirty.get();
        loop {
            let next = self.inner.queue.borrow_mut().pop();
            let Some(id) = next else { break };
            let flags = {
                self.inner
                    .arena
                    .borrow()
                    .get(id)
                    .map(|e| e.dirty)
                    .unwrap_or_else(Dirty::empty)
            };
            if flags.is_empty() {
                continue;
            }
            if rects_valid && self.rebuild_can_wait(id) {
                // Leave the flags set: the next layout that reaches this
                // element rebuilds it in `measure_inner`. Keeping it out of
                // the queue stops `has_pending_layout` from re-running the
                // whole layout for content no one can see.
                continue;
            }
            if let Some(e) = self.inner.arena.borrow_mut().get_mut(id) {
                e.dirty = Dirty::empty();
            }
            if !flags.needs_layout() {
                continue;
            }
            let Some(v) = self.view_rc(id) else { continue };
            self.build_with(id, v);
            self.mark_damage(id, Dirty::PAINT);
            let mut s = self.inner.stats.get();
            s.rebuilds += 1;
            self.inner.stats.set(s);
        }
    }

    /// Whether a rebuild can wait until layout reaches the element.
    ///
    /// Only leaves fully outside the viewport qualify: their content is not
    /// painted, and their rect will be recomputed when they scroll in.
    fn rebuild_can_wait(&self, id: ElementId) -> bool {
        let viewport = self.inner.viewport.get();
        if viewport.is_empty() {
            return false;
        }
        let arena = self.inner.arena.borrow();
        let Some(e) = arena.get(id) else {
            return false;
        };
        let rect = e.rect.get();
        // Parked rows sit far off screen; other rows are off screen when their
        // last arranged rect no longer overlaps the viewport.
        let parked = rect.right() < viewport.left() || rect.bottom() < viewport.top();
        let offscreen = !rect.is_empty() && !rect.intersects(viewport);
        (parked || offscreen) && e.view.as_ref().is_some_and(|v| v.is_leaf())
    }

    #[must_use]
    pub fn root(&self) -> Option<ElementId> {
        self.inner.root.get()
    }

    pub fn is_alive(&self, id: ElementId) -> bool {
        self.inner.arena.borrow().get(id).is_some()
    }

    pub fn children(&self, id: ElementId) -> Vec<ElementId> {
        self.inner
            .arena
            .borrow()
            .get(id)
            .map(|e| e.children.clone())
            .unwrap_or_default()
    }

    pub fn children_len(&self, id: ElementId) -> usize {
        self.inner
            .arena
            .borrow()
            .get(id)
            .map(|e| e.children.len())
            .unwrap_or(0)
    }

    pub fn key_of(&self, id: ElementId) -> Option<u64> {
        self.inner.arena.borrow().get(id).map(|e| e.key)
    }

    pub fn rect_of(&self, id: ElementId) -> Option<Rect> {
        self.inner.arena.borrow().get(id).map(|e| e.rect.get())
    }
    pub fn find_by_test_id(&self, test_id: &str) -> Option<ElementId> {
        let arena = self.inner.arena.borrow();
        for (i, slot) in arena.slots.iter().enumerate() {
            let Some(el) = slot else { continue };
            let id = ElementId {
                index: i as u32,
                generation: arena.generations[i],
            };
            if arena.get(id).is_none() {
                continue;
            }
            let Some(view) = el.view.clone() else {
                continue;
            };
            if view.test_id_erased().as_deref() == Some(test_id) {
                return Some(id);
            }
        }
        None
    }

    pub fn element_count(&self) -> usize {
        self.inner.arena.borrow().alive()
    }

    pub fn stats(&self) -> Stats {
        self.inner.stats.get()
    }

    /// Returns `(measure calls, cache hits)` since the last reset.
    ///
    /// A healthy incremental layout keeps calls close to hits: a cache miss
    /// means the element was measured (and text shaped) again.
    pub fn measure_cache_stats(&self) -> (u64, u64) {
        (
            self.inner.measure_calls.get(),
            self.inner.measure_hits.get(),
        )
    }

    /// Clears the [`Runtime::measure_cache_stats`] counters.
    pub fn reset_measure_cache_stats(&self) {
        self.inner.measure_calls.set(0);
        self.inner.measure_hits.set(0);
        self.inner.measure_ns.set(0);
        self.inner.arrange_ns.set(0);
    }

    /// Returns `(measure, arrange)` duration in nanoseconds for the last layout.
    pub fn layout_breakdown(&self) -> (u64, u64) {
        (self.inner.measure_ns.get(), self.inner.arrange_ns.get())
    }

    pub fn errors(&self) -> Vec<RuntimeError> {
        self.inner.errors.borrow().clone()
    }

    pub fn errors_seq(&self) -> Signal<u64> {
        self.inner.errors_seq.clone()
    }

    pub fn clear_errors(&self) {
        self.inner.errors.borrow_mut().clear();
    }

    pub fn is_descendant_of(&self, el: ElementId, ancestor: ElementId) -> bool {
        let mut cur = Some(el);
        while let Some(e) = cur {
            if e == ancestor {
                return true;
            }
            cur = self.parent_of(e);
        }
        false
    }

    fn record_error(&self, element: ElementId, type_name: String, message: String) {
        let err = RuntimeError {
            element,
            type_name,
            message,
        };
        {
            let mut errors = self.inner.errors.borrow_mut();
            if errors.len() >= MAX_ERRORS {
                errors.remove(0);
            }
            errors.push(err.clone());
        }
        let mut s = self.inner.stats.get();
        s.errors += 1;
        self.inner.stats.set(s);
        self.inner.errors_seq.update(|n| *n += 1);
        self.notify_boundaries(element, &err);
    }

    fn notify_boundaries(&self, element: ElementId, err: &RuntimeError) {
        let chain: Vec<ElementId> = {
            let Ok(arena) = self.inner.arena.try_borrow() else {
                return;
            };
            let mut out = Vec::new();
            let mut cur = arena.get(element).and_then(|_| self.parent_of(element));
            while let Some(id) = cur {
                out.push(id);
                cur = arena.get(id).and_then(|e| e.parent);
            }
            out
        };
        for id in chain {
            if let Some(boundary) = self.view::<crate::error_boundary::ErrorBoundary>(id) {
                boundary.notify(self, id, err);
                return;
            }
        }
    }

    pub fn interact(&self) -> InteractState {
        self.inner.interact.get()
    }

    pub fn pointer_pos(&self) -> Option<Point> {
        let st = self.inner.interact.get();
        st.pointer_seen.then_some(st.cursor)
    }

    fn subtree_wants_hover(&self, mut el: Option<ElementId>) -> bool {
        while let Some(e) = el {
            if self
                .view_rc(e)
                .map(|v| v.wants_hover_updates_erased())
                .unwrap_or(false)
            {
                return true;
            }
            el = self.parent_of(e);
        }
        false
    }

    pub fn cursor_icon(&self) -> CursorIcon {
        if self.inner.active_drag.borrow().is_some() {
            return CursorIcon::Grabbing;
        }
        let st = self.inner.interact.get();
        let mut cur = st.captured.or(st.hovered);
        while let Some(id) = cur {
            let Some(v) = self.view_rc(id) else {
                break;
            };
            let (state, _) = self.view_state(id);
            let icon = v.cursor_icon_erased(state);
            if icon != CursorIcon::Default {
                return icon;
            }
            cur = self.parent_of(id);
        }
        CursorIcon::Default
    }

    pub fn type_name_of(&self, id: ElementId) -> Option<String> {
        self.inner
            .arena
            .borrow()
            .get(id)?
            .view
            .as_ref()
            .map(|v| v.type_name().to_string())
    }

    pub fn view<T: View + 'static>(&self, id: ElementId) -> Option<Rc<T>> {
        let rc = self.view_rc(id)?;
        let any: Rc<dyn Any> = rc.as_any_rc();
        any.downcast::<T>().ok()
    }

    /// Whether the next [`Runtime::layout`] call has work to do.
    ///
    /// True for structural rebuilds and pending layout marks.
    /// Paint-only damage leaves the layout clean.
    pub fn layout_dirty(&self) -> bool {
        self.inner.layout_dirty.get() || self.has_pending_layout()
    }

    pub(crate) fn invalidate_layout(&self) {
        self.inner.layout_dirty.set(true);
    }

    /// Solves layout for `bounds`.
    ///
    /// The pass is skipped when the viewport and [`Runtime::layout_dirty`] are
    /// clean. Structural changes, scroll offsets, layout animations, and new
    /// viewports mark layout dirty.
    pub fn layout(&self, bounds: Rect, text: &mut TextSystem) {
        const MAX_SETTLE_PASSES: u8 = 4;
        if self.inner.viewport.get() == bounds
            && !self.inner.layout_dirty.get()
            && !self.has_pending_layout()
        {
            return;
        }
        // Apply reactive and structural updates before measuring. Otherwise
        // the queue is still full when the first pass ends, `has_pending_layout`
        // forces another pass, and the whole tree is laid out again after the
        // rebuild. Settling first gives one rebuild plus one layout pass.
        self.settle();
        for pass in 0..MAX_SETTLE_PASSES {
            self.inner.layout_dirty.set(false);
            self.layout_once(bounds, text);
            if !self.has_pending_layout() {
                // Rebuilding a deferred off-screen leaf during measure sets
                // this flag; the pass that just finished incorporated it.
                self.inner.layout_dirty.set(false);
                return;
            }
            if pass + 1 < MAX_SETTLE_PASSES {
                self.settle();
            }
        }
        log::warn!(
            "sequoia-view: layout still dirty after {MAX_SETTLE_PASSES} passes; \
             a view is scheduling layout while being laid out"
        );
    }

    fn has_pending_layout(&self) -> bool {
        let queue = self.inner.queue.borrow();
        if queue.is_empty() {
            return false;
        }
        let arena = self.inner.arena.borrow();
        queue.iter().any(|id| {
            arena
                .get(*id)
                .map(|e| e.dirty.needs_layout())
                .unwrap_or(false)
        })
    }

    fn layout_once(&self, bounds: Rect, text: &mut TextSystem) {
        let Some(root) = self.inner.root.get() else {
            return;
        };
        self.inner.wrap_cache.borrow_mut().clear();
        if self.inner.viewport.get() != bounds {
            self.inner.layers.borrow_mut().invalidate_all();
            let mut damage = self.inner.damage.borrow_mut();
            damage.mark_full();
            damage.mark_layout();
        }
        self.inner.viewport.set(bounds);

        self.inner.window_size.set(bounds.size);
        let default_font_size = self
            .inner
            .environment
            .borrow()
            .get::<Theme>()
            .unwrap_or_else(Theme::dark)
            .font_size;
        let mut ctx = LayoutCtx::new(text, default_font_size);
        let c = Constraints::loose(Size::new(bounds.size.width, bounds.size.height));
        let measure_start = Instant::now();
        let measured = self.measure(root, c, &mut ctx);
        self.inner
            .measure_ns
            .set(measure_start.elapsed().as_nanos() as u64);
        let root_size = if self.inner.root_fill.get() {
            filled_root_size(self.child_layout_style(root), bounds.size, measured)
        } else {
            measured
        };
        self.warn_if_root_not_fill(root, bounds, root_size);
        let root_rect = Rect::new(bounds.origin, root_size);
        let arrange_start = Instant::now();
        self.arrange(root, root_rect, &mut ctx);
        self.inner
            .arrange_ns
            .set(arrange_start.elapsed().as_nanos() as u64);

        self.layout_overlays(bounds, &mut ctx);
    }

    pub fn paint(&self, list: &mut RenderList, text: &mut TextSystem) {
        self.paint_region(list, text, CullCtx::ENABLED);
    }

    /// Paint with recoverable culling driven by `cull`.
    ///
    /// `paint` keeps the enabled culling path that this runtime used before
    /// the damage work, so existing benchmarks and callers do not pay for
    /// off-screen shaping. `CullCtx::DISABLED` is available for callers that
    /// need a full CPU pass; RenderList still drops items fully outside the
    /// active clip at push time, so the visible output is the same.
    pub fn paint_region(&self, list: &mut RenderList, text: &mut TextSystem, cull: CullCtx) {
        self.inner.redraw_armed.set(false);
        // Paint once into a scratch list while the shape cache records misses
        // instead of tessellating them, then build the recorded set on worker
        // threads before the real pass. If nothing was missing the scratch
        // list already is the frame, so warm frames still paint only once.
        // `paint_self` therefore has to stay free of accumulated state, which
        // the glyph-atlas repaint loop already requires.
        let session = RefCell::new(PaintSession::default());
        let mut scratch = RenderList::new();
        self.inner.shapes.begin_prefetch();
        self.paint_pass(&mut scratch, text, cull, &session);
        let misses = self.inner.shapes.end_prefetch();
        if misses == 0 {
            self.commit_paint_session(session.into_inner());
            if list.is_empty() {
                *list = scratch;
            } else {
                list.append(&scratch);
            }
            return;
        }
        // The prefetch pass painted placeholder shapes, so drop everything it
        // would have cached and paint again with the shapes now available.
        session.replace(PaintSession::default());
        self.inner.shapes.tessellate_prefetch();
        self.paint_pass(list, text, cull, &session);
        self.commit_paint_session(session.into_inner());
    }

    fn commit_paint_session(&self, session: PaintSession) {
        self.inner
            .layer_hits
            .set(self.inner.layer_hits.get().wrapping_add(session.layer_hits));
        self.inner.layer_misses.set(
            self.inner
                .layer_misses
                .get()
                .wrapping_add(session.layer_misses),
        );
        if session.captures.is_empty() {
            return;
        }
        let mut layers = self.inner.layers.borrow_mut();
        for (key, stamp, captured) in session.captures {
            layers.invalidate_element(key.element_id);
            layers.insert_stamped(key, captured, stamp);
        }
    }

    fn paint_pass(
        &self,
        list: &mut RenderList,
        text: &mut TextSystem,
        cull: CullCtx,
        session: &RefCell<PaintSession>,
    ) {
        self.inner.surfaces.borrow_mut().clear();

        let doomed = self.inner.overlays.borrow().transient_ids();
        for id in doomed {
            self.overlay_hide(id);
        }
        let Some(root) = self.inner.root.get() else {
            return;
        };
        let env = self.inner.environment.borrow().clone();
        let hover_chain = self.hover_chain();
        let pass = PaintPass {
            env: &env,
            hover_chain: &hover_chain,
            session,
        };
        // Nothing outside the viewport can reach the image, so clip the root
        // paint to it. Without this, an unbounded subtree (for example a
        // scroll view whose height follows its content) keeps shaping text and
        // pushing quads for thousands of rows that are never shown.
        let viewport = self.inner.viewport.get();
        let root_clip = cull.is_enabled() && !viewport.is_empty();
        if root_clip {
            list.push_clip(viewport);
        }
        self.paint_rec(
            root,
            Vec2::ZERO,
            1.0,
            Transform::IDENTITY,
            list,
            text,
            cull,
            pass,
        );

        {
            let viewport = self.inner.viewport.get();
            let default_font_size = self
                .inner
                .environment
                .borrow()
                .get::<Theme>()
                .unwrap_or_else(Theme::dark)
                .font_size;
            let mut ctx = LayoutCtx::new(&mut *text, default_font_size);
            self.layout_overlays(viewport, &mut ctx);
        }

        let ids = self.inner.overlays.borrow().ordered_ids();
        for id in ids {
            let el = self
                .inner
                .overlays
                .borrow()
                .get(id)
                .and_then(|e| e.element.get());
            if let Some(el) = el {
                self.paint_rec(
                    el,
                    Vec2::ZERO,
                    1.0,
                    Transform::IDENTITY,
                    list,
                    text,
                    cull,
                    pass,
                );
            }
        }
        if root_clip {
            list.pop_clip();
        }

        self.inner
            .live_anims
            .borrow_mut()
            .retain(|(el, _), _| self.inner.arena.borrow().get(*el).is_some());
    }

    pub fn take_surface_draws(&self) -> Vec<SurfaceDraw> {
        std::mem::take(&mut *self.inner.surfaces.borrow_mut())
    }

    pub fn hit_test(&self, pos: Point) -> Option<ElementId> {
        if let Some(hit) = self.hit_overlays(pos) {
            return Some(hit);
        }

        let root = self.inner.root.get()?;
        self.hit_rec(root, pos)
    }

    fn hit_rec(&self, el: ElementId, pos: Point) -> Option<ElementId> {
        let rect = {
            let arena = self.inner.arena.borrow();
            arena.get(el)?.rect.get()
        };
        if !rect.contains(pos) {
            return None;
        }
        for c in self.children(el).iter().rev() {
            if let Some(h) = self.hit_rec(*c, pos) {
                return Some(h);
            }
        }
        let hitable = self
            .view_rc(el)
            .map(|v| v.hit_testable_erased())
            .unwrap_or(true);
        if hitable { Some(el) } else { None }
    }

    /// Moves the pointer without keyboard modifiers.
    ///
    /// Prefer [`Runtime::pointer_move_with_mods`] on platforms that track
    /// modifier state.
    pub fn pointer_move(&self, pos: Point, text: &mut TextSystem) {
        self.pointer_move_with_mods(pos, Modifiers::NONE, text);
    }

    /// Moves the pointer and reports the current keyboard modifiers on the
    /// resulting [`PointerEvent::Move`].
    pub fn pointer_move_with_mods(&self, pos: Point, modifiers: Modifiers, text: &mut TextSystem) {
        let mut st = self.inner.interact.get();
        st.cursor = pos;
        st.pointer_seen = true;
        let old_hover = st.hovered;
        if st.captured.is_none() {
            st.hovered = self.hit_test(pos);
            self.inner.interact.set(st);
        }
        if old_hover != st.hovered {
            for el in [old_hover, st.hovered].iter().flatten() {
                self.inner.mark(*el, Dirty::PAINT);
            }
            self.request_redraw();
        }

        if self.subtree_wants_hover(st.hovered) {
            self.request_redraw();
        }

        if self.inner.pending_drag.borrow().is_some() || self.inner.active_drag.borrow().is_some() {
            self.poll_pending(pos, modifiers, text);
        }
        let ev = Event::Pointer(PointerEvent::Move { pos, modifiers });
        match st.captured {
            Some(c) => {
                let _ = self.dispatch_single(c, &ev, pos, text);
            }
            None => {
                if let Some(t) = st.hovered {
                    let _ = self.dispatch_single(t, &ev, pos, text);
                }
            }
        }
        if let Event::Pointer(pe) = &ev {
            match st.captured {
                Some(c) => self.forward_surface_pointer(c, pe),
                None => {
                    if let Some(t) = st.hovered {
                        self.forward_surface_pointer(t, pe);
                    }
                }
            }
        }
    }

    fn forward_surface_pointer(&self, el: ElementId, event: &PointerEvent) {
        let Some(v) = self.view_rc(el) else { return };
        let Some(mut binding) = v.surface_input_erased() else {
            return;
        };
        let Some(rect) = self.rect_of(el) else { return };
        (binding.on_pointer)(event, rect);
    }

    fn forward_surface_key(&self, el: ElementId, event: &KeyEvent) {
        let Some(v) = self.view_rc(el) else { return };
        let Some(mut binding) = v.surface_input_erased() else {
            return;
        };
        (binding.on_key)(event);
    }

    pub fn pointer_down(
        &self,
        pos: Point,
        button: PointerButton,
        mods: Modifiers,
        text: &mut TextSystem,
    ) {
        if button != PointerButton::Left && self.inner.active_drag.borrow().is_some() {
            self.cancel_drag(text);
            return;
        }

        let doomed = self.inner.overlays.borrow().outside_dismiss_ids(pos);
        for id in doomed {
            self.overlay_hide(id);
        }
        let target = self.hit_test(pos);
        {
            let mut st = self.inner.interact.get();
            st.cursor = pos;
            st.pressed = target;

            st.focus = match target {
                None => None,
                Some(t) => self.nearest_focusable(t).or(st.focus),
            };

            if st.focus.is_some_and(|f| !self.is_alive(f)) {
                st.focus = None;
            }
            self.inner.interact.set(st);
        }
        self.dismiss_focus_lost(target);
        if let Some(t) = target {
            let ev = Event::Pointer(PointerEvent::Down {
                button,
                pos,
                modifiers: mods,
            });
            self.dispatch_chain(t, &ev, pos, text);
            if let Event::Pointer(pe) = &ev {
                self.forward_surface_pointer(t, pe);
            }
            if let Some(cap) = self.auto_capture(t) {
                let mut st = self.inner.interact.get();
                st.captured = Some(cap);
                self.inner.interact.set(st);
            }
        }
        self.request_redraw();
    }

    pub fn pointer_up(
        &self,
        pos: Point,
        button: PointerButton,
        mods: Modifiers,
        text: &mut TextSystem,
    ) {
        if self.inner.active_drag.borrow().is_some() {
            if button == PointerButton::Left {
                self.finish_drop(pos, mods, text);
            } else {
                self.cancel_drag(text);
            }
            return;
        }

        if self.inner.pending_drag.borrow().is_some() {
            self.inner.pending_drag.borrow_mut().take();
            let mut st = self.inner.interact.get();
            st.captured = None;
            self.inner.interact.set(st);
        }
        let mut st = self.inner.interact.get();
        st.cursor = pos;
        st.hovered = self.hit_test(pos);
        self.inner.interact.set(st);
        let ev = Event::Pointer(PointerEvent::Up {
            button,
            pos,
            modifiers: mods,
        });
        match st.captured {
            Some(c) => {
                let handled = self.dispatch_single(c, &ev, pos, text);

                if !handled
                    && let Some(p) = st.pressed
                    && p != c
                    && self.is_alive(p)
                {
                    self.dispatch_chain(p, &ev, pos, text);
                }
            }
            None => {
                if let Some(p) = st.pressed {
                    self.dispatch_chain(p, &ev, pos, text);
                }
            }
        }
        if let Event::Pointer(pe) = &ev {
            match st.captured {
                Some(c) => self.forward_surface_pointer(c, pe),
                None => {
                    if let Some(p) = st.pressed {
                        self.forward_surface_pointer(p, pe);
                    }
                }
            }
        }
        let mut st2 = self.inner.interact.get();
        st2.pressed = None;
        st2.captured = None;
        self.inner.interact.set(st2);
        self.request_redraw();
    }

    pub fn wheel(&self, pos: Point, delta: Vec2, modifiers: Modifiers, text: &mut TextSystem) {
        let Some(target) = self.hit_test(pos) else {
            return;
        };
        let ev = Event::Pointer(PointerEvent::Wheel {
            delta,
            pos,
            modifiers,
        });
        self.dispatch_chain(target, &ev, pos, text);
        if let Event::Pointer(pe) = &ev {
            self.forward_surface_pointer(target, pe);
        }
        self.request_redraw();
    }

    pub fn pointer_pressure(&self) -> f32 {
        self.inner.stylus_pressure.get()
    }

    pub fn pointer_tool(&self) -> PenTool {
        self.inner.stylus_tool.get()
    }

    pub fn active_touches(&self) -> Vec<(u64, Point)> {
        self.inner
            .touches
            .borrow()
            .iter()
            .map(|(k, v)| (*k, *v))
            .collect()
    }

    fn set_stylus(&self, pressure: f32, tool: PenTool) {
        self.inner.stylus_pressure.set(pressure.clamp(0.0, 1.0));
        self.inner.stylus_tool.set(tool);
    }

    pub fn pen_down(
        &self,
        pos: Point,
        button: PointerButton,
        pressure: f32,
        tilt: Vec2,
        tool: PenTool,
        mods: Modifiers,
        text: &mut TextSystem,
    ) {
        let _ = tilt;
        self.set_stylus(pressure, tool);
        self.pointer_down(pos, button, mods, text);
    }

    pub fn pen_move(
        &self,
        pos: Point,
        pressure: f32,
        tilt: Vec2,
        tool: PenTool,
        text: &mut TextSystem,
    ) {
        let _ = tilt;
        self.set_stylus(pressure, tool);
        self.pointer_move(pos, text);
    }

    pub fn pen_up(
        &self,
        pos: Point,
        button: PointerButton,
        pressure: f32,
        mods: Modifiers,
        text: &mut TextSystem,
    ) {
        self.set_stylus(pressure, self.inner.stylus_tool.get());
        self.pointer_up(pos, button, mods, text);
    }

    pub fn touch_down(
        &self,
        id: u64,
        pos: Point,
        force: Option<f32>,
        mods: Modifiers,
        text: &mut TextSystem,
    ) {
        let first = self.inner.touches.borrow().is_empty();
        self.inner.touches.borrow_mut().insert(id, pos);
        self.set_stylus(force.unwrap_or(1.0), PenTool::Touch);
        if first {
            self.pointer_down(pos, PointerButton::Left, mods, text);
        }
        if let Some(t) = self.hit_test(pos) {
            let ev = Event::Pointer(PointerEvent::TouchDown {
                id,
                pos,
                force,
                modifiers: mods,
            });
            self.dispatch_chain(t, &ev, pos, text);
            if let Event::Pointer(pe) = &ev {
                self.forward_surface_pointer(t, pe);
            }
        }
        self.request_redraw();
    }

    pub fn touch_move(&self, id: u64, pos: Point, force: Option<f32>, text: &mut TextSystem) {
        let is_first = self
            .inner
            .touches
            .borrow()
            .keys()
            .next()
            .is_some_and(|first| *first == id);
        self.inner.touches.borrow_mut().insert(id, pos);
        self.set_stylus(force.unwrap_or(1.0), PenTool::Touch);
        if is_first {
            self.pointer_move(pos, text);
        }
        let ev = Event::Pointer(PointerEvent::TouchMove {
            id,
            pos,
            force,
            modifiers: Modifiers::NONE,
        });

        match self.inner.interact.get().captured {
            Some(c) => {
                self.dispatch_single(c, &ev, pos, text);
                if let Event::Pointer(pe) = &ev {
                    self.forward_surface_pointer(c, pe);
                }
            }
            None => {
                if let Some(t) = self.hit_test(pos) {
                    self.dispatch_chain(t, &ev, pos, text);
                    if let Event::Pointer(pe) = &ev {
                        self.forward_surface_pointer(t, pe);
                    }
                }
            }
        }
        self.request_redraw();
    }

    pub fn touch_up(&self, id: u64, pos: Point, mods: Modifiers, text: &mut TextSystem) {
        let was_last = {
            let mut touches = self.inner.touches.borrow_mut();
            touches.remove(&id);
            touches.is_empty()
        };
        let ev = Event::Pointer(PointerEvent::TouchUp {
            id,
            pos,
            modifiers: mods,
        });

        match self.inner.interact.get().captured {
            Some(c) => {
                self.dispatch_single(c, &ev, pos, text);
                if let Event::Pointer(pe) = &ev {
                    self.forward_surface_pointer(c, pe);
                }
            }
            None => {
                if let Some(t) = self.hit_test(pos) {
                    self.dispatch_chain(t, &ev, pos, text);
                    if let Event::Pointer(pe) = &ev {
                        self.forward_surface_pointer(t, pe);
                    }
                }
            }
        }
        if was_last {
            self.pointer_up(pos, PointerButton::Left, mods, text);
        } else {
            self.request_redraw();
        }
    }

    pub fn pinch(&self, pos: Point, delta: f32, mods: Modifiers, text: &mut TextSystem) {
        let Some(target) = self.hit_test(pos) else {
            return;
        };
        let ev = Event::Pointer(PointerEvent::Pinch {
            delta,
            pos,
            modifiers: mods,
        });
        self.dispatch_chain(target, &ev, pos, text);
        if let Event::Pointer(pe) = &ev {
            self.forward_surface_pointer(target, pe);
        }
        self.request_redraw();
    }

    pub fn key(&self, key: Key, mods: Modifiers, text: &mut TextSystem) {
        if key == Key::ESCAPE && self.inner.active_drag.borrow().is_some() {
            self.cancel_drag(text);
            return;
        }
        let esc = self.inner.overlays.borrow().escape_dismiss_id();
        if key == Key::ESCAPE
            && let Some(id) = esc
        {
            self.overlay_hide(id);
            return;
        }
        if key == Key::TAB && !self.focused_accepts_tab() {
            self.focus_next(mods.contains(Modifiers::SHIFT));
            self.request_redraw();
            return;
        }
        let st = self.inner.interact.get();
        let Some(f) = st.focus else { return };
        if !self.is_alive(f) {
            return;
        }
        let ev = Event::Key(KeyEvent {
            key,
            modifiers: mods,
        });
        self.dispatch_chain(f, &ev, Point::ZERO, text);
        if let Event::Key(ke) = &ev {
            self.forward_surface_key(f, ke);
        }
        self.request_redraw();
    }

    pub fn ime(&self, event: ImeEvent, text: &mut TextSystem) {
        let st = self.inner.interact.get();
        let Some(f) = st.focus else { return };
        if !self.is_alive(f) {
            return;
        }
        let ev = Event::Ime(event);

        let cursor = st.cursor;
        self.dispatch_chain(f, &ev, cursor, text);
        self.request_redraw();
    }

    pub fn files_hovered(&self, paths: Vec<std::path::PathBuf>, pos: Point, text: &mut TextSystem) {
        let Some(target) = self.hit_test(pos) else {
            return;
        };
        let ev = Event::FilesHovered {
            paths,
            position: pos,
        };
        self.dispatch_chain(target, &ev, pos, text);
        self.request_redraw();
    }

    pub fn files_dropped(&self, paths: Vec<std::path::PathBuf>, pos: Point, text: &mut TextSystem) {
        let Some(target) = self.hit_test(pos) else {
            return;
        };
        let ev = Event::FilesDropped {
            paths,
            position: pos,
        };
        self.dispatch_chain(target, &ev, pos, text);
        self.request_redraw();
    }

    pub fn files_cancelled(&self, text: &mut TextSystem) {
        let pos = self.inner.interact.get().cursor;
        let ev = Event::FilesCancelled;
        if let Some(target) = self.hit_test(pos) {
            self.dispatch_chain(target, &ev, pos, text);
        }
        self.request_redraw();
    }

    pub fn ime_cursor_rect(&self) -> Option<Rect> {
        let st = self.inner.interact.get();
        let f = st.focus?;
        let caret = self.view_rc(f).and_then(|v| v.ime_caret_rect_erased());
        caret.or_else(|| self.rect_of(f))
    }

    pub fn overlay_show(&self, entry: OverlayEntry) -> OverlayId {
        let transient = entry.transient;
        let view = entry.view.clone_inner();
        let value = unwrap_any(view);
        let el = self.alloc(value, None, 0, 0);
        if let Some(v) = self.view_rc(el) {
            self.build_with(el, v);
        }
        if let Some(v) = self.view_rc(el) {
            let type_name = v.type_name().to_string();
            if std::panic::catch_unwind(AssertUnwindSafe(|| {
                v.on_mount();
            }))
            .is_err()
            {
                self.record_error(el, type_name, "on_mount panicked".to_string());
            }
        }
        entry.element.set(Some(el));
        let id = self.inner.overlays.borrow_mut().insert(entry);
        self.inner
            .damage
            .borrow_mut()
            .mark(Dirty::PAINT | Dirty::OVERLAY);
        if !transient {
            self.request_redraw();
        }
        id
    }

    pub fn overlay_hide(&self, id: OverlayId) -> bool {
        let Some(entry) = self.inner.overlays.borrow_mut().remove(id) else {
            return false;
        };
        if let Some(el) = entry.element.get() {
            self.unmount_subtree(el);
        }
        self.request_redraw();
        true
    }

    pub fn overlay_rect(&self, id: OverlayId) -> Option<Rect> {
        self.inner.overlays.borrow().get(id).map(|e| e.rect.get())
    }

    pub fn overlay_exists(&self, id: OverlayId) -> bool {
        self.inner.overlays.borrow().get(id).is_some()
    }

    pub fn overlay_element(&self, id: OverlayId) -> Option<ElementId> {
        self.inner
            .overlays
            .borrow()
            .get(id)
            .and_then(|e| e.element.get())
    }

    pub fn accessibility_tree(&self) -> Vec<crate::a11y::AccessibleNode> {
        let Some(root) = self.inner.root.get() else {
            return Vec::new();
        };
        self.accessibility_children(root)
    }

    fn accessibility_children(&self, el: ElementId) -> Vec<crate::a11y::AccessibleNode> {
        let mut out = Vec::new();
        for child in self.children(el) {
            if !self.is_alive(child) {
                continue;
            }
            let kids = self.accessibility_children(child);
            match self.view_rc(child).and_then(|v| v.accessibility_erased()) {
                Some(a) => out.push(crate::a11y::AccessibleNode {
                    element: child,
                    role: a.role,
                    label: a.label,
                    value: a.value,
                    caret: a.caret,
                    selection: a.selection,
                    disabled: a.disabled,
                    children: kids,
                }),
                None => out.extend(kids),
            }
        }
        out
    }

    pub fn overlay_ids(&self) -> Vec<OverlayId> {
        self.inner.overlays.borrow().ordered_ids()
    }

    pub fn overlay_count(&self) -> usize {
        self.inner.overlays.borrow().len()
    }

    pub fn overlay_set_position(&self, id: OverlayId, x: f32, y: f32) -> bool {
        let ok = self.inner.overlays.borrow_mut().set_offset(id, (x, y));
        if ok {
            self.request_redraw();
        }
        ok
    }

    pub fn begin_pending(
        &self,
        source: ElementId,
        payload: DragPayload,
        origin: Point,
        source_rect: Rect,
        options: DragOptions,
    ) {
        if self.inner.active_drag.borrow().is_some() || !self.is_alive(source) {
            return;
        }
        *self.inner.pending_drag.borrow_mut() = Some(PendingDrag {
            source,
            origin,
            source_rect,
            payload,
            preview: options.preview,
            threshold: options.threshold,
        });
    }

    pub fn current_drag(&self) -> Option<DragSession> {
        self.inner
            .active_drag
            .borrow()
            .as_ref()
            .map(ActiveDrag::snapshot)
    }

    pub fn has_pending_drag(&self) -> bool {
        self.inner.pending_drag.borrow().is_some()
    }

    pub fn drag_target_contains(&self, el: ElementId) -> bool {
        let Some(target) = self
            .inner
            .active_drag
            .borrow()
            .as_ref()
            .and_then(|a| a.target)
        else {
            return false;
        };
        let mut cur = Some(el);
        while let Some(e) = cur {
            if e == target {
                return true;
            }
            cur = self.parent_of(e);
        }
        false
    }

    pub fn drop_target_at(&self, pos: Point, payload: &DragPayload) -> Option<ElementId> {
        let mut cur = self.hit_test(pos);
        while let Some(el) = cur {
            if self.is_alive(el)
                && self
                    .view_rc(el)
                    .is_some_and(|v| v.accepts_drop_erased(payload))
            {
                return Some(el);
            }
            cur = self.parent_of(el);
        }
        None
    }

    pub fn cancel_drag(&self, text: &mut TextSystem) {
        let (source, current) = {
            let guard = self.inner.active_drag.borrow();
            let Some(act) = guard.as_ref() else {
                drop(guard);
                self.inner.pending_drag.borrow_mut().take();
                return;
            };
            (act.source, act.current)
        };
        if let Some(src) = source.filter(|s| self.is_alive(*s)) {
            self.call_drag_end(
                src,
                DragEnd {
                    dropped: false,
                    cancelled: true,
                },
                current,
                text,
            );
        }
        let active = self.inner.active_drag.borrow_mut().take();
        self.inner.pending_drag.borrow_mut().take();
        if let Some(act) = active
            && let Some(pv) = act.preview
        {
            self.overlay_hide(pv);
        }
        let mut st = self.inner.interact.get();
        st.pressed = None;
        st.captured = None;
        self.inner.interact.set(st);
        self.request_redraw();
    }

    fn poll_pending(&self, current: Point, modifiers: Modifiers, text: &mut TextSystem) {
        if self.inner.active_drag.borrow().is_some() {
            self.update_active(current, modifiers, text);
            return;
        }
        let pending = self.inner.pending_drag.borrow_mut().take();
        let Some(p) = pending else { return };
        if !self.is_alive(p.source) {
            return;
        }
        if !exceeded_threshold(p.origin, current, p.threshold) {
            *self.inner.pending_drag.borrow_mut() = Some(p);
            return;
        }
        let grab = grab_offset(p.origin, p.source_rect);
        let id = DragId(self.inner.next_drag_id.get());
        self.inner.next_drag_id.set(id.0 + 1);
        let preview = p.preview.map(|view| {
            let at = preview_origin(current, grab);
            self.overlay_show(
                OverlayEntry::new(view)
                    .at(at.x, at.y)
                    .layer(OverlayLayer::DragPreview)
                    .input_mode(InputMode::Passthrough),
            )
        });
        let target = self.drop_target_at(current, &p.payload);
        *self.inner.active_drag.borrow_mut() = Some(ActiveDrag {
            id,
            payload: p.payload,
            source: Some(p.source),
            origin: p.origin,
            grab_offset: grab,
            current,
            modifiers,
            target,
            preview,
        });

        let mut st = self.inner.interact.get();
        st.captured = Some(p.source);
        self.inner.interact.set(st);
        self.call_drag_start(p.source, current, text);
        if let Some(t) = target {
            self.call_drag_over(t, current, modifiers, text);
        }
        self.request_redraw();
    }

    fn update_active(&self, current: Point, modifiers: Modifiers, text: &mut TextSystem) {
        let (target, preview_move) = {
            let mut guard = self.inner.active_drag.borrow_mut();
            let Some(act) = guard.as_mut() else {
                return;
            };
            act.current = current;
            act.modifiers = modifiers;
            let t = self.drop_target_at(current, &act.payload);
            act.target = t;
            let mv = act
                .preview
                .map(|id| (id, preview_origin(current, act.grab_offset)));
            (t, mv)
        };
        if let Some((id, at)) = preview_move {
            self.overlay_set_position(id, at.x, at.y);
        }
        if let Some(t) = target {
            self.call_drag_over(t, current, modifiers, text);
        }
        self.request_redraw();
    }

    fn finish_drop(&self, current: Point, modifiers: Modifiers, text: &mut TextSystem) -> bool {
        let payload = {
            let guard = self.inner.active_drag.borrow();
            let Some(act) = guard.as_ref() else {
                return false;
            };
            act.payload.clone()
        };

        let target = self.drop_target_at(current, &payload);
        let mut dropped = false;
        if let Some(t) = target {
            let rect = self.rect_of(t).unwrap_or(Rect::ZERO);
            let pos = DropPosition::in_rect(current, rect, modifiers);
            dropped = self.call_drop(t, pos, text);
        }
        let (source, preview) = {
            let mut guard = self.inner.active_drag.borrow_mut();
            match guard.take() {
                Some(act) => (act.source, act.preview),

                None => return true,
            }
        };
        self.inner.pending_drag.borrow_mut().take();
        if let Some(pv) = preview {
            self.overlay_hide(pv);
        }
        let mut st = self.inner.interact.get();
        st.pressed = None;
        st.captured = None;
        st.hovered = self.hit_test(current);
        self.inner.interact.set(st);
        if let Some(src) = source.filter(|s| self.is_alive(*s)) {
            self.call_drag_end(
                src,
                DragEnd {
                    dropped,
                    cancelled: false,
                },
                current,
                text,
            );
        }
        self.request_redraw();
        true
    }

    fn drag_ctx_parts(&self, el: ElementId) -> (VisualState, bool, Rect, Environment) {
        let (state, hover_self) = self.view_state(el);
        let rect = {
            let arena = self.inner.arena.borrow();
            arena.get(el).map(|e| e.rect.get()).unwrap_or(Rect::ZERO)
        };
        let env = self.inner.environment.borrow().clone();
        (state, hover_self, rect, env)
    }

    fn call_drag_start(&self, el: ElementId, pos: Point, text: &mut TextSystem) {
        let Some(v) = self.view_rc(el) else { return };
        let cells = DispatchCells::new();
        let (state, hover_self, rect, env) = self.drag_ctx_parts(el);
        let mut ctx = EventCtx {
            phase: EventPhase::Target,
            element: el,
            state,
            hover_self,
            pos,
            rect,
            environment: &env,
            window: self.inner.window.get(),
            stopped: &cells.stopped,
            handled: &cells.handled,
            capture_req: &cells.capture_req,
            release_req: &cells.release_req,
            focus_req: &cells.focus_req,
            text,
            runtime: self,
        };
        let type_name = v.type_name().to_string();
        if std::panic::catch_unwind(AssertUnwindSafe(|| {
            v.on_drag_start_erased(&mut ctx);
        }))
        .is_err()
        {
            self.record_error(el, type_name, "on_drag_start panicked".to_string());
        }
    }

    fn call_drag_over(
        &self,
        el: ElementId,
        current: Point,
        modifiers: Modifiers,
        text: &mut TextSystem,
    ) {
        let Some(v) = self.view_rc(el) else { return };
        let cells = DispatchCells::new();
        let (state, hover_self, rect, env) = self.drag_ctx_parts(el);
        let mut ctx = EventCtx {
            phase: EventPhase::Target,
            element: el,
            state,
            hover_self,
            pos: current,
            rect,
            environment: &env,
            window: self.inner.window.get(),
            stopped: &cells.stopped,
            handled: &cells.handled,
            capture_req: &cells.capture_req,
            release_req: &cells.release_req,
            focus_req: &cells.focus_req,
            text,
            runtime: self,
        };
        let pos = DropPosition::in_rect(current, rect, modifiers);
        let type_name = v.type_name().to_string();
        if std::panic::catch_unwind(AssertUnwindSafe(|| {
            v.on_drag_over_erased(pos, &mut ctx);
        }))
        .is_err()
        {
            self.record_error(el, type_name, "on_drag_over panicked".to_string());
        }
    }

    fn call_drop(&self, el: ElementId, pos: DropPosition, text: &mut TextSystem) -> bool {
        let Some(v) = self.view_rc(el) else {
            return false;
        };
        let cells = DispatchCells::new();
        let (state, hover_self, rect, env) = self.drag_ctx_parts(el);
        let mut ctx = EventCtx {
            phase: EventPhase::Target,
            element: el,
            state,
            hover_self,
            pos: pos.global,
            rect,
            environment: &env,
            window: self.inner.window.get(),
            stopped: &cells.stopped,
            handled: &cells.handled,
            capture_req: &cells.capture_req,
            release_req: &cells.release_req,
            focus_req: &cells.focus_req,
            text,
            runtime: self,
        };
        let type_name = v.type_name().to_string();
        if std::panic::catch_unwind(AssertUnwindSafe(|| {
            v.on_drop_erased(pos, &mut ctx);
        }))
        .is_err()
        {
            self.record_error(el, type_name, "on_drop panicked".to_string());
            return false;
        }
        cells.handled.get()
    }

    fn call_drag_end(&self, el: ElementId, end: DragEnd, current: Point, text: &mut TextSystem) {
        let Some(v) = self.view_rc(el) else { return };
        let cells = DispatchCells::new();
        let (state, hover_self, rect, env) = self.drag_ctx_parts(el);
        let mut ctx = EventCtx {
            phase: EventPhase::Target,
            element: el,
            state,
            hover_self,
            pos: current,
            rect,
            environment: &env,
            window: self.inner.window.get(),
            stopped: &cells.stopped,
            handled: &cells.handled,
            capture_req: &cells.capture_req,
            release_req: &cells.release_req,
            focus_req: &cells.focus_req,
            text,
            runtime: self,
        };
        let type_name = v.type_name().to_string();
        if std::panic::catch_unwind(AssertUnwindSafe(|| {
            v.on_drag_end_erased(end, &mut ctx);
        }))
        .is_err()
        {
            self.record_error(el, type_name, "on_drag_end panicked".to_string());
        }
    }

    fn layout_overlays(&self, viewport: Rect, ctx: &mut LayoutCtx) {
        for id in self.inner.overlays.borrow().ordered_ids() {
            self.layout_one_overlay(id, viewport, ctx);
        }
    }

    fn layout_one_overlay(&self, id: OverlayId, viewport: Rect, ctx: &mut LayoutCtx) {
        let (anchor, placement, position, offset, overflow, el) = {
            let store = self.inner.overlays.borrow();
            let Some(e) = store.get(id) else { return };
            let Some(el) = e.element.get() else { return };
            (e.anchor, e.placement, e.position, e.offset, e.overflow, el)
        };

        let anchor_rect = match anchor {
            Anchor::View(aid) => match self.rect_of(aid) {
                Some(r) => r,

                None => {
                    self.record_error(
                        el,
                        "Overlay".to_string(),
                        "dead Anchor::View: overlay falls back to (0,0); recreate entry with live ctx.element".to_string(),
                    );
                    Rect::ZERO
                }
            },
            _ => self.resolve_anchor(anchor, viewport),
        };

        let measured = self.measure(el, Constraints::UNBOUNDED, ctx);

        let pos = compute_position(
            position,
            placement,
            anchor_rect,
            measured,
            viewport,
            offset,
            overflow,
        );
        let rect = Rect::new(pos, measured);

        self.arrange(el, rect, ctx);

        if let Some(e) = self.inner.overlays.borrow().get(id) {
            e.rect.set(rect);
        }
    }

    fn resolve_anchor(&self, anchor: Anchor, viewport: Rect) -> Rect {
        match anchor {
            Anchor::View(id) => self.rect_of(id).unwrap_or(Rect::ZERO),
            Anchor::Rect(r) => r,
            Anchor::Point(p) => Rect::new(p, Size::ZERO),
            Anchor::Cursor => Rect::new(self.inner.interact.get().cursor, Size::ZERO),
            Anchor::Viewport => viewport,
        }
    }

    fn hit_overlays(&self, pos: Point) -> Option<ElementId> {
        for id in self.inner.overlays.borrow().ordered_ids().into_iter().rev() {
            let (mode, el, rect) = {
                let store = self.inner.overlays.borrow();
                let Some(e) = store.get(id) else { continue };
                let Some(el) = e.element.get() else { continue };
                (e.input_mode, el, e.rect.get())
            };
            match mode {
                InputMode::Passthrough => continue,
                InputMode::Modal => {
                    if rect.contains(pos)
                        && let Some(hit) = self.hit_rec(el, pos)
                    {
                        return Some(hit);
                    }
                    return Some(el);
                }
                InputMode::Interactive => {
                    if rect.contains(pos)
                        && let Some(hit) = self.hit_rec(el, pos)
                    {
                        return Some(hit);
                    }
                }
            }
        }
        None
    }

    fn interaction_target_within(
        &self,
        subtree: ElementId,
        target: Option<ElementId>,
    ) -> Option<u64> {
        let target = target?;
        let mut cur = Some(target);
        let mut walked = 0u32;
        while let Some(e) = cur {
            if e == subtree {
                return Some(target.key());
            }
            cur = self.parent_of(e);
            walked += 1;
            if walked > 4096 {
                break;
            }
        }
        None
    }

    fn hover_chain(&self) -> Vec<ElementId> {
        let Some(hovered) = self.inner.interact.get().hovered else {
            return Vec::new();
        };
        let arena = self.inner.arena.borrow();
        let mut chain = Vec::new();
        let mut cur = Some(hovered);
        let mut walked = 0;
        while let Some(e) = cur {
            chain.push(e);
            cur = arena.get(e).and_then(|el| el.parent);
            walked += 1;
            if walked > 4096 {
                break;
            }
        }
        chain
    }

    /// Whether the focused element is a text input.
    ///
    /// Hosts use this to suppress plain-key accelerators while the user is
    /// typing. Command shortcuts remain available.
    pub fn text_input_focused(&self) -> bool {
        let st = self.inner.interact.get();
        st.focus
            .and_then(|f| self.view_rc(f))
            .is_some_and(|v| v.accepts_text_input_erased())
    }

    pub fn focus_in_subtree(&self, el: ElementId) -> bool {
        let st = self.inner.interact.get();
        let Some(f) = st.focus else { return false };
        if f == el {
            return true;
        }
        let mut cur = self.parent_of(f);
        while let Some(e) = cur {
            if e == el {
                return true;
            }
            cur = self.parent_of(e);
        }
        false
    }

    pub fn parent_of(&self, el: ElementId) -> Option<ElementId> {
        self.inner.arena.borrow().get(el)?.parent
    }

    fn focused_accepts_tab(&self) -> bool {
        let st = self.inner.interact.get();
        let Some(f) = st.focus else { return false };
        if !self.is_alive(f) {
            return false;
        }
        self.view_rc(f).is_some_and(|v| v.accepts_tab_erased())
    }

    fn nearest_focusable(&self, mut el: ElementId) -> Option<ElementId> {
        loop {
            if let Some(v) = self.view_rc(el)
                && v.focusable_erased()
            {
                return Some(el);
            }
            {
                let p = self.parent_of(el)?;
                el = p
            }
        }
    }

    fn nearest_trap_scope(&self, mut el: ElementId) -> Option<ElementId> {
        loop {
            if let Some(v) = self.view_rc(el)
                && v.focus_trap_erased()
            {
                return Some(el);
            }
            {
                let p = self.parent_of(el)?;
                el = p
            }
        }
    }

    fn collect_focusables(&self, el: ElementId, out: &mut Vec<ElementId>) {
        if let Some(v) = self.view_rc(el)
            && v.focusable_erased()
        {
            out.push(el);
        }
        for c in self.children(el) {
            self.collect_focusables(c, out);
        }
    }

    pub fn focus_next(&self, backward: bool) {
        let mut st = self.inner.interact.get();

        let mut f = Vec::new();
        let scope = st.focus.and_then(|c| self.nearest_trap_scope(c));
        match scope {
            Some(s) => self.collect_focusables(s, &mut f),
            None => {
                if let Some(root) = self.inner.root.get() {
                    self.collect_focusables(root, &mut f);
                }
            }
        }
        if f.is_empty() {
            return;
        }
        let len = f.len();
        let next = match st.focus.and_then(|c| f.iter().position(|&e| e == c)) {
            Some(i) if backward => (i + len - 1) % len,
            Some(i) => (i + 1) % len,
            None => 0,
        };
        st.focus = Some(f[next]);
        self.inner.interact.set(st);
        self.dismiss_focus_lost(st.focus);
    }

    pub fn set_focus(&self, el: Option<ElementId>) {
        let mut st = self.inner.interact.get();
        let old = st.focus;
        st.focus = el;
        self.inner.interact.set(st);
        for previous in [old, el].into_iter().flatten() {
            self.mark_damage(previous, Dirty::PAINT);
        }
        self.request_redraw();
        self.dismiss_focus_lost(el);
    }

    fn target_in_overlay(&self, target: ElementId, overlay_el: Option<ElementId>) -> bool {
        let Some(root) = overlay_el else { return false };
        let mut cur = Some(target);
        while let Some(el) = cur {
            if el == root {
                return true;
            }
            cur = self.parent_of(el);
        }
        false
    }

    fn dismiss_focus_lost(&self, target: Option<ElementId>) {
        let ids = self.inner.overlays.borrow().focus_lost_ids(target, |el| {
            target.is_some_and(|t| self.target_in_overlay(t, el))
        });
        for id in ids {
            self.overlay_hide(id);
        }
    }

    fn auto_capture(&self, target: ElementId) -> Option<ElementId> {
        let mut cur = Some(target);
        while let Some(el) = cur {
            if let Some(v) = self.view_rc(el)
                && v.captures_pointer_ctx_erased(self, el)
            {
                return Some(el);
            }
            cur = self.parent_of(el);
        }
        None
    }

    fn view_state(&self, el: ElementId) -> (VisualState, bool) {
        let st = self.inner.interact.get();
        let mut vs = VisualState::default();
        vs.hovered = self.hovered_within(el, st.hovered);
        vs.pressed = st.pressed == Some(el);
        vs.focused = st.focus == Some(el);
        (vs, st.hovered == Some(el))
    }

    /// True when the pointer is over `el` or over one of its descendants.
    ///
    /// A container must keep its hover state while the pointer is on a child,
    /// including children that live in an overlay layer. The hover chain for
    /// overlay elements walks up to the overlay root just like the main tree,
    /// so checking ancestors fixes hover inside menus and popovers.
    fn hovered_within(&self, el: ElementId, hovered: Option<ElementId>) -> bool {
        let Some(mut cur) = hovered else {
            return false;
        };
        let mut walked = 0u32;
        loop {
            if cur == el {
                return true;
            }
            let Some(parent) = self.parent_of(cur) else {
                return false;
            };
            cur = parent;
            walked += 1;
            if walked > 4096 {
                return false;
            }
        }
    }

    pub fn visual_state(&self, el: ElementId) -> VisualState {
        self.view_state(el).0
    }

    fn call_on_event(
        &self,
        el: ElementId,
        event: &Event,
        phase: EventPhase,
        pos: Point,
        cells: &DispatchCells,
        text: &mut TextSystem,
    ) {
        let Some(v) = self.view_rc(el) else { return };
        let (state, hover_self) = self.view_state(el);
        let rect = {
            let arena = self.inner.arena.borrow();
            arena.get(el).map(|e| e.rect.get()).unwrap_or(Rect::ZERO)
        };

        let env = self.inner.environment.borrow().clone();
        let mut ctx = EventCtx {
            phase,
            element: el,
            state,
            hover_self,
            pos,
            rect,
            environment: &env,
            window: self.inner.window.get(),
            stopped: &cells.stopped,
            handled: &cells.handled,
            capture_req: &cells.capture_req,
            release_req: &cells.release_req,
            focus_req: &cells.focus_req,
            text,
            runtime: self,
        };

        let type_name = v.type_name().to_string();
        if std::panic::catch_unwind(AssertUnwindSafe(|| {
            v.on_event_erased(event, &mut ctx);
        }))
        .is_err()
        {
            let msg = format!("on_event panicked ({phase:?})");
            self.record_error(el, type_name, msg);
        }
    }

    fn dispatch_chain(&self, target: ElementId, event: &Event, pos: Point, text: &mut TextSystem) {
        let mut path = vec![target];
        while let Some(last) = path.last() {
            let Some(p) = self.parent_of(*last) else {
                break;
            };
            path.push(p);
        }
        path.reverse();
        let n = path.len();
        let cells = DispatchCells::new();

        for &el in &path[..n - 1] {
            if cells.stopped.get() || cells.handled.get() {
                self.apply_dispatch_requests(target, &cells);
                return;
            }
            self.call_on_event(el, event, EventPhase::Capture, pos, &cells, text);
        }
        if !(cells.stopped.get() || cells.handled.get()) {
            self.call_on_event(target, event, EventPhase::Target, pos, &cells, text);
        }
        for &el in path[..n - 1].iter().rev() {
            if cells.stopped.get() || cells.handled.get() {
                break;
            }
            self.call_on_event(el, event, EventPhase::Bubble, pos, &cells, text);
        }
        self.apply_dispatch_requests(target, &cells);
    }

    fn dispatch_single(
        &self,
        el: ElementId,
        event: &Event,
        pos: Point,
        text: &mut TextSystem,
    ) -> bool {
        let cells = DispatchCells::new();
        self.call_on_event(el, event, EventPhase::Target, pos, &cells, text);
        self.apply_dispatch_requests(el, &cells);
        cells.handled.get() || cells.stopped.get()
    }

    fn apply_dispatch_requests(&self, el: ElementId, cells: &DispatchCells) {
        let mut st = self.inner.interact.get();
        if cells.release_req.get() {
            if st.captured == Some(el) {
                st.captured = None;
            }
        } else if let Some(req) = cells.capture_req.get() {
            st.captured = Some(req);
        }
        if cells.focus_req.get() {
            st.focus = Some(el);
        }
        self.inner.interact.set(st);
    }

    pub fn pointer_cancel(&self, text: &mut TextSystem) {
        let captured = self.inner.interact.get().captured;
        if let Some(c) = captured {
            let pos = self.inner.interact.get().cursor;
            let ev = Event::Pointer(PointerEvent::Cancel);
            let _ = self.dispatch_single(c, &ev, pos, text);
        }
        self.inner.pending_drag.borrow_mut().take();
        if self.inner.active_drag.borrow().is_some() {
            self.cancel_drag(text);
            return;
        }
        let mut st = self.inner.interact.get();
        st.pressed = None;
        st.captured = None;
        st.hovered = None;
        self.inner.interact.set(st);
        self.request_redraw();
    }

    pub(crate) fn measure_node(
        &self,
        el: ElementId,
        constraints: Constraints,
        ctx: &mut LayoutCtx,
    ) -> Size {
        self.measure(el, constraints, ctx)
    }

    pub(crate) fn arrange_node(&self, el: ElementId, rect: Rect, ctx: &mut LayoutCtx) {
        self.arrange(el, rect, ctx)
    }

    pub(crate) fn layout_epoch(&self) -> u64 {
        self.inner.layout_epoch.get()
    }

    pub(crate) fn translate_subtree(&self, root: ElementId, delta: Vec2) {
        if delta == Vec2::ZERO {
            return;
        }
        let mut stack = vec![root];
        while let Some(id) = stack.pop() {
            let children = {
                let mut arena = self.inner.arena.borrow_mut();
                let Some(e) = arena.get_mut(id) else {
                    continue;
                };
                e.rect.set(e.rect.get().translate(delta));
                e.children.clone()
            };
            stack.extend(children);
        }
    }

    pub(crate) fn child_layout_style(&self, el: ElementId) -> LayoutStyle {
        let Some(view) = self.view_rc(el) else {
            return LayoutStyle::default();
        };
        let mut style = view.layout_style_ctx_erased(self, el);
        if view.is_leaf() || !(style.width.is_fit() || style.height.is_fit()) {
            return style;
        }
        let children = self.children(el);
        if children.len() != 1 {
            return style;
        }
        let child_style = self
            .view_rc(children[0])
            .map(|v| v.layout_style_ctx_erased(self, children[0]))
            .unwrap_or_default();
        if style.width.is_fit() && child_style.width.is_fill() {
            style.width = child_style.width;
        }
        if style.height.is_fit() && child_style.height.is_fill() {
            style.height = child_style.height;
        }
        style
    }

    pub fn check_root_fill(&self, root: ElementId, bounds: Rect, measured: Size) -> bool {
        let style = self.child_layout_style(root);
        let fill_w = style.width.is_fill();
        let fill_h = style.height.is_fill();
        if fill_w && fill_h {
            return true;
        }
        let gap_w = bounds.size.width - measured.width;
        let gap_h = bounds.size.height - measured.height;

        if gap_w <= 1.0 && gap_h <= 1.0 {
            return true;
        }
        let type_name = self.type_name_of(root).unwrap_or_else(|| "?".into());
        log::warn!(
            "sequoia-view: root `{type_name}` has no fill_size (width_fill={fill_w}, height_fill={fill_h}); \
             measured {measured:?} with window {:?} — unpainted background. Add `.fill_size()` to the root.",
            bounds.size
        );
        false
    }

    fn warn_if_root_not_fill(&self, root: ElementId, bounds: Rect, measured: Size) {
        let _ = self.check_root_fill(root, bounds, measured);
    }

    fn measure(&self, el: ElementId, constraints: Constraints, ctx: &mut LayoutCtx) -> Size {
        match std::panic::catch_unwind(AssertUnwindSafe(|| {
            self.measure_inner(el, constraints, ctx)
        })) {
            Ok(s) => s,
            Err(_) => {
                let type_name = self.type_name_of(el).unwrap_or_else(|| "?".into());
                self.record_error(el, type_name, "measure panicked".to_string());
                Size::ZERO
            }
        }
    }

    fn baseline_offset(&self, el: ElementId, width: f32, ctx: &mut LayoutCtx) -> Option<f32> {
        self.view_rc(el)
            .and_then(|v| v.baseline_offset_erased(ctx, width))
    }

    fn measure_inner(&self, el: ElementId, constraints: Constraints, ctx: &mut LayoutCtx) -> Size {
        self.inner
            .measure_calls
            .set(self.inner.measure_calls.get().wrapping_add(1));

        // A leaf whose rebuild waited while it was off screen is now being
        // reached by layout (it became visible, or its size is needed), so
        // bring its content up to date before trusting any cached size.
        let pending = self
            .inner
            .arena
            .borrow()
            .get(el)
            .is_some_and(|e| e.dirty.needs_layout());
        if pending && let Some(v) = self.view_rc(el) {
            self.build_with(el, v);
            if let Some(e) = self.inner.arena.borrow_mut().get_mut(el) {
                e.dirty = Dirty::empty();
            }
            let mut s = self.inner.stats.get();
            s.rebuilds += 1;
            self.inner.stats.set(s);
        }

        {
            let arena = self.inner.arena.borrow();
            if arena.get(el).map(|e| e.dirty.is_empty()).unwrap_or(false) {
                drop(arena);
                let measures = self.inner.measures.borrow();
                if let Some(entries) = measures.get(&el)
                    && let Some(e) = entries.iter().find(|e| e.constraints == constraints)
                {
                    self.inner
                        .measure_hits
                        .set(self.inner.measure_hits.get().wrapping_add(1));
                    return e.size;
                }
            }
        }
        let Some(v) = self.view_rc(el) else {
            return Size::ZERO;
        };
        let children = self.children(el);
        let style = self.child_layout_style(el);
        let container = v.container();
        let grid = v.grid();

        let dock = if grid.is_some() { None } else { v.dock() };

        let wrap = if grid.is_some() || dock.is_some() {
            None
        } else {
            v.wrap()
        };

        let masonry = if grid.is_some() || dock.is_some() || wrap.is_some() {
            None
        } else {
            v.masonry()
        };

        let flex = v.flex_weights().unwrap_or_default();
        let pre_placements = v.grid_placements().unwrap_or_default();
        let children_len = children.len();

        {
            let measures = self.inner.measures.borrow();
            if let Some(entries) = measures.get(&el)
                && let Some(e) = entries.iter().find(|e| {
                    e.constraints == constraints
                        && e.style == style
                        && e.container == container
                        && e.grid == grid
                        && e.placements == pre_placements
                        && e.dock == dock
                        && e.wrap == wrap
                        && e.masonry == masonry
                        && e.children_len == children_len
                })
            {
                self.inner
                    .measure_hits
                    .set(self.inner.measure_hits.get().wrapping_add(1));
                return e.size;
            }
        }

        ctx.set_available_width(constraints.max.width);
        let intrinsic = v.intrinsic_size(ctx);
        let avail = constraints.max;
        let mut w = match style.width {
            Length::Px(p) => p,
            Length::Percent(p) => {
                if avail.width.is_finite() && p.is_finite() {
                    (avail.width * p / 100.0).max(0.0)
                } else {
                    intrinsic.map(|i| i.width).unwrap_or(0.0)
                }
            }
            Length::Fill(_) => {
                if avail.width.is_finite() {
                    avail.width
                } else {
                    intrinsic.map(|i| i.width).unwrap_or(0.0)
                }
            }
            Length::Fit => intrinsic.map(|i| i.width).unwrap_or(0.0),
        };
        let mut h = match style.height {
            Length::Px(p) => p,
            Length::Percent(p) => {
                if avail.height.is_finite() && p.is_finite() {
                    (avail.height * p / 100.0).max(0.0)
                } else {
                    intrinsic.map(|i| i.height).unwrap_or(0.0)
                }
            }
            Length::Fill(_) => {
                if avail.height.is_finite() {
                    avail.height
                } else {
                    intrinsic.map(|i| i.height).unwrap_or(0.0)
                }
            }
            Length::Fit => intrinsic.map(|i| i.height).unwrap_or(0.0),
        };

        let content_width = matches!(style.width, Length::Fit)
            || (style.width.is_fill() && !avail.width.is_finite());
        let content_height = matches!(style.height, Length::Fit)
            || (style.height.is_fill() && !avail.height.is_finite());

        let apply_aspect = |mut w: f32, mut h: f32| -> (f32, f32) {
            if let Some(r) = style.aspect_ratio
                && r.is_finite()
                && r > 0.0
            {
                match (content_width, content_height) {
                    (true, false) => w = (h * r).max(0.0),
                    (false, true) => h = (w / r).max(0.0),
                    (true, true) => {
                        if w <= 0.0 && h > 0.0 {
                            w = (h * r).max(0.0);
                        } else if h <= 0.0 && w > 0.0 {
                            h = (w / r).max(0.0);
                        }
                    }
                    (false, false) => {}
                }
            }
            (w, h)
        };

        let eff_container: Option<ContainerStyle> =
            if grid.is_some() || dock.is_some() || wrap.is_some() || masonry.is_some() {
                None
            } else {
                container.or_else(|| {
                    if children.is_empty()
                        || intrinsic.is_some()
                        || (!content_width && !content_height)
                    {
                        None
                    } else {
                        Some(ContainerStyle::new(Axis::Vertical, 0.0))
                    }
                })
            };

        if let Some(cstyle) = eff_container
            && !children.is_empty()
            && !(intrinsic.is_some() && !content_width && !content_height)
            && !(v.contain_size_erased() && !content_width && !content_height)
        {
            let pad = style.padding;
            let inner_avail = Size::new(
                ((if content_width { avail.width } else { w }) - pad.horizontal_sum()).max(0.0),
                ((if content_height { avail.height } else { h }) - pad.vertical_sum()).max(0.0),
            );
            let (total_main, cross_max) = self.measure_children(
                &children,
                &cstyle,
                inner_avail,
                &flex,
                ctx,
                match cstyle.axis {
                    Axis::Horizontal => content_height,
                    Axis::Vertical => content_width,
                },
            );
            let (mw, mh) = match cstyle.axis {
                Axis::Horizontal => (total_main, cross_max),
                Axis::Vertical => (cross_max, total_main),
            };
            if content_width && intrinsic.is_none() {
                w = mw + pad.horizontal_sum();
            }
            if content_height && intrinsic.is_none() {
                h = mh + pad.vertical_sum();
            }
        }

        let placements = v.grid_placements().unwrap_or_default();
        if let Some(ref gstyle) = grid
            && !children.is_empty()
            && !(intrinsic.is_some() && !content_width && !content_height)
            && !(v.contain_size_erased() && !content_width && !content_height)
        {
            let pad = style.padding;
            let inner_avail = Size::new(
                ((if content_width { avail.width } else { w }) - pad.horizontal_sum()).max(0.0),
                ((if content_height { avail.height } else { h }) - pad.vertical_sum()).max(0.0),
            );
            let (gw, gh) = self.measure_grid(&children, gstyle, &placements, inner_avail, ctx);
            if content_width && intrinsic.is_none() {
                w = gw + pad.horizontal_sum();
            }
            if content_height && intrinsic.is_none() {
                h = gh + pad.vertical_sum();
            }
        }

        if let Some(ref dstyle) = dock
            && !children.is_empty()
            && !(intrinsic.is_some() && !content_width && !content_height)
            && !(v.contain_size_erased() && !content_width && !content_height)
        {
            let pad = style.padding;
            let inner_avail = Size::new(
                ((if content_width { avail.width } else { w }) - pad.horizontal_sum()).max(0.0),
                ((if content_height { avail.height } else { h }) - pad.vertical_sum()).max(0.0),
            );
            let (dw, dh) = self.measure_dock(&children, dstyle, inner_avail, ctx);
            if content_width && intrinsic.is_none() {
                w = dw + pad.horizontal_sum();
            }
            if content_height && intrinsic.is_none() {
                h = dh + pad.vertical_sum();
            }
        }

        if let Some(wstyle) = wrap
            && !children.is_empty()
            && !(intrinsic.is_some() && !content_width && !content_height)
            && !(v.contain_size_erased() && !content_width && !content_height)
        {
            let pad = style.padding;
            let inner_avail = Size::new(
                ((if content_width { avail.width } else { w }) - pad.horizontal_sum()).max(0.0),
                ((if content_height { avail.height } else { h }) - pad.vertical_sum()).max(0.0),
            );
            let (ww, wh) = self.measure_wrap(&children, &wstyle, inner_avail, ctx);
            if content_width && intrinsic.is_none() {
                w = ww + pad.horizontal_sum();
            }
            if content_height && intrinsic.is_none() {
                h = wh + pad.vertical_sum();
            }
        }

        if let Some(mstyle) = masonry
            && !children.is_empty()
            && !(intrinsic.is_some() && !content_width && !content_height)
            && !(v.contain_size_erased() && !content_width && !content_height)
        {
            let pad = style.padding;
            let inner_avail = Size::new(
                ((if content_width { avail.width } else { w }) - pad.horizontal_sum()).max(0.0),
                ((if content_height { avail.height } else { h }) - pad.vertical_sum()).max(0.0),
            );
            let (mw, mh) =
                self.measure_masonry(&children, &mstyle, inner_avail, content_width, ctx);
            if content_width && intrinsic.is_none() {
                w = mw + pad.horizontal_sum();
            }
            if content_height && intrinsic.is_none() {
                h = mh + pad.vertical_sum();
            }
        }

        let (w, h) = apply_aspect(w, h);
        let size = clamp_to(style.clamp_size(Size::new(w, h)), constraints);
        let might_collapse = size.width <= 0.5 || size.height <= 0.5;
        if might_collapse
            && !v.is_leaf()
            && !children.is_empty()
            && (style.width.is_fit() || style.height.is_fit())
        {
            let mut fill_w = false;
            let mut fill_h = false;
            for child in &children {
                let child_style = self.child_layout_style(*child);
                fill_w |= child_style.width.is_fill();
                fill_h |= child_style.height.is_fill();
            }
            let collapsed_w =
                style.width.is_fit() && fill_w && size.width <= 0.5 && constraints.max.width > 1.0;
            let collapsed_h = style.height.is_fit()
                && fill_h
                && size.height <= 0.5
                && constraints.max.height > 1.0;
            if collapsed_w || collapsed_h {
                log::warn!(
                    "sequoia-view: composite `{}` collapsed to {size:?} while a body child \
                     requests fill; give the composite an explicit size or a `layout_style` \
                     using `Length::Fill(1.0)`",
                    v.type_name()
                );
            }
        }
        {
            let entry = MeasureEntry {
                constraints,
                style,
                container,
                grid,
                placements,
                dock,
                wrap,
                masonry,
                children_len: children.len(),
                size,
            };
            let mut measures = self.inner.measures.borrow_mut();
            let entries = measures.entry(el).or_default();
            if let Some(slot) = entries.iter_mut().find(|e| e.constraints == constraints) {
                *slot = entry;
            } else {
                if entries.len() >= MAX_MEASURE_VARIANTS {
                    entries.remove(0);
                }
                entries.push(entry);
            }
        }
        size
    }

    fn measure_children(
        &self,
        children: &[ElementId],
        cstyle: &ContainerStyle,
        inner_avail: Size,
        flex: &[f32],
        ctx: &mut LayoutCtx,
        need_cross: bool,
    ) -> (f32, f32) {
        let (avail_main, avail_cross) = match cstyle.axis {
            Axis::Horizontal => (inner_avail.width, inner_avail.height),
            Axis::Vertical => (inner_avail.height, inner_avail.width),
        };

        if cstyle.wrap {
            let flow: Vec<(usize, ElementId)> = children
                .iter()
                .copied()
                .enumerate()
                .filter(|(_, c)| !self.child_layout_style(*c).is_absolute())
                .collect();
            if flow.is_empty() {
                return (0.0, 0.0);
            }
            return self.measure_children_wrapped(
                &flow,
                cstyle,
                inner_avail,
                flex,
                ctx,
                need_cross,
            );
        }

        // A bounded main axis means the caller already fixed the visible
        // extent (the window or a clipped container). Rows past that extent
        // cannot be seen, so measuring them would shape text and allocate
        // vectors for nothing. An unbounded axis keeps the full pass: a
        // scroll view relies on the content size it gets from here.
        let cull = Self::can_cull_main_axis(avail_main);
        let capacity = children.len().min(256);
        let mut bases = Vec::with_capacity(capacity);
        let mut crosses = Vec::with_capacity(if need_cross { capacity } else { 0 });
        let mut items = Vec::with_capacity(capacity);
        let mut child_styles = Vec::with_capacity(capacity);
        let mut ids = Vec::with_capacity(capacity);
        let mut used_outer = 0.0_f32;
        let mut shrinkable = false;

        for (orig_i, &child) in children.iter().enumerate() {
            let cs = self.child_layout_style(child);
            if cs.is_absolute() {
                continue;
            }
            let extra = flex.get(orig_i).copied().unwrap_or(0.0);
            let (base, grow, shrink, cross, mn, mx) =
                self.child_layout_info_full(child, cstyle, avail_main, avail_cross, extra, ctx);
            let fixed = Self::cullable_main(&cs, cstyle.axis, base, mn);
            shrinkable |= !fixed;
            if !bases.is_empty() {
                used_outer += cstyle.gap;
            }
            used_outer += base;
            bases.push(base);
            ids.push(child);
            if need_cross {
                crosses.push(cross);
            }
            items.push(FlexItem::new(base, grow, shrink, mn, mx));
            child_styles.push(cs);
            if cull && !shrinkable && used_outer > avail_main && fixed {
                break;
            }
        }
        if bases.is_empty() {
            return (0.0, 0.0);
        }
        let gaps = Self::main_gap_specs(&child_styles, cstyle.axis, cstyle.gap, avail_main);
        let resolved_gaps = Self::distribute_main(&items, &mut bases, &gaps, avail_main);

        if need_cross && avail_main.is_finite() {
            for (k, &child) in ids.iter().enumerate() {
                if self.subtree_has_wrap_axis(child, cstyle.axis) {
                    crosses[k] =
                        self.constrained_cross(child, cstyle.axis, bases[k], avail_cross, ctx);
                }
            }
        }

        let total_main = bases.iter().sum::<f32>() + resolved_gaps.iter().sum::<f32>();
        let cross_max = if need_cross {
            crosses.iter().cloned().fold(0.0_f32, f32::max)
        } else {
            0.0
        };
        (total_main, cross_max)
    }

    fn measure_children_wrapped(
        &self,
        flow: &[(usize, ElementId)],
        cstyle: &ContainerStyle,
        inner_avail: Size,
        flex: &[f32],
        ctx: &mut LayoutCtx,
        need_cross: bool,
    ) -> (f32, f32) {
        let (avail_main, avail_cross) = match cstyle.axis {
            Axis::Horizontal => (inner_avail.width, inner_avail.height),
            Axis::Vertical => (inner_avail.height, inner_avail.width),
        };

        let mut mains = Vec::with_capacity(flow.len());
        let mut crosses = Vec::with_capacity(flow.len());
        let mut grows = Vec::with_capacity(flow.len());
        let mut shrinks = Vec::with_capacity(flow.len());
        let mut mins = Vec::with_capacity(flow.len());
        let mut maxs = Vec::with_capacity(flow.len());
        for &(orig_i, child) in flow {
            let extra = flex.get(orig_i).copied().unwrap_or(0.0);
            let (base, grow, shrink, cross, mn, mx) =
                self.child_layout_info_full(child, cstyle, avail_main, avail_cross, extra, ctx);
            mains.push(base);
            crosses.push(cross);
            grows.push(grow);
            shrinks.push(shrink);
            mins.push(mn);
            maxs.push(mx);
        }
        let lines = wrap_lines(&mains, avail_main, cstyle.gap);
        if lines.is_empty() {
            return (0.0, 0.0);
        }
        let mut main_max = 0.0f32;
        let mut cross_total = 0.0f32;
        for (li, &(s, e)) in lines.iter().enumerate() {
            let mut line_sizes = mains[s..e].to_vec();
            let items: Vec<FlexItem> = (s..e)
                .map(|i| FlexItem::new(mains[i], grows[i], shrinks[i], mins[i], maxs[i]))
                .collect();
            let line_gaps = cstyle.main_gaps_total(e - s);
            distribute_flex(&items, &mut line_sizes, line_gaps, avail_main);
            let used: f32 = line_sizes.iter().sum::<f32>() + line_gaps;
            main_max = main_max.max(used);
            if need_cross {
                let line_cross = crosses[s..e].iter().cloned().fold(0.0f32, f32::max);
                if li > 0 {
                    cross_total += cstyle.cross_gap;
                }
                cross_total += line_cross;
            }
        }

        (main_max.max(0.0), cross_total.max(0.0))
    }

    fn subtree_has_wrap_axis(&self, root: ElementId, axis: Axis) -> bool {
        let axis_u8 = match axis {
            Axis::Horizontal => 0,
            Axis::Vertical => 1,
        };
        let key = (root.index, root.generation, axis_u8);
        if let Some(hit) = self.inner.wrap_cache.borrow().get(&key).copied() {
            return hit;
        }
        let mut stack = vec![root];
        let mut found = false;
        while let Some(id) = stack.pop() {
            if let Some(v) = self.view_rc(id) {
                let grid = v.grid();
                let dock = if grid.is_some() { None } else { v.dock() };
                let wrap = if grid.is_some() || dock.is_some() {
                    None
                } else {
                    v.wrap()
                };
                if let Some(w) = wrap
                    && w.axis == axis
                {
                    found = true;
                    break;
                }
                if axis == Axis::Horizontal
                    && wrap.is_none()
                    && dock.is_none()
                    && grid.is_none()
                    && v.masonry().is_some()
                {
                    found = true;
                    break;
                }
            }
            {
                let arena = self.inner.arena.borrow();
                if let Some(e) = arena.get(id) {
                    stack.extend(e.children.iter().copied());
                }
            }
        }
        self.inner.wrap_cache.borrow_mut().insert(key, found);
        found
    }

    fn subtree_redistributes(&self, root: ElementId) -> bool {
        let key = (root.index, root.generation, 2u8);
        if let Some(hit) = self.inner.wrap_cache.borrow().get(&key).copied() {
            return hit;
        }
        let mut found = false;
        let mut stack = vec![root];
        while let Some(id) = stack.pop() {
            let Some(v) = self.view_rc(id) else {
                continue;
            };
            if v.flex_weights().is_some_and(|w| w.iter().any(|f| *f > 0.0)) {
                found = true;
                break;
            }
            let cs = self.child_layout_style(id);
            if cs.flex_weight() > 0.0
                || matches!(cs.width, Length::Fill(_))
                || matches!(cs.height, Length::Fill(_))
            {
                found = true;
                break;
            }
            {
                let arena = self.inner.arena.borrow();
                if let Some(e) = arena.get(id) {
                    stack.extend(e.children.iter().copied());
                }
            }
        }
        self.inner.wrap_cache.borrow_mut().insert(key, found);
        found
    }

    fn constrained_cross(
        &self,
        child: ElementId,
        container_axis: Axis,
        allocated_main: f32,
        avail_cross: f32,
        ctx: &mut LayoutCtx,
    ) -> f32 {
        if self.view_rc(child).is_none() {
            return 0.0;
        }
        let cs = self.child_layout_style(child);

        let margin_main = cs.margin_main(container_axis);
        let allocated = (allocated_main - margin_main).max(0.0);
        let max = match container_axis {
            Axis::Horizontal => Size::new(allocated, avail_cross),
            Axis::Vertical => Size::new(avail_cross, allocated),
        };
        let m = self.measure(
            child,
            Constraints {
                min: Size::ZERO,
                max,
            },
            ctx,
        );
        let cross_margin = cs.margin_cross(container_axis);
        match container_axis {
            Axis::Horizontal => {
                cs.clamp_height(resolve_cross(cs.height, m.height, avail_cross))
                    .max(0.0)
                    + cross_margin
            }
            Axis::Vertical => {
                cs.clamp_width(resolve_cross(cs.width, m.width, avail_cross))
                    .max(0.0)
                    + cross_margin
            }
        }
    }

    fn child_limits_full(&self, child: ElementId, axis: Axis) -> (f32, f32, f32, f32, f32) {
        match self.view_rc(child) {
            Some(_v) => {
                let cs = self.child_layout_style(child);
                let margin_main = cs.margin_main(axis);
                let margin_cross = cs.margin_cross(axis);
                let px_floor_main = match axis {
                    Axis::Horizontal => match cs.width {
                        Length::Px(w) => w.max(0.0),
                        _ => 0.0,
                    },
                    Axis::Vertical => match cs.height {
                        Length::Px(h) => h.max(0.0),
                        _ => 0.0,
                    },
                };
                let px_floor_cross = match axis {
                    Axis::Horizontal => match cs.height {
                        Length::Px(h) => h.max(0.0),
                        _ => 0.0,
                    },
                    Axis::Vertical => match cs.width {
                        Length::Px(w) => w.max(0.0),
                        _ => 0.0,
                    },
                };
                let (min_c, max_c) = match axis {
                    Axis::Horizontal => (cs.min_height, cs.max_height),
                    Axis::Vertical => (cs.min_width, cs.max_width),
                };
                let min_c = {
                    let m = if min_c.is_finite() {
                        min_c.max(0.0)
                    } else {
                        0.0
                    };
                    m.max(px_floor_cross)
                };
                let max_c = if max_c.is_nan() {
                    f32::INFINITY
                } else if max_c.is_infinite() {
                    if max_c > 0.0 { f32::INFINITY } else { 0.0 }
                } else {
                    max_c.max(0.0)
                };
                (
                    cs.min_main(axis).max(px_floor_main) + margin_main,
                    cs.max_main(axis) + margin_main,
                    min_c + margin_cross,
                    max_c + margin_cross,
                    cs.flex_shrink_weight(),
                )
            }
            None => (0.0, f32::INFINITY, 0.0, f32::INFINITY, 1.0),
        }
    }

    fn child_layout_info_full(
        &self,
        child: ElementId,
        cstyle: &ContainerStyle,
        avail_main: f32,
        avail_cross: f32,
        flex_extra: f32,
        ctx: &mut LayoutCtx,
    ) -> (f32, f32, f32, f32, f32, f32) {
        if self.view_rc(child).is_none() {
            return (0.0, 0.0, 1.0, 0.0, 0.0, f32::INFINITY);
        }
        let cs = self.child_layout_style(child);
        let (main_len, cross_len) = match cstyle.axis {
            Axis::Horizontal => (cs.width, cs.height),
            Axis::Vertical => (cs.height, cs.width),
        };

        let (child_max_w, child_max_h) = match cstyle.axis {
            Axis::Horizontal => (f32::INFINITY, avail_cross),
            Axis::Vertical => (avail_cross, f32::INFINITY),
        };
        let m = self.measure(
            child,
            Constraints {
                min: Size::ZERO,
                max: Size::new(child_max_w, child_max_h),
            },
            ctx,
        );
        let (main_intrinsic, cross_intrinsic) = match cstyle.axis {
            Axis::Horizontal => (m.width, m.height),
            Axis::Vertical => (m.height, m.width),
        };

        let (mut base, fill_grow) = resolve_main(main_len, main_intrinsic, avail_main);

        let (basis_base, basis_grow) =
            resolve_flex_basis(cs.flex_basis, (base, fill_grow), main_intrinsic, avail_main);
        base = basis_base;
        let mut grow_basis = fill_grow.max(basis_grow);
        let mut cross = resolve_cross(cross_len, cross_intrinsic, avail_cross);

        if matches!(cross_len, Length::Fit) && !self.subtree_redistributes(child) {
            let m_true = self.measure(
                child,
                Constraints {
                    min: Size::ZERO,
                    max: Size::new(f32::INFINITY, f32::INFINITY),
                },
                ctx,
            );
            let true_main_intrinsic = match cstyle.axis {
                Axis::Horizontal => m_true.width,
                Axis::Vertical => m_true.height,
            };
            let true_cross_intrinsic = match cstyle.axis {
                Axis::Horizontal => m_true.height,
                Axis::Vertical => m_true.width,
            };
            // Content that grows on the main axis when the cross axis is
            // constrained has reflowed (auto-wrapped text). Its unconstrained
            // cross size is not a meaningful minimum, or wrapping could never
            // take effect.
            if main_intrinsic <= true_main_intrinsic + 0.01 {
                cross = cross.max(resolve_cross(cross_len, true_cross_intrinsic, avail_cross));
            }
        }

        let main_auto =
            matches!(main_len, Length::Fit) || (main_len.is_fill() && !avail_main.is_finite());
        let cross_auto =
            matches!(cross_len, Length::Fit) || (cross_len.is_fill() && !avail_cross.is_finite());

        let (bw, bh) = match cstyle.axis {
            Axis::Horizontal => cs.apply_aspect(base, cross, main_auto, cross_auto),
            Axis::Vertical => {
                let (h, w) = (base, cross);
                let (w2, h2) = cs.apply_aspect(w, h, cross_auto, main_auto);
                (h2, w2)
            }
        };
        base = bw;
        cross = bh;

        let extra = if flex_extra.is_finite() && flex_extra > 0.0 {
            flex_extra
        } else {
            0.0
        };
        let grow = grow_basis.max(cs.flex_weight()).max(extra);
        grow_basis = grow;
        let shrink = cs.flex_shrink_weight();

        let (mut mn, mx, _, _, _) = self.child_limits_full(child, cstyle.axis);
        let margin_main = cs.margin_main(cstyle.axis);
        let margin_cross = cs.margin_cross(cstyle.axis);
        let (base, cross) = match cstyle.axis {
            Axis::Horizontal => (
                cs.clamp_width(base).max(0.0) + margin_main,
                cs.clamp_height(cross).max(0.0) + margin_cross,
            ),
            Axis::Vertical => (
                cs.clamp_height(base).max(0.0) + margin_main,
                cs.clamp_width(cross).max(0.0) + margin_cross,
            ),
        };

        if grow <= 0.0 && matches!(main_len, Length::Fit) {
            mn = mn.max(base);
        }
        let _ = grow_basis;
        (base.max(0.0), grow, shrink, cross.max(0.0), mn, mx)
    }

    fn child_grid_placement(&self, child: ElementId) -> GridPlacement {
        self.view_rc(child)
            .and_then(|v| v.grid_placement())
            .unwrap_or(GridPlacement::AUTO)
    }

    fn grid_cells(
        &self,
        children: &[ElementId],
        grid: &GridStyle,
        placements: &[GridPlacement],
    ) -> Vec<(usize, usize, usize, usize)> {
        let ncols = grid.columns.len().max(1);
        let mut cells = Vec::with_capacity(children.len());
        let mut occupied: Vec<Vec<bool>> = Vec::new();
        let ensure_row = |occupied: &mut Vec<Vec<bool>>, r: usize| {
            while occupied.len() <= r {
                occupied.push(vec![false; ncols]);
            }
        };
        let mut cursor = (0usize, 0usize);
        for (idx, &child) in children.iter().enumerate() {
            if self.child_layout_style(child).is_absolute() {
                cells.push((0, 0, 0, 0));
                continue;
            }
            let p = placements
                .get(idx)
                .copied()
                .filter(|p| !p.is_auto())
                .or_else(|| Some(self.child_grid_placement(child)))
                .unwrap_or(GridPlacement::AUTO);
            let cs = p.col_span.max(1).min(ncols);
            let rs = p.row_span.max(1);
            if let (Some(c), Some(r)) = (p.column, p.row) {
                let c = c.min(ncols.saturating_sub(1));
                ensure_row(&mut occupied, r + rs - 1);
                for row in occupied.iter_mut().skip(r).take(rs) {
                    for cell in row.iter_mut().take((c + cs).min(ncols)).skip(c) {
                        *cell = true;
                    }
                }
                cells.push((c, r, cs, rs));
                continue;
            }

            match grid.auto_flow {
                sequoia_layout::GridFlow::Row => {
                    let (mut c, mut r) = cursor;
                    loop {
                        ensure_row(&mut occupied, r + rs - 1);

                        let mut placed: Option<usize> = None;
                        let start_c = if r == cursor.1 { c } else { 0 };
                        for cc in start_c..ncols {
                            if cc + cs > ncols {
                                break;
                            }
                            let free =
                                (cc..cc + cs).all(|x| (r..r + rs).all(|rr| !occupied[rr][x]));
                            if free {
                                placed = Some(cc);
                                break;
                            }
                        }
                        if let Some(cc) = placed {
                            for row in occupied.iter_mut().skip(r).take(rs) {
                                for cell in row.iter_mut().skip(cc).take(cs) {
                                    *cell = true;
                                }
                            }
                            cells.push((cc, r, cs, rs));
                            cursor = (cc + cs, r);
                            if cursor.0 >= ncols {
                                cursor = (0, r + 1);
                            }
                            break;
                        }

                        c = 0;
                        r += 1;
                    }
                }
                sequoia_layout::GridFlow::Column => {
                    let idx = cells.iter().filter(|(_, _, cs, _)| *cs > 0).count();
                    let nrows_est = children.len().div_ceil(ncols).max(1);
                    let col = (idx / nrows_est) % ncols;
                    let row = idx % nrows_est;
                    ensure_row(&mut occupied, row + rs - 1);
                    cells.push((col.min(ncols - 1), row, cs, rs));
                }
            }
        }
        cells
    }

    fn track_cap(&self, track: Option<&Track>, avail: f32) -> f32 {
        match track {
            Some(Track::Px(v)) => v.max(0.0),
            Some(Track::Percent(p)) if avail.is_finite() && p.is_finite() => {
                (avail * p / 100.0).max(0.0)
            }
            Some(Track::MinMax { max, .. }) => self.track_cap(Some(max), avail),
            _ => f32::INFINITY,
        }
    }

    fn grid_content_sizes(
        &self,
        children: &[ElementId],
        grid: &GridStyle,
        placements: &[GridPlacement],
        inner_avail: Size,
        ctx: &mut LayoutCtx,
    ) -> (Vec<f32>, Vec<f32>, Vec<(usize, usize, usize, usize)>, usize) {
        let ncols = grid.columns.len().max(1);
        let cells = self.grid_cells(children, grid, placements);
        let nrows_needed = cells
            .iter()
            .map(|(_, r, _, rs)| if *rs > 0 { r + rs } else { 0 })
            .max()
            .unwrap_or(0)
            .max(grid.rows.len())
            .max(1);

        let mut content_col = vec![0.0_f32; ncols];
        let mut content_row = vec![0.0_f32; nrows_needed];

        let tracks_fixed = grid.columns.iter().all(|t| {
            matches!(
                t,
                sequoia_layout::Track::Px(_)
                    | sequoia_layout::Track::Percent(_)
                    | sequoia_layout::Track::Fill(_)
            )
        }) && grid.rows.len() >= nrows_needed
            && grid.rows.iter().all(|t| {
                matches!(
                    t,
                    sequoia_layout::Track::Px(_)
                        | sequoia_layout::Track::Percent(_)
                        | sequoia_layout::Track::Fill(_)
                )
            });
        if tracks_fixed && inner_avail.width.is_finite() && inner_avail.height.is_finite() {
            return (content_col, content_row, cells, nrows_needed);
        }

        for (i, &child) in children.iter().enumerate() {
            let (col, row, cs, _rs) = cells[i];
            if cs == 0 {
                continue;
            }
            let col_fixed = matches!(
                grid.columns.get(col),
                Some(sequoia_layout::Track::Px(_)) | Some(sequoia_layout::Track::Percent(_))
            );
            let row_fixed = matches!(
                grid.rows.get(row),
                Some(sequoia_layout::Track::Px(_)) | Some(sequoia_layout::Track::Percent(_))
            );
            if col_fixed && row_fixed {
                continue;
            }
            let col_max = self.track_cap(grid.columns.get(col), inner_avail.width);
            let m = self.measure(
                child,
                Constraints {
                    min: Size::ZERO,
                    max: Size::new(col_max, f32::INFINITY),
                },
                ctx,
            );

            let style = self.child_layout_style(child);
            let outer = style.outer_size(m);
            content_col[col] = content_col[col].max(outer.width);
            if row < content_row.len() {
                content_row[row] = content_row[row].max(outer.height);
            }
        }

        (content_col, content_row, cells, nrows_needed)
    }

    fn grid_rows(grid: &GridStyle, nrows_needed: usize) -> Vec<Track> {
        let mut rows: Vec<Track> = grid.rows.clone();
        rows.resize(nrows_needed, Track::Fit);
        rows
    }

    fn measure_grid(
        &self,
        children: &[ElementId],
        grid: &GridStyle,
        placements: &[GridPlacement],
        inner_avail: Size,
        ctx: &mut LayoutCtx,
    ) -> (f32, f32) {
        let (content_col, content_row, _cells, nrows_needed) =
            self.grid_content_sizes(children, grid, placements, inner_avail, ctx);
        let widths = resolve_tracks(
            &grid.columns,
            &content_col,
            inner_avail.width,
            grid.column_gap,
        );
        let rows = Self::grid_rows(grid, nrows_needed);
        let heights = resolve_tracks(&rows, &content_row, inner_avail.height, grid.row_gap);

        let gaps_x = grid.column_gap * widths.len().saturating_sub(1) as f32;
        let gaps_y = grid.row_gap * heights.len().saturating_sub(1) as f32;
        (
            widths.iter().sum::<f32>() + gaps_x,
            heights.iter().sum::<f32>() + gaps_y,
        )
    }

    fn measure_wrap(
        &self,
        children: &[ElementId],
        wstyle: &WrapStyle,
        inner_avail: Size,
        ctx: &mut LayoutCtx,
    ) -> (f32, f32) {
        let avail_main = match wstyle.axis {
            Axis::Horizontal => inner_avail.width,
            Axis::Vertical => inner_avail.height,
        };
        let (mains, crosses, _) = self.wrap_child_sizes(children, wstyle, ctx);
        let lines = wstyle.lines(&mains, avail_main);

        let mut main_max = 0.0_f32;
        let mut cross_total = 0.0_f32;
        for (line_idx, &(start, end)) in lines.iter().enumerate() {
            let mut used = 0.0_f32;
            let mut line_cross = 0.0_f32;
            for i in start..end {
                if i > start {
                    used += wstyle.main_gap();
                }
                used += mains[i];
                line_cross = line_cross.max(crosses[i]);
            }
            main_max = main_max.max(used);
            if line_idx > 0 {
                cross_total += wstyle.cross_gap();
            }
            cross_total += line_cross;
        }

        match wstyle.axis {
            Axis::Horizontal => (main_max, cross_total),
            Axis::Vertical => (cross_total, main_max),
        }
    }

    fn measure_masonry(
        &self,
        children: &[ElementId],
        mstyle: &MasonryStyle,
        inner_avail: Size,
        content_width: bool,
        ctx: &mut LayoutCtx,
    ) -> (f32, f32) {
        let flow: Vec<ElementId> = children
            .iter()
            .copied()
            .filter(|c| !self.child_layout_style(*c).is_absolute())
            .collect();
        if flow.is_empty() {
            return (0.0, 0.0);
        }

        let columns = mstyle.columns.max(1);
        let column_gap = sanitize_gap(mstyle.column_gap);
        let row_gap = sanitize_gap(mstyle.row_gap);

        let column_width = if content_width || !inner_avail.width.is_finite() {
            flow.iter()
                .map(|&child| {
                    let m = self.measure(
                        child,
                        Constraints {
                            min: Size::ZERO,
                            max: Size::new(f32::INFINITY, f32::INFINITY),
                        },
                        ctx,
                    );
                    let cs = self.child_layout_style(child);
                    (m.width + cs.margin.horizontal_sum()).max(0.0)
                })
                .fold(0.0_f32, f32::max)
        } else {
            masonry_column_width(inner_avail.width, columns, column_gap)
        };

        let mut heights = Vec::with_capacity(flow.len());
        for child in flow {
            let cs = self.child_layout_style(child);
            let max_width = (column_width - cs.margin.horizontal_sum()).max(0.0);
            let m = self.measure(
                child,
                Constraints {
                    min: Size::ZERO,
                    max: Size::new(max_width, f32::INFINITY),
                },
                ctx,
            );
            heights.push((m.height + cs.margin.vertical_sum()).max(0.0));
        }

        let (_, height) = masonry_assign(&heights, columns, row_gap);
        let width = column_width * columns as f32 + column_gap * columns.saturating_sub(1) as f32;
        (width.max(0.0), height.max(0.0))
    }

    fn wrap_child_sizes(
        &self,
        children: &[ElementId],
        wstyle: &WrapStyle,
        ctx: &mut LayoutCtx,
    ) -> (Vec<f32>, Vec<f32>, Vec<ElementId>) {
        let mut mains = Vec::with_capacity(children.len());
        let mut crosses = Vec::with_capacity(children.len());
        let mut ids = Vec::with_capacity(children.len());
        for &child in children {
            if self.child_layout_style(child).is_absolute() {
                continue;
            }
            let m = self.measure(
                child,
                Constraints {
                    min: Size::ZERO,
                    max: Size::new(f32::INFINITY, f32::INFINITY),
                },
                ctx,
            );
            let cs = self.child_layout_style(child);
            let (main, cross) = match wstyle.axis {
                Axis::Horizontal => (
                    m.width + cs.margin.horizontal_sum(),
                    m.height + cs.margin.vertical_sum(),
                ),
                Axis::Vertical => (
                    m.height + cs.margin.vertical_sum(),
                    m.width + cs.margin.horizontal_sum(),
                ),
            };
            mains.push(main.max(0.0));
            crosses.push(cross.max(0.0));
            ids.push(child);
        }
        (mains, crosses, ids)
    }

    fn arrange(&self, el: ElementId, rect: Rect, ctx: &mut LayoutCtx) {
        if std::panic::catch_unwind(AssertUnwindSafe(|| self.arrange_inner(el, rect, ctx))).is_err()
        {
            let type_name = self.type_name_of(el).unwrap_or_else(|| "?".into());
            self.record_error(el, type_name, "arrange panicked".to_string());
        }
    }

    fn arrange_inner(&self, el: ElementId, rect: Rect, ctx: &mut LayoutCtx) {
        if let Some(e) = self.inner.arena.borrow_mut().get_mut(el) {
            e.rect.set(rect);
            e.laid_out.set(true);
        }

        if let Some(v) = self.view_rc(el)
            && v.arrange_override_erased(self, el, rect, ctx)
        {
            return;
        }

        let Some(v) = self.view_rc(el) else { return };
        let style = self.child_layout_style(el);
        let content = Rect::from_xywh(
            rect.left() + style.padding.left,
            rect.top() + style.padding.top,
            (rect.size.width - style.padding.horizontal_sum()).max(0.0),
            (rect.size.height - style.padding.vertical_sum()).max(0.0),
        );

        if let Some(gstyle) = v.grid() {
            let children = self.children(el);
            if !children.is_empty() {
                let placements = v.grid_placements().unwrap_or_default();
                self.arrange_grid(&children, &gstyle, &placements, content, ctx);
            } else {
                for &child in &self.children(el) {
                    if self.child_layout_style(child).is_absolute() {
                        self.arrange_absolute(child, content, ctx);
                    }
                }
            }
            return;
        }

        if let Some(dstyle) = v.dock() {
            let children = self.children(el);
            if !children.is_empty() {
                self.arrange_dock(&children, &dstyle, content, ctx);
            }
            return;
        }

        if let Some(wstyle) = v.wrap() {
            let children = self.children(el);
            if !children.is_empty() {
                self.arrange_wrap(&children, &wstyle, content, ctx);
            }
            return;
        }

        if let Some(mstyle) = v.masonry() {
            let children = self.children(el);
            if !children.is_empty() {
                self.arrange_masonry(&children, &mstyle, content, ctx);
            }
            return;
        }

        if let Some(cstyle) = v.container() {
            let children = self.children(el);
            if !children.is_empty() {
                let flex = v.flex_weights().unwrap_or_default();
                self.arrange_children(&children, &cstyle, content, &flex, ctx);
                return;
            }
        }

        let children = self.children(el);
        if children.len() == 1 {
            let child = children[0];
            let cs = self.child_layout_style(child);
            if cs.is_absolute() {
                self.arrange_absolute(child, content, ctx);
                return;
            }
            let avail = Size::new(
                (content.size.width - cs.margin.horizontal_sum()).max(0.0),
                (content.size.height - cs.margin.vertical_sum()).max(0.0),
            );
            let m = self.measure(
                child,
                Constraints {
                    min: Size::ZERO,
                    max: avail,
                },
                ctx,
            );
            let (cw, ch) = match self.view_rc(child) {
                Some(_v) => {
                    let cs = self.child_layout_style(child);
                    let w_auto = matches!(cs.width, Length::Fit)
                        || (cs.width.is_fill() && !avail.width.is_finite());
                    let h_auto = matches!(cs.height, Length::Fit)
                        || (cs.height.is_fill() && !avail.height.is_finite());
                    let w = resolve_cross(cs.width, m.width, avail.width);
                    let h = resolve_cross(cs.height, m.height, avail.height);
                    let (w, h) = cs.apply_aspect(w, h, w_auto, h_auto);
                    (cs.clamp_width(w).max(0.0), cs.clamp_height(h).max(0.0))
                }
                None => (avail.width, avail.height),
            };
            self.arrange(
                child,
                Rect::from_xywh(
                    content.left() + cs.margin.left,
                    content.top() + cs.margin.top,
                    cw,
                    ch,
                ),
                ctx,
            );
        } else if children.len() > 1 {
            let flow: Vec<ElementId> = children
                .iter()
                .copied()
                .filter(|c| !self.child_layout_style(*c).is_absolute())
                .collect();
            if flow.len() == 1 {
                let child = flow[0];
                let cs = self.child_layout_style(child);
                let avail = Size::new(
                    (content.size.width - cs.margin.horizontal_sum()).max(0.0),
                    (content.size.height - cs.margin.vertical_sum()).max(0.0),
                );
                let m = self.measure(child, Constraints::loose(avail), ctx);
                let w = cs
                    .clamp_width(resolve_cross(cs.width, m.width, avail.width))
                    .max(0.0);
                let h = cs
                    .clamp_height(resolve_cross(cs.height, m.height, avail.height))
                    .max(0.0);
                self.arrange(
                    child,
                    Rect::from_xywh(
                        content.left() + cs.margin.left,
                        content.top() + cs.margin.top,
                        w,
                        h,
                    ),
                    ctx,
                );
            } else if !flow.is_empty() {
                let cs = ContainerStyle::new(Axis::Vertical, 0.0);
                self.arrange_children(&flow, &cs, content, &[], ctx);
            }
            for &child in &children {
                if self.child_layout_style(child).is_absolute() {
                    self.arrange_absolute(child, content, ctx);
                }
            }
        }
    }

    fn arrange_wrap(
        &self,
        children: &[ElementId],
        wstyle: &WrapStyle,
        content: Rect,
        ctx: &mut LayoutCtx,
    ) {
        let avail_main = match wstyle.axis {
            Axis::Horizontal => content.size.width,
            Axis::Vertical => content.size.height,
        };
        let (mains, crosses, ids) = self.wrap_child_sizes(children, wstyle, ctx);
        let lines = wstyle.lines(&mains, avail_main);
        let (main_gap, cross_gap) = (wstyle.main_gap(), wstyle.cross_gap());

        let mut cross_cursor = 0.0_f32;
        for (line_idx, &(start, end)) in lines.iter().enumerate() {
            let line_cross = crosses[start..end].iter().copied().fold(0.0_f32, f32::max);
            if line_idx > 0 {
                cross_cursor += cross_gap;
            }
            let mut main_cursor = 0.0_f32;
            for i in start..end {
                let child = ids[i];
                if i > start {
                    main_cursor += main_gap;
                }
                let cs = self.child_layout_style(child);
                let (m_main_start, m_main_end, m_cross_start, m_cross_end) = match wstyle.axis {
                    Axis::Horizontal => (
                        cs.margin.left,
                        cs.margin.right,
                        cs.margin.top,
                        cs.margin.bottom,
                    ),
                    Axis::Vertical => (
                        cs.margin.top,
                        cs.margin.bottom,
                        cs.margin.left,
                        cs.margin.right,
                    ),
                };
                let main_outer = mains[i];
                let cross_outer = crosses[i];
                let main_inner = (main_outer - m_main_start - m_main_end).max(0.0);
                let mut cross_inner = (cross_outer - m_cross_start - m_cross_end).max(0.0);
                let cross_off = match wstyle.align {
                    Align::Start | Align::Stretch | Align::Baseline => 0.0,
                    Align::Center => ((line_cross - cross_outer) * 0.5).max(0.0),
                    Align::End => (line_cross - cross_outer).max(0.0),
                };
                if wstyle.align == Align::Stretch {
                    let cross_len = match wstyle.axis {
                        Axis::Horizontal => cs.height,
                        Axis::Vertical => cs.width,
                    };
                    if matches!(cross_len, Length::Fit) {
                        cross_inner = (line_cross - m_cross_start - m_cross_end).max(0.0);
                    }
                }
                let rect = match wstyle.axis {
                    Axis::Horizontal => Rect::from_xywh(
                        content.left() + main_cursor + m_main_start,
                        content.top() + cross_cursor + cross_off + m_cross_start,
                        main_inner,
                        cross_inner,
                    ),
                    Axis::Vertical => Rect::from_xywh(
                        content.left() + cross_cursor + cross_off + m_cross_start,
                        content.top() + main_cursor + m_main_start,
                        cross_inner,
                        main_inner,
                    ),
                };
                self.arrange(child, rect, ctx);
                main_cursor += main_outer;
            }
            cross_cursor += line_cross;
        }

        for &child in children {
            if self.child_layout_style(child).is_absolute() {
                self.arrange_absolute(child, content, ctx);
            }
        }
    }

    fn arrange_masonry(
        &self,
        children: &[ElementId],
        mstyle: &MasonryStyle,
        content: Rect,
        ctx: &mut LayoutCtx,
    ) {
        let flow: Vec<ElementId> = children
            .iter()
            .copied()
            .filter(|c| !self.child_layout_style(*c).is_absolute())
            .collect();
        let columns = mstyle.columns.max(1);
        let column_gap = sanitize_gap(mstyle.column_gap);
        let row_gap = sanitize_gap(mstyle.row_gap);

        let column_width = if content.size.width.is_finite() {
            masonry_column_width(content.size.width, columns, column_gap)
        } else {
            flow.iter()
                .map(|&child| {
                    let m = self.measure(
                        child,
                        Constraints {
                            min: Size::ZERO,
                            max: Size::new(f32::INFINITY, f32::INFINITY),
                        },
                        ctx,
                    );
                    let cs = self.child_layout_style(child);
                    (m.width + cs.margin.horizontal_sum()).max(0.0)
                })
                .fold(0.0_f32, f32::max)
        };

        let mut infos = Vec::with_capacity(flow.len());
        let mut heights = Vec::with_capacity(flow.len());
        for &child in &flow {
            let cs = self.child_layout_style(child);
            let max_width = (column_width - cs.margin.horizontal_sum()).max(0.0);
            let m = self.measure(
                child,
                Constraints {
                    min: Size::ZERO,
                    max: Size::new(max_width, f32::INFINITY),
                },
                ctx,
            );
            heights.push((m.height + cs.margin.vertical_sum()).max(0.0));
            infos.push((child, cs, m));
        }

        let (placements, _) = masonry_assign(&heights, columns, row_gap);
        for (i, (child, cs, m)) in infos.into_iter().enumerate() {
            let placement = placements.get(i).copied().unwrap_or_default();
            let avail_w = (column_width - cs.margin.horizontal_sum()).max(0.0);
            let align = cs.effective_align(mstyle.align);
            let mut w = cs
                .clamp_width(resolve_cross(cs.width, m.width, avail_w))
                .max(0.0);
            if align == Align::Stretch && matches!(cs.width, Length::Fit) {
                w = avail_w.min(cs.max_width).max(cs.min_width).max(0.0);
            }
            let h = cs.clamp_height(m.height).max(0.0);
            let ox = match align {
                Align::Start | Align::Stretch | Align::Baseline => 0.0,
                Align::Center => ((avail_w - w).max(0.0)) * 0.5,
                Align::End => (avail_w - w).max(0.0),
            };
            let column_x = content.left()
                + placement.column as f32 * (column_width + column_gap)
                + cs.margin.left
                + ox;
            let y = content.top() + placement.top + cs.margin.top;
            self.arrange(
                child,
                Rect::from_xywh(column_x, y, w.max(0.0), h.max(0.0)),
                ctx,
            );
        }

        for &child in children {
            if self.child_layout_style(child).is_absolute() {
                self.arrange_absolute(child, content, ctx);
            }
        }
    }

    fn arrange_children(
        &self,
        children: &[ElementId],
        cstyle: &ContainerStyle,
        content: Rect,
        flex: &[f32],
        ctx: &mut LayoutCtx,
    ) {
        if cstyle.wrap {
            let flow_idx: Vec<usize> = children
                .iter()
                .enumerate()
                .filter(|(_, c)| !self.child_layout_style(**c).is_absolute())
                .map(|(i, _)| i)
                .collect();
            self.arrange_children_wrapped(children, &flow_idx, cstyle, content, flex, ctx);
        } else {
            self.arrange_children_linear(children, cstyle, content, flex, ctx);
        }

        for &child in children {
            if self.child_layout_style(child).is_absolute() {
                self.arrange_absolute(child, content, ctx);
            }
        }
    }

    fn arrange_children_linear(
        &self,
        children: &[ElementId],
        cstyle: &ContainerStyle,
        content: Rect,
        flex: &[f32],
        ctx: &mut LayoutCtx,
    ) {
        let (avail_main, avail_cross) = match cstyle.axis {
            Axis::Horizontal => (content.size.width, content.size.height),
            Axis::Vertical => (content.size.height, content.size.width),
        };

        // Mirror `measure_children`: stop arranging once the main axis is
        // full. Absolute children are still arranged by `arrange_children`.
        let cull = Self::can_cull_main_axis(avail_main);
        let mut infos: Vec<(ElementId, f32, f32, f32, f32, f32, f32, LayoutStyle)> =
            Vec::with_capacity(children.len().min(256));
        let mut used_outer = 0.0_f32;
        let mut cut = None;
        let mut shrinkable = false;
        for (orig, &child) in children.iter().enumerate() {
            let extra = flex.get(orig).copied().unwrap_or(0.0);
            let cs = self.child_layout_style(child);
            if cs.is_absolute() {
                continue;
            }
            let (base, grow, shrink, cross, mn, mx) =
                self.child_layout_info_full(child, cstyle, avail_main, avail_cross, extra, ctx);
            let fixed = Self::cullable_main(&cs, cstyle.axis, base, mn);
            shrinkable |= !fixed;
            if !infos.is_empty() {
                used_outer += cstyle.gap;
            }
            used_outer += base;
            infos.push((child, base, grow, shrink, cross, mn, mx, cs));
            if cull && !shrinkable && used_outer > avail_main && fixed {
                cut = Some(orig + 1);
                break;
            }
        }
        if let Some(cut) = cut {
            // Skipped rows keep no geometry this pass. Park their roots outside
            // every clip and mark them hidden so paint and hit testing do not
            // draw stale content at an old (or origin) rect.
            let parked = Rect::from_xywh(-1.0e6, -1.0e6, 0.0, 0.0);
            let mut arena = self.inner.arena.borrow_mut();
            for &child in &children[cut..] {
                if let Some(e) = arena.get_mut(child) {
                    e.rect.set(parked);
                    e.laid_out.set(false);
                }
            }
        }
        let child_styles: Vec<LayoutStyle> = infos.iter().map(|info| info.7).collect();
        let gaps = Self::main_gap_specs(&child_styles, cstyle.axis, cstyle.gap, avail_main);

        let resolved_gaps = {
            let items: Vec<FlexItem> = infos
                .iter()
                .map(|(_, b, g, s, _, mn, mx, _)| FlexItem::new(*b, *g, *s, *mn, *mx))
                .collect();
            let mut bases: Vec<f32> = infos.iter().map(|(_, b, ..)| *b).collect();
            let resolved = Self::distribute_main(&items, &mut bases, &gaps, avail_main);
            for (info, base) in infos.iter_mut().zip(bases) {
                info.1 = base;
            }
            resolved
        };

        if avail_main.is_finite() {
            for info in infos.iter_mut() {
                if self.subtree_has_wrap_axis(info.0, cstyle.axis) {
                    info.4 = self.constrained_cross(info.0, cstyle.axis, info.1, avail_cross, ctx);
                }
            }
        }

        let used_main: f32 =
            infos.iter().map(|(_, b, ..)| *b).sum::<f32>() + resolved_gaps.iter().sum::<f32>();
        let extra = Self::extra_main(avail_main, used_main);
        let (mut cursor, gap_step) = cstyle.justify.distribute(infos.len(), cstyle.gap, extra);

        let baseline_aligned: Vec<bool> = if cstyle.axis == Axis::Horizontal {
            infos
                .iter()
                .map(|(_, _, _, _, _, _, _, cs)| {
                    cs.effective_align(cstyle.align) == Align::Baseline
                })
                .collect()
        } else {
            vec![false; infos.len()]
        };
        let baselines: Vec<f32> = if baseline_aligned.iter().any(|&b| b) {
            infos
                .iter()
                .zip(&baseline_aligned)
                .map(|((child, base, _, _, cross, _, _, cs), &aligned)| {
                    if !aligned {
                        return 0.0;
                    }
                    let inner_h = (*cross - cs.margin.top - cs.margin.bottom).max(0.0);
                    let width = (*base - cs.margin_main(cstyle.axis)).max(0.0);
                    self.baseline_offset(*child, width, ctx).unwrap_or(inner_h)
                })
                .collect()
        } else {
            vec![0.0; infos.len()]
        };
        let max_baseline = baselines.iter().copied().fold(0.0_f32, f32::max);

        for (i, info) in infos.iter().enumerate() {
            let (child, base, _, _, cross, _, _, cs) = *info;
            if i > 0 {
                cursor += resolved_gaps.get(i - 1).copied().unwrap_or(0.0) + gap_step;
            }
            let (margin_main_start, margin_cross_start) = match cstyle.axis {
                Axis::Horizontal => (cs.margin.left, cs.margin.top),
                Axis::Vertical => (cs.margin.top, cs.margin.left),
            };
            let (cross_off, cross_size) = self.place_cross(child, cstyle, cross, avail_cross);
            let shift = Self::indent_cross_shift(&cs, cstyle.axis, avail_cross);
            let baseline_shift = if baseline_aligned[i] {
                (max_baseline - baselines[i]).max(0.0)
            } else {
                0.0
            };
            let base_inner = (base - cs.margin_main(cstyle.axis)).max(0.0);
            let (rx, ry, rw, rh) = match cstyle.axis {
                Axis::Horizontal => (
                    content.left() + cursor + margin_main_start,
                    content.top() + cross_off + shift + baseline_shift,
                    base_inner,
                    cross_size,
                ),
                Axis::Vertical => (
                    content.left() + cross_off + shift,
                    content.top() + cursor + margin_main_start,
                    cross_size,
                    base_inner,
                ),
            };
            let _ = margin_cross_start;
            cursor += base;
            if i + 1 == infos.len() {
                cursor += resolved_gaps.last().copied().unwrap_or(0.0);
            }
            self.arrange(
                child,
                Rect::from_xywh(rx, ry, rw.max(0.0), rh.max(0.0)),
                ctx,
            );
        }
    }

    fn arrange_children_wrapped(
        &self,
        children: &[ElementId],
        flow_idx: &[usize],
        cstyle: &ContainerStyle,
        content: Rect,
        flex: &[f32],
        ctx: &mut LayoutCtx,
    ) {
        let (avail_main, avail_cross) = match cstyle.axis {
            Axis::Horizontal => (content.size.width, content.size.height),
            Axis::Vertical => (content.size.height, content.size.width),
        };
        let n = flow_idx.len();
        if n == 0 {
            return;
        }
        let mut bases = Vec::with_capacity(n);
        let mut crosses = Vec::with_capacity(n);
        let mut items = Vec::with_capacity(n);
        let mut ids = Vec::with_capacity(n);
        for &orig in flow_idx {
            let child = children[orig];
            let extra = flex.get(orig).copied().unwrap_or(0.0);
            let (base, grow, shrink, cross, mn, mx) =
                self.child_layout_info_full(child, cstyle, avail_main, avail_cross, extra, ctx);
            ids.push(child);
            bases.push(base);
            crosses.push(cross);
            items.push(FlexItem::new(base, grow, shrink, mn, mx));
        }
        let lines = wrap_lines(&bases, avail_main, cstyle.gap);

        let mut line_crosses: Vec<f32> = Vec::with_capacity(lines.len());
        for &(s, e) in &lines {
            let mut line_sizes = bases[s..e].to_vec();
            distribute_flex(
                &items[s..e],
                &mut line_sizes,
                cstyle.main_gaps_total(e - s),
                avail_main,
            );
            for (k, v) in (s..e).zip(line_sizes) {
                bases[k] = v;
            }

            if avail_main.is_finite() {
                for k in s..e {
                    if self.subtree_has_wrap_axis(ids[k], cstyle.axis) {
                        crosses[k] =
                            self.constrained_cross(ids[k], cstyle.axis, bases[k], avail_cross, ctx);
                    }
                }
            }
            line_crosses.push(crosses[s..e].iter().cloned().fold(0.0f32, f32::max));
        }
        let total_cross: f32 = line_crosses.iter().sum::<f32>()
            + cstyle.cross_gap * lines.len().saturating_sub(1) as f32;
        let cross_extra = if avail_cross.is_finite() {
            (avail_cross - total_cross).max(0.0)
        } else {
            0.0
        };
        let (mut cross_cursor, cross_step) = match cstyle.align_content {
            Align::Start | Align::Baseline => (0.0, 0.0),
            Align::Center => (cross_extra * 0.5, 0.0),
            Align::End => (cross_extra, 0.0),
            Align::Stretch if line_crosses.len() > 1 => {
                (0.0, cross_extra / (line_crosses.len() - 1) as f32)
            }
            Align::Stretch => (0.0, 0.0),
        };

        for (li, &(s, e)) in lines.iter().enumerate() {
            let line_cross = line_crosses[li];
            if li > 0 {
                cross_cursor += cstyle.cross_gap + cross_step;
            }
            let used: f32 = bases[s..e].iter().sum::<f32>() + cstyle.main_gaps_total(e - s);
            let line_extra = if avail_main.is_finite() {
                (avail_main - used).max(0.0)
            } else {
                0.0
            };
            let (mut cursor, gap_step) = cstyle.justify.distribute(e - s, cstyle.gap, line_extra);
            for k in s..e {
                if k > s {
                    cursor += cstyle.gap + gap_step;
                }
                let child = ids[k];
                let cs = self.child_layout_style(child);
                let margin_main_start = match cstyle.axis {
                    Axis::Horizontal => cs.margin.left,
                    Axis::Vertical => cs.margin.top,
                };
                let (cross_off, cross_size) =
                    self.place_cross(child, cstyle, crosses[k], line_cross);
                let base_inner = (bases[k] - cs.margin_main(cstyle.axis)).max(0.0);
                let (rx, ry, rw, rh) = match cstyle.axis {
                    Axis::Horizontal => (
                        content.left() + cursor + margin_main_start,
                        content.top() + cross_cursor + cross_off,
                        base_inner,
                        cross_size,
                    ),
                    Axis::Vertical => (
                        content.left() + cross_cursor + cross_off,
                        content.top() + cursor + margin_main_start,
                        cross_size,
                        base_inner,
                    ),
                };
                cursor += bases[k];
                self.arrange(
                    child,
                    Rect::from_xywh(rx, ry, rw.max(0.0), rh.max(0.0)),
                    ctx,
                );
            }
            cross_cursor += line_cross;
        }
    }

    fn arrange_grid(
        &self,
        children: &[ElementId],
        grid: &GridStyle,
        placements: &[GridPlacement],
        content: Rect,
        ctx: &mut LayoutCtx,
    ) {
        let (content_col, content_row, cells, nrows_needed) =
            self.grid_content_sizes(children, grid, placements, content.size, ctx);
        let widths = resolve_tracks(
            &grid.columns,
            &content_col,
            content.size.width,
            grid.column_gap,
        );
        let rows = Self::grid_rows(grid, nrows_needed);
        let heights = resolve_tracks(&rows, &content_row, content.size.height, grid.row_gap);
        let xs = track_offsets(&widths, grid.column_gap);
        let ys = track_offsets(&heights, grid.row_gap);

        for (i, &child) in children.iter().enumerate() {
            let cs = self.child_layout_style(child);
            if cs.is_absolute() {
                self.arrange_absolute(child, content, ctx);
                continue;
            }
            let (col, row, col_span, row_span) = cells.get(i).copied().unwrap_or((0, 0, 1, 1));
            if col_span == 0 {
                continue;
            }

            let cw = (col..(col + col_span).min(widths.len()))
                .map(|c| widths[c])
                .sum::<f32>()
                + grid.column_gap * col_span.saturating_sub(1) as f32;
            let ch = (row..(row + row_span).min(heights.len()))
                .map(|r| heights[r])
                .sum::<f32>()
                + grid.row_gap * row_span.saturating_sub(1) as f32;
            let col_max = self.track_cap(grid.columns.get(col), content.size.width);
            let m = self.measure(
                child,
                Constraints {
                    min: Size::ZERO,
                    max: Size::new(col_max, f32::INFINITY),
                },
                ctx,
            );
            let eff_h = cs.effective_align(grid.align_items);
            let eff_w = cs.effective_align(grid.justify_items);

            let mut w = cs
                .clamp_width(resolve_cross(cs.width, m.width, cw))
                .max(0.0);
            let mut h = cs
                .clamp_height(resolve_cross(cs.height, m.height, ch))
                .max(0.0);
            if eff_w == Align::Stretch && matches!(cs.width, Length::Fit) && cw.is_finite() {
                w = (cw - cs.margin.horizontal_sum())
                    .max(0.0)
                    .min(cs.max_width)
                    .max(cs.min_width);
            }
            if eff_h == Align::Stretch && matches!(cs.height, Length::Fit) && ch.is_finite() {
                h = (ch - cs.margin.vertical_sum())
                    .max(0.0)
                    .min(cs.max_height)
                    .max(cs.min_height);
            }
            let cell_x = content.left() + xs.get(col).copied().unwrap_or(0.0);
            let cell_y = content.top() + ys.get(row).copied().unwrap_or(0.0);
            let avail_w = (cw - cs.margin.horizontal_sum()).max(0.0);
            let avail_h = (ch - cs.margin.vertical_sum()).max(0.0);
            let ox = match eff_w {
                Align::Start | Align::Stretch | Align::Baseline => 0.0,
                Align::Center => ((avail_w - w).max(0.0)) * 0.5,
                Align::End => (avail_w - w).max(0.0),
            };
            let oy = match eff_h {
                Align::Start | Align::Stretch | Align::Baseline => 0.0,
                Align::Center => ((avail_h - h).max(0.0)) * 0.5,
                Align::End => (avail_h - h).max(0.0),
            };
            self.arrange(
                child,
                Rect::from_xywh(
                    cell_x + cs.margin.left + ox,
                    cell_y + cs.margin.top + oy,
                    w,
                    h,
                ),
                ctx,
            );
        }
    }

    fn measure_dock(
        &self,
        children: &[ElementId],
        dstyle: &DockStyle,
        inner_avail: Size,
        ctx: &mut LayoutCtx,
    ) -> (f32, f32) {
        let flow: Vec<ElementId> = children
            .iter()
            .copied()
            .filter(|c| !self.child_layout_style(*c).is_absolute())
            .collect();
        let n = flow.len();
        if n == 0 {
            return (0.0, 0.0);
        }
        let gap = sanitize_gap(dstyle.gap);

        let order = dock_layout_order(&dstyle.docks, dstyle.last_child_fill, dstyle.ordered, n);
        let mut remaining = Size::new(inner_avail.width.max(0.0), inner_avail.height.max(0.0));
        let mut measured = vec![Size::ZERO; n];
        let mut thick = vec![0.0_f32; n];

        for (pos, &i) in order.iter().enumerate() {
            let child = flow[i];
            let d = resolve_dock(&dstyle.docks, dstyle.last_child_fill, dstyle.ordered, i, n);
            let max = match d {
                Dock::Left | Dock::Right => Size::new(f32::INFINITY, remaining.height),
                Dock::Top | Dock::Bottom => Size::new(remaining.width, f32::INFINITY),
                Dock::Fill => remaining,
            };
            let m = self.measure(child, Constraints::loose(max), ctx);
            let cs = self.child_layout_style(child);
            let t = match d {
                Dock::Left | Dock::Right => Self::clamp_dock_thickness(
                    cs.clamp_width(dock_thickness(cs.width, m.width, remaining.width)),
                    remaining.width,
                ),
                Dock::Top | Dock::Bottom => Self::clamp_dock_thickness(
                    cs.clamp_height(dock_thickness(cs.height, m.height, remaining.height)),
                    remaining.height,
                ),
                Dock::Fill => 0.0,
            };
            measured[i] = m;
            thick[i] = t;
            remaining = Self::shrink_dock_remaining(remaining, d, t, gap, pos, n);
        }

        let mut cw = 0.0_f32;
        let mut ch = 0.0_f32;
        for &i in order.iter().rev() {
            let m = measured[i];
            match resolve_dock(&dstyle.docks, dstyle.last_child_fill, dstyle.ordered, i, n) {
                Dock::Fill => {
                    cw = cw.max(m.width);
                    ch = ch.max(m.height);
                }
                Dock::Left | Dock::Right => {
                    cw += thick[i];

                    if order.iter().position(|&x| x == i).unwrap_or(0) + 1 < n {
                        cw += gap;
                    }
                    ch = ch.max(m.height);
                }
                Dock::Top | Dock::Bottom => {
                    cw = cw.max(m.width);
                    ch += thick[i];
                    if order.iter().position(|&x| x == i).unwrap_or(0) + 1 < n {
                        ch += gap;
                    }
                }
            }
        }
        (cw.max(0.0), ch.max(0.0))
    }

    fn arrange_dock(
        &self,
        children: &[ElementId],
        dstyle: &DockStyle,
        content: Rect,
        ctx: &mut LayoutCtx,
    ) {
        let flow: Vec<ElementId> = children
            .iter()
            .copied()
            .filter(|c| !self.child_layout_style(*c).is_absolute())
            .collect();
        let n = flow.len();
        let gap = sanitize_gap(dstyle.gap);
        let order = dock_layout_order(&dstyle.docks, dstyle.last_child_fill, dstyle.ordered, n);
        let mut remaining = content;
        for (pos, &i) in order.iter().enumerate() {
            let child = flow[i];
            let d = resolve_dock(&dstyle.docks, dstyle.last_child_fill, dstyle.ordered, i, n);
            let max = match d {
                Dock::Left | Dock::Right => {
                    Size::new(f32::INFINITY, remaining.size.height.max(0.0))
                }
                Dock::Top | Dock::Bottom => Size::new(remaining.size.width.max(0.0), f32::INFINITY),
                Dock::Fill => Size::new(
                    remaining.size.width.max(0.0),
                    remaining.size.height.max(0.0),
                ),
            };
            let m = self.measure(child, Constraints::loose(max), ctx);
            let cs = self.child_layout_style(child);
            let rect = match d {
                Dock::Left => {
                    let t = Self::clamp_dock_thickness(
                        cs.clamp_width(dock_thickness(cs.width, m.width, remaining.size.width)),
                        remaining.size.width,
                    );
                    let h = cs.clamp_height(remaining.size.height.max(0.0)).max(0.0);
                    Rect::from_xywh(remaining.left(), remaining.top(), t, h)
                }
                Dock::Right => {
                    let t = Self::clamp_dock_thickness(
                        cs.clamp_width(dock_thickness(cs.width, m.width, remaining.size.width)),
                        remaining.size.width,
                    );
                    let h = cs.clamp_height(remaining.size.height.max(0.0)).max(0.0);
                    Rect::from_xywh(remaining.right() - t, remaining.top(), t, h)
                }
                Dock::Top => {
                    let t = Self::clamp_dock_thickness(
                        cs.clamp_height(dock_thickness(cs.height, m.height, remaining.size.height)),
                        remaining.size.height,
                    );
                    let w = cs.clamp_width(remaining.size.width.max(0.0)).max(0.0);
                    Rect::from_xywh(remaining.left(), remaining.top(), w, t)
                }
                Dock::Bottom => {
                    let t = Self::clamp_dock_thickness(
                        cs.clamp_height(dock_thickness(cs.height, m.height, remaining.size.height)),
                        remaining.size.height,
                    );
                    let w = cs.clamp_width(remaining.size.width.max(0.0)).max(0.0);
                    Rect::from_xywh(remaining.left(), remaining.bottom() - t, w, t)
                }
                Dock::Fill => {
                    let w = cs.clamp_width(remaining.size.width.max(0.0)).max(0.0);
                    let h = cs.clamp_height(remaining.size.height.max(0.0)).max(0.0);
                    Rect::from_xywh(remaining.left(), remaining.top(), w, h)
                }
            };
            self.arrange(
                child,
                Rect::from_xywh(
                    rect.left(),
                    rect.top(),
                    rect.size.width.max(0.0),
                    rect.size.height.max(0.0),
                ),
                ctx,
            );
            remaining = Self::shrink_dock_rect(
                remaining,
                d,
                Self::dock_rect_thickness(rect, d),
                gap,
                pos,
                n,
            );
        }
        for &child in children {
            if self.child_layout_style(child).is_absolute() {
                self.arrange_absolute(child, content, ctx);
            }
        }
    }

    fn dock_rect_thickness(rect: Rect, d: Dock) -> f32 {
        match d {
            Dock::Left | Dock::Right => rect.size.width.max(0.0),
            Dock::Top | Dock::Bottom => rect.size.height.max(0.0),
            Dock::Fill => 0.0,
        }
    }

    fn clamp_dock_thickness(thickness: f32, remaining: f32) -> f32 {
        let t = if thickness.is_finite() {
            thickness.max(0.0)
        } else {
            0.0
        };
        if remaining.is_finite() {
            t.min(remaining.max(0.0))
        } else {
            t
        }
    }

    fn shrink_dock_remaining(
        remaining: Size,
        d: Dock,
        thickness: f32,
        gap: f32,
        index: usize,
        count: usize,
    ) -> Size {
        let extra = if d.is_side() && index + 1 < count {
            gap
        } else {
            0.0
        };
        let sub = thickness + extra;
        match d {
            Dock::Left | Dock::Right => {
                Size::new(shrink_dock_axis(remaining.width, sub), remaining.height)
            }
            Dock::Top | Dock::Bottom => {
                Size::new(remaining.width, shrink_dock_axis(remaining.height, sub))
            }
            Dock::Fill => Size::ZERO,
        }
    }

    fn shrink_dock_rect(
        remaining: Rect,
        d: Dock,
        thickness: f32,
        gap: f32,
        index: usize,
        count: usize,
    ) -> Rect {
        let extra = if d.is_side() && index + 1 < count {
            gap
        } else {
            0.0
        };
        let sub = thickness + extra;
        match d {
            Dock::Left => Rect::from_xywh(
                remaining.left() + sub,
                remaining.top(),
                shrink_dock_axis(remaining.size.width, sub),
                remaining.size.height.max(0.0),
            ),
            Dock::Right => Rect::from_xywh(
                remaining.left(),
                remaining.top(),
                shrink_dock_axis(remaining.size.width, sub),
                remaining.size.height.max(0.0),
            ),
            Dock::Top => Rect::from_xywh(
                remaining.left(),
                remaining.top() + sub,
                remaining.size.width.max(0.0),
                shrink_dock_axis(remaining.size.height, sub),
            ),
            Dock::Bottom => Rect::from_xywh(
                remaining.left(),
                remaining.top(),
                remaining.size.width.max(0.0),
                shrink_dock_axis(remaining.size.height, sub),
            ),
            Dock::Fill => Rect::from_xywh(remaining.left(), remaining.top(), 0.0, 0.0),
        }
    }

    /// A linear container can stop at the visible main-axis extent only when
    /// that extent is bounded. An unbounded axis (a scroll view measuring its
    /// content) must see every child so the scroll range stays correct.
    fn can_cull_main_axis(avail_main: f32) -> bool {
        avail_main.is_finite() && avail_main >= 0.0
    }

    /// Whether a child may be the last laid-out item before the cut: it must
    /// not claim flexible space, must not shrink into view below its base, and
    /// must not pull later siblings back with a negative margin.
    fn cullable_main(cs: &LayoutStyle, axis: Axis, base: f32, min: f32) -> bool {
        let (start, end) = match axis {
            Axis::Horizontal => (cs.margin.left, cs.margin.right),
            Axis::Vertical => (cs.margin.top, cs.margin.bottom),
        };
        let auto_main = match axis {
            Axis::Horizontal => cs.width,
            Axis::Vertical => cs.height,
        };
        start >= 0.0
            && end >= 0.0
            && cs.flex_weight() <= 0.0
            && !auto_main.is_fill()
            && min + 0.01 >= base
    }

    fn extra_main(avail_main: f32, used_main: f32) -> f32 {
        if avail_main.is_finite() {
            (avail_main - used_main).max(0.0)
        } else {
            0.0
        }
    }

    fn sanitize_gap_value(v: f32) -> f32 {
        if v.is_finite() { v.max(0.0) } else { 0.0 }
    }

    fn main_gap_spec(
        trailing: Option<Length>,
        leading: Option<Length>,
        default_gap: f32,
        avail_main: f32,
    ) -> (f32, f32) {
        let mut fixed = 0.0;
        let mut fill = 0.0;
        let mut any = false;
        for indent in [trailing, leading].into_iter().flatten() {
            any = true;
            match indent {
                Length::Px(v) => fixed += Self::sanitize_gap_value(v),
                Length::Percent(p) => {
                    if avail_main.is_finite() {
                        let p = Self::sanitize_gap_value(p);
                        fixed += (avail_main * p / 100.0).max(0.0);
                    }
                }
                Length::Fill(w) => fill += Self::sanitize_gap_value(w),
                Length::Fit => {}
            }
        }
        if !any {
            fixed = Self::sanitize_gap_value(default_gap);
        }
        (fixed, fill)
    }

    fn main_gap_specs(
        styles: &[LayoutStyle],
        axis: Axis,
        default_gap: f32,
        avail_main: f32,
    ) -> Vec<(f32, f32)> {
        let mut gaps = Vec::with_capacity(styles.len());
        for pair in styles.windows(2) {
            gaps.push(Self::main_gap_spec(
                pair[0].indent_main_end(axis),
                pair[1].indent_main_start(axis),
                default_gap,
                avail_main,
            ));
        }
        if let Some(last) = styles.last() {
            gaps.push(Self::main_gap_spec(
                None,
                last.indent_main_end(axis),
                0.0,
                avail_main,
            ));
        }
        gaps
    }

    fn distribute_main(
        items: &[FlexItem],
        sizes: &mut [f32],
        gaps: &[(f32, f32)],
        avail_main: f32,
    ) -> Vec<f32> {
        let fixed_total: f32 = gaps.iter().map(|gap| gap.0).sum();
        let fill_count = gaps.iter().filter(|gap| gap.1 > 0.0).count();
        if fill_count == 0 {
            distribute_flex(items, sizes, fixed_total, avail_main);
            return gaps.iter().map(|gap| gap.0).collect();
        }

        let mut combined = Vec::with_capacity(items.len() + fill_count);
        let mut combined_sizes = Vec::with_capacity(items.len() + fill_count);
        combined.extend_from_slice(items);
        combined_sizes.extend_from_slice(sizes);

        let mut slots = Vec::with_capacity(fill_count);
        for (gap_index, gap) in gaps.iter().enumerate() {
            if gap.1 > 0.0 {
                slots.push((gap_index, combined.len()));
                combined.push(FlexItem::new(0.0, gap.1, 0.0, 0.0, f32::INFINITY));
                combined_sizes.push(0.0);
            }
        }

        distribute_flex(&combined, &mut combined_sizes, fixed_total, avail_main);
        sizes.copy_from_slice(&combined_sizes[..items.len()]);

        let mut resolved: Vec<f32> = gaps.iter().map(|gap| gap.0).collect();
        for (gap_index, slot) in slots {
            resolved[gap_index] += combined_sizes[slot];
        }
        resolved
    }

    fn resolve_cross_indent(indent: Length, avail_cross: f32) -> f32 {
        match indent {
            Length::Px(v) => Self::sanitize_gap_value(v),
            Length::Percent(p) => {
                if avail_cross.is_finite() {
                    let p = Self::sanitize_gap_value(p);
                    (avail_cross * p / 100.0).max(0.0)
                } else {
                    0.0
                }
            }
            Length::Fill(_) | Length::Fit => 0.0,
        }
    }

    fn indent_cross_shift(cs: &LayoutStyle, axis: Axis, avail_cross: f32) -> f32 {
        let start = cs
            .indent_cross_start(axis)
            .map(|v| Self::resolve_cross_indent(v, avail_cross))
            .unwrap_or(0.0);
        let end = cs
            .indent_cross_end(axis)
            .map(|v| Self::resolve_cross_indent(v, avail_cross))
            .unwrap_or(0.0);
        start - end
    }

    fn place_cross(
        &self,
        child: ElementId,
        cstyle: &ContainerStyle,
        cross: f32,
        avail_cross: f32,
    ) -> (f32, f32) {
        if self.view_rc(child).is_none() {
            return (0.0, 0.0);
        }
        let cs = self.child_layout_style(child);
        let eff = cs.effective_align(cstyle.align);
        let (m_start, m_end) = match cstyle.axis {
            Axis::Horizontal => (cs.margin.top, cs.margin.bottom),
            Axis::Vertical => (cs.margin.left, cs.margin.right),
        };
        let m_total = m_start + m_end;
        let cross_inner = (cross - m_total).max(0.0);

        let floor = {
            let (cross_len, explicit_min, explicit_max) = match cstyle.axis {
                Axis::Horizontal => (cs.height, cs.min_height, cs.max_height),
                Axis::Vertical => (cs.width, cs.min_width, cs.max_width),
            };
            let px = match cross_len {
                Length::Px(v) if v.is_finite() => v.max(0.0),
                _ => 0.0,
            };
            let explicit_min = if explicit_min.is_finite() {
                explicit_min.max(0.0)
            } else {
                0.0
            };
            let mx = if explicit_max.is_nan() || explicit_max == f32::INFINITY {
                f32::INFINITY
            } else {
                explicit_max.max(0.0)
            };

            let content_floor = match cross_len {
                Length::Fit => cross_inner,
                _ => 0.0,
            };
            px.max(explicit_min).max(content_floor).min(mx)
        };

        let avail_inner = if avail_cross.is_finite() {
            (avail_cross - m_total).max(0.0)
        } else {
            f32::INFINITY
        };
        let placed_inner = cross_inner.min(avail_inner).max(floor);
        let slack = if avail_inner.is_finite() {
            (avail_inner - placed_inner).max(0.0)
        } else {
            0.0
        };
        match eff {
            Align::Start | Align::Baseline => (m_start, placed_inner),
            Align::Center => (m_start + slack * 0.5, placed_inner),
            Align::End => (m_start + slack, placed_inner),
            Align::Stretch => {
                let (auto_cross, max_cross) = match cstyle.axis {
                    Axis::Horizontal => (matches!(cs.height, Length::Fit), cs.max_height),
                    Axis::Vertical => (matches!(cs.width, Length::Fit), cs.max_width),
                };

                if auto_cross && avail_inner.is_finite() {
                    let stretched = avail_inner.min(max_cross).max(floor).max(0.0);
                    (m_start, stretched)
                } else {
                    (m_start, placed_inner)
                }
            }
        }
    }

    pub(crate) fn arrange_absolute(&self, child: ElementId, content: Rect, ctx: &mut LayoutCtx) {
        let cs = self.child_layout_style(child);
        let Some(inset) = cs.absolute_inset_of() else {
            let m = self.measure(child, Constraints::loose(content.size), ctx);
            let w = cs
                .clamp_width(resolve_cross(cs.width, m.width, content.size.width))
                .max(0.0);
            let h = cs
                .clamp_height(resolve_cross(cs.height, m.height, content.size.height))
                .max(0.0);
            self.arrange(
                child,
                Rect::from_xywh(
                    content.left() + cs.margin.left,
                    content.top() + cs.margin.top,
                    w,
                    h,
                ),
                ctx,
            );
            return;
        };
        let ml = cs.margin.left;
        let mt = cs.margin.top;
        let mr = cs.margin.right;
        let mb = cs.margin.bottom;
        let avail_w = (content.size.width - ml - mr).max(0.0);
        let avail_h = (content.size.height - mt - mb).max(0.0);
        let m = self.measure(child, Constraints::loose(Size::new(avail_w, avail_h)), ctx);

        let mut w = resolve_cross(cs.width, m.width, avail_w);
        let mut h = resolve_cross(cs.height, m.height, avail_h);
        if let (Some(l), Some(r)) = (inset.left, inset.right)
            && (matches!(cs.width, Length::Fit) || matches!(cs.width, Length::Fill(_)))
        {
            w = (content.size.width - l.max(0.0) - r.max(0.0) - ml - mr).max(0.0);
        }
        if let (Some(t), Some(b)) = (inset.top, inset.bottom)
            && (matches!(cs.height, Length::Fit) || matches!(cs.height, Length::Fill(_)))
        {
            h = (content.size.height - t.max(0.0) - b.max(0.0) - mt - mb).max(0.0);
        }
        w = cs.clamp_width(w).max(0.0);
        h = cs.clamp_height(h).max(0.0);
        let x = match (inset.left, inset.right) {
            (Some(l), _) => content.left() + l + ml,
            (None, Some(r)) => content.right() - r - mr - w,
            (None, None) => content.left() + ml,
        };
        let y = match (inset.top, inset.bottom) {
            (Some(t), _) => content.top() + t + mt,
            (None, Some(b)) => content.bottom() - b - mb - h,
            (None, None) => content.top() + mt,
        };
        self.arrange(child, Rect::from_xywh(x, y, w, h), ctx);
    }

    fn paint_rec(
        &self,
        id: ElementId,
        parent_offset: Vec2,
        parent_scale: f32,
        parent_transform: Transform,
        list: &mut RenderList,
        text: &mut TextSystem,
        cull: CullCtx,
        pass: PaintPass<'_>,
    ) {
        let depth = list.clip_depth();
        let opacity_depth = list.opacity_depth();
        let transform_depth = list.transform_depth();
        match std::panic::catch_unwind(AssertUnwindSafe(|| {
            self.paint_rec_inner(
                id,
                parent_offset,
                parent_scale,
                parent_transform,
                &mut *list,
                &mut *text,
                cull,
                pass,
            )
        })) {
            Ok(()) => {}
            Err(_) => {
                list.truncate_clips(depth);
                list.truncate_opacity(opacity_depth);
                list.truncate_transforms(transform_depth);
                let type_name = self.type_name_of(id).unwrap_or_else(|| "?".into());
                self.record_error(id, type_name, "paint panicked".to_string());
            }
        }
    }

    fn paint_rec_inner(
        &self,
        id: ElementId,
        parent_offset: Vec2,
        parent_scale: f32,
        parent_transform: Transform,
        list: &mut RenderList,
        text: &mut TextSystem,
        cull: CullCtx,
        pass: PaintPass<'_>,
    ) {
        let Some(v) = self.view_rc(id) else { return };
        let (base_rect, laid_out) = {
            let arena = self.inner.arena.borrow();
            match arena.get(id) {
                Some(e) => (e.rect.get(), e.laid_out.get()),
                None => return,
            }
        };
        if !laid_out {
            // Layout culled this subtree past the visible main-axis extent.
            // Its descendants may still hold old rects, so stop at the root.
            return;
        }

        let own = v.paint_offset_ctx_erased(self, id);
        let acc = Vec2::new(parent_offset.x + own.x, parent_offset.y + own.y);
        let rect = if acc.x == 0.0 && acc.y == 0.0 {
            base_rect
        } else {
            base_rect.translate(acc)
        };

        let scale = {
            let own = v.paint_scale_ctx_erased(self, id);
            let own = if own.is_finite() && own > 0.0 {
                own
            } else {
                1.0
            };
            (parent_scale * own).max(0.0)
        };
        let rect = if (scale - 1.0).abs() > f32::EPSILON {
            let cx = rect.origin.x + rect.size.width * 0.5;
            let cy = rect.origin.y + rect.size.height * 0.5;
            let w = (rect.size.width * scale).max(0.0);
            let h = (rect.size.height * scale).max(0.0);
            Rect::from_xywh(cx - w * 0.5, cy - h * 0.5, w, h)
        } else {
            rect
        };

        let own_rotation = {
            let d = v.paint_rotation_ctx_erased(self, id);
            if d.is_finite() { d } else { 0.0 }
        };
        let own_transform = if own_rotation.abs() > 0.001 {
            Transform::rotate_around_degrees(own_rotation, rect.center())
        } else {
            Transform::IDENTITY
        };
        let total_transform = parent_transform.then(own_transform);
        let pushes_transform = !own_transform.is_identity();
        if pushes_transform {
            list.push_transform(own_transform);
        }

        let paint_bounds = total_transform.apply_rect_aabb(rect);

        let opacity = v
            .paint_opacity_ctx_erased(self, id)
            .map(|o| {
                if o.is_finite() {
                    o.clamp(0.0, 1.0)
                } else {
                    1.0
                }
            })
            .unwrap_or(1.0);
        let pushes_opacity = opacity < 1.0 - f32::EPSILON;
        if pushes_opacity {
            list.push_opacity(opacity);
        }

        let clip = list.active_clip();
        let clip_self = v.clip_self_erased();
        if cull.fully_clipped(paint_bounds, clip, clip_self) {
            if pushes_opacity {
                list.pop_opacity();
            }
            if pushes_transform {
                list.pop_transform();
            }
            return;
        }
        if !cull.intersects(paint_bounds, clip) {
            self.paint_children(id, acc, scale, total_transform, list, text, cull, pass);
            if pushes_opacity {
                list.pop_opacity();
            }
            if pushes_transform {
                list.pop_transform();
            }
            return;
        }

        let should_clip =
            clip_self || v.layout_style_ctx_erased(self, id).overflow == Overflow::Hidden;
        if should_clip {
            let clip_rect = if pushes_transform { paint_bounds } else { rect };
            let r = v.clip_radius_erased();
            if r > 0.0 {
                list.push_rounded_clip(clip_rect, r);
            } else {
                list.push_clip(clip_rect);
            }
        }

        let surface_target = v.surface_target_erased();
        let foreground_filter = v.foreground_filter_erased().filter(|f| !f.is_empty());
        let cacheable =
            v.cache_layer_erased() && surface_target.is_none() && foreground_filter.is_none();

        let cache = if cacheable {
            let revision = self
                .inner
                .arena
                .borrow()
                .get(id)
                .map(|e| e.revision)
                .unwrap_or(0);
            let key = LayerKey {
                element_id: id.key(),
                revision,
            };
            let interact = self.inner.interact.get();
            let stamp = LayerStamp {
                rect,
                scale,
                transform: total_transform,
                clip: list.active_clip(),
                rounded_clip: list.active_rounded_clip(),
                opacity: list.active_opacity(),
                text_atlas: text.atlas().id(),
                text_epoch: text.atlas().epoch(),
                window: self.inner.window.get(),
                hovered: self.interaction_target_within(id, interact.hovered),
                pressed: self.interaction_target_within(id, interact.pressed),
                focused: self.interaction_target_within(id, interact.focus),
                captured: self.interaction_target_within(id, interact.captured),
                cull,
            };
            if let Some(hit) = self.inner.layers.borrow().get_stamped(key, &stamp) {
                pass.session.borrow_mut().layer_hits += 1;
                list.append(&hit);
                if should_clip {
                    list.pop_clip();
                }
                if pushes_opacity {
                    list.pop_opacity();
                }
                if pushes_transform {
                    list.pop_transform();
                }
                return;
            }
            pass.session.borrow_mut().layer_misses += 1;
            self.inner.layers.borrow_mut().invalidate_element(id.key());
            let surfaces = self.inner.surfaces.borrow().len();
            Some((key, stamp, list.mark(), surfaces))
        } else {
            None
        };

        if let Some(target) = surface_target {
            let clipped = match list.active_clip() {
                Some(c) => c.intersect(rect),
                None => rect,
            };
            if !clipped.is_empty() {
                self.inner.surfaces.borrow_mut().push(SurfaceDraw {
                    rect: clipped,
                    full: rect,
                    target,
                });
            }
        }

        let filter_handle = foreground_filter.and_then(|f| {
            let r = if pushes_transform { paint_bounds } else { rect };
            list.push_filter_begin(r, 0.0, f.blur_px(), f.span_mask())
        });

        let depth = list.clip_depth();

        let (state, _) = self.view_state(id);
        let hovered_subtree = pass.hovered_subtree(id);
        {
            let res = std::panic::catch_unwind(AssertUnwindSafe(|| {
                let mut ctx = PaintCtx {
                    list: &mut *list,
                    text: &mut *text,
                    environment: pass.env,
                    rect,
                    element: id,
                    state,
                    window: self.inner.window.get(),
                    hovered_subtree,
                    runtime: self,
                    shapes: &self.inner.shapes,
                    draw_offset: Vec2::ZERO,
                    offset_stack: Vec::new(),
                };
                v.paint_self_erased(&mut ctx);
            }));
            if res.is_err() {
                self.record_error(
                    id,
                    v.type_name().to_string(),
                    "paint_self panicked".to_string(),
                );
            }
        }
        self.paint_children(id, acc, scale, total_transform, list, text, cull, pass);

        {
            let res = std::panic::catch_unwind(AssertUnwindSafe(|| {
                let mut ctx = PaintCtx {
                    list: &mut *list,
                    text: &mut *text,
                    environment: pass.env,
                    rect,
                    element: id,
                    state,
                    window: self.inner.window.get(),
                    hovered_subtree,
                    runtime: self,
                    shapes: &self.inner.shapes,
                    draw_offset: Vec2::ZERO,
                    offset_stack: Vec::new(),
                };
                v.paint_foreground_erased(&mut ctx);
            }));
            if res.is_err() {
                self.record_error(
                    id,
                    v.type_name().to_string(),
                    "paint_foreground panicked".to_string(),
                );
            }
        }
        if let Some(h) = filter_handle {
            list.push_filter_end(h);
        }

        if let Some((key, stamp, mark, surfaces)) = cache
            && text.atlas().epoch() == stamp.text_epoch
            && self.inner.surfaces.borrow().len() == surfaces
            && let Some(captured) = list.suffix(mark)
        {
            pass.session
                .borrow_mut()
                .captures
                .push((key, stamp, captured));
        }

        list.truncate_clips(depth);
        if should_clip {
            list.pop_clip();
        }
        if pushes_opacity {
            list.pop_opacity();
        }
        if pushes_transform {
            list.pop_transform();
        }
    }

    fn paint_children(
        &self,
        id: ElementId,
        acc: Vec2,
        scale: f32,
        transform: Transform,
        list: &mut RenderList,
        text: &mut TextSystem,
        cull: CullCtx,
        pass: PaintPass<'_>,
    ) {
        const INLINE: usize = 16;
        let mut stack = [ElementId {
            index: 0,
            generation: 0,
        }; INLINE];
        let n = {
            let arena = self.inner.arena.borrow();
            let Some(el) = arena.get(id) else { return };
            let n = el.children.len();
            if n <= INLINE {
                stack[..n].copy_from_slice(&el.children);
            }
            n
        };
        if n <= INLINE {
            for c in &stack[..n] {
                self.paint_rec(*c, acc, scale, transform, list, text, cull, pass);
            }
        } else {
            for c in self.children(id) {
                self.paint_rec(c, acc, scale, transform, list, text, cull, pass);
            }
        }
    }

    fn view_rc(&self, id: ElementId) -> Option<Rc<dyn ErasedView>> {
        self.inner.arena.borrow().get(id)?.view.clone()
    }

    fn invalidate_measure_chain(&self, id: ElementId) {
        self.inner.layout_dirty.set(true);
        self.inner
            .layout_epoch
            .set(self.inner.layout_epoch.get().wrapping_add(1));
        let mut measures = self.inner.measures.borrow_mut();
        let arena = self.inner.arena.borrow();
        let mut cur = Some(id);
        let mut n = 0u32;
        while let Some(c) = cur {
            if measures.remove(&c).is_some() {
                n += 1;
            }
            cur = arena.get(c).and_then(|e| e.parent);
            if n > 4096 {
                break;
            }
        }
        drop(arena);
        drop(measures);
        if n > 0 {
            let mut s = self.inner.stats.get();
            s.measure_invalidations += u64::from(n);
            self.inner.stats.set(s);
        }
    }

    fn alloc(
        &self,
        value: Rc<dyn ErasedView>,
        parent: Option<ElementId>,
        index: usize,
        key: u64,
    ) -> ElementId {
        let (slot, generation) = { self.inner.arena.borrow_mut().alloc_slot() };
        let id = ElementId {
            index: slot,
            generation,
        };
        let weak: Weak<Inner> = Rc::downgrade(&self.inner);
        let watcher = Watcher::new(move || {
            if let Some(inner) = weak.upgrade() {
                inner.schedule(id);
            }
        });
        {
            let mut arena = self.inner.arena.borrow_mut();
            arena.slots[slot as usize] = Some(Element {
                parent,
                key,
                children: Vec::new(),
                view: Some(value),
                watcher: Some(watcher),
                reads: ReadSet::empty(),
                dirty: Dirty::empty(),
                revision: 0,
                rect: Cell::new(Rect::ZERO),
                laid_out: Cell::new(true),
            });
            if let Some(p) = parent
                && let Some(pe) = arena.get_mut(p)
            {
                let at = index.min(pe.children.len());
                pe.children.insert(at, id);
            }
        }
        let mut s = self.inner.stats.get();
        s.mounts += 1;
        self.inner.stats.set(s);
        id
    }

    fn build_with(&self, el: ElementId, value: Rc<dyn ErasedView>) {
        self.inner.bump_revision(el);
        self.invalidate_measure_chain(el);
        let v = value;

        let type_name = v.type_name().to_string();
        let fail = |rt: &Self| {
            rt.rebind_reads(el, sequoia_reactive::ReadSet::empty());
            rt.truncate_children(el, 0);
            rt.record_error(el, type_name.clone(), "body panicked".to_string());
        };

        let overridden_res =
            std::panic::catch_unwind(AssertUnwindSafe(|| capture_reads(|| v.children_override())));
        let Ok((overridden, override_reads)) = overridden_res else {
            fail(self);
            return;
        };
        if let Some(children) = overridden {
            let reads = match std::panic::catch_unwind(AssertUnwindSafe(|| {
                capture_reads(|| v.call_body())
            })) {
                Ok((_, body_reads)) => override_reads.union(body_reads),
                Err(_) => override_reads,
            };
            self.rebind_reads(el, reads);
            let list = children
                .into_iter()
                .enumerate()
                .map(|(i, av)| (i as u64, av.into_inner()))
                .collect();
            self.reconcile_keyed(el, list);
            return;
        }

        {
            let keyed_res =
                std::panic::catch_unwind(AssertUnwindSafe(|| capture_reads(|| v.keyed_children())));
            let Ok((keyed, reads)) = keyed_res else {
                fail(self);
                return;
            };
            if let Some(children) = keyed {
                let reads = match std::panic::catch_unwind(AssertUnwindSafe(|| {
                    capture_reads(|| v.call_body())
                })) {
                    Ok((_, body_reads)) => reads.union(body_reads),
                    Err(_) => reads,
                };
                self.rebind_reads(el, reads);
                let list = children
                    .into_iter()
                    .map(|(k, av)| (k, av.into_inner()))
                    .collect();
                self.reconcile_keyed(el, list);
                return;
            }
        }

        let is_leaf = match std::panic::catch_unwind(AssertUnwindSafe(|| v.is_leaf())) {
            Ok(b) => b,
            Err(_) => {
                self.record_error(el, type_name.clone(), "is_leaf panicked".to_string());
                false
            }
        };
        if is_leaf {
            let leaf_res =
                std::panic::catch_unwind(AssertUnwindSafe(|| capture_reads(|| v.call_body())));
            let Ok((_, reads)) = leaf_res else {
                fail(self);
                return;
            };
            self.rebind_reads(el, reads);
            self.truncate_children(el, 0);
            return;
        }

        let body_res =
            std::panic::catch_unwind(AssertUnwindSafe(|| capture_reads(|| v.call_body())));
        let Ok((body, reads)) = body_res else {
            fail(self);
            return;
        };
        self.rebind_reads(el, reads);
        self.reconcile_keyed(el, vec![(0, body.into_inner())]);
    }

    fn reconcile_keyed(&self, parent: ElementId, new: Vec<(u64, Rc<dyn ErasedView>)>) {
        let old: Vec<(u64, ElementId)> = {
            let arena = self.inner.arena.borrow();
            arena
                .get(parent)
                .map(|p| {
                    p.children
                        .iter()
                        .filter_map(|&c| arena.get(c).map(|e| (e.key, c)))
                        .collect()
                })
                .unwrap_or_default()
        };

        let new_keys: HashSet<u64> = new.iter().map(|(k, _)| *k).collect();

        for (k, id) in &old {
            if !new_keys.contains(k) {
                self.unmount_subtree(*id);
            }
        }

        let mut buckets: HashMap<u64, Vec<ElementId>> = HashMap::new();
        for (k, id) in old {
            if new_keys.contains(&k) {
                buckets.entry(k).or_default().push(id);
            }
        }
        for ids in buckets.values_mut() {
            ids.reverse();
        }

        let mut order: Vec<ElementId> = Vec::with_capacity(new.len());
        for (key, view) in new {
            let view = unwrap_any(view);
            let reused = buckets.get_mut(&key).and_then(|ids| ids.pop());
            match reused {
                Some(el) => {
                    let same_type = {
                        let arena = self.inner.arena.borrow();
                        arena
                            .get(el)
                            .and_then(|e| e.view.as_ref())
                            .map(|v| v.view_type())
                            == Some(view.view_type())
                    };
                    if same_type {
                        let old_view = self
                            .inner
                            .arena
                            .borrow()
                            .get(el)
                            .and_then(|e| e.view.clone());
                        if let Some(old) = old_view {
                            view.reuse_state_erased(&*old);
                        }
                        if let Some(e) = self.inner.arena.borrow_mut().get_mut(el) {
                            e.key = key;
                            e.view = Some(view);
                        }
                        self.invalidate_measure_chain(el);
                        if let Some(v) = self.view_rc(el) {
                            self.build_with(el, v);
                        }
                        order.push(el);
                    } else {
                        self.unmount_subtree(el);
                        order.push(self.mount_fresh_detached(view, key));
                    }
                }
                None => order.push(self.mount_fresh_detached(view, key)),
            }
        }

        for (_, leftover) in buckets {
            for id in leftover {
                self.unmount_subtree(id);
            }
        }

        self.invalidate_measure_chain(parent);
        self.set_children(parent, order);
    }

    fn mount_fresh_detached(&self, value: Rc<dyn ErasedView>, key: u64) -> ElementId {
        let id = self.alloc(value, None, 0, key);
        if let Some(v) = self.view_rc(id) {
            self.build_with(id, v);
        }
        if let Some(v) = self.view_rc(id) {
            let type_name = v.type_name().to_string();
            if std::panic::catch_unwind(AssertUnwindSafe(|| {
                v.on_mount();
            }))
            .is_err()
            {
                self.record_error(id, type_name, "on_mount panicked".to_string());
            }
        }
        id
    }

    fn set_children(&self, parent: ElementId, order: Vec<ElementId>) {
        {
            let mut arena = self.inner.arena.borrow_mut();
            for &c in &order {
                if let Some(e) = arena.get_mut(c) {
                    e.parent = Some(parent);
                }
            }
            if let Some(p) = arena.get_mut(parent) {
                p.children = order;
            }
        }
        self.invalidate_measure_chain(parent);
    }

    fn truncate_children(&self, el: ElementId, keep: usize) {
        let doomed: Vec<ElementId> = {
            let arena = self.inner.arena.borrow();
            arena
                .get(el)
                .map(|e| e.children.iter().skip(keep).copied().collect())
                .unwrap_or_default()
        };
        for d in doomed {
            self.unmount_subtree(d);
        }
        if let Some(e) = self.inner.arena.borrow_mut().get_mut(el) {
            e.children.truncate(keep);
        }
    }

    fn rebind_reads(&self, el: ElementId, reads: ReadSet) {
        if let Some(e) = self.inner.arena.borrow_mut().get_mut(el) {
            // A rebuild usually reads the same signals again. Re-binding would
            // scan this element's whole observer list on every signal, so one
            // coarse update of 3000 rows would take O(n^2).
            if e.reads.same_deps(&reads) {
                return;
            }
            if let Some(w) = e.watcher.clone() {
                e.reads.unbind(&w);
            }
            e.reads = reads;
            if let Some(w) = e.watcher.clone() {
                e.reads.bind(&w);
            }
        }
    }

    fn unmount_subtree(&self, id: ElementId) {
        self.invalidate_measure_chain(id);
        let children: Vec<ElementId> = {
            let arena = self.inner.arena.borrow();
            arena
                .get(id)
                .map(|e| e.children.clone())
                .unwrap_or_default()
        };
        for c in children {
            self.unmount_subtree(c);
        }
        let (parent, slot, view) = {
            let mut arena = self.inner.arena.borrow_mut();
            let Some(e) = arena.get_mut(id) else { return };
            if let Some(w) = e.watcher.take() {
                e.reads.unbind(&w);
            }
            (e.parent, id.index, e.view.take())
        };
        if let Some(v) = view {
            let type_name = v.type_name().to_string();
            if std::panic::catch_unwind(AssertUnwindSafe(|| {
                v.on_unmount();
            }))
            .is_err()
            {
                self.record_error(id, type_name, "on_unmount panicked".to_string());
            }
        }
        if let Some(p) = parent {
            let mut arena = self.inner.arena.borrow_mut();
            if let Some(pe) = arena.get_mut(p)
                && let Some(pos) = pe.children.iter().position(|&c| c == id)
            {
                pe.children.remove(pos);
            }
        }
        self.inner.measures.borrow_mut().remove(&id);
        self.inner
            .live_anims
            .borrow_mut()
            .retain(|(eid, _), _| *eid != id);

        self.inner.states.borrow_mut().remove(&id);
        if let Some(cancels) = self.inner.scoped_cancels.borrow_mut().remove(&id) {
            for cancel in cancels {
                let _ = std::panic::catch_unwind(AssertUnwindSafe(cancel));
            }
        }
        self.inner.layers.borrow_mut().invalidate_element(id.key());
        self.inner.arena.borrow_mut().free_slot(slot);

        let anchored = self.inner.overlays.borrow().anchored_to(id);
        for oid in anchored {
            self.overlay_hide(oid);
        }

        if self
            .inner
            .pending_drag
            .borrow()
            .as_ref()
            .is_some_and(|p| p.source == id)
        {
            self.inner.pending_drag.borrow_mut().take();
        }
        {
            let mut guard = self.inner.active_drag.borrow_mut();
            if let Some(act) = guard.as_mut() {
                if act.source == Some(id) {
                    act.source = None;
                }
                if act.target == Some(id) {
                    act.target = None;
                }
            }
        }
        let mut s = self.inner.stats.get();
        s.unmounts += 1;
        self.inner.stats.set(s);
    }
}

fn shrink_dock_axis(remaining: f32, used: f32) -> f32 {
    if remaining.is_finite() {
        (remaining - used).max(0.0)
    } else {
        remaining
    }
}

fn filled_root_size(style: LayoutStyle, bounds: Size, measured: Size) -> Size {
    Size::new(
        if style.width.is_fit() {
            style.clamp_width(bounds.width)
        } else {
            measured.width
        },
        if style.height.is_fit() {
            style.clamp_height(bounds.height)
        } else {
            measured.height
        },
    )
}

fn unwrap_any(mut v: Rc<dyn ErasedView>) -> Rc<dyn ErasedView> {
    for _ in 0..64 {
        let any: Rc<dyn Any> = v.clone().as_any_rc();
        match any.downcast::<AnyView>() {
            Ok(av) => {
                let inner = av.clone_inner();
                if Rc::ptr_eq(&inner, &v) {
                    return v;
                }
                v = inner;
            }
            Err(_) => return v,
        }
    }
    v
}

#[cfg(test)]
mod tests {
    use super::*;

    fn id(index: u32) -> ElementId {
        ElementId {
            index,
            generation: 0,
        }
    }

    #[test]
    fn filled_root_size_stretches_only_fit_axes() {
        let bounds = Size::new(800.0, 600.0);
        let measured = Size::new(120.0, 40.0);
        assert_eq!(
            filled_root_size(LayoutStyle::default(), bounds, measured),
            bounds
        );

        let style = LayoutStyle {
            width: Length::px(120.0),
            height: Length::percent(50.0),
            ..LayoutStyle::default()
        };
        assert_eq!(filled_root_size(style, bounds, measured), measured);

        let capped = LayoutStyle {
            max_width: 400.0,
            max_height: 300.0,
            ..LayoutStyle::default()
        };
        assert_eq!(
            filled_root_size(capped, bounds, measured),
            Size::new(400.0, 300.0)
        );
    }

    #[test]
    fn bounded_column_lays_out_only_visible_rows() {
        struct FixedRow;
        impl View for FixedRow {
            fn body(&self) -> impl View + 'static {
                crate::Unit
            }
            fn layout_style(&self) -> LayoutStyle {
                LayoutStyle {
                    width: Length::Fill(1.0),
                    height: Length::px(20.0),
                    ..LayoutStyle::default()
                }
            }
        }

        let mut col = crate::views::Column::new();
        for _ in 0..3000 {
            col = col.child(FixedRow);
        }
        let rt = Runtime::new();
        rt.mount(col);
        let mut text = TextSystem::new();
        let bounds = Rect::from_xywh(0.0, 0.0, 800.0, 600.0);
        rt.reset_measure_cache_stats();
        rt.layout(bounds, &mut text);

        let (calls, _) = rt.measure_cache_stats();
        assert!(calls < 400, "virtualized layout measured {calls} nodes");
        let root = rt.root().unwrap();
        let last = *rt.children(root).last().unwrap();
        assert!(
            rt.rect_of(last).unwrap().is_empty(),
            "a row past the visible extent was arranged"
        );
    }

    #[test]
    fn paint_dirty_does_not_rebuild_but_layout_dirty_does() {
        let rt = Runtime::new();
        rt.mount(crate::Unit);
        let root = rt.root().unwrap();

        rt.mark_damage(root, Dirty::PAINT);
        assert!(rt.damage_flags().contains(Dirty::PAINT));
        assert!(!rt.damage_flags().needs_layout());
        rt.tick();
        assert_eq!(
            rt.stats().rebuilds,
            0,
            "paint-only damage skips settle rebuild"
        );

        rt.request_rebuild(root);
        rt.tick();
        assert_eq!(rt.stats().rebuilds, 1, "layout damage rebuilds the element");
    }

    #[test]
    fn layout_is_skipped_when_clean_and_reruns_when_dirty() {
        #[derive(Clone)]
        struct Counted(Rc<Cell<u32>>);

        impl View for Counted {
            fn body(&self) -> impl View + 'static {
                crate::Unit
            }

            fn layout_style(&self) -> LayoutStyle {
                self.0.set(self.0.get() + 1);
                LayoutStyle::default()
            }
        }

        let calls = Rc::new(Cell::new(0));
        let rt = Runtime::new();
        rt.mount(Counted(calls.clone()));
        let root = rt.root().unwrap();
        let mut text = TextSystem::new();
        let bounds = Rect::from_xywh(0.0, 0.0, 200.0, 120.0);

        rt.layout(bounds, &mut text);
        let first = calls.get();
        assert!(first > 0);

        rt.layout(bounds, &mut text);
        assert_eq!(calls.get(), first, "clean layout is skipped");

        rt.mark_damage(root, Dirty::PAINT);
        rt.layout(bounds, &mut text);
        assert_eq!(calls.get(), first, "paint damage does not relayout");

        rt.request_rebuild(root);
        rt.tick();
        rt.layout(bounds, &mut text);
        assert!(calls.get() > first, "layout dirty rebuilds and relayouts");

        let second = calls.get();
        rt.layout(Rect::from_xywh(0.0, 0.0, 320.0, 180.0), &mut text);
        assert!(calls.get() > second, "viewport change relayouts");
    }

    #[test]
    fn animated_layout_props_relayout_on_clock_advance() {
        use crate::layout_live::AnimatedSize;
        use crate::live::SignalLiveExt;

        #[derive(Clone)]
        struct AnimatedRoot {
            width: sequoia_reactive::Signal<f32>,
        }

        impl View for AnimatedRoot {
            fn body(&self) -> impl View + 'static {
                AnimatedSize::width(
                    crate::Unit,
                    self.width
                        .clone()
                        .animate(AnimSpec::linear(std::time::Duration::from_secs(10))),
                )
            }
        }

        let width = sequoia_reactive::Signal::new(80.0f32);
        let rt = Runtime::new();
        rt.set_manual_clock(true);
        rt.mount(AnimatedRoot {
            width: width.clone(),
        });
        let root = rt.root().unwrap();
        let child = rt.children(root)[0];
        let mut text = TextSystem::new();
        let bounds = Rect::from_xywh(0.0, 0.0, 400.0, 200.0);

        rt.layout(bounds, &mut text);
        assert!((rt.rect_of(child).unwrap().size.width - 80.0).abs() < 0.01);

        width.set(200.0);
        rt.tick();
        rt.layout(bounds, &mut text);
        let start = rt.rect_of(child).unwrap().size.width;

        rt.advance_for_test(std::time::Duration::from_secs(5));
        rt.layout(bounds, &mut text);
        let mid = rt.rect_of(child).unwrap().size.width;
        assert!(mid > start, "animated width should grow: {start} -> {mid}");
        assert!(mid < 200.0, "animation should still be in flight: {mid}");
    }

    #[test]
    fn cached_layer_invalidates_when_child_rebuilds() {
        use crate::views::{Cached, Panel};
        use sequoia_core::Color;

        #[derive(Clone)]
        struct ColorBox(Signal<Color>);

        impl View for ColorBox {
            fn body(&self) -> impl View + 'static {
                Panel::new().background(self.0.get()).size(40.0, 30.0)
            }
        }

        let color = Signal::new(Color::RED);
        let rt = Runtime::new();
        rt.mount(Cached::new(ColorBox(color.clone())));
        let mut text = TextSystem::new();
        let bounds = Rect::from_xywh(0.0, 0.0, 200.0, 200.0);
        rt.layout(bounds, &mut text);

        let mut first = RenderList::new();
        rt.paint(&mut first, &mut text);
        assert_eq!(first.quads().next().unwrap().color, Color::RED);

        let mut second = RenderList::new();
        rt.paint(&mut second, &mut text);
        assert_eq!(rt.layer_cache_stats(), (1, 1));

        color.set(Color::BLUE);
        rt.tick();
        rt.layout(bounds, &mut text);
        let mut third = RenderList::new();
        rt.paint(&mut third, &mut text);
        assert_eq!(third.quads().next().unwrap().color, Color::BLUE);
        assert_eq!(rt.layer_cache_stats().1, 2, "signal change misses");
    }

    #[test]
    fn cached_layer_misses_for_another_text_system() {
        use crate::views::{Cached, Panel};

        let rt = Runtime::new();
        rt.mount(Cached::new(
            Panel::new()
                .background(sequoia_core::Color::RED)
                .size(40.0, 30.0),
        ));
        let bounds = Rect::from_xywh(0.0, 0.0, 200.0, 200.0);
        let mut first_text = TextSystem::new();
        rt.layout(bounds, &mut first_text);
        let mut first = RenderList::new();
        rt.paint(&mut first, &mut first_text);
        let mut second = RenderList::new();
        rt.paint(&mut second, &mut first_text);
        assert_eq!(rt.layer_cache_stats(), (1, 1));

        let mut second_text = TextSystem::new();
        let mut third = RenderList::new();
        rt.paint(&mut third, &mut second_text);
        assert_eq!(
            rt.layer_cache_stats(),
            (1, 2),
            "different atlas ids cannot replay cached glyph UVs"
        );
    }

    #[test]
    fn cached_layer_replays_filtered_subtrees() {
        use crate::filter_view::Filtered;
        use crate::views::{Cached, Panel};
        use sequoia_core::Color;
        use sequoia_style::Filter;

        let rt = Runtime::new();
        rt.mount(Cached::new(Filtered::new(
            Panel::new().background(Color::RED).size(40.0, 30.0),
            Filter::blur(8.0),
        )));
        let mut text = TextSystem::new();
        let bounds = Rect::from_xywh(0.0, 0.0, 200.0, 200.0);
        rt.layout(bounds, &mut text);

        let mut first = RenderList::new();
        rt.paint(&mut first, &mut text);
        assert_eq!(rt.layer_cache_stats(), (0, 1), "first pass fills the cache");
        assert_eq!(first.filter_spans().len(), 1);

        let mut second = RenderList::new();
        rt.paint(&mut second, &mut text);
        assert_eq!(
            rt.layer_cache_stats(),
            (1, 1),
            "filtered subtree replays from the layer cache"
        );
        assert_eq!(
            second.filter_spans(),
            first.filter_spans(),
            "filter span survives append with the same absolute range"
        );
    }

    #[test]
    fn cached_layer_replays_until_revision_changes() {
        use crate::views::{Cached, Panel};

        let rt = Runtime::new();
        rt.mount(Cached::new(
            Panel::new()
                .background(sequoia_core::Color::RED)
                .size(40.0, 30.0),
        ));
        let mut text = TextSystem::new();
        rt.layout(Rect::from_xywh(0.0, 0.0, 200.0, 200.0), &mut text);

        let mut first = RenderList::new();
        rt.paint(&mut first, &mut text);
        let (hits, misses) = rt.layer_cache_stats();
        assert_eq!((hits, misses), (0, 1), "first pass fills the cache");

        let mut second = RenderList::new();
        rt.paint(&mut second, &mut text);
        assert_eq!(second.len(), first.len(), "cached output is replayed");
        assert_eq!(rt.layer_cache_stats(), (1, 1), "second pass hits");

        let child = rt.children(rt.root().unwrap())[0];
        rt.mark_damage(child, Dirty::PAINT);
        let mut third = RenderList::new();
        rt.paint(&mut third, &mut text);
        assert_eq!(
            rt.layer_cache_stats(),
            (1, 2),
            "child revision bump invalidates the ancestor layer"
        );
        assert_eq!(third.len(), first.len());
    }

    #[test]
    fn root_fill_stretches_root_to_viewport() {
        let rt = Runtime::new();
        rt.set_root_fill(true);
        rt.mount(crate::Unit);
        let mut text = TextSystem::new();
        let bounds = Rect::from_xywh(0.0, 0.0, 800.0, 600.0);
        rt.layout(bounds, &mut text);
        assert_eq!(rt.rect_of(rt.root().unwrap()).unwrap().size, bounds.size);
    }

    #[test]
    fn text_without_wrap_stays_single_line_at_fractional_scale() {
        use crate::views::Text;

        let mut text = TextSystem::new();
        if text.shape("Hg", 16.0).glyph_count() == 0 {
            eprintln!("skip: no fonts in environment");
            return;
        }
        text.set_scale_factor(1.5);
        let content = "Dark Theme";

        for i in 16..=48 {
            let size = i as f32 * 0.5;
            let expected = text.shape(content, size).height();
            let rt = Runtime::new();
            rt.mount(Text::new(content).size(size));
            rt.layout(Rect::from_xywh(0.0, 0.0, 400.0, 400.0), &mut text);
            let height = rt.rect_of(rt.root().unwrap()).unwrap().size.height;
            assert!(
                (height - expected).abs() < 0.01,
                "non-wrapped text at size {size} measured {height}, expected {expected}"
            );
        }

        let multiline = text.shape("one\ntwo", 16.0);
        let rt = Runtime::new();
        rt.mount(Text::new("one\ntwo").size(16.0));
        rt.layout(Rect::from_xywh(0.0, 0.0, 400.0, 400.0), &mut text);
        let height = rt.rect_of(rt.root().unwrap()).unwrap().size.height;
        assert!((height - multiline.height()).abs() < 0.01);
        assert!(height > text.shape("one", 16.0).height() * 1.5);
    }

    #[test]
    fn text_auto_wrap_uses_own_width_line_height_and_max_lines() {
        use crate::views::Text;

        let mut text = TextSystem::new();
        if text.shape("Hg", 16.0).glyph_count() == 0 {
            eprintln!("skip: no fonts in environment");
            return;
        }
        let content = "one two three four five six seven eight nine ten";

        let mut measure = |view: Text| {
            let rt = Runtime::new();
            rt.mount(view);
            rt.layout(Rect::from_xywh(0.0, 0.0, 400.0, 400.0), &mut text);
            let rect = rt.rect_of(rt.root().unwrap()).unwrap();
            rect.size
        };

        let normal = measure(Text::new(content).size(16.0).width(80.0).wrap());
        let tall = measure(
            Text::new(content)
                .size(16.0)
                .width(80.0)
                .wrap()
                .line_height(2.0),
        );
        let limited = measure(
            Text::new(content)
                .size(16.0)
                .width(80.0)
                .wrap()
                .line_height(2.0)
                .max_lines(2),
        );

        assert!(normal.width <= 80.5, "width: {}", normal.width);
        assert!(normal.height > 16.0, "wrapped: {}", normal.height);
        assert!(tall.height > normal.height + 8.0);
        assert!(limited.height < tall.height);
        assert!(limited.height <= 64.5, "limited: {}", limited.height);
    }

    #[test]
    fn rich_text_auto_wrap_uses_own_width_line_height_and_max_lines() {
        use crate::rich_text::RichText;
        use sequoia_text::TextSpan;

        let mut text = TextSystem::new();
        if text.shape("Hg", 16.0).glyph_count() == 0 {
            eprintln!("skip: no fonts in environment");
            return;
        }
        let content = "one two three four five six seven eight nine ten";
        let spans = || vec![TextSpan::new(content)];

        let mut measure = |view: RichText| {
            let rt = Runtime::new();
            rt.mount(view);
            rt.layout(Rect::from_xywh(0.0, 0.0, 400.0, 400.0), &mut text);
            let rect = rt.rect_of(rt.root().unwrap()).unwrap();
            rect.size
        };

        let normal = measure(RichText::new(spans()).size(16.0).width(80.0).wrap());
        let tall = measure(
            RichText::new(spans())
                .size(16.0)
                .width(80.0)
                .wrap()
                .line_height(2.0),
        );
        let limited = measure(
            RichText::new(spans())
                .size(16.0)
                .width(80.0)
                .wrap()
                .line_height(2.0)
                .max_lines(2),
        );

        assert!(normal.width <= 80.5, "width: {}", normal.width);
        assert!(normal.height > 16.0, "wrapped: {}", normal.height);
        assert!(tall.height > normal.height + 8.0);
        assert!(limited.height < tall.height);
        assert!(limited.height <= 64.5, "limited: {}", limited.height);
    }

    #[test]
    fn row_baseline_aligns_text_first_baselines() {
        use crate::views::{Row, Text};

        let rt = Runtime::new();
        rt.mount(
            Row::new()
                .align_items(Align::Baseline)
                .child(Text::new("Big").size(40.0))
                .child(Text::new("small").size(12.0)),
        );
        let mut text = TextSystem::new();
        rt.layout(Rect::from_xywh(0.0, 0.0, 400.0, 200.0), &mut text);
        let root = rt.root().unwrap();
        let children = rt.children(root);
        let big = rt.rect_of(children[0]).unwrap();
        let small = rt.rect_of(children[1]).unwrap();
        let big_baseline = big.top() + text.shape("Big", 40.0).first_baseline();
        let small_baseline = small.top() + text.shape("small", 12.0).first_baseline();
        assert!(
            (big_baseline - small_baseline).abs() < 0.5,
            "baselines: {big_baseline} vs {small_baseline}"
        );
        assert!(small.top() > big.top(), "smaller text is pushed down");
    }

    #[test]
    fn clock_advances_exactly_in_manual_mode() {
        let rt = Runtime::new();
        rt.set_manual_clock(true);
        rt.advance_for_test(std::time::Duration::from_millis(500));
        assert!((rt.elapsed_secs() - 0.5).abs() < 1e-6);
        assert!((rt.frame_dt_secs() - 0.5).abs() < 1e-6);

        rt.set_animation_speed(2.0);
        rt.advance_for_test(std::time::Duration::from_millis(250));
        assert!((rt.elapsed_secs() - 1.0).abs() < 1e-6);
        assert!((rt.frame_dt_secs() - 0.5).abs() < 1e-6);
    }

    #[test]
    fn reduced_motion_freezes_the_shared_clock() {
        let rt = Runtime::new();
        rt.set_manual_clock(true);
        rt.set_reduced_motion(true);
        rt.advance_for_test(std::time::Duration::from_millis(500));
        assert_eq!(rt.elapsed_secs(), 0.0);
        assert_eq!(rt.frame_dt_secs(), 0.0);
    }

    #[test]
    fn live_anims_are_evicted_with_their_elements() {
        let rt = Runtime::new();
        rt.mount(crate::Unit);
        let root = rt.root().unwrap();
        let spec = AnimSpec::FAST;
        rt.live_f32(root, Prop::OPACITY, 1.0, Some(&spec), None);
        assert_eq!(rt.live_anim_count(), 1);

        rt.live_f32(id(9999), Prop::OPACITY, 1.0, Some(&spec), None);
        assert_eq!(rt.live_anim_count(), 2);
        let mut list = RenderList::default();
        let mut text = TextSystem::new();
        rt.paint(&mut list, &mut text);
        assert_eq!(rt.live_anim_count(), 1, "detached element evicted on paint");

        rt.mount(crate::Unit);
        assert_eq!(rt.live_anim_count(), 0, "unmount evicts animations");
    }

    #[test]
    fn with_state_allows_reentrant_access() {
        let rt = Runtime::new();
        let (a, b) = (id(0), id(1));
        rt.with_state::<u32, _>(a, |x| *x += 1);
        let out = rt.with_state::<u32, _>(a, |x| {
            *x += 10;
            let inner = rt.with_state::<String, _>(b, |s| {
                s.push_str("inner");
                s.clone()
            });
            format!("{x}:{inner}")
        });
        assert_eq!(out, "11:inner");
        assert_eq!(rt.with_state::<u32, _>(a, |x| *x), 11);
        assert_eq!(rt.state_count(), 2);
        assert!(rt.has_state(a) && rt.has_state(b));
    }

    #[test]
    fn with_state_survives_panic_and_keeps_slot() {
        let rt = Runtime::new();
        let a = id(0);
        rt.with_state::<u32, _>(a, |x| *x = 7);
        let hook = std::panic::take_hook();
        std::panic::set_hook(Box::new(|_| {}));
        let r = std::panic::catch_unwind(AssertUnwindSafe(|| {
            rt.with_state::<u32, _>(a, |x| {
                *x = 99;
                panic!("boom");
            });
        }));
        std::panic::set_hook(hook);
        assert!(r.is_err(), "panic went through with_state");
        assert_eq!(
            rt.with_state::<u32, _>(a, |x| *x),
            99,
            "the slot is back after the panic"
        );
        assert_eq!(rt.state_count(), 1);
    }
}