cranpose_ui/layout/

mod.rs

pub mod core;
pub mod policies;
mod semantics_labels;

use std::{
    cell::{Cell, RefCell},
    fmt,
    mem::size_of,
    rc::Rc,
    sync::OnceLock,
};

use cranpose_core::{
    Applier, ApplierHost, Composer, ConcreteApplierHost, MemoryApplier, Node, NodeError, NodeId,
    Phase, RuntimeHandle, SlotTable, SlotsHost, SnapshotStateObserver,
};
use cranpose_foundation::{
    CanvasSemanticsNode, CollectionInfo, InvalidationKind, LiveRegionMode, ModifierNodeContext,
    NodeCapabilities, ProgressBarRangeInfo, ScrollAxisRange, SemanticsConfiguration,
    SemanticsCustomAction, SemanticsDismiss, SemanticsExpand, SemanticsLongClick,
    SemanticsMagicTap, SemanticsScrollBy, SemanticsScrollToIndex, SemanticsSetProgress,
    SemanticsSetSelection, SemanticsSetText, SemanticsWidgetRole, text::TextRange,
};
use cranpose_ui_layout::{Constraints, MeasurePolicy, Placement};
use web_time::Instant;

#[cfg(test)]
use self::core::{HorizontalAlignment, VerticalAlignment};
use self::core::{Measurable, Placeable};
use crate::{
    modifier::{
        DimensionConstraint, EdgeInsets, Modifier, ModifierNodeSlices,
        ModifierNodeSlicesDebugStats, Point, Rect as GeometryRect, ResolvedModifiers, Size,
    },
    subcompose_layout::{CachedBatchMeasureInputs, SubcomposeLayoutNode},
    widgets::nodes::{IntrinsicKind, LayoutNode, LayoutNodeCacheHandles, LayoutState},
};

#[derive(Default)]
pub(crate) struct LayoutNodeContext {
    invalidations: Vec<InvalidationKind>,
    update_requested: bool,
    active_capabilities: Vec<NodeCapabilities>,
    density: f32,
}

impl LayoutNodeContext {
    pub(crate) fn new(density: f32) -> Self {
        Self {
            density,
            ..Self::default()
        }
    }

    pub(crate) fn take_invalidations(&mut self) -> Vec<InvalidationKind> {
        std::mem::take(&mut self.invalidations)
    }
}

impl ModifierNodeContext for LayoutNodeContext {
    fn invalidate(&mut self, kind: InvalidationKind) {
        if !self.invalidations.contains(&kind) {
            self.invalidations.push(kind);
        }
    }

    fn request_update(&mut self) {
        self.update_requested = true;
    }

    fn push_active_capabilities(&mut self, capabilities: NodeCapabilities) {
        self.active_capabilities.push(capabilities);
    }

    fn pop_active_capabilities(&mut self) {
        self.active_capabilities.pop();
    }

    fn density(&self) -> f32 {
        self.density
    }
}

#[doc(hidden)]
pub fn invalidate_all_layout_caches() {
    crate::render_state::invalidate_layout_cache_epoch();
}

fn layout_measure_telemetry_threshold_ms() -> Option<f64> {
    static THRESHOLD_MS: OnceLock<Option<f64>> = OnceLock::new();
    *THRESHOLD_MS.get_or_init(|| {
        std::env::var("CRANPOSE_LAYOUT_MEASURE_TELEMETRY_MS")
            .ok()
            .and_then(|value| value.parse::<f64>().ok())
            .filter(|value| value.is_finite() && *value >= 0.0)
            .or_else(|| {
                std::env::var_os("CRANPOSE_LAYOUT_MEASURE_TELEMETRY")
                    .is_some()
                    .then_some(4.0)
            })
    })
}

struct LayoutMeasureTelemetry {
    root: NodeId,
    start: Instant,
    after_repasses: Instant,
    after_guard: Instant,
    after_builder: Instant,
    after_measure: Instant,
    after_root_place: Instant,
    after_aux: Instant,
    after_builder_drop: Instant,
    after_guard_drop: Instant,
}

fn log_layout_measure_telemetry(times: LayoutMeasureTelemetry) {
    let Some(threshold_ms) = layout_measure_telemetry_threshold_ms() else {
        return;
    };

    let total_ms = times
        .after_guard_drop
        .duration_since(times.start)
        .as_secs_f64()
        * 1000.0;
    if total_ms < threshold_ms {
        return;
    }

    let repass_ms = times
        .after_repasses
        .duration_since(times.start)
        .as_secs_f64()
        * 1000.0;
    let guard_ms = times
        .after_guard
        .duration_since(times.after_repasses)
        .as_secs_f64()
        * 1000.0;
    let builder_ms = times
        .after_builder
        .duration_since(times.after_guard)
        .as_secs_f64()
        * 1000.0;
    let measure_ms = times
        .after_measure
        .duration_since(times.after_builder)
        .as_secs_f64()
        * 1000.0;
    let root_place_ms = times
        .after_root_place
        .duration_since(times.after_measure)
        .as_secs_f64()
        * 1000.0;
    let aux_ms = times
        .after_aux
        .duration_since(times.after_root_place)
        .as_secs_f64()
        * 1000.0;
    let builder_drop_ms = times
        .after_builder_drop
        .duration_since(times.after_aux)
        .as_secs_f64()
        * 1000.0;
    let guard_drop_ms = times
        .after_guard_drop
        .duration_since(times.after_builder_drop)
        .as_secs_f64()
        * 1000.0;
    log::warn!(
        "[layout-measure-telemetry] root={} total_ms={total_ms:.2} repass_ms={repass_ms:.2} guard_ms={guard_ms:.2} builder_ms={builder_ms:.2} measure_ms={measure_ms:.2} root_place_ms={root_place_ms:.2} aux_ms={aux_ms:.2} builder_drop_ms={builder_drop_ms:.2} guard_drop_ms={guard_drop_ms:.2}",
        times.root
    );
}

fn log_node_measure_telemetry(
    kind: &'static str,
    node_id: NodeId,
    constraints: Constraints,
    size: Size,
    children: usize,
    start: Instant,
) {
    let Some(threshold_ms) = layout_measure_telemetry_threshold_ms() else {
        return;
    };

    let total_ms = start.elapsed().as_secs_f64() * 1000.0;
    if total_ms < threshold_ms {
        return;
    }

    log::warn!(
        "[layout-node-telemetry] kind={kind} node={} total_ms={total_ms:.2} constraints=({:.1},{:.1},{:.1},{:.1}) size=({:.1},{:.1}) children={children}",
        node_id,
        constraints.min_width,
        constraints.max_width,
        constraints.min_height,
        constraints.max_height,
        size.width,
        size.height,
    );
}

struct ApplierSlotGuard<'a> {
    target: &'a mut MemoryApplier,
    host: Rc<ConcreteApplierHost<MemoryApplier>>,
    slots: Rc<RefCell<SlotTable>>,
}

impl<'a> ApplierSlotGuard<'a> {
    fn new(target: &'a mut MemoryApplier) -> Self {
        let original_applier = std::mem::replace(target, MemoryApplier::new());
        let host = Rc::new(ConcreteApplierHost::new(original_applier));

        let slots = {
            let mut applier_ref = host.borrow_typed();
            std::mem::take(applier_ref.slots())
        };
        let slots = Rc::new(RefCell::new(slots));

        Self {
            target,
            host,
            slots,
        }
    }

    fn host(&self) -> Rc<ConcreteApplierHost<MemoryApplier>> {
        Rc::clone(&self.host)
    }

    fn slots_handle(&self) -> Rc<RefCell<SlotTable>> {
        Rc::clone(&self.slots)
    }
}

impl Drop for ApplierSlotGuard<'_> {
    fn drop(&mut self) {
        {
            let mut applier_ref = self.host.borrow_typed();
            *applier_ref.slots() = std::mem::take(&mut *self.slots.borrow_mut());
        }

        {
            let mut applier_ref = self.host.borrow_typed();
            let original_applier = std::mem::take(&mut *applier_ref);
            let _ = std::mem::replace(self.target, original_applier);
        }
    }
}

struct ModifierChainMeasurement {
    size: Size,
    content_offset: Point,
    offset: Point,
    window_root: bool,
}

type LayoutModifierNodeData = (
    usize,
    Rc<RefCell<Box<dyn cranpose_foundation::ModifierNode>>>,
);

struct ScratchVecPool<T> {
    available: Vec<Vec<T>>,
}

impl<T> ScratchVecPool<T> {
    fn acquire(&mut self) -> Vec<T> {
        self.available.pop().unwrap_or_default()
    }

    fn release(&mut self, mut values: Vec<T>) {
        values.clear();
        self.available.push(values);
    }

    #[cfg(test)]
    fn available_count(&self) -> usize {
        self.available.len()
    }
}

impl<T> Default for ScratchVecPool<T> {
    fn default() -> Self {
        Self {
            available: Vec::new(),
        }
    }
}

#[derive(Default)]
pub(crate) struct FrameLayoutArena {
    tmp_records: ScratchVecPool<(NodeId, ChildRecord)>,
    tmp_child_ids: ScratchVecPool<NodeId>,
    tmp_layout_node_data: ScratchVecPool<LayoutModifierNodeData>,
    tmp_placements: ScratchVecPool<Placement>,
}

#[cfg(test)]
impl FrameLayoutArena {
    pub(crate) fn available_placement_scratch_count(&self) -> usize {
        self.tmp_placements.available_count()
    }

    pub(crate) fn seed_placement_scratch_for_test(&mut self) {
        self.tmp_placements.release(Vec::with_capacity(1));
    }
}

/// Discrete event callback reference produced during semantics extraction.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticsCallback {
    node_id: NodeId,
}

impl SemanticsCallback {
    pub fn new(node_id: NodeId) -> Self {
        Self { node_id }
    }

    pub fn node_id(&self) -> NodeId {
        self.node_id
    }
}

/// Semantics action exposed to the input system.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum SemanticsAction {
    Click { handler: SemanticsCallback },
}

/// A text node's text in the semantics tree, shared with the node's modifier
/// slices rather than copied out of them.
#[derive(Clone, Debug)]
pub struct SemanticsText(Rc<crate::text::AnnotatedString>);

impl SemanticsText {
    /// The text the node shows.
    pub fn as_str(&self) -> &str {
        &self.0.text
    }
}

impl PartialEq for SemanticsText {
    fn eq(&self, other: &Self) -> bool {
        self.as_str() == other.as_str()
    }
}

impl Eq for SemanticsText {}

impl From<&str> for SemanticsText {
    fn from(text: &str) -> Self {
        Self(Rc::new(crate::text::AnnotatedString::from(text)))
    }
}

/// Semantic role describing how a node should participate in accessibility and hit testing.
/// Roles are now derived from SemanticsConfiguration rather than widget types.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum SemanticsRole {
    /// Generic container or layout node
    Layout,
    /// Subcomposition boundary
    Subcompose,
    /// Text content derived from the text node semantics payload.
    Text { value: SemanticsText },
    /// Spacer (non-interactive)
    Spacer,
    /// Button (derived from the semantics `role`)
    Button,
    /// Unknown or unspecified role
    Unknown,
}

/// A single node within the semantics tree.
///
/// Not `Eq`: a node now carries drawn-control bounds, which are floats. The
/// tree is compared for "did anything a screen reader can see change", and
/// that comparison is `PartialEq` everywhere else on the accessibility path
/// (`AccessibilityRect`, `AccessibilityElement`) for the same reason.
#[derive(Clone, Debug, PartialEq)]
pub struct SemanticsNode {
    pub node_id: NodeId,
    /// Where the node lies in the root's coordinates: its layout rect,
    /// before graphics-layer transforms, as [`LayoutBox::rect`] holds it.
    pub bounds: GeometryRect,
    /// Incarnation of the runtime node, incremented when its storage is recycled.
    pub node_generation: u32,
    /// Where this node sits in the tree (layout, text, subcomposition …).
    pub role: SemanticsRole,
    /// What kind of control this node is, as a screen reader announces it —
    /// Compose's `Role`. Separate from [`SemanticsNode::role`] because a
    /// clickable `Row` is structurally a layout node and semantically a button.
    pub widget_role: Option<SemanticsWidgetRole>,
    pub actions: Vec<SemanticsAction>,
    pub children: Vec<SemanticsNode>,
    pub description: Option<String>,
    pub state_description: Option<String>,
    pub on_click_label: Option<String>,
    /// Direct activation callback for keyboard and assistive technology.
    pub on_click: Option<SemanticsCustomAction>,
    /// What this control does when a screen reader asks for its long press.
    pub on_long_click: Option<SemanticsLongClick>,
    /// What the long press does, as a verb phrase a reader reads out.
    pub on_long_click_label: Option<String>,
    /// What this control does on VoiceOver's magic tap.
    pub on_magic_tap: Option<SemanticsMagicTap>,
    /// What the magic tap does, as a verb phrase a reader reads out.
    pub on_magic_tap_label: Option<String>,
    /// The short names a person says to Voice Control to reach this control.
    pub input_labels: Vec<String>,
    /// The language of this control's text, as a BCP 47 tag.
    pub language: Option<String>,
    pub selected: Option<bool>,
    pub toggled: Option<bool>,
    pub enabled: bool,
    pub custom_actions: Vec<SemanticsCustomAction>,
    /// Controls this node drew rather than laid out; their bounds are relative
    /// to this node's own top-left. See [`CanvasSemanticsNode`].
    pub canvas_children: Vec<CanvasSemanticsNode>,
    pub editable_text: bool,
    /// Whether an editable field accepts line breaks, independent of its current text.
    pub multiline: bool,
    /// Whether a screen reader skips this node and everything under it.
    pub hidden: bool,
    /// Whether this subtree makes content outside it unavailable to assistive technology.
    pub is_modal: bool,
    /// Whether a screen reader takes this node and the text under it as one
    /// stop.
    pub merge_descendants: bool,
    /// Whether the selectable controls under this node form one group.
    pub selectable_group: bool,
    /// The title of the screen or pane this node is the root of.
    pub pane_title: Option<String>,
    /// Why the control's content is wrong, when it is.
    pub error: Option<String>,
    /// Whether this field holds a secret, so its text stays unspoken.
    pub password: bool,
    /// Where a screen reader visits this node among the ones beside it.
    pub traversal_index: f32,
    /// The text an editable field holds.
    pub text: Option<String>,
    pub text_selection: Option<TextRange>,
    /// Whether this node registered a focus target, so focus can land on it.
    /// Compose's `SemanticsProperties.Focused` companion.
    pub focusable: bool,
    /// Whether focus sits on this node right now.
    pub focused: bool,
    /// How urgently a screen reader reads this node when its text changes.
    /// Compose's `SemanticsProperties.LiveRegion`.
    pub live_region: Option<LiveRegionMode>,
    /// The value this control holds inside a range. Compose's
    /// `ProgressBarRangeInfo`.
    pub progress: Option<ProgressBarRangeInfo>,
    /// What this control does when a screen reader moves its value.
    pub set_progress: Option<SemanticsSetProgress>,
    /// What this field does when a screen reader hands it text.
    pub set_text: Option<SemanticsSetText>,
    /// What this field does when a screen reader moves its caret or picks a
    /// stretch of its text.
    pub set_selection: Option<SemanticsSetSelection>,
    /// What this control does when a screen reader asks it to open.
    pub expand: Option<SemanticsExpand>,
    /// What this control does when a screen reader asks it to close.
    pub collapse: Option<SemanticsExpand>,
    /// What this control does when a screen reader asks to send it away.
    pub dismiss: Option<SemanticsDismiss>,
    /// How far this container scrolled up and down, when it scrolls.
    pub vertical_scroll: Option<ScrollAxisRange>,
    /// How far this container scrolled left and right, when it scrolls.
    pub horizontal_scroll: Option<ScrollAxisRange>,
    /// What this container does when a screen reader pages it.
    pub scroll_by: Option<SemanticsScrollBy>,
    /// What this list does when a screen reader asks for the row at an index.
    pub scroll_to_index: Option<SemanticsScrollToIndex>,
    /// How many rows and columns this list holds, when it is a list.
    pub collection: Option<CollectionInfo>,
}

impl Default for SemanticsNode {
    fn default() -> Self {
        Self {
            node_id: 0,
            bounds: GeometryRect::EMPTY,
            node_generation: 0,
            role: SemanticsRole::Unknown,
            widget_role: None,
            actions: Vec::new(),
            children: Vec::new(),
            description: None,
            state_description: None,
            on_click_label: None,
            on_click: None,
            on_long_click: None,
            on_long_click_label: None,
            on_magic_tap: None,
            on_magic_tap_label: None,
            input_labels: Vec::new(),
            language: None,
            selected: None,
            toggled: None,
            enabled: true,
            custom_actions: Vec::new(),
            canvas_children: Vec::new(),
            editable_text: false,
            multiline: false,
            hidden: false,
            is_modal: false,
            merge_descendants: false,
            selectable_group: false,
            pane_title: None,
            error: None,
            password: false,
            traversal_index: 0.0,
            text: None,
            text_selection: None,
            focusable: false,
            focused: false,
            live_region: None,
            progress: None,
            set_progress: None,
            set_text: None,
            set_selection: None,
            expand: None,
            collapse: None,
            dismiss: None,
            vertical_scroll: None,
            horizontal_scroll: None,
            scroll_by: None,
            scroll_to_index: None,
            collection: None,
        }
    }
}

/// Rooted semantics tree extracted after layout.
#[derive(Clone, Debug, PartialEq)]
pub struct SemanticsTree {
    root: SemanticsNode,
}

impl SemanticsTree {
    fn new(mut root: SemanticsNode) -> Self {
        if let Some(modal) = take_top_modal(&mut root) {
            root = modal;
        }
        Self { root }
    }

    /// Returns the top visible modal subtree, or the full root when no modal is open.
    pub fn root(&self) -> &SemanticsNode {
        &self.root
    }
}

/// Whether a modal of `size` takes space; a zero-sized modal hides nothing.
fn modal_takes_space(size: Size) -> bool {
    size.width > 0.0 && size.height > 0.0 && size.width.is_finite() && size.height.is_finite()
}

fn take_top_modal(node: &mut SemanticsNode) -> Option<SemanticsNode> {
    if node.hidden {
        return None;
    }
    for child in node.children.iter_mut().rev() {
        if let Some(modal) = take_top_modal(child) {
            return Some(modal);
        }
    }
    node.is_modal.then(|| std::mem::take(node))
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct LayoutAllocationDebugStats {
    pub layout_box_count: usize,
    pub layout_box_child_count: usize,
    pub layout_box_child_capacity: usize,
    pub layout_box_heap_bytes: usize,
    pub modifier_slice_count: usize,
    pub modifier_slice_heap_bytes: usize,
    pub modifier_draw_command_count: usize,
    pub modifier_draw_command_capacity: usize,
    pub modifier_pointer_input_count: usize,
    pub modifier_pointer_input_capacity: usize,
    pub modifier_text_content_count: usize,
    pub modifier_text_style_count: usize,
    pub modifier_text_layout_options_count: usize,
    pub modifier_prepared_text_layout_count: usize,
    pub modifier_graphics_layer_count: usize,
    pub modifier_graphics_layer_resolver_count: usize,
    pub semantics_node_count: usize,
    pub semantics_action_count: usize,
    pub semantics_action_capacity: usize,
    pub semantics_child_count: usize,
    pub semantics_child_capacity: usize,
    pub semantics_description_count: usize,
    pub semantics_description_bytes: usize,
    pub semantics_heap_bytes: usize,
}

impl LayoutAllocationDebugStats {
    fn add_modifier_slice(&mut self, stats: ModifierNodeSlicesDebugStats) {
        self.modifier_slice_count += 1;
        self.modifier_slice_heap_bytes += stats.heap_bytes;
        self.modifier_draw_command_count += stats.draw_command_count;
        self.modifier_draw_command_capacity += stats.draw_command_capacity;
        self.modifier_pointer_input_count += stats.pointer_input_count;
        self.modifier_pointer_input_capacity += stats.pointer_input_capacity;
        self.modifier_text_content_count += usize::from(stats.has_text_content);
        self.modifier_text_style_count += usize::from(stats.has_text_style);
        self.modifier_text_layout_options_count += usize::from(stats.has_text_layout_options);
        self.modifier_prepared_text_layout_count += usize::from(stats.has_prepared_text_layout);
        self.modifier_graphics_layer_count += usize::from(stats.has_graphics_layer);
        self.modifier_graphics_layer_resolver_count +=
            usize::from(stats.has_graphics_layer_resolver);
    }
}

/// Result of running layout for a Compose tree.
#[derive(Debug, Clone)]
pub struct LayoutTree {
    root: LayoutBox,
}

impl LayoutTree {
    pub fn new(root: LayoutBox) -> Self {
        Self { root }
    }

    pub fn root(&self) -> &LayoutBox {
        &self.root
    }

    pub fn root_mut(&mut self) -> &mut LayoutBox {
        &mut self.root
    }

    pub fn into_root(self) -> LayoutBox {
        self.root
    }

    pub fn debug_allocation_stats(&self) -> LayoutAllocationDebugStats {
        let mut stats = LayoutAllocationDebugStats::default();
        record_layout_box_allocation_stats(&self.root, &mut stats);
        stats
    }
}

/// Layout information for a single node.
#[derive(Debug, Clone)]
pub struct LayoutBox {
    pub node_id: NodeId,
    /// Incarnation of the runtime node captured with these layout bounds.
    pub node_generation: u32,
    pub rect: GeometryRect,
    /// Content offset for scroll/inner transforms (applies to children, NOT this node's position)
    pub content_offset: Point,
    pub node_data: LayoutNodeData,
    pub children: Vec<LayoutBox>,
}

impl LayoutBox {
    pub fn new(
        node_id: NodeId,
        rect: GeometryRect,
        content_offset: Point,
        node_data: LayoutNodeData,
        children: Vec<LayoutBox>,
    ) -> Self {
        Self {
            node_id,
            node_generation: 0,
            rect,
            content_offset,
            node_data,
            children,
        }
    }
}

/// Snapshot of the data required to render a layout node.
#[derive(Debug, Clone)]
pub struct LayoutNodeData {
    /// Composable origins retained by an inspection-enabled layout node.
    #[cfg(feature = "inspection")]
    pub source_trace: Rc<[cranpose_core::source_trace::SourceLocation]>,
    pub modifier: Modifier,
    pub resolved_modifiers: ResolvedModifiers,
    pub modifier_slices: Rc<ModifierNodeSlices>,
    pub semantics: Option<Rc<SemanticsConfiguration>>,
    pub kind: LayoutNodeKind,
}

impl LayoutNodeData {
    pub fn new(
        modifier: Modifier,
        resolved_modifiers: ResolvedModifiers,
        modifier_slices: Rc<ModifierNodeSlices>,
        semantics: Option<Rc<SemanticsConfiguration>>,
        kind: LayoutNodeKind,
    ) -> Self {
        Self {
            #[cfg(feature = "inspection")]
            source_trace: Rc::default(),
            modifier,
            resolved_modifiers,
            modifier_slices,
            semantics,
            kind,
        }
    }

    /// Semantics the node's live modifier chain reported when the snapshot
    /// was taken.
    pub fn semantics(&self) -> Option<&SemanticsConfiguration> {
        self.semantics.as_deref()
    }

    pub fn resolved_modifiers(&self) -> ResolvedModifiers {
        self.resolved_modifiers
    }

    pub fn modifier_slices(&self) -> &ModifierNodeSlices {
        &self.modifier_slices
    }
}

/// Classification of the node captured inside a [`LayoutBox`].
///
/// Note: Text content is no longer represented as a distinct LayoutNodeKind.
/// Text nodes now use `LayoutNodeKind::Layout` with their content stored in
/// `modifier_slices.text_content()` via TextModifierNode, following Jetpack
/// Compose's pattern where text is a modifier node capability.
#[derive(Clone)]
pub enum LayoutNodeKind {
    Layout,
    Subcompose,
    Spacer,
    Button { on_click: Rc<RefCell<dyn FnMut()>> },
    Unknown,
}

impl fmt::Debug for LayoutNodeKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            LayoutNodeKind::Layout => f.write_str("Layout"),
            LayoutNodeKind::Subcompose => f.write_str("Subcompose"),
            LayoutNodeKind::Spacer => f.write_str("Spacer"),
            LayoutNodeKind::Button { .. } => f.write_str("Button"),
            LayoutNodeKind::Unknown => f.write_str("Unknown"),
        }
    }
}

/// Extension trait that equips `MemoryApplier` with layout computation.
pub trait LayoutEngine {
    fn compute_layout(&mut self, root: NodeId, max_size: Size) -> Result<LayoutTree, NodeError>;
}

impl LayoutEngine for MemoryApplier {
    fn compute_layout(&mut self, root: NodeId, max_size: Size) -> Result<LayoutTree, NodeError> {
        let measurements = measure_layout(self, root, max_size)?;
        measurements
            .into_layout_tree()
            .ok_or(NodeError::MissingContext {
                id: root,
                reason: "layout tree was not requested",
            })
    }
}

/// Result of running the measure pass for a Compose layout tree.
#[derive(Debug, Clone)]
pub struct LayoutMeasurements {
    root: Rc<MeasuredNode>,
    semantics: Option<SemanticsTree>,
    layout_tree: Option<LayoutTree>,
}

impl LayoutMeasurements {
    fn new(
        root: Rc<MeasuredNode>,
        semantics: Option<SemanticsTree>,
        layout_tree: Option<LayoutTree>,
    ) -> Self {
        Self {
            root,
            semantics,
            layout_tree,
        }
    }

    /// Returns the measured size of the root node.
    pub fn root_size(&self) -> Size {
        self.root.size
    }

    pub fn semantics_tree(&self) -> Option<&SemanticsTree> {
        self.semantics.as_ref()
    }

    pub fn debug_allocation_stats(&self) -> LayoutAllocationDebugStats {
        let mut stats = self
            .layout_tree
            .as_ref()
            .map(LayoutTree::debug_allocation_stats)
            .unwrap_or_default();
        if let Some(semantics) = &self.semantics {
            record_semantics_allocation_stats(semantics.root(), &mut stats);
        }
        stats
    }

    /// Consumes the measurements and returns the built [`LayoutTree`], if requested.
    pub fn into_layout_tree(self) -> Option<LayoutTree> {
        self.layout_tree
    }

    /// Returns a cloned [`LayoutTree`] for rendering/debug consumers, if requested.
    pub fn layout_tree(&self) -> Option<LayoutTree> {
        self.layout_tree.clone()
    }
}

/// Builds a semantics tree from an existing [`LayoutTree`].
///
/// This is useful for consumers that need semantics on demand without forcing
/// every layout pass to eagerly allocate a full [`SemanticsTree`].
pub fn build_semantics_tree_from_layout_tree(layout_tree: &LayoutTree) -> SemanticsTree {
    SemanticsTree::new(build_semantics_node_from_layout_box(layout_tree.root()))
}

/// Builds a layout snapshot from retained layout state in the live applier tree.
///
/// Renderers use retained node state directly. This function exists for debug,
/// robot, and tests that need an owned [`LayoutTree`] without forcing every
/// layout pass to allocate one.
pub fn build_layout_tree_from_applier(
    applier: &mut MemoryApplier,
    root: NodeId,
) -> Result<Option<LayoutTree>, NodeError> {
    let origin = layout_tree_origin(read_layout_node(applier, root, |state, _| state)?);
    let mut child_stack = Vec::new();
    place_layout_box(applier, root, origin, Point::default(), &mut child_stack)
        .map(|root| root.map(LayoutTree::new))
}

fn layout_tree_origin(root: Option<LayoutState>) -> Point {
    let Some(state) = root else {
        return Point::default();
    };
    let position = state.position();
    Point {
        x: -position.x,
        y: -position.y,
    }
}

/// Reads a layout or subcompose node's layout state and the children it
/// places, borrowed in place. `None` when the node is neither.
fn read_layout_node<R>(
    applier: &mut MemoryApplier,
    node_id: NodeId,
    mut read: impl FnMut(LayoutState, &[NodeId]) -> R,
) -> Result<Option<R>, NodeError> {
    match applier
        .with_node::<LayoutNode, _>(node_id, |node| read(node.layout_state(), &node.children))
    {
        Ok(value) => return Ok(Some(value)),
        Err(NodeError::TypeMismatch { .. } | NodeError::Missing { .. }) => {}
        Err(err) => return Err(err),
    }

    match applier.with_node::<SubcomposeLayoutNode, _>(node_id, |node| {
        let state = node.layout_state();
        node.with_active_children(|children| read(state, children))
    }) {
        Ok(value) => Ok(Some(value)),
        Err(NodeError::TypeMismatch { .. } | NodeError::Missing { .. }) => Ok(None),
        Err(err) => Err(err),
    }
}

fn snapshot_node_data(
    applier: &mut MemoryApplier,
    node_id: NodeId,
    top_left: Point,
    size: Size,
    parent_layer_translation: Point,
) -> Result<(LayoutNodeData, Point), NodeError> {
    let info = runtime_metadata_for(applier, node_id)?;
    let kind = layout_kind_from_metadata(node_id, &info);
    let RuntimeNodeMetadata {
        modifier,
        resolved_modifiers,
        modifier_slices,
        semantics,
        ..
    } = info;

    let layer_translation = match modifier_slices.graphics_layer() {
        Some(layer) => Point {
            x: parent_layer_translation.x + layer.translation_x,
            y: parent_layer_translation.y + layer.translation_y,
        },
        None => parent_layer_translation,
    };

    publish_window_geometry(&modifier_slices, top_left, layer_translation, size);

    let data = LayoutNodeData::new(
        modifier,
        resolved_modifiers,
        modifier_slices,
        semantics,
        kind,
    );
    #[cfg(feature = "inspection")]
    let data = {
        let mut data = data;
        data.source_trace = applier
            .with_node::<LayoutNode, _>(node_id, |node| node.source_trace.clone())
            .unwrap_or_default();
        data
    };
    Ok((data, layer_translation))
}

/// Places `node_id`'s box and its subtree. `child_stack` is shared by the
/// whole walk: each node pushes its children above its parent's, reads them
/// from there while its descendants push and pop above them, and pops them
/// when done, so no node's child list is copied out of the applier.
fn place_layout_box(
    applier: &mut MemoryApplier,
    node_id: NodeId,
    parent_content_origin: Point,
    parent_layer_translation: Point,
    child_stack: &mut Vec<NodeId>,
) -> Result<Option<LayoutBox>, NodeError> {
    let first_child = child_stack.len();
    let Some(state) = read_layout_node(applier, node_id, |state, children| {
        if state.is_placed() {
            child_stack.extend_from_slice(children);
        }
        state
    })?
    else {
        return Ok(None);
    };
    if !state.is_placed() {
        return Ok(None);
    }

    let top_left = Point {
        x: parent_content_origin.x + state.position().x,
        y: parent_content_origin.y + state.position().y,
    };
    let rect = GeometryRect {
        x: top_left.x,
        y: top_left.y,
        width: state.size().width,
        height: state.size().height,
    };
    let (data, layer_translation) = snapshot_node_data(
        applier,
        node_id,
        top_left,
        state.size(),
        parent_layer_translation,
    )?;
    let child_origin = Point {
        x: top_left.x + state.content_offset.x,
        y: top_left.y + state.content_offset.y,
    };
    let end = child_stack.len();
    let mut children = Vec::with_capacity(end - first_child);
    for index in first_child..end {
        let child_id = child_stack[index];
        if crate::modifier::is_window_root(applier, child_id) {
            continue;
        }
        if let Some(child) = place_layout_box(
            applier,
            child_id,
            child_origin,
            layer_translation,
            child_stack,
        )? {
            children.push(child);
        }
    }
    child_stack.truncate(first_child);

    Ok(Some(LayoutBox {
        node_generation: applier.node_generation(node_id),
        ..LayoutBox::new(node_id, rect, state.content_offset, data, children)
    }))
}

/// A semantics node's rect from its placement under a parent whose content
/// starts at `origin`, and where its own content starts: the rule
/// [`build_layout_tree_from_applier`] places boxes by, with the root at the
/// origin.
fn semantics_placement(
    state: &crate::widgets::nodes::layout_node::LayoutState,
    origin: Option<Point>,
) -> (GeometryRect, Point) {
    let top_left = origin.map_or_else(Point::default, |origin| Point {
        x: origin.x + state.position().x,
        y: origin.y + state.position().y,
    });
    let content = Point {
        x: top_left.x + state.content_offset.x,
        y: top_left.y + state.content_offset.y,
    };
    (
        GeometryRect::from_origin_size(top_left, state.size()),
        content,
    )
}

/// Builds a semantics snapshot from retained layout state in the live applier tree.
///
/// This is the on-demand counterpart to [`build_layout_tree_from_applier`].
/// It follows the currently placed child set, including subcompose active
/// children, and clears semantics dirty flags for nodes it visits.
pub fn build_semantics_tree_from_applier(
    applier: &mut MemoryApplier,
    root: NodeId,
) -> Result<Option<SemanticsTree>, NodeError> {
    let mut child_stack = Vec::new();
    semantics_node_from_applier(applier, root, None, &mut child_stack)
        .map(|root| root.map(SemanticsTree::new))
}

/// Builds the semantics nodes of the children a node pushed onto
/// `child_stack` above `first_child`, then pops them. The stack is shared
/// by the whole walk, so no node's child list is copied out of the applier.
fn semantics_children_from_applier(
    applier: &mut MemoryApplier,
    child_stack: &mut Vec<NodeId>,
    first_child: usize,
    content: Point,
) -> Result<Vec<SemanticsNode>, NodeError> {
    let end = child_stack.len();
    let mut children = Vec::with_capacity(end - first_child);
    for index in first_child..end {
        let child_id = child_stack[index];
        if crate::modifier::is_window_root(applier, child_id) {
            continue;
        }
        if let Some(child) =
            semantics_node_from_applier(applier, child_id, Some(content), child_stack)?
        {
            children.push(child);
        }
    }
    child_stack.truncate(first_child);
    Ok(children)
}

fn semantics_node_from_applier(
    applier: &mut MemoryApplier,
    node_id: NodeId,
    origin: Option<Point>,
    child_stack: &mut Vec<NodeId>,
) -> Result<Option<SemanticsNode>, NodeError> {
    let first_child = child_stack.len();
    match applier.with_node::<LayoutNode, _>(node_id, |layout| {
        let state = layout.layout_state();
        if !state.is_placed() {
            return None;
        }
        let role = role_from_modifier_slices(&layout.modifier_slices_snapshot());
        let config = layout.semantics_configuration();
        child_stack.extend_from_slice(&layout.children);
        layout.clear_needs_semantics();
        Some((role, config, semantics_placement(&state, origin)))
    }) {
        Ok(Some((role, config, (bounds, content)))) => {
            let children =
                semantics_children_from_applier(applier, child_stack, first_child, content)?;
            return Ok(Some(semantics_node_from_parts(
                node_id,
                applier.node_generation(node_id),
                role,
                config,
                children,
                bounds,
            )));
        }
        Ok(None) => return Ok(None),
        Err(NodeError::TypeMismatch { .. } | NodeError::Missing { .. }) => {}
        Err(err) => return Err(err),
    }

    match applier.with_node::<SubcomposeLayoutNode, _>(node_id, |subcompose| {
        let state = subcompose.layout_state();
        if !state.is_placed() {
            return None;
        }
        let config = subcompose.semantics_configuration();
        subcompose.with_active_children(|children| child_stack.extend_from_slice(children));
        subcompose.clear_needs_semantics();
        Some((config, semantics_placement(&state, origin)))
    }) {
        Ok(Some((config, (bounds, content)))) => {
            let children =
                semantics_children_from_applier(applier, child_stack, first_child, content)?;
            Ok(Some(semantics_node_from_parts(
                node_id,
                applier.node_generation(node_id),
                SemanticsRole::Subcompose,
                config,
                children,
                bounds,
            )))
        }
        Ok(None) | Err(NodeError::TypeMismatch { .. } | NodeError::Missing { .. }) => Ok(None),
        Err(err) => Err(err),
    }
}

/// The modal the semantics tree of `root` would be rooted at, found without
/// building the tree: the topmost placed, visible modal that takes space,
/// or `None` when no modal is open. Unlike a tree build, it leaves the
/// nodes' semantics dirty flags alone.
pub fn top_modal_from_applier(
    applier: &mut MemoryApplier,
    root: NodeId,
) -> Result<Option<NodeId>, NodeError> {
    // One depth-first walk on a shared stack, last child first, with a
    // modal's own step below its children's: the first modal step popped is
    // the modal drawn on top. It runs every frame, so no node's children are
    // copied and each node is looked up once.
    enum Step {
        Enter { node: NodeId, child: bool },
        Modal(NodeId),
    }

    fn push_placed(
        steps: &mut Vec<Step>,
        node: NodeId,
        reach: cranpose_foundation::SemanticsReach,
        size: Size,
        children: impl IntoIterator<Item = NodeId>,
    ) {
        if reach.hidden {
            return;
        }
        if reach.is_modal && modal_takes_space(size) {
            steps.push(Step::Modal(node));
        }
        steps.extend(
            children
                .into_iter()
                .map(|node| Step::Enter { node, child: true }),
        );
    }

    let mut steps = vec![Step::Enter {
        node: root,
        child: false,
    }];
    while let Some(step) = steps.pop() {
        let (node_id, child) = match step {
            Step::Modal(node) => return Ok(Some(node)),
            Step::Enter { node, child } => (node, child),
        };
        let node = match applier.get_mut(node_id) {
            Ok(node) => node.as_any_mut(),
            Err(NodeError::Missing { .. }) => continue,
            Err(error) => return Err(error),
        };
        if let Some(layout) = node.downcast_mut::<LayoutNode>() {
            let state = layout.layout_state();
            if state.is_placed() && !(child && layout.is_window_root()) {
                let children = layout.children.iter().copied();
                push_placed(
                    &mut steps,
                    node_id,
                    layout.semantics_reach(),
                    state.size(),
                    children,
                );
            }
        } else if let Some(subcompose) = node.downcast_mut::<SubcomposeLayoutNode>() {
            let state = subcompose.layout_state();
            if state.is_placed() {
                let reach = subcompose.semantics_reach();
                subcompose.with_active_children(|children| {
                    push_placed(
                        &mut steps,
                        node_id,
                        reach,
                        state.size(),
                        children.iter().copied(),
                    );
                });
            }
        }
    }
    Ok(None)
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct MeasureLayoutOptions {
    pub collect_semantics: bool,
    pub build_layout_tree: bool,
}

impl Default for MeasureLayoutOptions {
    fn default() -> Self {
        Self {
            collect_semantics: true,
            build_layout_tree: true,
        }
    }
}

/// Check if a node or any of its descendants needs measure (selective measure optimization).
/// This can be used by the app shell to skip layout when the tree is clean.
///
/// O(1) check - just looks at root's dirty flag.
/// Works because all mutation paths bubble dirty flags to root via composer commands.
///
/// Returns Result to force caller to handle errors explicitly. No more unwrap_or(true) safety net.
pub fn tree_needs_layout(applier: &mut dyn Applier, root: NodeId) -> Result<bool, NodeError> {
    Ok(applier.get_mut(root)?.needs_layout())
}

fn publish_window_geometry(
    modifier_slices: &crate::modifier::ModifierNodeSlices,
    top_left: Point,
    layer_translation: Point,
    size: Size,
) {
    let origin = Point {
        x: top_left.x + layer_translation.x,
        y: top_left.y + layer_translation.y,
    };
    if let Some(sink) = modifier_slices.text_window_origin() {
        sink.set(origin);
    }
    if let Some(sink) = modifier_slices.viewport_window_rect() {
        sink.set(GeometryRect {
            x: origin.x,
            y: origin.y,
            width: size.width,
            height: size.height,
        });
    }
    modifier_slices.publish_pointer_input_size(size);
}

/// Check if the root semantics snapshot is dirty.
///
/// Semantics invalidations bubble to the root the same way layout invalidations do,
/// so a root check is sufficient to determine whether the next layout pass needs to
/// rebuild semantic data even when geometry is otherwise unchanged.
pub fn tree_needs_semantics(applier: &mut dyn Applier, root: NodeId) -> Result<bool, NodeError> {
    Ok(applier.get_mut(root)?.needs_semantics())
}

#[cfg(test)]
pub(crate) fn bubble_layout_dirty(applier: &mut MemoryApplier, node_id: NodeId) {
    cranpose_core::bubble_layout_dirty(applier as &mut dyn Applier, node_id);
}

/// Runs the measure phase for the subtree rooted at `root`.
pub fn measure_layout(
    applier: &mut MemoryApplier,
    root: NodeId,
    max_size: Size,
) -> Result<LayoutMeasurements, NodeError> {
    measure_layout_with_options(applier, root, max_size, MeasureLayoutOptions::default())
}

pub fn measure_layout_with_options(
    applier: &mut MemoryApplier,
    root: NodeId,
    max_size: Size,
    options: MeasureLayoutOptions,
) -> Result<LayoutMeasurements, NodeError> {
    let telemetry_start = Instant::now();
    process_pending_layout_repasses(applier, root)?;
    let after_repasses = Instant::now();

    let constraints = Constraints {
        min_width: 0.0,
        max_width: max_size.width,
        min_height: 0.0,
        max_height: max_size.height,
    };

    let (needs_remeasure, _needs_semantics, cached_epoch) = match applier
        .with_node::<LayoutNode, _>(root, |node| {
            (
                node.needs_measure(),
                node.needs_semantics(),
                node.cache_handles().epoch(),
            )
        }) {
        Ok(tuple) => tuple,
        Err(NodeError::TypeMismatch { .. }) => {
            let node = applier.get_mut(root)?;
            let measure_dirty = node.needs_measure();
            let semantics_dirty = node.needs_semantics();
            (measure_dirty, semantics_dirty, 0)
        }
        Err(err) => return Err(err),
    };

    let epoch = if needs_remeasure {
        crate::render_state::next_layout_cache_epoch()
    } else if cached_epoch != 0 {
        cached_epoch
    } else {
        crate::render_state::current_layout_cache_epoch()
    };

    let guard = ApplierSlotGuard::new(applier);
    let applier_host = guard.host();
    let slots_handle = guard.slots_handle();
    let after_guard = Instant::now();

    let frame_arena = crate::render_state::take_layout_frame_arena();
    let mut builder = LayoutBuilder::new_with_epoch(
        Rc::clone(&applier_host),
        epoch,
        Rc::clone(&slots_handle),
        frame_arena,
    );
    let after_builder = Instant::now();

    let measured = builder.measure_node(root, normalize_constraints(constraints))?;
    let after_measure = Instant::now();

    if let Ok(mut applier) = applier_host.try_borrow_typed()
        && applier
            .with_node::<LayoutNode, _>(root, |node| {
                node.set_position(Point::default());
            })
            .is_err()
    {
        let _ = applier.with_node::<SubcomposeLayoutNode, _>(root, |node| {
            node.set_position(Point::default());
        });
    }
    let after_root_place = Instant::now();

    let (layout_tree, semantics) = {
        let mut applier_ref = applier_host.borrow_typed();
        let layout_tree = if options.build_layout_tree {
            Some(build_layout_tree(&mut applier_ref, &measured)?)
        } else {
            None
        };
        let semantics = if options.collect_semantics {
            let semantics_tree = if let Some(layout_tree) = layout_tree.as_ref() {
                clear_semantics_dirty_flags(&mut applier_ref, &measured)?;
                build_semantics_tree_from_layout_tree(layout_tree)
            } else {
                build_semantics_tree_from_live_nodes(&mut applier_ref, &measured)?
            };
            Some(semantics_tree)
        } else {
            None
        };
        (layout_tree, semantics)
    };
    let after_aux = Instant::now();

    drop(builder);
    let after_builder_drop = Instant::now();

    drop(guard);
    let after_guard_drop = Instant::now();

    log_layout_measure_telemetry(LayoutMeasureTelemetry {
        root,
        start: telemetry_start,
        after_repasses,
        after_guard,
        after_builder,
        after_measure,
        after_root_place,
        after_aux,
        after_builder_drop,
        after_guard_drop,
    });

    Ok(LayoutMeasurements::new(measured, semantics, layout_tree))
}

fn process_pending_layout_repasses(
    applier: &mut MemoryApplier,
    root: NodeId,
) -> Result<(), NodeError> {
    for node_id in crate::render_state::take_modifier_slice_repass_nodes() {
        if let Ok(node) = applier.get_mut(node_id) {
            let any = node.as_any_mut();
            if let Some(layout) = any.downcast_mut::<crate::widgets::nodes::LayoutNode>() {
                layout.mark_modifier_slices_dirty();
            } else if let Some(subcompose) =
                any.downcast_mut::<crate::subcompose_layout::SubcomposeLayoutNode>()
            {
                subcompose.mark_modifier_slices_dirty();
            }
        }
    }
    let measure_repass_nodes = crate::take_measure_repass_nodes();
    let repass_nodes = crate::take_layout_repass_nodes();
    if measure_repass_nodes.is_empty() && repass_nodes.is_empty() {
        return Ok(());
    }
    for node_id in measure_repass_nodes {
        cranpose_core::bubble_measure_dirty(applier as &mut dyn Applier, node_id);
    }
    for node_id in repass_nodes {
        cranpose_core::bubble_layout_dirty(applier as &mut dyn Applier, node_id);
    }
    applier.get_mut(root)?.mark_needs_layout();
    Ok(())
}

struct LayoutBuilder {
    state: Rc<RefCell<LayoutBuilderState>>,
}

impl LayoutBuilder {
    fn new_with_epoch(
        applier: Rc<ConcreteApplierHost<MemoryApplier>>,
        epoch: u64,
        slots: Rc<RefCell<SlotTable>>,
        frame_arena: FrameLayoutArena,
    ) -> Self {
        Self {
            state: Rc::new(RefCell::new(LayoutBuilderState::new_with_epoch(
                applier,
                epoch,
                slots,
                frame_arena,
            ))),
        }
    }

    fn measure_node(
        &mut self,
        node_id: NodeId,
        constraints: Constraints,
    ) -> Result<Rc<MeasuredNode>, NodeError> {
        LayoutBuilderState::measure_node(Rc::clone(&self.state), node_id, constraints)
    }

    fn set_runtime_handle(&mut self, handle: Option<RuntimeHandle>) {
        self.state.borrow_mut().runtime_handle = handle;
    }
}

impl Drop for LayoutBuilder {
    fn drop(&mut self) {
        if Rc::strong_count(&self.state) != 1 {
            return;
        }
        let Ok(mut state) = self.state.try_borrow_mut() else {
            return;
        };
        crate::render_state::replace_layout_frame_arena(std::mem::take(&mut state.frame_arena));
    }
}

struct LayoutBuilderState {
    applier: Rc<ConcreteApplierHost<MemoryApplier>>,
    runtime_handle: Option<RuntimeHandle>,
    slots: Rc<RefCell<SlotTable>>,
    cache_epoch: u64,
    cache_floor: u64,
    frame_arena: FrameLayoutArena,
}

struct LayoutRuntimeFrameBindingCleanup {
    state: Rc<RefCell<LayoutRuntimeState>>,
}

impl LayoutRuntimeFrameBindingCleanup {
    fn new(state: Rc<RefCell<LayoutRuntimeState>>) -> Self {
        Self { state }
    }
}

impl Drop for LayoutRuntimeFrameBindingCleanup {
    fn drop(&mut self) {
        self.state.borrow().clear_frame_bindings();
    }
}

impl LayoutBuilderState {
    fn new_with_epoch(
        applier: Rc<ConcreteApplierHost<MemoryApplier>>,
        epoch: u64,
        slots: Rc<RefCell<SlotTable>>,
        frame_arena: FrameLayoutArena,
    ) -> Self {
        let runtime_handle = applier.borrow_typed().runtime_handle();

        Self {
            applier,
            runtime_handle,
            slots,
            cache_epoch: epoch,
            cache_floor: crate::render_state::layout_cache_floor(),
            frame_arena,
        }
    }

    fn try_with_applier_result<R>(
        state_rc: &Rc<RefCell<Self>>,
        f: impl FnOnce(&mut MemoryApplier) -> Result<R, NodeError>,
    ) -> Option<Result<R, NodeError>> {
        let host = {
            let state = state_rc.borrow();
            Rc::clone(&state.applier)
        };

        let Ok(mut applier) = host.try_borrow_typed() else {
            return None;
        };

        Some(f(&mut applier))
    }

    fn with_applier_result<R>(
        state_rc: &Rc<RefCell<Self>>,
        f: impl FnOnce(&mut MemoryApplier) -> Result<R, NodeError>,
    ) -> Result<R, NodeError> {
        Self::try_with_applier_result(state_rc, f).unwrap_or_else(|| {
            Err(NodeError::MissingContext {
                id: NodeId::default(),
                reason: "applier already borrowed",
            })
        })
    }

    fn clear_node_placed(state_rc: &Rc<RefCell<Self>>, node_id: NodeId) {
        let host = {
            let state = state_rc.borrow();
            Rc::clone(&state.applier)
        };
        let Ok(mut applier) = host.try_borrow_typed() else {
            return;
        };
        if applier
            .with_node::<LayoutNode, _>(node_id, |node| {
                node.clear_placed();
            })
            .is_err()
        {
            let _ = applier.with_node::<SubcomposeLayoutNode, _>(node_id, |node| {
                node.clear_placed();
            });
        }
    }

    fn measure_node(
        state_rc: Rc<RefCell<Self>>,
        node_id: NodeId,
        constraints: Constraints,
    ) -> Result<Rc<MeasuredNode>, NodeError> {
        let telemetry_start = Instant::now();
        Self::clear_node_placed(&state_rc, node_id);

        if let Some(subcompose) =
            Self::try_measure_subcompose(Rc::clone(&state_rc), node_id, constraints)?
        {
            log_node_measure_telemetry(
                "subcompose",
                node_id,
                constraints,
                subcompose.size,
                subcompose.children.len(),
                telemetry_start,
            );
            return Ok(subcompose);
        }

        if let Some(result) = Self::try_with_applier_result(&state_rc, |applier| {
            match applier.with_node::<LayoutNode, _>(node_id, |layout_node| {
                LayoutNodeSnapshot::from_layout_node(layout_node)
            }) {
                Ok(snapshot) => Ok(Some(snapshot)),
                Err(NodeError::TypeMismatch { .. } | NodeError::Missing { .. }) => Ok(None),
                Err(err) => Err(err),
            }
        }) && let Some(snapshot) = result?
        {
            let measured =
                Self::measure_layout_node(Rc::clone(&state_rc), node_id, snapshot, constraints)?;
            log_node_measure_telemetry(
                "layout",
                node_id,
                constraints,
                measured.size,
                measured.children.len(),
                telemetry_start,
            );
            return Ok(measured);
        }

        let measured = Rc::new(MeasuredNode::new(
            node_id,
            Size::default(),
            Point { x: 0.0, y: 0.0 },
            Point::default(),
            Vec::new(),
        ));
        log_node_measure_telemetry(
            "fallback",
            node_id,
            constraints,
            measured.size,
            measured.children.len(),
            telemetry_start,
        );
        Ok(measured)
    }

    fn cached_measure_node_with_applier(
        applier: &mut MemoryApplier,
        node_id: NodeId,
        constraints: Constraints,
    ) -> Result<Option<Rc<MeasuredNode>>, NodeError> {
        let Some(data) = Self::layout_child_measure_data(applier, node_id)? else {
            return Ok(None);
        };
        if data.needs_measure
            || data.needs_layout
            || data.cache.epoch() == 0
            || data.cache.epoch() != crate::render_state::current_layout_cache_epoch()
        {
            return Ok(None);
        }

        let Some(measured) = data.cache.get_measurement(constraints) else {
            return Ok(None);
        };

        if let Some(layout_state) = data.layout_state {
            let mut layout_state = layout_state.borrow_mut();
            layout_state.set_size(measured.size);
        } else {
            let _ = applier.with_node::<SubcomposeLayoutNode, _>(node_id, |node| {
                node.set_measured_size(measured.size);
            });
        }

        Ok(Some(measured))
    }

    fn try_measure_subcompose(
        state_rc: Rc<RefCell<Self>>,
        node_id: NodeId,
        constraints: Constraints,
    ) -> Result<Option<Rc<MeasuredNode>>, NodeError> {
        let applier_host = {
            let state = state_rc.borrow();
            Rc::clone(&state.applier)
        };

        let (node_handle, resolved_modifiers) = {
            let Ok(mut applier) = applier_host.try_borrow_typed() else {
                return Ok(None);
            };
            let node = match applier.get_mut(node_id) {
                Ok(node) => node,
                Err(NodeError::Missing { .. }) => return Ok(None),
                Err(err) => return Err(err),
            };
            let any = node.as_any_mut();
            if let Some(subcompose) =
                any.downcast_mut::<crate::subcompose_layout::SubcomposeLayoutNode>()
            {
                let handle = subcompose.handle();
                let resolved_modifiers = handle
                    .resolved_modifiers()
                    .on_device_grid(subcompose.density().density());
                (handle, resolved_modifiers)
            } else {
                return Ok(None);
            }
        };

        let runtime_handle = {
            let mut state = state_rc.borrow_mut();
            if state.runtime_handle.is_none()
                && let Ok(applier) = applier_host.try_borrow_typed()
            {
                state.runtime_handle = applier.runtime_handle();
            }
            state
                .runtime_handle
                .clone()
                .ok_or(NodeError::MissingContext {
                    id: node_id,
                    reason: "runtime handle required for subcomposition",
                })?
        };

        let props = resolved_modifiers.layout_properties();
        let padding = resolved_modifiers.padding();
        let offset = resolved_modifiers.offset();
        let mut inner_constraints = normalize_constraints(subtract_padding(constraints, padding));

        if let DimensionConstraint::Points(width) = props.width() {
            let constrained_width = width - padding.horizontal_sum();
            inner_constraints.max_width = inner_constraints.max_width.min(constrained_width);
            inner_constraints.min_width = inner_constraints.min_width.min(constrained_width);
        }
        if let DimensionConstraint::Points(height) = props.height() {
            let constrained_height = height - padding.vertical_sum();
            inner_constraints.max_height = inner_constraints.max_height.min(constrained_height);
            inner_constraints.min_height = inner_constraints.min_height.min(constrained_height);
        }

        let mut slots_guard = SlotsGuard::take(Rc::clone(&state_rc));
        let slots_host = slots_guard.host();
        let applier_host_dyn: Rc<dyn ApplierHost> = applier_host.clone();
        let observer = SnapshotStateObserver::new(|callback| callback());
        let composer = Composer::new(
            Rc::clone(&slots_host),
            applier_host_dyn,
            runtime_handle,
            observer,
            Some(node_id),
        );
        composer.enter_phase(Phase::Measure);

        let state_rc_clone = Rc::clone(&state_rc);
        let measure_error = RefCell::new(None);
        let state_rc_for_subcompose = Rc::clone(&state_rc_clone);
        let error_for_subcompose = &measure_error;
        let measured_children = node_handle.measured_children_scratch();
        let measured_children_for_subcompose = Rc::clone(&measured_children);
        let state_rc_for_cached = Rc::clone(&state_rc_clone);
        let error_for_cached = &measure_error;
        let measured_children_for_cached = Rc::clone(&measured_children);
        let measured_children_for_lookup = Rc::clone(&measured_children);
        let measured_children_for_retained = Rc::clone(&measured_children);

        let measure_result = node_handle.measure_with_cached_batch(
            &composer,
            node_id,
            inner_constraints,
            CachedBatchMeasureInputs {
                measurer: Box::new(
                    move |child_id: NodeId, child_constraints: Constraints| -> Size {
                        match Self::measure_node(
                            Rc::clone(&state_rc_for_subcompose),
                            child_id,
                            child_constraints,
                        ) {
                            Ok(measured) => {
                                measured_children_for_subcompose
                                    .borrow_mut()
                                    .insert(child_id, Rc::clone(&measured));
                                measured.size
                            }
                            Err(err) => {
                                let mut slot = error_for_subcompose.borrow_mut();
                                if slot.is_none() {
                                    *slot = Some(err);
                                }
                                Size::default()
                            }
                        }
                    },
                ),
                cached_measure_batch_registrar: Box::new(
                    move |child_ids: &[NodeId],
                          child_constraints: Constraints,
                          out: &mut Vec<Option<Size>>| {
                        out.clear();
                        out.resize(child_ids.len(), None);

                        let applier_host = {
                            let state = state_rc_for_cached.borrow();
                            Rc::clone(&state.applier)
                        };
                        let Ok(mut applier) = applier_host.try_borrow_typed() else {
                            return;
                        };

                        let mut measured_children = measured_children_for_cached.borrow_mut();
                        for (index, &child_id) in child_ids.iter().enumerate() {
                            match Self::cached_measure_node_with_applier(
                                &mut applier,
                                child_id,
                                child_constraints,
                            ) {
                                Ok(Some(measured)) => {
                                    out[index] = Some(measured.size);
                                    measured_children.insert(child_id, Rc::clone(&measured));
                                }
                                Ok(None) => {}
                                Err(err) => {
                                    let mut slot = error_for_cached.borrow_mut();
                                    if slot.is_none() {
                                        *slot = Some(err);
                                    }
                                    break;
                                }
                            }
                        }
                    },
                ),
                retained_measure_lookup: Box::new(move |child_id| {
                    measured_children_for_lookup
                        .borrow()
                        .get(&child_id)
                        .cloned()
                }),
                retained_measure_registrar: Box::new(move |measurements| {
                    let mut measured_children = measured_children_for_retained.borrow_mut();
                    for measured in measurements {
                        measured_children.insert(measured.node_id(), Rc::clone(measured));
                    }
                }),
                error: &measure_error,
            },
        )?;
        drop(composer);
        slots_guard.restore(slots_host.into_table()?);

        if let Some(err) = measure_error.borrow_mut().take() {
            return Err(err);
        }

        let cranpose_ui_layout::MeasureResult {
            size: measured_size,
            placements,
        } = measure_result;

        let mut width = measured_size.width + padding.horizontal_sum();
        let mut height = measured_size.height + padding.vertical_sum();

        width = resolve_dimension(
            width,
            props.width(),
            props.min_width(),
            props.max_width(),
            constraints.min_width,
            constraints.max_width,
        );
        height = resolve_dimension(
            height,
            props.height(),
            props.min_height(),
            props.max_height(),
            constraints.min_height,
            constraints.max_height,
        );

        let mut children = Vec::with_capacity(placements.len());
        let mut measured_children_by_id = measured_children.borrow_mut();

        if let Ok(mut applier) = applier_host.try_borrow_typed() {
            let _ = applier.with_node::<SubcomposeLayoutNode, _>(node_id, |parent_node| {
                parent_node.set_measured_size(Size { width, height });
                parent_node.clear_needs_measure();
                parent_node.clear_needs_layout();
            });
        }

        for placement in &placements {
            let child = if let Some(measured) = measured_children_by_id.remove(&placement.node_id) {
                measured
            } else {
                Self::measure_node(Rc::clone(&state_rc), placement.node_id, inner_constraints)?
            };
            let policy_position = Point {
                x: padding.left + placement.x,
                y: padding.top + placement.y,
            };
            let retained_position = Point {
                x: policy_position.x + child.offset.x,
                y: policy_position.y + child.offset.y,
            };

            if let Ok(mut applier) = applier_host.try_borrow_typed()
                && applier
                    .with_node::<LayoutNode, _>(placement.node_id, |node| {
                        node.set_position(retained_position);
                    })
                    .is_err()
            {
                let _ = applier.with_node::<SubcomposeLayoutNode, _>(placement.node_id, |node| {
                    node.set_position(retained_position);
                });
            }

            children.push(MeasuredChild {
                node: child,
                offset: policy_position,
            });
        }

        node_handle.set_active_children(children.iter().map(|c| c.node.node_id));
        node_handle.recycle_placement_scratch(placements);

        Ok(Some(Rc::new(MeasuredNode::new(
            node_id,
            Size { width, height },
            offset,
            Point::default(),
            children,
        ))))
    }
    fn measure_through_modifier_chain(
        state_rc: &Rc<RefCell<Self>>,
        node_id: NodeId,
        runtime_state: &mut LayoutRuntimeState,
        measure_policy: &Rc<dyn MeasurePolicy>,
        constraints: Constraints,
        layout_node_data: &mut Vec<LayoutModifierNodeData>,
        placements: &mut Vec<Placement>,
    ) -> ModifierChainMeasurement {
        use cranpose_foundation::NodeCapabilities;

        layout_node_data.clear();
        let mut offset = Point::default();
        let mut density = crate::density::Density::default();
        let mut window_root = false;
        let mut geometry = None;

        {
            let state = state_rc.borrow();
            let mut applier = state.applier.borrow_typed();

            let _ = applier.with_node::<LayoutNode, _>(node_id, |layout_node| {
                density = layout_node.density();
                window_root = layout_node.is_window_root();
                geometry = Some(layout_node.coordinator_geometry());
                let chain_handle = layout_node.modifier_chain();

                if !chain_handle.has_layout_nodes() {
                    return;
                }

                chain_handle.chain().for_each_forward_matching(
                    NodeCapabilities::LAYOUT,
                    |node_ref| {
                        if let Some(index) = node_ref.entry_index() {
                            if let Some(node_rc) = chain_handle.chain().get_node_rc(index) {
                                layout_node_data.push((index, Rc::clone(&node_rc)));
                            }

                            node_ref.with_node(|node| {
                                if let Some(offset_node) =
                                    node.as_any()
                                        .downcast_ref::<crate::modifier_nodes::OffsetNode>()
                                {
                                    let delta = offset_node.device_offset(density.density());
                                    offset.x += delta.x;
                                    offset.y += delta.y;
                                }
                            });
                        }
                    },
                );
            });
        }

        let scope = crate::density::DensityMeasureScope::new(density);

        if layout_node_data.is_empty() {
            let final_size = measure_policy.measure_into(
                &scope,
                runtime_state.child_measurables(),
                constraints,
                placements,
            );
            if let Some(geometry) = geometry {
                geometry.replace([GeometryRect {
                    x: 0.0,
                    y: 0.0,
                    width: final_size.width,
                    height: final_size.height,
                }]);
            }

            return ModifierChainMeasurement {
                size: final_size,
                content_offset: Point::default(),
                offset,
                window_root,
            };
        }

        runtime_state.reconcile_coordinator_chain(layout_node_data.as_slice());
        let frame = CoordinatorFrame::new(
            measure_policy,
            &scope,
            runtime_state.child_measurables(),
            placements,
        );

        let placeable = runtime_state
            .coordinator_chain()
            .measure_from(0, &frame, constraints);
        let final_size = Size {
            width: placeable.width(),
            height: placeable.height(),
        };

        if let Some(geometry) = geometry {
            runtime_state
                .coordinator_chain()
                .write_geometry(&geometry, offset);
        }

        let content_offset = placeable.content_offset();
        let all_placement_offset = Point {
            x: content_offset.0,
            y: content_offset.1,
        };

        let content_offset = Point {
            x: all_placement_offset.x - offset.x,
            y: all_placement_offset.y - offset.y,
        };

        let invalidations = frame.take_invalidations();
        if !invalidations.is_empty() {
            Self::with_applier_result(state_rc, |applier| {
                applier.with_node::<LayoutNode, _>(node_id, |layout_node| {
                    for kind in invalidations {
                        match kind {
                            InvalidationKind::Layout => layout_node.mark_needs_measure(),
                            InvalidationKind::Draw => layout_node.mark_needs_redraw(),
                            InvalidationKind::Semantics => layout_node.mark_needs_semantics(),
                            InvalidationKind::PointerInput => layout_node.mark_needs_pointer_pass(),
                            InvalidationKind::Focus => layout_node.mark_needs_focus_sync(),
                        }
                    }
                })
            })
            .ok();
        }

        ModifierChainMeasurement {
            size: final_size,
            content_offset,
            offset,
            window_root,
        }
    }

    fn layout_child_measure_data(
        applier: &mut MemoryApplier,
        child_id: NodeId,
    ) -> Result<Option<LayoutChildMeasureData>, NodeError> {
        match applier.with_node::<LayoutNode, _>(child_id, |n| LayoutChildMeasureData {
            cache: n.cache_handles(),
            layout_state: Some(n.layout_state_handle()),
            needs_layout: n.needs_layout(),
            needs_measure: n.needs_measure(),
        }) {
            Ok(data) => Ok(Some(data)),
            Err(NodeError::TypeMismatch { .. }) => {
                match applier.with_node::<SubcomposeLayoutNode, _>(child_id, |n| {
                    LayoutChildMeasureData {
                        cache: n.cache_handles(),
                        layout_state: None,
                        needs_layout: n.needs_layout(),
                        needs_measure: n.needs_measure(),
                    }
                }) {
                    Ok(data) => Ok(Some(data)),
                    Err(NodeError::TypeMismatch { .. } | NodeError::Missing { .. }) => Ok(None),
                    Err(err) => Err(err),
                }
            }
            Err(NodeError::Missing { .. }) => Ok(None),
            Err(err) => Err(err),
        }
    }

    fn measure_layout_node(
        state_rc: Rc<RefCell<Self>>,
        node_id: NodeId,
        snapshot: LayoutNodeSnapshot,
        constraints: Constraints,
    ) -> Result<Rc<MeasuredNode>, NodeError> {
        let (cache_epoch, cache_floor) = {
            let state = state_rc.borrow();
            (state.cache_epoch, state.cache_floor)
        };
        let LayoutNodeSnapshot {
            measure_policy,
            cache,
            layout_runtime_state,
            needs_layout,
            needs_measure,
        } = snapshot;
        cache.activate(cache_epoch);

        if !needs_measure
            && !needs_layout
            && let Some(cached) = cache.get_measurement(constraints)
        {
            Self::with_applier_result(&state_rc, |applier| {
                applier.with_node::<LayoutNode, _>(node_id, |node| {
                    node.clear_needs_measure();
                    node.clear_needs_layout();
                })
            })
            .ok();
            return Ok(cached);
        }

        let (runtime_handle, applier_host) = {
            let state = state_rc.borrow();
            (state.runtime_handle.clone(), Rc::clone(&state.applier))
        };

        let measure_handle = LayoutMeasureHandle::new(Rc::clone(&state_rc));
        let error = Rc::new(RefCell::new(None));
        let mut pools = VecPools::acquire(Rc::clone(&state_rc));
        let (records, child_ids, layout_node_data, placements) = pools.parts();

        applier_host
            .borrow_typed()
            .with_node::<LayoutNode, _>(node_id, |node| {
                child_ids.extend_from_slice(&node.children);
            })?;

        let mut valid_child_count = 0;
        for index in 0..child_ids.len() {
            let child_id = child_ids[index];
            let child_exists = {
                let mut applier = applier_host.borrow_typed();
                Self::layout_child_measure_data(&mut applier, child_id)?.is_some()
            };
            if child_exists {
                child_ids[valid_child_count] = child_id;
                valid_child_count += 1;
            }
        }
        child_ids.truncate(valid_child_count);

        let _frame_binding_cleanup =
            LayoutRuntimeFrameBindingCleanup::new(Rc::clone(&layout_runtime_state));

        {
            let mut runtime_state = layout_runtime_state.borrow_mut();
            runtime_state.reconcile_child_measurables(child_ids.as_slice());

            for (index, &child_id) in child_ids.iter().enumerate() {
                let data = {
                    let mut applier = applier_host.borrow_typed();
                    Self::layout_child_measure_data(&mut applier, child_id)?
                };
                let Some(data) = data else {
                    continue;
                };

                let child_is_stale = data.is_stale(cache_floor);
                let child_cache_epoch = if child_is_stale {
                    cache_epoch
                } else {
                    data.cache.epoch()
                };
                let child_state = runtime_state.child_state(index);
                child_state.configure(LayoutChildMeasureConfig {
                    applier: Rc::clone(&applier_host),
                    node_id: child_id,
                    error: Rc::clone(&error),
                    runtime_handle: runtime_handle.clone(),
                    cache: data.cache,
                    cache_epoch: child_cache_epoch,
                    force_remeasure: child_is_stale,
                    measure_handle: Some(measure_handle.clone()),
                    layout_state: data.layout_state,
                });
                records.push((child_id, ChildRecord { state: child_state }));
            }
        }

        let chain_constraints = constraints;

        let modifier_chain_result = {
            let mut runtime_state = layout_runtime_state.borrow_mut();
            Self::measure_through_modifier_chain(
                &state_rc,
                node_id,
                &mut runtime_state,
                &measure_policy,
                chain_constraints,
                layout_node_data,
                placements,
            )
        };

        let (width, height, content_offset, offset, window_root) = {
            let result = modifier_chain_result;
            if let Some(err) = error.borrow_mut().take() {
                return Err(err);
            }

            (
                result.size.width,
                result.size.height,
                result.content_offset,
                result.offset,
                result.window_root,
            )
        };

        let mut measured_children = Vec::with_capacity(records.len());
        for (child_id, record) in records.iter() {
            if let Some(measured) = record.state.take_measured() {
                let placed = placements
                    .iter()
                    .find(|placement| placement.node_id == *child_id)
                    .map(|placement| Point {
                        x: placement.x,
                        y: placement.y,
                    });
                if let Some(raw) = placed {
                    record.state.place_retained(Point {
                        x: raw.x + measured.offset.x,
                        y: raw.y + measured.offset.y,
                    });
                }
                let base_position = placed
                    .or_else(|| record.state.last_position())
                    .unwrap_or(Point { x: 0.0, y: 0.0 });
                let position = Point {
                    x: content_offset.x + base_position.x,
                    y: content_offset.y + base_position.y,
                };
                measured_children.push(MeasuredChild {
                    node: measured,
                    offset: position,
                });
            }
        }

        let measured = Rc::new(
            MeasuredNode::new(
                node_id,
                Size { width, height },
                offset,
                content_offset,
                measured_children,
            )
            .with_window_root(window_root),
        );

        cache.store_measurement(constraints, Rc::clone(&measured));

        Self::with_applier_result(&state_rc, |applier| {
            applier.with_node::<LayoutNode, _>(node_id, |node| {
                node.clear_needs_measure();
                node.clear_needs_layout();
                node.set_measured_size(Size { width, height });
                node.set_content_offset(content_offset);
            })
        })
        .ok();

        Ok(measured)
    }
}

struct LayoutChildMeasureData {
    cache: LayoutNodeCacheHandles,
    layout_state: Option<Rc<RefCell<LayoutState>>>,
    needs_layout: bool,
    needs_measure: bool,
}

impl LayoutChildMeasureData {
    fn is_stale(&self, cache_floor: u64) -> bool {
        self.needs_layout || self.needs_measure || self.cache.epoch() < cache_floor
    }
}

struct LayoutNodeSnapshot {
    measure_policy: Rc<dyn MeasurePolicy>,
    cache: LayoutNodeCacheHandles,
    layout_runtime_state: Rc<RefCell<LayoutRuntimeState>>,
    needs_layout: bool,
    needs_measure: bool,
}

impl LayoutNodeSnapshot {
    fn from_layout_node(node: &LayoutNode) -> Self {
        Self {
            measure_policy: Rc::clone(&node.measure_policy),
            cache: node.cache_handles(),
            layout_runtime_state: node.layout_runtime_state_handle(),
            needs_layout: node.needs_layout(),
            needs_measure: node.needs_measure(),
        }
    }
}

struct VecPools {
    state: Rc<RefCell<LayoutBuilderState>>,
    records: Vec<(NodeId, ChildRecord)>,
    child_ids: Vec<NodeId>,
    layout_node_data: Vec<LayoutModifierNodeData>,
    placements: Vec<Placement>,
}

impl VecPools {
    fn acquire(state: Rc<RefCell<LayoutBuilderState>>) -> Self {
        let (records, child_ids, layout_node_data, placements) = {
            let mut state_mut = state.borrow_mut();
            (
                state_mut.frame_arena.tmp_records.acquire(),
                state_mut.frame_arena.tmp_child_ids.acquire(),
                state_mut.frame_arena.tmp_layout_node_data.acquire(),
                state_mut.frame_arena.tmp_placements.acquire(),
            )
        };
        Self {
            state,
            records,
            child_ids,
            layout_node_data,
            placements,
        }
    }

    #[expect(clippy::type_complexity)]
    fn parts(
        &mut self,
    ) -> (
        &mut Vec<(NodeId, ChildRecord)>,
        &mut Vec<NodeId>,
        &mut Vec<LayoutModifierNodeData>,
        &mut Vec<Placement>,
    ) {
        (
            &mut self.records,
            &mut self.child_ids,
            &mut self.layout_node_data,
            &mut self.placements,
        )
    }
}

impl Drop for VecPools {
    fn drop(&mut self) {
        let mut state = self.state.borrow_mut();
        state
            .frame_arena
            .tmp_records
            .release(std::mem::take(&mut self.records));
        state
            .frame_arena
            .tmp_child_ids
            .release(std::mem::take(&mut self.child_ids));
        state
            .frame_arena
            .tmp_layout_node_data
            .release(std::mem::take(&mut self.layout_node_data));
        state
            .frame_arena
            .tmp_placements
            .release(std::mem::take(&mut self.placements));
    }
}

struct SlotsGuard {
    state: Rc<RefCell<LayoutBuilderState>>,
    slots: Option<SlotTable>,
}

impl SlotsGuard {
    fn take(state: Rc<RefCell<LayoutBuilderState>>) -> Self {
        let slots = {
            let state_ref = state.borrow();
            let mut slots_ref = state_ref.slots.borrow_mut();
            std::mem::take(&mut *slots_ref)
        };
        Self {
            state,
            slots: Some(slots),
        }
    }

    fn host(&mut self) -> Rc<SlotsHost> {
        let slots = self.slots.take().unwrap_or_default();
        Rc::new(SlotsHost::new(slots))
    }

    fn restore(&mut self, slots: SlotTable) {
        debug_assert!(self.slots.is_none());
        self.slots = Some(slots);
    }
}

impl Drop for SlotsGuard {
    fn drop(&mut self) {
        if let Some(slots) = self.slots.take() {
            let state_ref = self.state.borrow();
            *state_ref.slots.borrow_mut() = slots;
        }
    }
}

#[derive(Clone)]
struct LayoutMeasureHandle {
    state: Rc<RefCell<LayoutBuilderState>>,
}

impl LayoutMeasureHandle {
    fn new(state: Rc<RefCell<LayoutBuilderState>>) -> Self {
        Self { state }
    }

    fn measure(
        &self,
        node_id: NodeId,
        constraints: Constraints,
    ) -> Result<Rc<MeasuredNode>, NodeError> {
        LayoutBuilderState::measure_node(Rc::clone(&self.state), node_id, constraints)
    }
}

#[derive(Debug, Clone)]
pub(crate) struct MeasuredNode {
    node_id: NodeId,
    size: Size,
    offset: Point,
    content_offset: Point,
    children: Vec<MeasuredChild>,
    window_root: bool,
}

impl MeasuredNode {
    fn new(
        node_id: NodeId,
        size: Size,
        offset: Point,
        content_offset: Point,
        children: Vec<MeasuredChild>,
    ) -> Self {
        Self {
            node_id,
            size,
            offset,
            content_offset,
            children,
            window_root: false,
        }
    }

    fn with_window_root(mut self, window_root: bool) -> Self {
        self.window_root = window_root;
        self
    }

    pub(crate) fn size_for_parent(&self) -> Size {
        if self.window_root {
            Size::new(0.0, 0.0)
        } else {
            self.size
        }
    }

    #[cfg(test)]
    pub(crate) fn leaf(node_id: NodeId, size: Size) -> Self {
        Self::new(
            node_id,
            size,
            Point::default(),
            Point::default(),
            Vec::new(),
        )
    }

    pub(crate) fn node_id(&self) -> NodeId {
        self.node_id
    }

    pub(crate) fn size(&self) -> Size {
        self.size
    }
}

#[derive(Debug, Clone)]
struct MeasuredChild {
    node: Rc<MeasuredNode>,
    offset: Point,
}

struct ChildRecord {
    state: Rc<LayoutChildMeasureState>,
}

struct CoordinatorFrame<'a> {
    measure_policy: &'a Rc<dyn MeasurePolicy>,
    scope: &'a dyn cranpose_ui_layout::MeasureScope,
    measurables: &'a [Box<dyn Measurable>],
    placements: RefCell<&'a mut Vec<Placement>>,
    context: RefCell<LayoutNodeContext>,
}

impl<'a> CoordinatorFrame<'a> {
    fn new(
        measure_policy: &'a Rc<dyn MeasurePolicy>,
        scope: &'a dyn cranpose_ui_layout::MeasureScope,
        measurables: &'a [Box<dyn Measurable>],
        placements: &'a mut Vec<Placement>,
    ) -> Self {
        Self {
            measure_policy,
            scope,
            measurables,
            placements: RefCell::new(placements),
            context: RefCell::new(LayoutNodeContext::new(scope.density())),
        }
    }

    fn take_invalidations(&self) -> Vec<InvalidationKind> {
        self.context.borrow_mut().take_invalidations()
    }
}

struct CoordinatorLink<'chain, 'frame_ref, 'frame_data> {
    chain: &'chain CoordinatorChain,
    frame: &'frame_ref CoordinatorFrame<'frame_data>,
    index: usize,
}

impl Measurable for CoordinatorLink<'_, '_, '_> {
    fn measure(&self, constraints: Constraints) -> Placeable {
        self.chain.measure_from(self.index, self.frame, constraints)
    }

    fn min_intrinsic_width(&self, height: f32) -> f32 {
        self.chain
            .min_intrinsic_width_from(self.index, self.frame, height)
    }

    fn max_intrinsic_width(&self, height: f32) -> f32 {
        self.chain
            .max_intrinsic_width_from(self.index, self.frame, height)
    }

    fn min_intrinsic_height(&self, width: f32) -> f32 {
        self.chain
            .min_intrinsic_height_from(self.index, self.frame, width)
    }

    fn max_intrinsic_height(&self, width: f32) -> f32 {
        self.chain
            .max_intrinsic_height_from(self.index, self.frame, width)
    }
}

struct CoordinatorNode {
    modifier_index: usize,
    node: Rc<RefCell<Box<dyn cranpose_foundation::ModifierNode>>>,
    measured_size: Cell<Size>,
    accumulated_offset: Cell<Point>,
}

impl CoordinatorNode {
    fn new(
        modifier_index: usize,
        node: Rc<RefCell<Box<dyn cranpose_foundation::ModifierNode>>>,
    ) -> Self {
        Self {
            modifier_index,
            node,
            measured_size: Cell::new(Size::default()),
            accumulated_offset: Cell::new(Point::default()),
        }
    }

    fn matches(
        &self,
        modifier_index: usize,
        node: &Rc<RefCell<Box<dyn cranpose_foundation::ModifierNode>>>,
    ) -> bool {
        self.modifier_index == modifier_index && Rc::ptr_eq(&self.node, node)
    }

    #[cfg(test)]
    fn ptr(&self) -> usize {
        Rc::as_ptr(&self.node) as *const () as usize
    }
}

#[derive(Default)]
struct CoordinatorChain {
    nodes: Vec<CoordinatorNode>,
    /// The size the node's own measure policy measured its content at.
    inner_size: Cell<Size>,
}

impl CoordinatorChain {
    fn reconcile(&mut self, layout_node_data: &[LayoutModifierNodeData]) {
        if self.matches(layout_node_data) {
            return;
        }

        let mut previous_nodes = std::mem::take(&mut self.nodes);
        self.nodes.reserve(layout_node_data.len());

        for (modifier_index, node) in layout_node_data {
            if let Some(position) = previous_nodes
                .iter()
                .position(|candidate| candidate.matches(*modifier_index, node))
            {
                self.nodes.push(previous_nodes.swap_remove(position));
            } else {
                self.nodes
                    .push(CoordinatorNode::new(*modifier_index, Rc::clone(node)));
            }
        }
    }

    fn matches(&self, layout_node_data: &[LayoutModifierNodeData]) -> bool {
        self.nodes.len() == layout_node_data.len()
            && self
                .nodes
                .iter()
                .zip(layout_node_data.iter())
                .all(|(node, (modifier_index, node_rc))| node.matches(*modifier_index, node_rc))
    }

    fn measure_from(
        &self,
        index: usize,
        frame: &CoordinatorFrame<'_>,
        constraints: Constraints,
    ) -> Placeable {
        let Some(node) = self.nodes.get(index) else {
            let mut placements = frame.placements.borrow_mut();
            let size = frame.measure_policy.measure_into(
                frame.scope,
                frame.measurables,
                constraints,
                &mut placements,
            );
            self.inner_size.set(size);
            return Placeable::value(size.width, size.height, NodeId::default());
        };

        let wrapped = CoordinatorLink {
            chain: self,
            frame,
            index: index + 1,
        };
        let node_borrow = node.node.borrow();

        let Some(layout_node) = node_borrow.as_layout_node() else {
            let placeable = wrapped.measure(constraints);
            node.measured_size.set(Size {
                width: placeable.width(),
                height: placeable.height(),
            });
            let child_accumulated = self.total_content_offset_from(index + 1);
            node.accumulated_offset.set(child_accumulated);
            return Placeable::value_with_offset(
                placeable.width(),
                placeable.height(),
                NodeId::default(),
                (child_accumulated.x, child_accumulated.y),
            );
        };

        let result = match frame.context.try_borrow_mut() {
            Ok(mut context) => layout_node.measure(&mut *context, &wrapped, constraints),
            Err(_) => {
                let mut temp = LayoutNodeContext::new(frame.scope.density());
                let result = layout_node.measure(&mut temp, &wrapped, constraints);
                if let Ok(mut context) = frame.context.try_borrow_mut() {
                    for kind in temp.take_invalidations() {
                        context.invalidate(kind);
                    }
                }
                result
            }
        };

        node.measured_size.set(result.size);
        let local_offset = Point {
            x: result.placement_offset_x,
            y: result.placement_offset_y,
        };
        let child_accumulated = self.total_content_offset_from(index + 1);
        let accumulated = Point {
            x: local_offset.x + child_accumulated.x,
            y: local_offset.y + child_accumulated.y,
        };
        node.accumulated_offset.set(accumulated);

        Placeable::value_with_offset(
            result.size.width,
            result.size.height,
            NodeId::default(),
            (accumulated.x, accumulated.y),
        )
    }

    fn min_intrinsic_width_from(
        &self,
        index: usize,
        frame: &CoordinatorFrame<'_>,
        height: f32,
    ) -> f32 {
        let Some(node) = self.nodes.get(index) else {
            return frame
                .measure_policy
                .min_intrinsic_width(frame.measurables, height);
        };
        let wrapped = CoordinatorLink {
            chain: self,
            frame,
            index: index + 1,
        };
        let node_borrow = node.node.borrow();
        node_borrow.as_layout_node().map_or_else(
            || wrapped.min_intrinsic_width(height),
            |layout_node| layout_node.min_intrinsic_width(&wrapped, height, frame.scope.density()),
        )
    }

    fn max_intrinsic_width_from(
        &self,
        index: usize,
        frame: &CoordinatorFrame<'_>,
        height: f32,
    ) -> f32 {
        let Some(node) = self.nodes.get(index) else {
            return frame
                .measure_policy
                .max_intrinsic_width(frame.measurables, height);
        };
        let wrapped = CoordinatorLink {
            chain: self,
            frame,
            index: index + 1,
        };
        let node_borrow = node.node.borrow();
        node_borrow.as_layout_node().map_or_else(
            || wrapped.max_intrinsic_width(height),
            |layout_node| layout_node.max_intrinsic_width(&wrapped, height, frame.scope.density()),
        )
    }

    fn min_intrinsic_height_from(
        &self,
        index: usize,
        frame: &CoordinatorFrame<'_>,
        width: f32,
    ) -> f32 {
        let Some(node) = self.nodes.get(index) else {
            return frame
                .measure_policy
                .min_intrinsic_height(frame.measurables, width);
        };
        let wrapped = CoordinatorLink {
            chain: self,
            frame,
            index: index + 1,
        };
        let node_borrow = node.node.borrow();
        node_borrow.as_layout_node().map_or_else(
            || wrapped.min_intrinsic_height(width),
            |layout_node| layout_node.min_intrinsic_height(&wrapped, width, frame.scope.density()),
        )
    }

    fn max_intrinsic_height_from(
        &self,
        index: usize,
        frame: &CoordinatorFrame<'_>,
        width: f32,
    ) -> f32 {
        let Some(node) = self.nodes.get(index) else {
            return frame
                .measure_policy
                .max_intrinsic_height(frame.measurables, width);
        };
        let wrapped = CoordinatorLink {
            chain: self,
            frame,
            index: index + 1,
        };
        let node_borrow = node.node.borrow();
        node_borrow.as_layout_node().map_or_else(
            || wrapped.max_intrinsic_height(width),
            |layout_node| layout_node.max_intrinsic_height(&wrapped, width, frame.scope.density()),
        )
    }

    /// Writes where each coordinator and the node's content ended up in the
    /// last measure, relative to the node drawn at its `node_offset`.
    fn write_geometry(&self, geometry: &crate::modifier::CoordinatorGeometry, node_offset: Point) {
        let content = self.total_content_offset_from(0);
        let placed = |inner_offset: Point, size: Size| GeometryRect {
            x: content.x - inner_offset.x - node_offset.x,
            y: content.y - inner_offset.y - node_offset.y,
            width: size.width,
            height: size.height,
        };
        geometry.replace(
            self.nodes
                .iter()
                .map(|node| placed(node.accumulated_offset.get(), node.measured_size.get()))
                .chain(std::iter::once(placed(
                    Point::default(),
                    self.inner_size.get(),
                ))),
        );
    }

    fn total_content_offset_from(&self, index: usize) -> Point {
        self.nodes
            .get(index)
            .map(|node| node.accumulated_offset.get())
            .unwrap_or_default()
    }

    #[cfg(test)]
    fn debug_ptrs(&self) -> Vec<usize> {
        self.nodes.iter().map(CoordinatorNode::ptr).collect()
    }
}

#[derive(Default)]
pub(crate) struct LayoutRuntimeState {
    child_ids: Vec<NodeId>,
    child_states: Vec<Rc<LayoutChildMeasureState>>,
    child_measurables: Vec<Box<dyn Measurable>>,
    coordinator_chain: CoordinatorChain,
}

impl LayoutRuntimeState {
    fn reconcile_child_measurables(&mut self, child_ids: &[NodeId]) {
        if self.child_ids == child_ids {
            return;
        }

        let mut previous_ids = std::mem::take(&mut self.child_ids);
        let mut previous_states = std::mem::take(&mut self.child_states);
        let mut previous_measurables = std::mem::take(&mut self.child_measurables);

        self.child_ids.reserve(child_ids.len());
        self.child_states.reserve(child_ids.len());
        self.child_measurables.reserve(child_ids.len());

        for &child_id in child_ids {
            if let Some(position) = previous_ids.iter().position(|&id| id == child_id) {
                self.child_ids.push(previous_ids.swap_remove(position));
                self.child_states
                    .push(previous_states.swap_remove(position));
                self.child_measurables
                    .push(previous_measurables.swap_remove(position));
            } else {
                let state = LayoutChildMeasureState::new(child_id);
                self.child_ids.push(child_id);
                self.child_states.push(Rc::clone(&state));
                self.child_measurables
                    .push(Box::new(LayoutChildMeasurable::new(state)));
            }
        }
    }

    fn child_state(&self, index: usize) -> Rc<LayoutChildMeasureState> {
        Rc::clone(&self.child_states[index])
    }

    fn child_measurables(&self) -> &[Box<dyn Measurable>] {
        self.child_measurables.as_slice()
    }

    fn reconcile_coordinator_chain(&mut self, layout_node_data: &[LayoutModifierNodeData]) {
        self.coordinator_chain.reconcile(layout_node_data);
    }

    fn coordinator_chain(&self) -> &CoordinatorChain {
        &self.coordinator_chain
    }

    fn clear_frame_bindings(&self) {
        for child_state in &self.child_states {
            child_state.clear_frame_bindings();
        }
    }

    #[cfg(test)]
    pub(crate) fn debug_stats(&self) -> LayoutRuntimeDebugStats {
        LayoutRuntimeDebugStats {
            child_ids: self.child_ids.clone(),
            child_state_ptrs: self
                .child_states
                .iter()
                .map(|state| Rc::as_ptr(state) as *const () as usize)
                .collect(),
            child_measurable_ptrs: self
                .child_measurables
                .iter()
                .map(|measurable| {
                    measurable.as_ref() as *const dyn Measurable as *const () as usize
                })
                .collect(),
            child_measurable_count: self.child_measurables.len(),
            coordinator_node_ptrs: self.coordinator_chain.debug_ptrs(),
            coordinator_node_count: self.coordinator_chain.nodes.len(),
        }
    }
}

#[cfg(test)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct LayoutRuntimeDebugStats {
    pub(crate) child_ids: Vec<NodeId>,
    pub(crate) child_state_ptrs: Vec<usize>,
    pub(crate) child_measurable_ptrs: Vec<usize>,
    pub(crate) child_measurable_count: usize,
    pub(crate) coordinator_node_ptrs: Vec<usize>,
    pub(crate) coordinator_node_count: usize,
}

struct LayoutChildMeasureConfig {
    applier: Rc<ConcreteApplierHost<MemoryApplier>>,
    node_id: NodeId,
    error: Rc<RefCell<Option<NodeError>>>,
    runtime_handle: Option<RuntimeHandle>,
    cache: LayoutNodeCacheHandles,
    cache_epoch: u64,
    force_remeasure: bool,
    measure_handle: Option<LayoutMeasureHandle>,
    layout_state: Option<Rc<RefCell<LayoutState>>>,
}

struct LayoutChildMeasureState {
    applier: RefCell<Option<Rc<ConcreteApplierHost<MemoryApplier>>>>,
    node_id: Cell<NodeId>,
    measured: RefCell<Option<Rc<MeasuredNode>>>,
    last_position: Cell<Option<Point>>,
    error: RefCell<Option<Rc<RefCell<Option<NodeError>>>>>,
    runtime_handle: RefCell<Option<RuntimeHandle>>,
    cache: RefCell<LayoutNodeCacheHandles>,
    cache_epoch: Cell<u64>,
    force_remeasure: Cell<bool>,
    measure_handle: RefCell<Option<LayoutMeasureHandle>>,
    layout_state: RefCell<Option<Rc<RefCell<LayoutState>>>>,
}

impl LayoutChildMeasureState {
    fn new(node_id: NodeId) -> Rc<Self> {
        Rc::new(Self {
            applier: RefCell::new(None),
            node_id: Cell::new(node_id),
            measured: RefCell::new(None),
            last_position: Cell::new(None),
            error: RefCell::new(None),
            runtime_handle: RefCell::new(None),
            cache: RefCell::new(LayoutNodeCacheHandles::default()),
            cache_epoch: Cell::new(0),
            force_remeasure: Cell::new(true),
            measure_handle: RefCell::new(None),
            layout_state: RefCell::new(None),
        })
    }

    fn configure(&self, config: LayoutChildMeasureConfig) {
        config.cache.activate(config.cache_epoch);
        *self.applier.borrow_mut() = Some(config.applier);
        self.node_id.set(config.node_id);
        self.measured.borrow_mut().take();
        self.last_position.set(None);
        *self.error.borrow_mut() = Some(config.error);
        *self.runtime_handle.borrow_mut() = config.runtime_handle;
        *self.cache.borrow_mut() = config.cache;
        self.cache_epoch.set(config.cache_epoch);
        self.force_remeasure.set(config.force_remeasure);
        *self.measure_handle.borrow_mut() = config.measure_handle;
        *self.layout_state.borrow_mut() = config.layout_state;
    }

    fn clear_frame_bindings(&self) {
        self.measured.borrow_mut().take();
        *self.applier.borrow_mut() = None;
        *self.error.borrow_mut() = None;
        *self.runtime_handle.borrow_mut() = None;
        *self.measure_handle.borrow_mut() = None;
        *self.layout_state.borrow_mut() = None;
    }

    fn node_id(&self) -> NodeId {
        self.node_id.get()
    }

    fn cache(&self) -> LayoutNodeCacheHandles {
        self.cache.borrow().clone()
    }

    fn applier(&self) -> Option<Rc<ConcreteApplierHost<MemoryApplier>>> {
        self.applier.borrow().clone()
    }

    fn layout_state(&self) -> Option<Rc<RefCell<LayoutState>>> {
        self.layout_state.borrow().clone()
    }

    fn take_measured(&self) -> Option<Rc<MeasuredNode>> {
        self.measured.borrow_mut().take()
    }

    fn last_position(&self) -> Option<Point> {
        self.last_position.get()
    }

    fn set_last_position(&self, position: Point) {
        self.last_position.set(Some(position));
    }

    fn place_retained(&self, position: Point) {
        self.set_last_position(position);
        if let Some(layout_state) = self.layout_state() {
            layout_state.borrow_mut().place(position);
            return;
        }
        let Some(applier) = self.applier() else {
            return;
        };
        let Ok(mut applier) = applier.try_borrow_typed() else {
            return;
        };
        let node_id = self.node_id();
        if applier
            .with_node::<LayoutNode, _>(node_id, |node| {
                node.set_position(position);
            })
            .is_err()
        {
            let _ = applier.with_node::<SubcomposeLayoutNode, _>(node_id, |node| {
                node.set_position(position);
            });
        }
    }

    fn set_measured(&self, measured: Option<Rc<MeasuredNode>>) {
        *self.measured.borrow_mut() = measured;
    }

    fn record_error(&self, err: NodeError) {
        let Some(error) = self.error.borrow().clone() else {
            return;
        };
        let mut slot = error.borrow_mut();
        if slot.is_none() {
            *slot = Some(err);
        }
    }

    fn perform_measure(&self, constraints: Constraints) -> Result<Rc<MeasuredNode>, NodeError> {
        let node_id = self.node_id();
        if let Some(handle) = self.measure_handle.borrow().clone() {
            return handle.measure(node_id, constraints);
        }
        let applier = self.applier().ok_or(NodeError::MissingContext {
            id: node_id,
            reason: "layout child applier not configured",
        })?;
        measure_node_with_host(
            applier,
            self.runtime_handle.borrow().clone(),
            node_id,
            constraints,
            self.cache_epoch.get(),
        )
    }

    fn intrinsic_measure(&self, constraints: Constraints) -> Option<Rc<MeasuredNode>> {
        let cache = self.cache();
        cache.activate(self.cache_epoch.get());
        if !self.force_remeasure.get()
            && let Some(cached) = cache.get_measurement(constraints)
        {
            return Some(cached);
        }

        match self.perform_measure(constraints) {
            Ok(measured) => {
                self.force_remeasure.set(false);
                cache.store_measurement(constraints, Rc::clone(&measured));
                Some(measured)
            }
            Err(err) => {
                self.record_error(err);
                None
            }
        }
    }
}

struct LayoutChildMeasurable {
    state: Rc<LayoutChildMeasureState>,
}

impl LayoutChildMeasurable {
    fn new(state: Rc<LayoutChildMeasureState>) -> Self {
        Self { state }
    }

    fn resolved_parent_data(&self) -> Option<cranpose_ui_layout::ParentData> {
        let applier = self.state.applier()?;
        let node_id = self.state.node_id();
        let Ok(mut applier) = applier.try_borrow_typed() else {
            return None;
        };

        applier
            .with_node::<LayoutNode, _>(node_id, |layout_node| {
                let props = layout_node.resolved_modifiers().layout_properties();
                let weight = props.weight().unwrap_or_default();
                cranpose_ui_layout::ParentData {
                    weight: weight.weight,
                    fill: weight.fill,
                    box_alignment: props.box_alignment(),
                    row_alignment: props.row_alignment(),
                    column_alignment: props.column_alignment(),
                }
            })
            .ok()
    }
}

impl Measurable for LayoutChildMeasurable {
    fn measure(&self, constraints: Constraints) -> Placeable {
        let state = &self.state;
        let cache = state.cache();
        cache.activate(state.cache_epoch.get());
        let measured_size;
        if !state.force_remeasure.get() {
            if let Some(cached) = cache.get_measurement(constraints) {
                measured_size = cached.size;
                state.set_measured(Some(Rc::clone(&cached)));
            } else {
                match state.perform_measure(constraints) {
                    Ok(measured) => {
                        state.force_remeasure.set(false);
                        measured_size = measured.size;
                        cache.store_measurement(constraints, Rc::clone(&measured));
                        state.set_measured(Some(measured));
                    }
                    Err(err) => {
                        state.record_error(err);
                        state.set_measured(None);
                        measured_size = Size {
                            width: 0.0,
                            height: 0.0,
                        };
                    }
                }
            }
        } else {
            match state.perform_measure(constraints) {
                Ok(measured) => {
                    state.force_remeasure.set(false);
                    measured_size = measured.size;
                    cache.store_measurement(constraints, Rc::clone(&measured));
                    state.set_measured(Some(measured));
                }
                Err(err) => {
                    state.record_error(err);
                    state.set_measured(None);
                    measured_size = Size {
                        width: 0.0,
                        height: 0.0,
                    };
                }
            }
        }

        if let Some(layout_state) = state.layout_state() {
            let mut layout_state = layout_state.borrow_mut();
            layout_state.set_size(measured_size);
        } else if let Some(applier) = state.applier() {
            let Ok(mut applier) = applier.try_borrow_typed() else {
                return Placeable::value(
                    measured_size.width,
                    measured_size.height,
                    state.node_id(),
                );
            };
            let _ = applier.with_node::<LayoutNode, _>(state.node_id(), |node| {
                node.set_measured_size(measured_size);
            });
        }

        let state = Rc::clone(&self.state);
        let node_id = state.node_id();
        let size_for_parent = state
            .measured
            .borrow()
            .as_ref()
            .map_or(measured_size, |measured| measured.size_for_parent());

        let place_fn = Rc::new(move |x: f32, y: f32| {
            let internal_offset = state
                .measured
                .borrow()
                .as_ref()
                .map(|m| m.offset)
                .unwrap_or_default();

            state.place_retained(Point {
                x: x + internal_offset.x,
                y: y + internal_offset.y,
            });
        });

        Placeable::with_place_fn(
            size_for_parent.width,
            size_for_parent.height,
            node_id,
            place_fn,
        )
    }

    fn min_intrinsic_width(&self, height: f32) -> f32 {
        let kind = IntrinsicKind::MinWidth(height);
        let cache = self.state.cache();
        cache.activate(self.state.cache_epoch.get());
        if !self.state.force_remeasure.get()
            && let Some(value) = cache.get_intrinsic(&kind)
        {
            return value;
        }
        let constraints = Constraints {
            min_width: 0.0,
            max_width: f32::INFINITY,
            min_height: height,
            max_height: height,
        };
        if let Some(node) = self.state.intrinsic_measure(constraints) {
            let value = node.size_for_parent().width;
            cache.store_intrinsic(kind, value);
            value
        } else {
            0.0
        }
    }

    fn max_intrinsic_width(&self, height: f32) -> f32 {
        let kind = IntrinsicKind::MaxWidth(height);
        let cache = self.state.cache();
        cache.activate(self.state.cache_epoch.get());
        if !self.state.force_remeasure.get()
            && let Some(value) = cache.get_intrinsic(&kind)
        {
            return value;
        }
        let constraints = Constraints {
            min_width: 0.0,
            max_width: f32::INFINITY,
            min_height: 0.0,
            max_height: height,
        };
        if let Some(node) = self.state.intrinsic_measure(constraints) {
            let value = node.size_for_parent().width;
            cache.store_intrinsic(kind, value);
            value
        } else {
            0.0
        }
    }

    fn min_intrinsic_height(&self, width: f32) -> f32 {
        let kind = IntrinsicKind::MinHeight(width);
        let cache = self.state.cache();
        cache.activate(self.state.cache_epoch.get());
        if !self.state.force_remeasure.get()
            && let Some(value) = cache.get_intrinsic(&kind)
        {
            return value;
        }
        let constraints = Constraints {
            min_width: width,
            max_width: width,
            min_height: 0.0,
            max_height: f32::INFINITY,
        };
        if let Some(node) = self.state.intrinsic_measure(constraints) {
            let value = node.size_for_parent().height;
            cache.store_intrinsic(kind, value);
            value
        } else {
            0.0
        }
    }

    fn max_intrinsic_height(&self, width: f32) -> f32 {
        let kind = IntrinsicKind::MaxHeight(width);
        let cache = self.state.cache();
        cache.activate(self.state.cache_epoch.get());
        if !self.state.force_remeasure.get()
            && let Some(value) = cache.get_intrinsic(&kind)
        {
            return value;
        }
        let constraints = Constraints {
            min_width: 0.0,
            max_width: width,
            min_height: 0.0,
            max_height: f32::INFINITY,
        };
        if let Some(node) = self.state.intrinsic_measure(constraints) {
            let value = node.size_for_parent().height;
            cache.store_intrinsic(kind, value);
            value
        } else {
            0.0
        }
    }

    fn flex_parent_data(&self) -> Option<cranpose_ui_layout::FlexParentData> {
        let parent_data = self.resolved_parent_data()?;
        if !parent_data.has_weight() {
            return None;
        }
        Some(cranpose_ui_layout::FlexParentData::new(
            parent_data.weight,
            parent_data.fill,
        ))
    }

    fn parent_data(&self) -> cranpose_ui_layout::ParentData {
        self.resolved_parent_data().unwrap_or_default()
    }
}

fn measure_node_with_host(
    applier: Rc<ConcreteApplierHost<MemoryApplier>>,
    runtime_handle: Option<RuntimeHandle>,
    node_id: NodeId,
    constraints: Constraints,
    epoch: u64,
) -> Result<Rc<MeasuredNode>, NodeError> {
    let runtime_handle = match runtime_handle {
        Some(handle) => Some(handle),
        None => applier.borrow_typed().runtime_handle(),
    };
    let mut builder = LayoutBuilder::new_with_epoch(
        applier,
        epoch,
        Rc::new(RefCell::new(SlotTable::default())),
        FrameLayoutArena::default(),
    );
    builder.set_runtime_handle(runtime_handle);
    builder.measure_node(node_id, constraints)
}

#[derive(Clone)]
struct RuntimeNodeMetadata {
    modifier: Modifier,
    resolved_modifiers: ResolvedModifiers,
    modifier_slices: Rc<ModifierNodeSlices>,
    semantics: Option<Rc<SemanticsConfiguration>>,
    role: SemanticsRole,
    button_handler: Option<Rc<RefCell<dyn FnMut()>>>,
}

impl Default for RuntimeNodeMetadata {
    fn default() -> Self {
        Self {
            modifier: Modifier::empty(),
            resolved_modifiers: ResolvedModifiers::default(),
            modifier_slices: Rc::default(),
            semantics: None,
            role: SemanticsRole::Unknown,
            button_handler: None,
        }
    }
}

fn role_from_modifier_slices(modifier_slices: &ModifierNodeSlices) -> SemanticsRole {
    modifier_slices
        .annotated_text()
        .map_or(SemanticsRole::Layout, |text| SemanticsRole::Text {
            value: SemanticsText(Rc::clone(text)),
        })
}

fn runtime_metadata_for(
    applier: &mut MemoryApplier,
    node_id: NodeId,
) -> Result<RuntimeNodeMetadata, NodeError> {
    if let Ok(meta) = applier.with_node::<LayoutNode, _>(node_id, |layout| {
        let modifier = layout.modifier.clone();
        let resolved_modifiers = layout.resolved_modifiers();
        let modifier_slices = layout.modifier_slices_snapshot();
        let role = role_from_modifier_slices(&modifier_slices);

        RuntimeNodeMetadata {
            modifier,
            resolved_modifiers,
            modifier_slices,
            semantics: layout.semantics_configuration().map(Rc::new),
            role,
            button_handler: None,
        }
    }) {
        return Ok(meta);
    }

    if let Ok((modifier, resolved_modifiers, modifier_slices, semantics)) =
        applier.with_node::<SubcomposeLayoutNode, _>(node_id, |node| {
            (
                node.modifier(),
                node.resolved_modifiers(),
                node.modifier_slices_snapshot(),
                node.semantics_configuration().map(Rc::new),
            )
        })
    {
        return Ok(RuntimeNodeMetadata {
            modifier,
            resolved_modifiers,
            modifier_slices,
            semantics,
            role: SemanticsRole::Subcompose,
            button_handler: None,
        });
    }
    Ok(RuntimeNodeMetadata::default())
}

fn clear_semantics_dirty_flags(
    applier: &mut MemoryApplier,
    node: &MeasuredNode,
) -> Result<(), NodeError> {
    match applier.with_node::<LayoutNode, _>(node.node_id, |layout| {
        layout.clear_needs_semantics();
    }) {
        Ok(()) => {}
        Err(NodeError::Missing { .. }) => {}
        Err(NodeError::TypeMismatch { .. }) => {
            match applier.with_node::<SubcomposeLayoutNode, _>(node.node_id, |subcompose| {
                subcompose.clear_needs_semantics();
            }) {
                Ok(()) | Err(NodeError::Missing { .. } | NodeError::TypeMismatch { .. }) => {}
                Err(err) => return Err(err),
            }
        }
        Err(err) => return Err(err),
    }

    for child in &node.children {
        clear_semantics_dirty_flags(applier, &child.node)?;
    }

    Ok(())
}

fn build_semantics_tree_from_live_nodes(
    applier: &mut MemoryApplier,
    node: &MeasuredNode,
) -> Result<SemanticsTree, NodeError> {
    Ok(SemanticsTree::new(build_semantics_node_from_live_nodes(
        applier, node, None,
    )?))
}

fn semantics_node_from_parts(
    node_id: NodeId,
    node_generation: u32,
    mut role: SemanticsRole,
    config: Option<SemanticsConfiguration>,
    children: Vec<SemanticsNode>,
    bounds: GeometryRect,
) -> SemanticsNode {
    let mut node = SemanticsNode {
        node_id,
        bounds,
        node_generation,
        children,
        ..SemanticsNode::default()
    };

    if let Some(config) = config {
        if config.role == Some(SemanticsWidgetRole::Button) {
            role = SemanticsRole::Button;
        }
        if config.is_activatable() {
            node.actions.push(SemanticsAction::Click {
                handler: SemanticsCallback::new(node_id),
            });
        }
        node.widget_role = config.role;
        node.description = config.content_description;
        node.state_description = config.state_description;
        node.on_click_label = config.on_click_label.or_else(|| {
            config
                .on_click
                .as_ref()
                .and_then(|action| (!action.label.is_empty()).then(|| action.label.clone()))
        });
        node.on_click = config.on_click;
        node.on_long_click = config.on_long_click;
        node.on_long_click_label = config.on_long_click_label;
        node.on_magic_tap = config.on_magic_tap;
        node.on_magic_tap_label = config.on_magic_tap_label;
        node.input_labels = config.input_labels;
        node.language = config.language;
        node.selected = config.selected;
        node.toggled = config.toggled;
        node.enabled = config.enabled;
        node.custom_actions = config.custom_actions;
        node.canvas_children = config.canvas_children;
        node.editable_text = config.is_editable_text;
        node.multiline = config.multiline;
        node.hidden = config.hidden;
        node.is_modal = config.is_modal
            && modal_takes_space(Size {
                width: bounds.width,
                height: bounds.height,
            });
        node.merge_descendants = config.merge_descendants;
        node.selectable_group = config.selectable_group;
        node.pane_title = config.pane_title;
        node.error = config.error;
        node.password = config.password;
        node.traversal_index = config.traversal_index;
        node.text = config.text;
        node.text_selection = config.text_selection;
        node.live_region = config.live_region;
        node.progress = config.progress;
        node.set_progress = config.set_progress;
        node.set_text = config.set_text;
        node.set_selection = config.set_selection;
        node.expand = config.expand;
        node.collapse = config.collapse;
        node.dismiss = config.dismiss;
        node.vertical_scroll = config.vertical_scroll;
        node.horizontal_scroll = config.horizontal_scroll;
        node.scroll_by = config.scroll_by;
        node.scroll_to_index = config.scroll_to_index;
        node.collection = config.collection;
    }

    node.focusable = crate::focus_dispatch::has_focus_target(node_id);
    node.focused = node.focusable && crate::focus_dispatch::active_focus_target() == Some(node_id);

    node.role = role;
    node
}

fn build_semantics_node_from_live_nodes(
    applier: &mut MemoryApplier,
    node: &MeasuredNode,
    origin: Option<Point>,
) -> Result<SemanticsNode, NodeError> {
    let (role, config, (bounds, content)) =
        match applier.with_node::<LayoutNode, _>(node.node_id, |layout| {
            let role = role_from_modifier_slices(&layout.modifier_slices_snapshot());
            let config = layout.semantics_configuration();
            layout.clear_needs_semantics();
            (
                role,
                config,
                semantics_placement(&layout.layout_state(), origin),
            )
        }) {
            Ok(data) => data,
            Err(NodeError::TypeMismatch { .. } | NodeError::Missing { .. }) => {
                match applier.with_node::<SubcomposeLayoutNode, _>(node.node_id, |subcompose| {
                    subcompose.clear_needs_semantics();
                    (
                        SemanticsRole::Subcompose,
                        subcompose.semantics_configuration(),
                        semantics_placement(&subcompose.layout_state(), origin),
                    )
                }) {
                    Ok(data) => data,
                    Err(NodeError::TypeMismatch { .. } | NodeError::Missing { .. }) => {
                        let top_left = origin.unwrap_or_default();
                        (
                            SemanticsRole::Unknown,
                            None,
                            (
                                GeometryRect::from_origin_size(top_left, node.size),
                                top_left,
                            ),
                        )
                    }
                    Err(err) => return Err(err),
                }
            }
            Err(err) => return Err(err),
        };

    let mut children = Vec::with_capacity(node.children.len());
    for child in &node.children {
        children.push(build_semantics_node_from_live_nodes(
            applier,
            &child.node,
            Some(content),
        )?);
    }

    Ok(semantics_node_from_parts(
        node.node_id,
        applier.node_generation(node.node_id),
        role,
        config,
        children,
        bounds,
    ))
}

fn record_semantics_allocation_stats(node: &SemanticsNode, stats: &mut LayoutAllocationDebugStats) {
    stats.semantics_node_count += 1;
    stats.semantics_action_count += node.actions.len();
    stats.semantics_action_capacity += node.actions.capacity();
    stats.semantics_child_count += node.children.len();
    stats.semantics_child_capacity += node.children.capacity();
    stats.semantics_heap_bytes += node.actions.capacity() * size_of::<SemanticsAction>();
    stats.semantics_heap_bytes += node.children.capacity() * size_of::<SemanticsNode>();

    if let Some(description) = &node.description {
        stats.semantics_description_count += 1;
        stats.semantics_description_bytes += description.capacity();
        stats.semantics_heap_bytes += description.capacity();
    }

    for child in &node.children {
        record_semantics_allocation_stats(child, stats);
    }
}

fn record_layout_box_allocation_stats(
    layout_box: &LayoutBox,
    stats: &mut LayoutAllocationDebugStats,
) {
    stats.layout_box_count += 1;
    stats.layout_box_child_count += layout_box.children.len();
    stats.layout_box_child_capacity += layout_box.children.capacity();
    stats.layout_box_heap_bytes += layout_box.children.capacity() * size_of::<LayoutBox>();
    stats.add_modifier_slice(layout_box.node_data.modifier_slices().debug_stats());

    for child in &layout_box.children {
        record_layout_box_allocation_stats(child, stats);
    }
}

fn build_layout_tree(
    applier: &mut MemoryApplier,
    node: &MeasuredNode,
) -> Result<LayoutTree, NodeError> {
    fn place(
        applier: &mut MemoryApplier,
        node: &MeasuredNode,
        origin: Point,
        parent_layer_translation: Point,
    ) -> Result<LayoutBox, NodeError> {
        let top_left = Point {
            x: origin.x + node.offset.x,
            y: origin.y + node.offset.y,
        };
        let rect = GeometryRect {
            x: top_left.x,
            y: top_left.y,
            width: node.size.width,
            height: node.size.height,
        };
        let (data, layer_translation) = snapshot_node_data(
            applier,
            node.node_id,
            top_left,
            node.size,
            parent_layer_translation,
        )?;
        let mut children = Vec::with_capacity(node.children.len());
        for child in &node.children {
            if crate::modifier::is_window_root(applier, child.node.node_id) {
                continue;
            }
            let child_origin = Point {
                x: top_left.x + child.offset.x,
                y: top_left.y + child.offset.y,
            };
            children.push(place(
                applier,
                &child.node,
                child_origin,
                layer_translation,
            )?);
        }
        Ok(LayoutBox {
            node_generation: applier.node_generation(node.node_id),
            ..LayoutBox::new(node.node_id, rect, node.content_offset, data, children)
        })
    }

    Ok(LayoutTree::new(place(
        applier,
        node,
        Point { x: 0.0, y: 0.0 },
        Point { x: 0.0, y: 0.0 },
    )?))
}

fn semantics_role_from_layout_box(layout_box: &LayoutBox) -> SemanticsRole {
    match &layout_box.node_data.kind {
        LayoutNodeKind::Subcompose => SemanticsRole::Subcompose,
        LayoutNodeKind::Spacer => SemanticsRole::Spacer,
        LayoutNodeKind::Unknown => SemanticsRole::Unknown,
        LayoutNodeKind::Button { .. } => SemanticsRole::Button,
        LayoutNodeKind::Layout => role_from_modifier_slices(layout_box.node_data.modifier_slices()),
    }
}

fn build_semantics_node_from_layout_box(layout_box: &LayoutBox) -> SemanticsNode {
    let children = layout_box
        .children
        .iter()
        .map(build_semantics_node_from_layout_box)
        .collect();

    semantics_node_from_parts(
        layout_box.node_id,
        layout_box.node_generation,
        semantics_role_from_layout_box(layout_box),
        layout_box.node_data.semantics().cloned(),
        children,
        layout_box.rect,
    )
}

fn layout_kind_from_metadata(_node_id: NodeId, info: &RuntimeNodeMetadata) -> LayoutNodeKind {
    match &info.role {
        SemanticsRole::Layout => LayoutNodeKind::Layout,
        SemanticsRole::Subcompose => LayoutNodeKind::Subcompose,
        SemanticsRole::Text { .. } => LayoutNodeKind::Layout,
        SemanticsRole::Spacer => LayoutNodeKind::Spacer,
        SemanticsRole::Button => {
            let handler = info
                .button_handler
                .as_ref()
                .cloned()
                .unwrap_or_else(|| Rc::new(RefCell::new(|| {})));
            LayoutNodeKind::Button { on_click: handler }
        }
        SemanticsRole::Unknown => LayoutNodeKind::Unknown,
    }
}

fn subtract_padding(constraints: Constraints, padding: EdgeInsets) -> Constraints {
    let horizontal = padding.horizontal_sum();
    let vertical = padding.vertical_sum();
    let min_width = (constraints.min_width - horizontal).max(0.0);
    let mut max_width = constraints.max_width;
    if max_width.is_finite() {
        max_width = (max_width - horizontal).max(0.0);
    }
    let min_height = (constraints.min_height - vertical).max(0.0);
    let mut max_height = constraints.max_height;
    if max_height.is_finite() {
        max_height = (max_height - vertical).max(0.0);
    }
    normalize_constraints(Constraints {
        min_width,
        max_width,
        min_height,
        max_height,
    })
}

fn resolve_dimension(
    base: f32,
    explicit: DimensionConstraint,
    min_override: Option<f32>,
    max_override: Option<f32>,
    min_limit: f32,
    max_limit: f32,
) -> f32 {
    let mut min_bound = min_limit;
    if let Some(min_value) = min_override {
        min_bound = min_bound.max(min_value);
    }

    let mut max_bound = if max_limit.is_finite() {
        max_limit
    } else {
        max_override.unwrap_or(max_limit)
    };
    if let Some(max_value) = max_override {
        if max_bound.is_finite() {
            max_bound = max_bound.min(max_value);
        } else {
            max_bound = max_value;
        }
    }
    if max_bound < min_bound {
        max_bound = min_bound;
    }

    let mut size = match explicit {
        DimensionConstraint::Points(points) => points,
        DimensionConstraint::Fraction(fraction) => {
            if max_limit.is_finite() {
                max_limit * fraction.clamp(0.0, 1.0)
            } else {
                base
            }
        }
        DimensionConstraint::Unspecified => base,
        DimensionConstraint::Intrinsic(_) => base,
    };

    size = clamp_dimension(size, min_bound, max_bound);
    size = clamp_dimension(size, min_limit, max_limit);
    size.max(0.0)
}

fn clamp_dimension(value: f32, min: f32, max: f32) -> f32 {
    let mut result = value.max(min);
    if max.is_finite() {
        result = result.min(max);
    }
    result
}

fn normalize_constraints(mut constraints: Constraints) -> Constraints {
    if constraints.max_width < constraints.min_width {
        constraints.max_width = constraints.min_width;
    }
    if constraints.max_height < constraints.min_height {
        constraints.max_height = constraints.min_height;
    }
    constraints
}

#[cfg(test)]
#[path = "tests/layout_tests.rs"]
mod tests;

#[cfg(test)]
#[path = "tests/coordinator_geometry_tests.rs"]
mod coordinator_geometry_tests;