cranpose_ui/

modifier_nodes.rs

use std::{
    cell::Cell,
    hash::{Hash, Hasher},
    rc::Rc,
};

use cranpose_core::NodeId;
use cranpose_foundation::{
    Constraints, DelegatableNode, DrawModifierNode, InvalidationKind, LayoutModifierNode,
    Measurable, ModifierNode, ModifierNodeContext, ModifierNodeElement, NodeCapabilities,
    NodeState, PointerEvent, PointerInputNode, Size,
};
use cranpose_ui_graphics::{ColorFilter, DrawScope, PointerIcon};
use cranpose_ui_layout::{Alignment, HorizontalAlignment, IntrinsicSize, VerticalAlignment};

mod clickable;

pub use clickable::{ClickableElement, ClickableNode};

use crate::{
    draw::DrawCommand,
    modifier::{
        BlendMode, Brush, Color, CompositingStrategy, EdgeInsets, GraphicsLayer, LayoutWeight,
        Point, RoundedCornerShape,
    },
};

fn hash_f32_value<H: Hasher>(state: &mut H, value: f32) {
    state.write_u32(value.to_bits());
}

fn hash_option_f32<H: Hasher>(state: &mut H, value: Option<f32>) {
    match value {
        Some(v) => {
            state.write_u8(1);
            hash_f32_value(state, v);
        }
        None => state.write_u8(0),
    }
}

/// Hashes which 3D role a layer has and which mesh it is drawn on: equal
/// layers hash alike, and the camera and placement are left to equality.
fn hash_space<H: Hasher>(state: &mut H, space: Option<&cranpose_ui_graphics::space::LayerSpace>) {
    use cranpose_ui_graphics::space::LayerSpace;
    match space {
        None => state.write_u8(0),
        Some(LayerSpace::Scene(_)) => state.write_u8(1),
        Some(LayerSpace::Surface(surface)) => {
            state.write_u8(2);
            state.write_u64(surface.mesh.id());
        }
        Some(LayerSpace::Transform(_)) => state.write_u8(3),
    }
}

fn hash_graphics_layer<H: Hasher>(state: &mut H, layer: &GraphicsLayer) {
    hash_f32_value(state, layer.alpha);
    hash_f32_value(state, layer.scale);
    hash_f32_value(state, layer.scale_x);
    hash_f32_value(state, layer.scale_y);
    hash_f32_value(state, layer.rotation_x);
    hash_f32_value(state, layer.rotation_y);
    hash_f32_value(state, layer.rotation_z);
    hash_f32_value(state, layer.camera_distance);
    hash_f32_value(state, layer.transform_origin.pivot_fraction_x);
    hash_f32_value(state, layer.transform_origin.pivot_fraction_y);
    hash_f32_value(state, layer.translation_x);
    hash_f32_value(state, layer.translation_y);
    hash_space(state, layer.space.as_deref());
    hash_f32_value(state, layer.shadow_elevation);
    hash_f32_value(state, layer.ambient_shadow_color.r());
    hash_f32_value(state, layer.ambient_shadow_color.g());
    hash_f32_value(state, layer.ambient_shadow_color.b());
    hash_f32_value(state, layer.ambient_shadow_color.a());
    hash_f32_value(state, layer.spot_shadow_color.r());
    hash_f32_value(state, layer.spot_shadow_color.g());
    hash_f32_value(state, layer.spot_shadow_color.b());
    hash_f32_value(state, layer.spot_shadow_color.a());
    match layer.shape {
        crate::modifier::LayerShape::Rectangle => {
            state.write_u8(0);
        }
        crate::modifier::LayerShape::Rounded(shape) => {
            state.write_u8(1);
            let radii = shape.radii();
            hash_f32_value(state, radii.top_left);
            hash_f32_value(state, radii.top_right);
            hash_f32_value(state, radii.bottom_right);
            hash_f32_value(state, radii.bottom_left);
        }
    }
    state.write_u8(layer.clip as u8);
    match &layer.color_filter {
        Some(ColorFilter::Tint(color)) => {
            state.write_u8(1);
            hash_f32_value(state, color.r());
            hash_f32_value(state, color.g());
            hash_f32_value(state, color.b());
            hash_f32_value(state, color.a());
        }
        Some(ColorFilter::Modulate(color)) => {
            state.write_u8(2);
            hash_f32_value(state, color.r());
            hash_f32_value(state, color.g());
            hash_f32_value(state, color.b());
            hash_f32_value(state, color.a());
        }
        Some(ColorFilter::Matrix(matrix)) => {
            state.write_u8(3);
            for &value in matrix.iter() {
                hash_f32_value(state, value);
            }
        }
        None => state.write_u8(0),
    }
    state.write_u8(layer.render_effect.is_some() as u8);
    state.write_u8(layer.backdrop_effect.is_some() as u8);
    let compositing_tag = match layer.compositing_strategy {
        CompositingStrategy::Auto => 0,
        CompositingStrategy::Offscreen => 1,
        CompositingStrategy::ModulateAlpha => 2,
    };
    state.write_u8(compositing_tag);
    let blend_tag = match layer.blend_mode {
        BlendMode::Clear => 0,
        BlendMode::Src => 1,
        BlendMode::Dst => 2,
        BlendMode::SrcOver => 3,
        BlendMode::DstOver => 4,
        BlendMode::SrcIn => 5,
        BlendMode::DstIn => 6,
        BlendMode::SrcOut => 7,
        BlendMode::DstOut => 8,
        BlendMode::SrcAtop => 9,
        BlendMode::DstAtop => 10,
        BlendMode::Xor => 11,
        BlendMode::Plus => 12,
        BlendMode::Modulate => 13,
        BlendMode::Screen => 14,
        BlendMode::Overlay => 15,
        BlendMode::Darken => 16,
        BlendMode::Lighten => 17,
        BlendMode::ColorDodge => 18,
        BlendMode::ColorBurn => 19,
        BlendMode::HardLight => 20,
        BlendMode::SoftLight => 21,
        BlendMode::Difference => 22,
        BlendMode::Exclusion => 23,
        BlendMode::Multiply => 24,
        BlendMode::Hue => 25,
        BlendMode::Saturation => 26,
        BlendMode::Color => 27,
        BlendMode::Luminosity => 28,
    };
    state.write_u8(blend_tag);
}

fn hash_horizontal_alignment<H: Hasher>(state: &mut H, alignment: HorizontalAlignment) {
    let tag = match alignment {
        HorizontalAlignment::Start => 0,
        HorizontalAlignment::CenterHorizontally => 1,
        HorizontalAlignment::End => 2,
    };
    state.write_u8(tag);
}

fn hash_vertical_alignment<H: Hasher>(state: &mut H, alignment: VerticalAlignment) {
    let tag = match alignment {
        VerticalAlignment::Top => 0,
        VerticalAlignment::CenterVertically => 1,
        VerticalAlignment::Bottom => 2,
    };
    state.write_u8(tag);
}

fn hash_alignment<H: Hasher>(state: &mut H, alignment: Alignment) {
    hash_horizontal_alignment(state, alignment.horizontal);
    hash_vertical_alignment(state, alignment.vertical);
}

macro_rules! impl_layout_modifier_node {
    ($ty:ty) => {
        impl ModifierNode for $ty {
            fn as_layout_node(&self) -> Option<&dyn LayoutModifierNode> {
                Some(self)
            }

            fn as_layout_node_mut(&mut self) -> Option<&mut dyn LayoutModifierNode> {
                Some(self)
            }
        }
    };
    ($ty:ty, invalidate = $invalidation:expr) => {
        impl ModifierNode for $ty {
            fn on_attach(&mut self, context: &mut dyn ModifierNodeContext) {
                context.invalidate($invalidation);
            }

            fn as_layout_node(&self) -> Option<&dyn LayoutModifierNode> {
                Some(self)
            }

            fn as_layout_node_mut(&mut self) -> Option<&mut dyn LayoutModifierNode> {
                Some(self)
            }
        }
    };
}
pub(crate) use impl_layout_modifier_node;

macro_rules! impl_draw_modifier_node {
    ($ty:ty) => {
        impl ModifierNode for $ty {
            fn on_attach(&mut self, context: &mut dyn ModifierNodeContext) {
                context.invalidate(InvalidationKind::Draw);
            }

            fn as_draw_node(&self) -> Option<&dyn DrawModifierNode> {
                Some(self)
            }

            fn as_draw_node_mut(&mut self) -> Option<&mut dyn DrawModifierNode> {
                Some(self)
            }
        }

        impl DrawModifierNode for $ty {}
    };
}

macro_rules! impl_sink_reporter_element {
    ($element:ty, $node:ty) => {
        impl ModifierNodeElement for $element {
            type Node = $node;

            fn create(&self) -> Self::Node {
                <$node>::new(self.sink.clone())
            }

            fn update(&self, node: &mut Self::Node) {
                node.sink = self.sink.clone();
            }

            fn capabilities(&self) -> NodeCapabilities {
                NodeCapabilities::LAYOUT
            }
        }
    };
}

/// One axis of what a size modifier that enforces incoming constraints
/// holds for: a fixed size that fit holds while the bounds allow it, and an
/// axis it leaves unsized passes the bounds to its content and holds what
/// the content holds.
fn size_axis_hold(
    (min, max): (Option<f32>, Option<f32>),
    target: f32,
    size: f32,
    wrapped: Option<cranpose_ui_layout::AxisHold>,
) -> Option<cranpose_ui_layout::AxisHold> {
    match (min, max) {
        (Some(min), Some(max)) if min == max && size == target => {
            Some(cranpose_ui_layout::AxisHold::sized(target))
        }
        (None, None) => wrapped,
        _ => None,
    }
}

/// One axis of what a fill modifier holds for: see
/// [`FillNode::measure_hold`].
fn fill_axis_hold(
    fills: bool,
    (max, size): (f32, f32),
    (fraction, density): (f32, f32),
    wrapped: Option<cranpose_ui_layout::AxisHold>,
) -> Option<cranpose_ui_layout::AxisHold> {
    use cranpose_ui_layout::{AxisHold, BoundRange};
    if !fills {
        return wrapped;
    }
    if max == f32::INFINITY {
        let wrapped = wrapped?;
        return Some(AxisHold {
            min: wrapped.min,
            max: wrapped.max.intersect(BoundRange::exactly(f32::INFINITY))?,
        });
    }
    (size == cranpose_ui_layout::round_to_px(max * fraction, density)).then_some(AxisHold {
        min: BoundRange::up_to(size),
        max: BoundRange::exactly(max),
    })
}

fn measure_pass_through(
    measurable: &dyn Measurable,
    constraints: Constraints,
    offset: impl FnOnce(Size) -> (f32, f32),
) -> cranpose_ui_layout::LayoutModifierMeasureResult {
    let placeable = measurable.measure(constraints);
    let size = Size {
        width: placeable.width(),
        height: placeable.height(),
    };
    let (x, y) = offset(size);
    cranpose_ui_layout::LayoutModifierMeasureResult::new(size, x, y)
}

fn attach_draw_observer(
    node_id_cell: &Cell<Option<NodeId>>,
    context: &mut dyn ModifierNodeContext,
) {
    node_id_cell.set(context.node_id());
    context.invalidate(InvalidationKind::Draw);
}

fn detach_draw_observer(node_id_cell: &Cell<Option<NodeId>>) {
    if let Some(node_id) = node_id_cell.replace(None) {
        crate::render_state::clear_draw_observations_for_node(node_id);
    }
}

enum SizeAxis {
    Width,
    Height,
}

fn size_intrinsic(
    target: Constraints,
    axis: SizeAxis,
    enforce_incoming: bool,
    cross: f32,
    intrinsic: impl FnOnce(f32) -> f32,
) -> f32 {
    let (target_min, target_max, cross_min, cross_max) = match axis {
        SizeAxis::Width => (
            target.min_width,
            target.max_width,
            target.min_height,
            target.max_height,
        ),
        SizeAxis::Height => (
            target.min_height,
            target.max_height,
            target.min_width,
            target.max_width,
        ),
    };
    if target_min == target_max && target_max != f32::INFINITY {
        target_max
    } else {
        let child_cross = if enforce_incoming {
            cross
        } else {
            cross.clamp(cross_min, cross_max)
        };
        intrinsic(child_cross).clamp(target_min, target_max)
    }
}

/// Node that adds padding around its content.
#[derive(Debug)]
pub struct PaddingNode {
    padding: EdgeInsets,
    state: NodeState,
}

impl PaddingNode {
    /// Creates a node that pads its content by `padding`, in logical pixels.
    pub fn new(padding: EdgeInsets) -> Self {
        Self {
            padding,
            state: NodeState::new(),
        }
    }

    /// Returns the padding on each edge, in logical pixels.
    pub fn padding(&self) -> EdgeInsets {
        self.padding
    }
}

impl DelegatableNode for PaddingNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_layout_modifier_node!(PaddingNode, invalidate = InvalidationKind::Layout);

impl LayoutModifierNode for PaddingNode {
    fn measure_hold(
        &self,
        density: f32,
        _constraints: Constraints,
        size: Size,
        wrapped: cranpose_ui_layout::WrappedHold,
    ) -> Option<cranpose_ui_layout::ConstraintsHold> {
        let inner = wrapped.hold?;
        let padding = device_padding(self.padding, density);
        let horizontal = padding.horizontal_sum();
        let vertical = padding.vertical_sum();
        // A padded size the bounds cut changes with them.
        if size.width != wrapped.size.width + horizontal
            || size.height != wrapped.size.height + vertical
        {
            return None;
        }
        cranpose_ui_layout::ConstraintsHold {
            width: inner.width.outset(horizontal),
            height: inner.height.outset(vertical),
        }
        .intersect(cranpose_ui_layout::ConstraintsHold::sized(
            size.width,
            size.height,
        ))
    }

    fn measure(
        &self,
        context: &mut dyn ModifierNodeContext,
        measurable: &dyn Measurable,
        constraints: Constraints,
    ) -> cranpose_ui_layout::LayoutModifierMeasureResult {
        let padding = device_padding(self.padding, context.density());
        let horizontal_padding = padding.horizontal_sum();
        let vertical_padding = padding.vertical_sum();

        let inner_constraints = Constraints {
            min_width: (constraints.min_width - horizontal_padding).max(0.0),
            max_width: (constraints.max_width - horizontal_padding).max(0.0),
            min_height: (constraints.min_height - vertical_padding).max(0.0),
            max_height: (constraints.max_height - vertical_padding).max(0.0),
        };

        let inner_placeable = measurable.measure(inner_constraints);
        let inner_width = inner_placeable.width();
        let inner_height = inner_placeable.height();

        let (width, height) = constraints.constrain(
            inner_width + horizontal_padding,
            inner_height + vertical_padding,
        );

        cranpose_ui_layout::LayoutModifierMeasureResult::new(
            Size { width, height },
            padding.left,
            padding.top,
        )
    }

    fn min_intrinsic_width(&self, measurable: &dyn Measurable, height: f32, density: f32) -> f32 {
        let padding = device_padding(self.padding, density);
        let inner_height = (height - padding.vertical_sum()).max(0.0);
        measurable.min_intrinsic_width(inner_height) + padding.horizontal_sum()
    }

    fn max_intrinsic_width(&self, measurable: &dyn Measurable, height: f32, density: f32) -> f32 {
        let padding = device_padding(self.padding, density);
        let inner_height = (height - padding.vertical_sum()).max(0.0);
        measurable.max_intrinsic_width(inner_height) + padding.horizontal_sum()
    }

    fn min_intrinsic_height(&self, measurable: &dyn Measurable, width: f32, density: f32) -> f32 {
        let padding = device_padding(self.padding, density);
        let inner_width = (width - padding.horizontal_sum()).max(0.0);
        measurable.min_intrinsic_height(inner_width) + padding.vertical_sum()
    }

    fn max_intrinsic_height(&self, measurable: &dyn Measurable, width: f32, density: f32) -> f32 {
        let padding = device_padding(self.padding, density);
        let inner_width = (width - padding.horizontal_sum()).max(0.0);
        measurable.max_intrinsic_height(inner_width) + padding.vertical_sum()
    }
}

/// `padding` with each side on a whole device pixel of `density`, as
/// Compose's `roundToPx` puts every padding side.
pub(crate) fn device_padding(padding: EdgeInsets, density: f32) -> EdgeInsets {
    use cranpose_ui_layout::round_to_px;
    EdgeInsets {
        left: round_to_px(padding.left, density),
        top: round_to_px(padding.top, density),
        right: round_to_px(padding.right, density),
        bottom: round_to_px(padding.bottom, density),
    }
}

/// Element that creates and updates padding nodes.
#[derive(Debug, Clone, PartialEq)]
pub struct PaddingElement {
    padding: EdgeInsets,
}

impl PaddingElement {
    /// Creates an element for a node that pads its content by `padding`, in logical pixels.
    pub fn new(padding: EdgeInsets) -> Self {
        Self { padding }
    }
}

impl Hash for PaddingElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        hash_f32_value(state, self.padding.left);
        hash_f32_value(state, self.padding.top);
        hash_f32_value(state, self.padding.right);
        hash_f32_value(state, self.padding.bottom);
    }
}

impl ModifierNodeElement for PaddingElement {
    type Node = PaddingNode;

    fn create(&self) -> Self::Node {
        PaddingNode::new(self.padding)
    }

    fn update(&self, node: &mut Self::Node) {
        if node.padding != self.padding {
            node.padding = self.padding;
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::LAYOUT
    }
}

/// Node that draws a background behind its content.
#[derive(Debug)]
pub struct BackgroundNode {
    color: Color,
    shape: Option<RoundedCornerShape>,
    state: NodeState,
}

impl BackgroundNode {
    /// Creates a node that fills its bounds with `color` behind its content, with square corners.
    pub fn new(color: Color) -> Self {
        Self {
            color,
            shape: None,
            state: NodeState::new(),
        }
    }

    /// Returns the fill color.
    pub fn color(&self) -> Color {
        self.color
    }

    /// Returns the corner shape of the fill, or `None` for square corners.
    pub fn shape(&self) -> Option<RoundedCornerShape> {
        self.shape
    }
}

impl DelegatableNode for BackgroundNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_draw_modifier_node!(BackgroundNode);

/// Element that creates and updates background nodes.
#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundElement {
    color: Color,
}

impl BackgroundElement {
    /// Creates an element for a node that fills its bounds with `color`.
    pub fn new(color: Color) -> Self {
        Self { color }
    }
}

impl Hash for BackgroundElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        hash_f32_value(state, self.color.0);
        hash_f32_value(state, self.color.1);
        hash_f32_value(state, self.color.2);
        hash_f32_value(state, self.color.3);
    }
}

impl ModifierNodeElement for BackgroundElement {
    type Node = BackgroundNode;

    fn create(&self) -> Self::Node {
        BackgroundNode::new(self.color)
    }

    fn update(&self, node: &mut Self::Node) {
        if node.color != self.color {
            node.color = self.color;
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::DRAW
    }
}

/// Node that tracks the latest rounded corner shape.
#[derive(Debug)]
pub struct CornerShapeNode {
    shape: RoundedCornerShape,
    state: NodeState,
}

impl CornerShapeNode {
    /// Creates a node that holds `shape` as the current rounded corner shape.
    pub fn new(shape: RoundedCornerShape) -> Self {
        Self {
            shape,
            state: NodeState::new(),
        }
    }

    /// Returns the corner shape.
    pub fn shape(&self) -> RoundedCornerShape {
        self.shape
    }
}

impl DelegatableNode for CornerShapeNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_draw_modifier_node!(CornerShapeNode);

/// Element that creates and updates corner shape nodes.
#[derive(Debug, Clone, PartialEq)]
pub struct CornerShapeElement {
    shape: RoundedCornerShape,
}

impl CornerShapeElement {
    /// Creates an element for a node that holds `shape` as the current rounded corner shape.
    pub fn new(shape: RoundedCornerShape) -> Self {
        Self { shape }
    }
}

impl Hash for CornerShapeElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        let radii = self.shape.radii();
        hash_f32_value(state, radii.top_left);
        hash_f32_value(state, radii.top_right);
        hash_f32_value(state, radii.bottom_right);
        hash_f32_value(state, radii.bottom_left);
    }
}

impl ModifierNodeElement for CornerShapeElement {
    type Node = CornerShapeNode;

    fn create(&self) -> Self::Node {
        CornerShapeNode::new(self.shape)
    }

    fn update(&self, node: &mut Self::Node) {
        if node.shape != self.shape {
            node.shape = self.shape;
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::DRAW
    }
}

#[derive(Debug, Clone, PartialEq)]
pub(crate) struct BorderElement {
    width: f32,
    brush: Brush,
    shape: RoundedCornerShape,
}

impl BorderElement {
    pub(crate) fn new(width: f32, brush: Brush, shape: RoundedCornerShape) -> Self {
        Self {
            width,
            brush,
            shape,
        }
    }

    /// The draw command stroking the border over the content.
    pub(crate) fn command(&self) -> DrawCommand {
        let Self {
            width,
            brush,
            shape,
        } = self.clone();
        DrawCommand::Overlay(Rc::new(move |scope| {
            let size = scope.size();
            if width <= 0.0 || size.width <= 0.0 || size.height <= 0.0 {
                return;
            }
            let radii = shape.resolve(size.width, size.height);
            let half = width / 2.0;
            if width * 2.0 >= size.width.min(size.height) {
                // A stroke as thick as half the node covers all of it.
                scope.draw_round_rect(brush.clone(), radii);
                return;
            }
            let inset = |radius: f32| (radius - half).max(0.0);
            scope.draw_round_rect_at_stroked(
                cranpose_ui_graphics::Rect {
                    x: half,
                    y: half,
                    width: size.width - width,
                    height: size.height - width,
                },
                brush.clone(),
                cranpose_ui_graphics::CornerRadii {
                    top_left: inset(radii.top_left),
                    top_right: inset(radii.top_right),
                    bottom_right: inset(radii.bottom_right),
                    bottom_left: inset(radii.bottom_left),
                },
                cranpose_ui_graphics::Stroke::new(width),
            );
        }))
    }
}

impl Hash for BorderElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        hash_f32_value(state, self.width);
        std::mem::discriminant(&self.brush).hash(state);
        if let Brush::Solid(color) = self.brush {
            hash_f32_value(state, color.0);
            hash_f32_value(state, color.1);
            hash_f32_value(state, color.2);
            hash_f32_value(state, color.3);
        }
        let radii = self.shape.radii();
        hash_f32_value(state, radii.top_left);
        hash_f32_value(state, radii.top_right);
        hash_f32_value(state, radii.bottom_right);
        hash_f32_value(state, radii.bottom_left);
    }
}

impl ModifierNodeElement for BorderElement {
    type Node = DrawCommandNode;

    fn create(&self) -> Self::Node {
        DrawCommandNode::new(vec![self.command()])
    }

    fn update(&self, node: &mut Self::Node) {
        node.commands = vec![self.command()];
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::DRAW
    }
}

pub(crate) struct GraphicsLayerNode {
    layer: GraphicsLayer,
    layer_resolver: Option<Rc<dyn Fn() -> GraphicsLayer>>,
    node_id: Rc<Cell<Option<NodeId>>>,
    state: NodeState,
}

impl GraphicsLayerNode {
    pub(crate) fn new(layer: GraphicsLayer) -> Self {
        Self {
            layer,
            layer_resolver: None,
            node_id: Rc::new(Cell::new(None)),
            state: NodeState::new(),
        }
    }

    pub(crate) fn new_lazy(layer_resolver: Rc<dyn Fn() -> GraphicsLayer>) -> Self {
        Self {
            layer: GraphicsLayer::default(),
            layer_resolver: Some(layer_resolver),
            node_id: Rc::new(Cell::new(None)),
            state: NodeState::new(),
        }
    }

    #[cfg(test)]
    pub(crate) fn layer(&self) -> GraphicsLayer {
        if let Some(resolve) = self.layer_resolver(0) {
            resolve()
        } else {
            self.layer.clone()
        }
    }

    pub(crate) fn layer_snapshot(&self) -> GraphicsLayer {
        self.layer.clone()
    }

    pub(crate) fn layer_resolver(
        &self,
        modifier_index: usize,
    ) -> Option<Rc<dyn Fn() -> GraphicsLayer>> {
        self.layer_resolver.as_ref().map(|resolve| {
            let resolve = Rc::clone(resolve);
            let node_id = Rc::clone(&self.node_id);
            Rc::new(move || {
                if let Some(node_id) = node_id.get() {
                    let scope = crate::render_state::DrawObservationScope::layer_properties(
                        node_id,
                        modifier_index,
                    );
                    crate::render_state::observe_draw_reads(scope, || resolve())
                } else {
                    resolve()
                }
            }) as Rc<dyn Fn() -> GraphicsLayer>
        })
    }

    fn set_static(&mut self, layer: GraphicsLayer) {
        let changed = self.layer != layer || self.layer_resolver.is_some();
        self.layer = layer;
        self.layer_resolver = None;
        if changed && let Some(node_id) = self.node_id.get() {
            crate::render_state::schedule_draw_repass(node_id);
        }
    }

    pub(crate) fn set_lazy(&mut self, layer_resolver: Rc<dyn Fn() -> GraphicsLayer>) {
        let changed = self
            .layer_resolver
            .as_ref()
            .is_none_or(|current| !Rc::ptr_eq(current, &layer_resolver));
        self.layer_resolver = Some(layer_resolver);
        if changed && let Some(node_id) = self.node_id.get() {
            crate::render_state::schedule_draw_repass(node_id);
        }
    }
}

impl DelegatableNode for GraphicsLayerNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl ModifierNode for GraphicsLayerNode {
    fn on_attach(&mut self, context: &mut dyn ModifierNodeContext) {
        attach_draw_observer(&self.node_id, context);
    }

    fn on_detach(&mut self) {
        detach_draw_observer(&self.node_id);
    }
}

impl std::fmt::Debug for GraphicsLayerNode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("GraphicsLayerNode")
            .field("layer", &self.layer)
            .field("lazy", &self.layer_resolver.is_some())
            .finish()
    }
}

#[derive(Debug, Clone, PartialEq)]
pub(crate) struct GraphicsLayerElement {
    layer: GraphicsLayer,
}

impl GraphicsLayerElement {
    pub(crate) fn new(layer: GraphicsLayer) -> Self {
        Self { layer }
    }
}

impl Hash for GraphicsLayerElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        hash_graphics_layer(state, &self.layer);
    }
}

impl ModifierNodeElement for GraphicsLayerElement {
    type Node = GraphicsLayerNode;

    fn create(&self) -> Self::Node {
        GraphicsLayerNode::new(self.layer.clone())
    }

    fn update(&self, node: &mut Self::Node) {
        node.set_static(self.layer.clone());
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::DRAW
    }
}

#[derive(Clone)]
pub(crate) struct LazyGraphicsLayerElement {
    layer_resolver: Rc<dyn Fn() -> GraphicsLayer>,
}

impl LazyGraphicsLayerElement {
    pub(crate) fn new(layer_resolver: Rc<dyn Fn() -> GraphicsLayer>) -> Self {
        Self { layer_resolver }
    }
}

impl std::fmt::Debug for LazyGraphicsLayerElement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("LazyGraphicsLayerElement")
            .field("resolver", &"<closure>")
            .finish()
    }
}

impl PartialEq for LazyGraphicsLayerElement {
    fn eq(&self, other: &Self) -> bool {
        Rc::ptr_eq(&self.layer_resolver, &other.layer_resolver)
    }
}

impl Eq for LazyGraphicsLayerElement {}

impl Hash for LazyGraphicsLayerElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        let ptr = Rc::as_ptr(&self.layer_resolver) as *const ();
        ptr.hash(state);
    }
}

impl ModifierNodeElement for LazyGraphicsLayerElement {
    type Node = GraphicsLayerNode;

    fn create(&self) -> Self::Node {
        GraphicsLayerNode::new_lazy(Rc::clone(&self.layer_resolver))
    }

    fn update(&self, node: &mut Self::Node) {
        node.set_lazy(Rc::clone(&self.layer_resolver));
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::DRAW
    }

    fn always_update(&self) -> bool {
        true
    }

    fn auto_invalidate_on_update(&self) -> bool {
        false
    }
}

/// Node that enforces size constraints on its content.
///
/// Matches Kotlin: `SizeNode` in foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Size.kt
#[derive(Debug)]
pub struct SizeNode {
    min_width: Option<f32>,
    max_width: Option<f32>,
    min_height: Option<f32>,
    max_height: Option<f32>,
    enforce_incoming: bool,
    /// The bounds rounded to the device grid of the density they were last
    /// asked for: each measure asks again for the same.
    rounded: Cell<Option<(f32, Constraints)>>,
    state: NodeState,
}

impl SizeNode {
    /// Creates a node that limits its content to the given widths and heights, in logical pixels. A
    /// `None` bound is left open. When `enforce_incoming` is true, the incoming constraints take
    /// precedence over these bounds.
    pub fn new(
        min_width: Option<f32>,
        max_width: Option<f32>,
        min_height: Option<f32>,
        max_height: Option<f32>,
        enforce_incoming: bool,
    ) -> Self {
        Self {
            min_width,
            max_width,
            min_height,
            max_height,
            enforce_incoming,
            rounded: Cell::new(None),
            state: NodeState::new(),
        }
    }

    /// The constraints the sizes ask for, each on a whole device pixel of
    /// `density` as Compose's `SizeNode` rounds them.
    fn target_constraints(&self, density: f32) -> Constraints {
        if let Some((rounded_for, target)) = self.rounded.get()
            && rounded_for == density
        {
            return target;
        }
        let target = self.round_targets(density);
        self.rounded.set(Some((density, target)));
        target
    }

    fn round_targets(&self, density: f32) -> Constraints {
        use cranpose_ui_layout::round_to_px;

        let max_width = self
            .max_width
            .map_or(f32::INFINITY, |v| round_to_px(v, density).max(0.0));
        let max_height = self
            .max_height
            .map_or(f32::INFINITY, |v| round_to_px(v, density).max(0.0));

        let min_width = self.min_width.map_or(0.0, |v| {
            let clamped = round_to_px(v, density).clamp(0.0, max_width);
            if clamped == f32::INFINITY {
                0.0
            } else {
                clamped
            }
        });

        let min_height = self.min_height.map_or(0.0, |v| {
            let clamped = round_to_px(v, density).clamp(0.0, max_height);
            if clamped == f32::INFINITY {
                0.0
            } else {
                clamped
            }
        });

        Constraints {
            min_width,
            max_width,
            min_height,
            max_height,
        }
    }

    /// Returns the smallest width in logical pixels, or `None` for no minimum.
    pub fn min_width(&self) -> Option<f32> {
        self.min_width
    }

    /// Returns the largest width in logical pixels, or `None` for no maximum.
    pub fn max_width(&self) -> Option<f32> {
        self.max_width
    }

    /// Returns the smallest height in logical pixels, or `None` for no minimum.
    pub fn min_height(&self) -> Option<f32> {
        self.min_height
    }

    /// Returns the largest height in logical pixels, or `None` for no maximum.
    pub fn max_height(&self) -> Option<f32> {
        self.max_height
    }

    /// Returns whether the incoming constraints take precedence over these bounds.
    pub fn enforce_incoming(&self) -> bool {
        self.enforce_incoming
    }
}

impl DelegatableNode for SizeNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_layout_modifier_node!(SizeNode, invalidate = InvalidationKind::Layout);

impl LayoutModifierNode for SizeNode {
    fn measure_hold(
        &self,
        density: f32,
        _constraints: Constraints,
        size: Size,
        wrapped: cranpose_ui_layout::WrappedHold,
    ) -> Option<cranpose_ui_layout::ConstraintsHold> {
        if !self.enforce_incoming {
            return None;
        }
        let target = self.target_constraints(density);
        Some(cranpose_ui_layout::ConstraintsHold {
            width: size_axis_hold(
                (self.min_width, self.max_width),
                target.min_width,
                size.width,
                wrapped.hold.map(|hold| hold.width),
            )?,
            height: size_axis_hold(
                (self.min_height, self.max_height),
                target.min_height,
                size.height,
                wrapped.hold.map(|hold| hold.height),
            )?,
        })
    }

    fn measure(
        &self,
        context: &mut dyn ModifierNodeContext,
        measurable: &dyn Measurable,
        constraints: Constraints,
    ) -> cranpose_ui_layout::LayoutModifierMeasureResult {
        let target = self.target_constraints(context.density());

        let wrapped_constraints = if self.enforce_incoming {
            Constraints {
                min_width: target
                    .min_width
                    .max(constraints.min_width)
                    .min(constraints.max_width),
                max_width: target
                    .max_width
                    .min(constraints.max_width)
                    .max(constraints.min_width),
                min_height: target
                    .min_height
                    .max(constraints.min_height)
                    .min(constraints.max_height),
                max_height: target
                    .max_height
                    .min(constraints.max_height)
                    .max(constraints.min_height),
            }
        } else {
            let resolved_min_width = if self.min_width.is_some() {
                target.min_width
            } else {
                constraints.min_width.min(target.max_width)
            };
            let resolved_max_width = if self.max_width.is_some() {
                target.max_width
            } else {
                constraints.max_width.max(target.min_width)
            };
            let resolved_min_height = if self.min_height.is_some() {
                target.min_height
            } else {
                constraints.min_height.min(target.max_height)
            };
            let resolved_max_height = if self.max_height.is_some() {
                target.max_height
            } else {
                constraints.max_height.max(target.min_height)
            };

            Constraints {
                min_width: resolved_min_width,
                max_width: resolved_max_width,
                min_height: resolved_min_height,
                max_height: resolved_max_height,
            }
        };

        let placeable = measurable.measure(wrapped_constraints);
        let measured_width = placeable.width();
        let measured_height = placeable.height();

        let result_width = if self.min_width.is_some()
            && self.max_width.is_some()
            && self.min_width == self.max_width
            && target.min_width >= wrapped_constraints.min_width
            && target.min_width <= wrapped_constraints.max_width
        {
            target.min_width
        } else {
            measured_width
        };

        let result_height = if self.min_height.is_some()
            && self.max_height.is_some()
            && self.min_height == self.max_height
            && target.min_height >= wrapped_constraints.min_height
            && target.min_height <= wrapped_constraints.max_height
        {
            target.min_height
        } else {
            measured_height
        };

        cranpose_ui_layout::LayoutModifierMeasureResult::with_size(Size {
            width: result_width,
            height: result_height,
        })
    }

    fn min_intrinsic_width(&self, measurable: &dyn Measurable, height: f32, density: f32) -> f32 {
        size_intrinsic(
            self.target_constraints(density),
            SizeAxis::Width,
            self.enforce_incoming,
            height,
            |h| measurable.min_intrinsic_width(h),
        )
    }

    fn max_intrinsic_width(&self, measurable: &dyn Measurable, height: f32, density: f32) -> f32 {
        size_intrinsic(
            self.target_constraints(density),
            SizeAxis::Width,
            self.enforce_incoming,
            height,
            |h| measurable.max_intrinsic_width(h),
        )
    }

    fn min_intrinsic_height(&self, measurable: &dyn Measurable, width: f32, density: f32) -> f32 {
        size_intrinsic(
            self.target_constraints(density),
            SizeAxis::Height,
            self.enforce_incoming,
            width,
            |w| measurable.min_intrinsic_height(w),
        )
    }

    fn max_intrinsic_height(&self, measurable: &dyn Measurable, width: f32, density: f32) -> f32 {
        size_intrinsic(
            self.target_constraints(density),
            SizeAxis::Height,
            self.enforce_incoming,
            width,
            |w| measurable.max_intrinsic_height(w),
        )
    }
}

/// Element that creates and updates size nodes.
///
/// Matches Kotlin: `SizeElement` in foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Size.kt
#[derive(Debug, Clone, PartialEq)]
pub struct SizeElement {
    min_width: Option<f32>,
    max_width: Option<f32>,
    min_height: Option<f32>,
    max_height: Option<f32>,
    enforce_incoming: bool,
}

impl SizeElement {
    /// Creates an element that fixes the width and height, in logical pixels. A `None` length is
    /// left free. The incoming constraints take precedence.
    pub fn new(width: Option<f32>, height: Option<f32>) -> Self {
        Self {
            min_width: width,
            max_width: width,
            min_height: height,
            max_height: height,
            enforce_incoming: true,
        }
    }

    /// Creates an element with the given widths and heights, in logical pixels. A `None` bound is
    /// left open. When `enforce_incoming` is true, the incoming constraints take precedence over
    /// these bounds.
    pub fn with_constraints(
        min_width: Option<f32>,
        max_width: Option<f32>,
        min_height: Option<f32>,
        max_height: Option<f32>,
        enforce_incoming: bool,
    ) -> Self {
        Self {
            min_width,
            max_width,
            min_height,
            max_height,
            enforce_incoming,
        }
    }
}

impl Hash for SizeElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        hash_option_f32(state, self.min_width);
        hash_option_f32(state, self.max_width);
        hash_option_f32(state, self.min_height);
        hash_option_f32(state, self.max_height);
        self.enforce_incoming.hash(state);
    }
}

impl ModifierNodeElement for SizeElement {
    type Node = SizeNode;

    fn create(&self) -> Self::Node {
        SizeNode::new(
            self.min_width,
            self.max_width,
            self.min_height,
            self.max_height,
            self.enforce_incoming,
        )
    }

    fn update(&self, node: &mut Self::Node) {
        if node.min_width != self.min_width
            || node.max_width != self.max_width
            || node.min_height != self.min_height
            || node.max_height != self.max_height
            || node.enforce_incoming != self.enforce_incoming
        {
            node.min_width = self.min_width;
            node.max_width = self.max_width;
            node.min_height = self.min_height;
            node.max_height = self.max_height;
            node.enforce_incoming = self.enforce_incoming;
            node.rounded.set(None);
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::LAYOUT
    }

    fn update_invalidation_kind(&self) -> Option<InvalidationKind> {
        Some(InvalidationKind::Layout)
    }
}

#[derive(Debug)]
pub(crate) struct PointerIconNode {
    icon: PointerIcon,
    state: NodeState,
}

impl PointerIconNode {
    pub(crate) fn new(icon: PointerIcon) -> Self {
        Self {
            icon,
            state: NodeState::new(),
        }
    }

    pub(crate) fn icon(&self) -> &PointerIcon {
        &self.icon
    }
}

impl DelegatableNode for PointerIconNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl ModifierNode for PointerIconNode {
    fn on_attach(&mut self, context: &mut dyn ModifierNodeContext) {
        context.invalidate(InvalidationKind::PointerInput);
    }

    fn as_pointer_input_node(&self) -> Option<&dyn PointerInputNode> {
        Some(self)
    }

    fn as_pointer_input_node_mut(&mut self) -> Option<&mut dyn PointerInputNode> {
        Some(self)
    }
}

impl PointerInputNode for PointerIconNode {
    fn on_pointer_event(
        &mut self,
        _context: &mut dyn ModifierNodeContext,
        _event: &PointerEvent,
    ) -> bool {
        false
    }

    fn hit_test(&self, _x: f32, _y: f32) -> bool {
        true
    }

    fn pointer_input_handler(&self) -> Option<Rc<dyn Fn(PointerEvent)>> {
        None
    }
}

#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub(crate) struct PointerIconElement {
    icon: PointerIcon,
}

impl PointerIconElement {
    pub(crate) fn new(icon: PointerIcon) -> Self {
        Self { icon }
    }
}

impl ModifierNodeElement for PointerIconElement {
    type Node = PointerIconNode;

    fn create(&self) -> Self::Node {
        PointerIconNode::new(self.icon.clone())
    }

    fn update(&self, node: &mut Self::Node) {
        node.icon = self.icon.clone();
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::POINTER_INPUT
    }
}

/// Node that applies alpha transparency to its content.
#[derive(Debug)]
pub struct AlphaNode {
    alpha: f32,
    state: NodeState,
}

impl AlphaNode {
    /// Creates a node that draws its content at opacity `alpha`, clamped to the range 0.0 to 1.0.
    pub fn new(alpha: f32) -> Self {
        Self {
            alpha: alpha.clamp(0.0, 1.0),
            state: NodeState::new(),
        }
    }
}

impl DelegatableNode for AlphaNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_draw_modifier_node!(AlphaNode);

/// Element that creates and updates alpha nodes.
#[derive(Debug, Clone, PartialEq)]
pub struct AlphaElement {
    alpha: f32,
}

impl AlphaElement {
    /// Creates an element for a node that draws its content at opacity `alpha`, clamped to the
    /// range 0.0 to 1.0.
    pub fn new(alpha: f32) -> Self {
        Self {
            alpha: alpha.clamp(0.0, 1.0),
        }
    }
}

impl Hash for AlphaElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        hash_f32_value(state, self.alpha);
    }
}

impl ModifierNodeElement for AlphaElement {
    type Node = AlphaNode;

    fn create(&self) -> Self::Node {
        AlphaNode::new(self.alpha)
    }

    fn update(&self, node: &mut Self::Node) {
        let new_alpha = self.alpha.clamp(0.0, 1.0);
        if (node.alpha - new_alpha).abs() > f32::EPSILON {
            node.alpha = new_alpha;
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::DRAW
    }
}

#[derive(Debug)]
pub(crate) struct ClipToBoundsNode {
    state: NodeState,
}

impl ClipToBoundsNode {
    pub(crate) fn new() -> Self {
        Self {
            state: NodeState::new(),
        }
    }
}

impl DelegatableNode for ClipToBoundsNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_draw_modifier_node!(ClipToBoundsNode);

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(crate) struct ClipToBoundsElement;

impl ClipToBoundsElement {
    pub(crate) fn new() -> Self {
        Self
    }
}

impl ModifierNodeElement for ClipToBoundsElement {
    type Node = ClipToBoundsNode;

    fn create(&self) -> Self::Node {
        ClipToBoundsNode::new()
    }

    fn update(&self, _node: &mut Self::Node) {}

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::DRAW
    }
}

pub trait WindowRectSink {
    fn set(&self, coordinates: cranpose_ui_graphics::WindowCoordinates);
}

impl WindowRectSink for Cell<cranpose_ui_graphics::Rect> {
    fn set(&self, coordinates: cranpose_ui_graphics::WindowCoordinates) {
        Self::set(self, coordinates.bounds());
    }
}

impl WindowRectSink for Cell<cranpose_ui_graphics::WindowCoordinates> {
    fn set(&self, coordinates: cranpose_ui_graphics::WindowCoordinates) {
        Self::set(self, coordinates);
    }
}

struct StateWindowRectSink(cranpose_core::MutableState<cranpose_ui_graphics::Rect>);

impl WindowRectSink for StateWindowRectSink {
    fn set(&self, coordinates: cranpose_ui_graphics::WindowCoordinates) {
        self.0.set(coordinates.bounds());
    }
}

pub(crate) struct WindowRectReporterNode {
    sink: Rc<dyn WindowRectSink>,
    state: NodeState,
}

impl WindowRectReporterNode {
    pub(crate) fn new(sink: Rc<dyn WindowRectSink>) -> Self {
        Self {
            sink,
            state: NodeState::new(),
        }
    }

    pub(crate) fn window_rect_sink(&self) -> Rc<dyn WindowRectSink> {
        Rc::clone(&self.sink)
    }
}

impl DelegatableNode for WindowRectReporterNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_layout_modifier_node!(WindowRectReporterNode);

impl LayoutModifierNode for WindowRectReporterNode {
    fn measure(
        &self,
        _context: &mut dyn ModifierNodeContext,
        measurable: &dyn Measurable,
        constraints: Constraints,
    ) -> cranpose_ui_layout::LayoutModifierMeasureResult {
        measure_pass_through(measurable, constraints, |_| (0.0, 0.0))
    }
}

#[derive(Clone)]
pub(crate) struct WindowRectReporterElement {
    sink: Rc<dyn WindowRectSink>,
}

impl WindowRectReporterElement {
    pub(crate) fn new(sink: Rc<Cell<cranpose_ui_graphics::Rect>>) -> Self {
        Self { sink }
    }

    pub(crate) fn from_coordinates(
        sink: Rc<Cell<cranpose_ui_graphics::WindowCoordinates>>,
    ) -> Self {
        Self { sink }
    }

    pub(crate) fn from_state(
        sink: cranpose_core::MutableState<cranpose_ui_graphics::Rect>,
    ) -> Self {
        Self {
            sink: Rc::new(StateWindowRectSink(sink)),
        }
    }
}

impl std::fmt::Debug for WindowRectReporterElement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("WindowRectReporterElement").finish()
    }
}

impl PartialEq for WindowRectReporterElement {
    fn eq(&self, other: &Self) -> bool {
        Rc::ptr_eq(&self.sink, &other.sink)
    }
}

impl Eq for WindowRectReporterElement {}

impl Hash for WindowRectReporterElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        std::ptr::hash(Rc::as_ptr(&self.sink).cast::<()>(), state);
    }
}

impl_sink_reporter_element!(WindowRectReporterElement, WindowRectReporterNode);

pub(crate) struct SelectableTextNode {
    sink: Rc<crate::selection_container::SelectableGeometry>,
    state: NodeState,
}

impl SelectableTextNode {
    pub(crate) fn new(sink: Rc<crate::selection_container::SelectableGeometry>) -> Self {
        Self {
            sink,
            state: NodeState::new(),
        }
    }

    pub(crate) fn geometry(&self) -> &crate::selection_container::SelectableGeometry {
        &self.sink
    }
}

impl DelegatableNode for SelectableTextNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_layout_modifier_node!(SelectableTextNode);

impl LayoutModifierNode for SelectableTextNode {
    fn measure(
        &self,
        _context: &mut dyn ModifierNodeContext,
        measurable: &dyn Measurable,
        constraints: Constraints,
    ) -> cranpose_ui_layout::LayoutModifierMeasureResult {
        measure_pass_through(measurable, constraints, |_| (0.0, 0.0))
    }
}

#[derive(Clone)]
pub(crate) struct SelectableTextElement {
    sink: Rc<crate::selection_container::SelectableGeometry>,
}

impl SelectableTextElement {
    pub(crate) fn new(sink: Rc<crate::selection_container::SelectableGeometry>) -> Self {
        Self { sink }
    }
}

impl std::fmt::Debug for SelectableTextElement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SelectableTextElement").finish()
    }
}

impl PartialEq for SelectableTextElement {
    fn eq(&self, other: &Self) -> bool {
        Rc::ptr_eq(&self.sink, &other.sink)
    }
}

impl Eq for SelectableTextElement {}

impl Hash for SelectableTextElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        std::ptr::hash(Rc::as_ptr(&self.sink), state);
    }
}

impl_sink_reporter_element!(SelectableTextElement, SelectableTextNode);

pub(crate) trait SizeSink {
    fn set(&self, size: Size);
}

impl SizeSink for Cell<Size> {
    fn set(&self, size: Size) {
        Self::set(self, size);
    }
}

struct StateSizeSink(cranpose_core::MutableState<Size>);

impl SizeSink for StateSizeSink {
    fn set(&self, size: Size) {
        self.0.set(size);
    }
}

pub(crate) struct SizeReporterNode {
    sink: Rc<dyn SizeSink>,
    state: NodeState,
    #[cfg(debug_assertions)]
    oscillation: Cell<(Size, Size, u32)>,
}

impl SizeReporterNode {
    pub(crate) fn new(sink: Rc<dyn SizeSink>) -> Self {
        Self {
            sink,
            state: NodeState::new(),
            #[cfg(debug_assertions)]
            oscillation: Cell::new((Size::default(), Size::default(), 0)),
        }
    }

    #[cfg(debug_assertions)]
    fn check_oscillation(&self, size: Size) {
        const ALTERNATION_CEILING: u32 = 64;
        let (last, second_last, count) = self.oscillation.get();
        let count = if size == second_last && size != last {
            count + 1
        } else if size == last {
            count
        } else {
            0
        };
        assert!(
            count <= ALTERNATION_CEILING,
            "size-reactive feedback loop: this node's measured size has \
             alternated between {last:?} and {size:?} for {count} passes — \
             its content's size depends on the size it reports (the \
             onSizeChanged self-reference hazard). Break the cycle by making \
             the reported size feed only content that does not change this \
             node's own measured size."
        );
        self.oscillation.set((size, last, count));
    }
}

impl DelegatableNode for SizeReporterNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_layout_modifier_node!(SizeReporterNode);

impl LayoutModifierNode for SizeReporterNode {
    fn measure(
        &self,
        _context: &mut dyn ModifierNodeContext,
        measurable: &dyn Measurable,
        constraints: Constraints,
    ) -> cranpose_ui_layout::LayoutModifierMeasureResult {
        measure_pass_through(measurable, constraints, |size| {
            #[cfg(debug_assertions)]
            self.check_oscillation(size);
            self.sink.set(size);
            (0.0, 0.0)
        })
    }
}

#[derive(Clone)]
pub(crate) struct SizeReporterElement {
    sink: Rc<dyn SizeSink>,
}

impl SizeReporterElement {
    pub(crate) fn new(sink: Rc<Cell<Size>>) -> Self {
        Self { sink }
    }

    pub(crate) fn from_state(sink: cranpose_core::MutableState<Size>) -> Self {
        Self {
            sink: Rc::new(StateSizeSink(sink)),
        }
    }
}

impl std::fmt::Debug for SizeReporterElement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SizeReporterElement").finish()
    }
}

impl PartialEq for SizeReporterElement {
    fn eq(&self, other: &Self) -> bool {
        std::ptr::addr_eq(Rc::as_ptr(&self.sink), Rc::as_ptr(&other.sink))
    }
}

impl Hash for SizeReporterElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        (Rc::as_ptr(&self.sink) as *const () as usize).hash(state);
    }
}

impl_sink_reporter_element!(SizeReporterElement, SizeReporterNode);

pub(crate) struct DrawCommandNode {
    commands: Vec<DrawCommand>,
    node_id: Cell<Option<NodeId>>,
    state: NodeState,
}

impl DrawCommandNode {
    pub(crate) fn new(commands: Vec<DrawCommand>) -> Self {
        Self {
            commands,
            node_id: Cell::new(None),
            state: NodeState::new(),
        }
    }

    #[cfg(test)]
    pub(crate) fn commands(&self) -> &[DrawCommand] {
        &self.commands
    }

    pub(crate) fn observed_commands(
        &self,
        modifier_index: usize,
    ) -> impl Iterator<Item = DrawCommand> + '_ {
        let node_id = self.node_id.get();
        self.commands
            .iter()
            .cloned()
            .enumerate()
            .map(move |(index, command)| {
                observe_draw_command(command, node_id, modifier_index, index)
            })
    }
}

impl DelegatableNode for DrawCommandNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl ModifierNode for DrawCommandNode {
    fn on_attach(&mut self, context: &mut dyn ModifierNodeContext) {
        attach_draw_observer(&self.node_id, context);
    }

    fn on_detach(&mut self) {
        detach_draw_observer(&self.node_id);
    }

    fn as_draw_node(&self) -> Option<&dyn DrawModifierNode> {
        Some(self)
    }

    fn as_draw_node_mut(&mut self) -> Option<&mut dyn DrawModifierNode> {
        Some(self)
    }
}

impl DrawModifierNode for DrawCommandNode {}

fn observe_draw_command(
    command: DrawCommand,
    node_id: Option<NodeId>,
    modifier_index: usize,
    command_index: usize,
) -> DrawCommand {
    let Some(node_id) = node_id else {
        return command;
    };
    let observation =
        crate::render_state::DrawObservationScope::new(node_id, modifier_index, command_index);
    match command {
        DrawCommand::Behind(draw) => DrawCommand::Behind(Rc::new(move |scope| {
            crate::render_state::observe_draw_reads(observation, || draw(scope));
        })),
        DrawCommand::WithContent(draw) => DrawCommand::WithContent(Rc::new(move |scope| {
            crate::render_state::observe_draw_reads(observation, || draw(scope));
        })),
        DrawCommand::Overlay(draw) => DrawCommand::Overlay(Rc::new(move |scope| {
            crate::render_state::observe_draw_reads(observation, || draw(scope));
        })),
    }
}

fn draw_command_tag(cmd: &DrawCommand) -> u8 {
    match cmd {
        DrawCommand::Behind(_) => 0,
        DrawCommand::WithContent(_) => 1,
        DrawCommand::Overlay(_) => 2,
    }
}

fn draw_command_closure_identity(cmd: &DrawCommand) -> *const () {
    match cmd {
        DrawCommand::Behind(f) | DrawCommand::WithContent(f) | DrawCommand::Overlay(f) => {
            Rc::as_ptr(f) as *const ()
        }
    }
}

#[derive(Clone)]
pub(crate) struct DrawCommandElement {
    commands: Vec<DrawCommand>,
}

impl DrawCommandElement {
    pub(crate) fn new(command: DrawCommand) -> Self {
        Self {
            commands: vec![command],
        }
    }

    pub(crate) fn from_commands(commands: Vec<DrawCommand>) -> Self {
        Self { commands }
    }
}

impl std::fmt::Debug for DrawCommandElement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DrawCommandElement")
            .field("commands", &self.commands.len())
            .finish()
    }
}

impl PartialEq for DrawCommandElement {
    fn eq(&self, other: &Self) -> bool {
        if self.commands.len() != other.commands.len() {
            return false;
        }
        self.commands
            .iter()
            .zip(other.commands.iter())
            .all(|(a, b)| {
                draw_command_tag(a) == draw_command_tag(b)
                    && draw_command_closure_identity(a) == draw_command_closure_identity(b)
            })
    }
}

impl Eq for DrawCommandElement {}

impl Hash for DrawCommandElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        "draw_commands".hash(state);
        self.commands.len().hash(state);
        for command in &self.commands {
            draw_command_tag(command).hash(state);
            (draw_command_closure_identity(command) as usize).hash(state);
        }
    }
}

impl ModifierNodeElement for DrawCommandElement {
    type Node = DrawCommandNode;

    fn create(&self) -> Self::Node {
        DrawCommandNode::new(self.commands.clone())
    }

    fn update(&self, node: &mut Self::Node) {
        node.commands.clone_from(&self.commands);
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::DRAW
    }
}

/// Node that offsets its content by a fixed (x, y) amount.
///
/// Matches Kotlin: `OffsetNode` in foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Offset.kt
#[derive(Debug)]
pub struct OffsetNode {
    x: f32,
    y: f32,
    rtl_aware: bool,
    layout_direction: crate::LayoutDirection,
    state: NodeState,
}

impl OffsetNode {
    /// Creates a node that moves its content by `x` and `y`, in logical pixels. With `rtl_aware`
    /// set, a right-to-left layout direction mirrors `x`.
    pub fn new(x: f32, y: f32, rtl_aware: bool) -> Self {
        Self {
            x,
            y,
            rtl_aware,
            layout_direction: crate::LayoutDirection::Ltr,
            state: NodeState::new(),
        }
    }

    /// Returns the offset in logical pixels, with `x` mirrored when the node is RTL aware and the
    /// layout direction is right-to-left.
    pub fn offset(&self) -> Point {
        Point {
            x: if self.rtl_aware && self.layout_direction.is_rtl() {
                -self.x
            } else {
                self.x
            },
            y: self.y,
        }
    }

    /// The offset on a whole device pixel of `density`, where Compose's
    /// `OffsetNode` places its content.
    pub fn device_offset(&self, density: f32) -> Point {
        use cranpose_ui_layout::round_to_px;
        let offset = self.offset();
        Point {
            x: round_to_px(offset.x, density),
            y: round_to_px(offset.y, density),
        }
    }

    /// Returns whether a right-to-left layout direction mirrors `x`.
    pub fn rtl_aware(&self) -> bool {
        self.rtl_aware
    }

    pub(crate) fn set_layout_direction(&mut self, direction: crate::LayoutDirection) {
        self.layout_direction = direction;
    }
}

impl DelegatableNode for OffsetNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_layout_modifier_node!(OffsetNode, invalidate = InvalidationKind::Layout);

impl LayoutModifierNode for OffsetNode {
    fn measure_hold(
        &self,
        _density: f32,
        _constraints: Constraints,
        _size: Size,
        wrapped: cranpose_ui_layout::WrappedHold,
    ) -> Option<cranpose_ui_layout::ConstraintsHold> {
        wrapped.hold
    }

    fn measure(
        &self,
        context: &mut dyn ModifierNodeContext,
        measurable: &dyn Measurable,
        constraints: Constraints,
    ) -> cranpose_ui_layout::LayoutModifierMeasureResult {
        let offset = self.device_offset(context.density());
        measure_pass_through(measurable, constraints, |_| (offset.x, offset.y))
    }
}

/// Element that creates and updates offset nodes.
///
/// Matches Kotlin: `OffsetElement` in foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Offset.kt
#[derive(Debug, Clone, PartialEq)]
pub struct OffsetElement {
    x: f32,
    y: f32,
    rtl_aware: bool,
}

impl OffsetElement {
    /// Creates an element that moves content by `x` and `y`, in logical pixels. With `rtl_aware`
    /// set, a right-to-left layout direction mirrors `x`.
    pub fn new(x: f32, y: f32, rtl_aware: bool) -> Self {
        Self { x, y, rtl_aware }
    }
}

impl Hash for OffsetElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        hash_f32_value(state, self.x);
        hash_f32_value(state, self.y);
        self.rtl_aware.hash(state);
    }
}

impl ModifierNodeElement for OffsetElement {
    type Node = OffsetNode;

    fn create(&self) -> Self::Node {
        OffsetNode::new(self.x, self.y, self.rtl_aware)
    }

    fn update(&self, node: &mut Self::Node) {
        if node.x != self.x || node.y != self.y || node.rtl_aware != self.rtl_aware {
            node.x = self.x;
            node.y = self.y;
            node.rtl_aware = self.rtl_aware;
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::LAYOUT
    }

    fn update_invalidation_kind(&self) -> Option<InvalidationKind> {
        Some(InvalidationKind::Layout)
    }
}

/// Node that offsets its content by a fraction of its own measured size.
///
/// There is no direct Jetpack Compose modifier equivalent; Compose's slide
/// transitions receive the measured size through a lambda instead. This node
/// backs `slide_in_vertically` / `slide_out_vertically` in
/// `AnimatedVisibility`, where the offset is expressed as a fraction of the
/// content height.
#[derive(Debug)]
pub struct FractionalOffsetNode {
    x_fraction: f32,
    y_fraction: f32,
    state: NodeState,
}

impl FractionalOffsetNode {
    /// Creates a node that moves its content by `x_fraction` of its own width and `y_fraction` of
    /// its own height.
    pub fn new(x_fraction: f32, y_fraction: f32) -> Self {
        Self {
            x_fraction,
            y_fraction,
            state: NodeState::new(),
        }
    }

    /// Returns the fractions as a point: `x` is the share of the width and `y` the share of the
    /// height.
    pub fn fractions(&self) -> Point {
        Point {
            x: self.x_fraction,
            y: self.y_fraction,
        }
    }
}

impl DelegatableNode for FractionalOffsetNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_layout_modifier_node!(FractionalOffsetNode, invalidate = InvalidationKind::Layout);

impl LayoutModifierNode for FractionalOffsetNode {
    fn measure_hold(
        &self,
        _density: f32,
        _constraints: Constraints,
        _size: Size,
        wrapped: cranpose_ui_layout::WrappedHold,
    ) -> Option<cranpose_ui_layout::ConstraintsHold> {
        wrapped.hold
    }

    fn measure(
        &self,
        _context: &mut dyn ModifierNodeContext,
        measurable: &dyn Measurable,
        constraints: Constraints,
    ) -> cranpose_ui_layout::LayoutModifierMeasureResult {
        measure_pass_through(measurable, constraints, |size| {
            (self.x_fraction * size.width, self.y_fraction * size.height)
        })
    }
}

/// Element that creates and updates fractional offset nodes.
#[derive(Debug, Clone, PartialEq)]
pub struct FractionalOffsetElement {
    x_fraction: f32,
    y_fraction: f32,
}

impl FractionalOffsetElement {
    /// Creates an element for a node that moves its content by `x_fraction` of its own width and
    /// `y_fraction` of its own height.
    pub fn new(x_fraction: f32, y_fraction: f32) -> Self {
        Self {
            x_fraction,
            y_fraction,
        }
    }
}

impl Hash for FractionalOffsetElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        "fractional_offset".hash(state);
        hash_f32_value(state, self.x_fraction);
        hash_f32_value(state, self.y_fraction);
    }
}

impl ModifierNodeElement for FractionalOffsetElement {
    type Node = FractionalOffsetNode;

    fn create(&self) -> Self::Node {
        FractionalOffsetNode::new(self.x_fraction, self.y_fraction)
    }

    fn update(&self, node: &mut Self::Node) {
        if node.x_fraction != self.x_fraction || node.y_fraction != self.y_fraction {
            node.x_fraction = self.x_fraction;
            node.y_fraction = self.y_fraction;
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::LAYOUT
    }

    fn update_invalidation_kind(&self) -> Option<InvalidationKind> {
        Some(InvalidationKind::Layout)
    }
}

/// Direction for fill modifiers (horizontal, vertical, or both).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FillDirection {
    /// Fill the available width.
    Horizontal,
    /// Fill the available height.
    Vertical,
    /// Fill the available width and height.
    Both,
}

/// Node that fills the maximum available space in one or both dimensions.
///
/// Matches Kotlin: `FillNode` in foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Size.kt
#[derive(Debug)]
pub struct FillNode {
    direction: FillDirection,
    fraction: f32,
    state: NodeState,
}

impl FillNode {
    /// Creates a node that fills `fraction` of the available space along `direction`.
    pub fn new(direction: FillDirection, fraction: f32) -> Self {
        Self {
            direction,
            fraction,
            state: NodeState::new(),
        }
    }

    /// Returns the axes the node fills.
    pub fn direction(&self) -> FillDirection {
        self.direction
    }

    /// Returns the share of the available space the node fills, from 0.0 to 1.0.
    pub fn fraction(&self) -> f32 {
        self.fraction
    }

    /// The extent the content gets of a given `extent` across the axis that
    /// `other` fills: the filled fraction, unless only `other` fills.
    fn filled(&self, extent: f32, other: FillDirection, density: f32) -> f32 {
        if self.direction == other || !extent.is_finite() {
            return extent;
        }
        cranpose_ui_layout::round_to_px(extent * self.fraction, density)
    }
}

impl DelegatableNode for FillNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_layout_modifier_node!(FillNode, invalidate = InvalidationKind::Layout);

impl LayoutModifierNode for FillNode {
    /// A filled axis holds while the same max fills it the same; an axis
    /// the node leaves alone passes the bounds on and holds what its content
    /// holds.
    fn measure_hold(
        &self,
        density: f32,
        constraints: Constraints,
        size: Size,
        wrapped: cranpose_ui_layout::WrappedHold,
    ) -> Option<cranpose_ui_layout::ConstraintsHold> {
        Some(cranpose_ui_layout::ConstraintsHold {
            width: fill_axis_hold(
                self.direction != FillDirection::Vertical,
                (constraints.max_width, size.width),
                (self.fraction, density),
                wrapped.hold.map(|hold| hold.width),
            )?,
            height: fill_axis_hold(
                self.direction != FillDirection::Horizontal,
                (constraints.max_height, size.height),
                (self.fraction, density),
                wrapped.hold.map(|hold| hold.height),
            )?,
        })
    }

    fn measure(
        &self,
        context: &mut dyn ModifierNodeContext,
        measurable: &dyn Measurable,
        constraints: Constraints,
    ) -> cranpose_ui_layout::LayoutModifierMeasureResult {
        let density = context.density();
        let (fill_width, child_min_width, child_max_width) = if self.direction
            != FillDirection::Vertical
            && constraints.max_width != f32::INFINITY
        {
            let width =
                cranpose_ui_layout::round_to_px(constraints.max_width * self.fraction, density)
                    .clamp(constraints.min_width, constraints.max_width);
            (width, width, width)
        } else {
            (
                constraints.max_width,
                constraints.min_width,
                constraints.max_width,
            )
        };

        let (fill_height, child_min_height, child_max_height) = if self.direction
            != FillDirection::Horizontal
            && constraints.max_height != f32::INFINITY
        {
            let height =
                cranpose_ui_layout::round_to_px(constraints.max_height * self.fraction, density)
                    .clamp(constraints.min_height, constraints.max_height);
            (height, height, height)
        } else {
            (
                constraints.max_height,
                constraints.min_height,
                constraints.max_height,
            )
        };

        let fill_constraints = Constraints {
            min_width: child_min_width,
            max_width: child_max_width,
            min_height: child_min_height,
            max_height: child_max_height,
        };

        let placeable = measurable.measure(fill_constraints);

        let result_width = if self.direction != FillDirection::Vertical
            && constraints.max_width != f32::INFINITY
        {
            fill_width
        } else {
            placeable.width()
        };

        let result_height = if self.direction != FillDirection::Horizontal
            && constraints.max_height != f32::INFINITY
        {
            fill_height
        } else {
            placeable.height()
        };

        cranpose_ui_layout::LayoutModifierMeasureResult::with_size(Size {
            width: result_width,
            height: result_height,
        })
    }

    fn min_intrinsic_width(&self, measurable: &dyn Measurable, height: f32, density: f32) -> f32 {
        measurable.min_intrinsic_width(self.filled(height, FillDirection::Horizontal, density))
    }

    fn max_intrinsic_width(&self, measurable: &dyn Measurable, height: f32, density: f32) -> f32 {
        measurable.max_intrinsic_width(self.filled(height, FillDirection::Horizontal, density))
    }

    fn min_intrinsic_height(&self, measurable: &dyn Measurable, width: f32, density: f32) -> f32 {
        measurable.min_intrinsic_height(self.filled(width, FillDirection::Vertical, density))
    }

    fn max_intrinsic_height(&self, measurable: &dyn Measurable, width: f32, density: f32) -> f32 {
        measurable.max_intrinsic_height(self.filled(width, FillDirection::Vertical, density))
    }
}

/// Element that creates and updates fill nodes.
///
/// Matches Kotlin: `FillElement` in foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Size.kt
#[derive(Debug, Clone, PartialEq)]
pub struct FillElement {
    direction: FillDirection,
    fraction: f32,
}

impl FillElement {
    /// Creates an element that fills `fraction` of the available width.
    pub fn width(fraction: f32) -> Self {
        Self {
            direction: FillDirection::Horizontal,
            fraction,
        }
    }

    /// Creates an element that fills `fraction` of the available height.
    pub fn height(fraction: f32) -> Self {
        Self {
            direction: FillDirection::Vertical,
            fraction,
        }
    }

    /// Creates an element that fills `fraction` of the available width and height.
    pub fn size(fraction: f32) -> Self {
        Self {
            direction: FillDirection::Both,
            fraction,
        }
    }
}

impl Hash for FillElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.direction.hash(state);
        hash_f32_value(state, self.fraction);
    }
}

impl ModifierNodeElement for FillElement {
    type Node = FillNode;

    fn create(&self) -> Self::Node {
        FillNode::new(self.direction, self.fraction)
    }

    fn update(&self, node: &mut Self::Node) {
        if node.direction != self.direction || node.fraction != self.fraction {
            node.direction = self.direction;
            node.fraction = self.fraction;
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::LAYOUT
    }
}

#[derive(Debug)]
pub(crate) struct WeightNode {
    weight: f32,
    fill: bool,
    state: NodeState,
}

impl WeightNode {
    pub(crate) fn new(weight: f32, fill: bool) -> Self {
        Self {
            weight,
            fill,
            state: NodeState::new(),
        }
    }

    pub(crate) fn layout_weight(&self) -> LayoutWeight {
        LayoutWeight {
            weight: self.weight,
            fill: self.fill,
        }
    }
}

impl DelegatableNode for WeightNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl ModifierNode for WeightNode {
    fn on_attach(&mut self, context: &mut dyn ModifierNodeContext) {
        context.invalidate(InvalidationKind::Layout);
    }
}

#[derive(Debug, Clone, PartialEq)]
pub(crate) struct WeightElement {
    weight: f32,
    fill: bool,
}

impl WeightElement {
    pub(crate) fn new(weight: f32, fill: bool) -> Self {
        Self { weight, fill }
    }
}

impl Hash for WeightElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        hash_f32_value(state, self.weight);
        self.fill.hash(state);
    }
}

impl ModifierNodeElement for WeightElement {
    type Node = WeightNode;

    fn create(&self) -> Self::Node {
        WeightNode::new(self.weight, self.fill)
    }

    fn update(&self, node: &mut Self::Node) {
        if node.weight != self.weight || node.fill != self.fill {
            node.weight = self.weight;
            node.fill = self.fill;
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::LAYOUT
    }
}

#[derive(Debug)]
pub(crate) struct AlignmentNode {
    box_alignment: Option<Alignment>,
    column_alignment: Option<HorizontalAlignment>,
    row_alignment: Option<VerticalAlignment>,
    row_baseline: bool,
    state: NodeState,
}

impl AlignmentNode {
    pub(crate) fn new(
        box_alignment: Option<Alignment>,
        column_alignment: Option<HorizontalAlignment>,
        row_alignment: Option<VerticalAlignment>,
        row_baseline: bool,
    ) -> Self {
        Self {
            box_alignment,
            column_alignment,
            row_alignment,
            row_baseline,
            state: NodeState::new(),
        }
    }

    pub(crate) fn box_alignment(&self) -> Option<Alignment> {
        self.box_alignment
    }

    pub(crate) fn column_alignment(&self) -> Option<HorizontalAlignment> {
        self.column_alignment
    }

    pub(crate) fn row_alignment(&self) -> Option<VerticalAlignment> {
        self.row_alignment
    }

    pub(crate) fn row_baseline(&self) -> bool {
        self.row_baseline
    }
}

impl DelegatableNode for AlignmentNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl ModifierNode for AlignmentNode {
    fn on_attach(&mut self, context: &mut dyn ModifierNodeContext) {
        context.invalidate(InvalidationKind::Layout);
    }
}

#[derive(Debug, Clone, PartialEq)]
pub(crate) struct AlignmentElement {
    box_alignment: Option<Alignment>,
    column_alignment: Option<HorizontalAlignment>,
    row_alignment: Option<VerticalAlignment>,
    row_baseline: bool,
}

impl AlignmentElement {
    pub(crate) fn box_alignment(alignment: Alignment) -> Self {
        Self {
            box_alignment: Some(alignment),
            column_alignment: None,
            row_alignment: None,
            row_baseline: false,
        }
    }

    pub(crate) fn column_alignment(alignment: HorizontalAlignment) -> Self {
        Self {
            box_alignment: None,
            column_alignment: Some(alignment),
            row_alignment: None,
            row_baseline: false,
        }
    }

    pub(crate) fn row_alignment(alignment: VerticalAlignment) -> Self {
        Self {
            box_alignment: None,
            column_alignment: None,
            row_alignment: Some(alignment),
            row_baseline: false,
        }
    }

    pub(crate) fn row_baseline() -> Self {
        Self {
            box_alignment: None,
            column_alignment: None,
            row_alignment: None,
            row_baseline: true,
        }
    }
}

impl Hash for AlignmentElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        if let Some(alignment) = self.box_alignment {
            state.write_u8(1);
            hash_alignment(state, alignment);
        } else {
            state.write_u8(0);
        }
        if let Some(alignment) = self.column_alignment {
            state.write_u8(1);
            hash_horizontal_alignment(state, alignment);
        } else {
            state.write_u8(0);
        }
        if let Some(alignment) = self.row_alignment {
            state.write_u8(1);
            hash_vertical_alignment(state, alignment);
        } else {
            state.write_u8(0);
        }
        self.row_baseline.hash(state);
    }
}

impl ModifierNodeElement for AlignmentElement {
    type Node = AlignmentNode;

    fn create(&self) -> Self::Node {
        AlignmentNode::new(
            self.box_alignment,
            self.column_alignment,
            self.row_alignment,
            self.row_baseline,
        )
    }

    fn update(&self, node: &mut Self::Node) {
        if node.box_alignment != self.box_alignment {
            node.box_alignment = self.box_alignment;
        }
        if node.column_alignment != self.column_alignment {
            node.column_alignment = self.column_alignment;
        }
        if node.row_alignment != self.row_alignment {
            node.row_alignment = self.row_alignment;
        }
        node.row_baseline = self.row_baseline;
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::LAYOUT
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum IntrinsicAxis {
    Width,
    Height,
}

#[derive(Debug)]
pub(crate) struct IntrinsicSizeNode {
    axis: IntrinsicAxis,
    size: IntrinsicSize,
    state: NodeState,
}

impl IntrinsicSizeNode {
    pub(crate) fn new(axis: IntrinsicAxis, size: IntrinsicSize) -> Self {
        Self {
            axis,
            size,
            state: NodeState::new(),
        }
    }

    /// The content's min or max intrinsic size along this node's axis, at
    /// the other axis' limit. Matches Kotlin: `calculateContentConstraints`
    /// in foundation-layout's `Intrinsic.kt`.
    fn content_extent(&self, measurable: &dyn Measurable, constraints: Constraints) -> f32 {
        let extent = match (self.axis, self.size) {
            (IntrinsicAxis::Width, IntrinsicSize::Min) => {
                measurable.min_intrinsic_width(constraints.max_height)
            }
            (IntrinsicAxis::Width, IntrinsicSize::Max) => {
                measurable.max_intrinsic_width(constraints.max_height)
            }
            (IntrinsicAxis::Height, IntrinsicSize::Min) => {
                measurable.min_intrinsic_height(constraints.max_width)
            }
            (IntrinsicAxis::Height, IntrinsicSize::Max) => {
                measurable.max_intrinsic_height(constraints.max_width)
            }
        };
        extent.max(0.0)
    }

    /// Along its own axis the node reports the one intrinsic size it lays
    /// out at, for both min and max; across it the content's pass through.
    fn intrinsic_width(&self, measurable: &dyn Measurable, height: f32) -> Option<f32> {
        (self.axis == IntrinsicAxis::Width).then(|| match self.size {
            IntrinsicSize::Min => measurable.min_intrinsic_width(height),
            IntrinsicSize::Max => measurable.max_intrinsic_width(height),
        })
    }

    fn intrinsic_height(&self, measurable: &dyn Measurable, width: f32) -> Option<f32> {
        (self.axis == IntrinsicAxis::Height).then(|| match self.size {
            IntrinsicSize::Min => measurable.min_intrinsic_height(width),
            IntrinsicSize::Max => measurable.max_intrinsic_height(width),
        })
    }
}

impl DelegatableNode for IntrinsicSizeNode {
    fn node_state(&self) -> &NodeState {
        &self.state
    }
}

impl_layout_modifier_node!(IntrinsicSizeNode, invalidate = InvalidationKind::Layout);

/// Measures the content at its intrinsic size along the node's axis, kept
/// within the incoming constraints, and leaves the other axis as it came.
/// Matches Kotlin: `IntrinsicWidthNode` and `IntrinsicHeightNode` with
/// `enforceIncoming = true`.
impl LayoutModifierNode for IntrinsicSizeNode {
    fn measure(
        &self,
        _context: &mut dyn ModifierNodeContext,
        measurable: &dyn Measurable,
        constraints: Constraints,
    ) -> cranpose_ui_layout::LayoutModifierMeasureResult {
        let extent = self.content_extent(measurable, constraints);
        let content = match self.axis {
            IntrinsicAxis::Width => {
                let width = extent.max(constraints.min_width).min(constraints.max_width);
                Constraints {
                    min_width: width,
                    max_width: width,
                    ..constraints
                }
            }
            IntrinsicAxis::Height => {
                let height = extent
                    .max(constraints.min_height)
                    .min(constraints.max_height);
                Constraints {
                    min_height: height,
                    max_height: height,
                    ..constraints
                }
            }
        };
        let placeable = measurable.measure(content);
        cranpose_ui_layout::LayoutModifierMeasureResult::with_size(Size {
            width: placeable.width(),
            height: placeable.height(),
        })
    }

    fn min_intrinsic_width(&self, measurable: &dyn Measurable, height: f32, _density: f32) -> f32 {
        self.intrinsic_width(measurable, height)
            .unwrap_or_else(|| measurable.min_intrinsic_width(height))
    }

    fn max_intrinsic_width(&self, measurable: &dyn Measurable, height: f32, _density: f32) -> f32 {
        self.intrinsic_width(measurable, height)
            .unwrap_or_else(|| measurable.max_intrinsic_width(height))
    }

    fn min_intrinsic_height(&self, measurable: &dyn Measurable, width: f32, _density: f32) -> f32 {
        self.intrinsic_height(measurable, width)
            .unwrap_or_else(|| measurable.min_intrinsic_height(width))
    }

    fn max_intrinsic_height(&self, measurable: &dyn Measurable, width: f32, _density: f32) -> f32 {
        self.intrinsic_height(measurable, width)
            .unwrap_or_else(|| measurable.max_intrinsic_height(width))
    }
}

#[derive(Debug, Clone, PartialEq)]
pub(crate) struct IntrinsicSizeElement {
    axis: IntrinsicAxis,
    size: IntrinsicSize,
}

impl IntrinsicSizeElement {
    pub(crate) fn width(size: IntrinsicSize) -> Self {
        Self {
            axis: IntrinsicAxis::Width,
            size,
        }
    }

    pub(crate) fn height(size: IntrinsicSize) -> Self {
        Self {
            axis: IntrinsicAxis::Height,
            size,
        }
    }
}

impl Hash for IntrinsicSizeElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        state.write_u8(match self.axis {
            IntrinsicAxis::Width => 0,
            IntrinsicAxis::Height => 1,
        });
        state.write_u8(match self.size {
            IntrinsicSize::Min => 0,
            IntrinsicSize::Max => 1,
        });
    }
}

impl ModifierNodeElement for IntrinsicSizeElement {
    type Node = IntrinsicSizeNode;

    fn create(&self) -> Self::Node {
        IntrinsicSizeNode::new(self.axis, self.size)
    }

    fn update(&self, node: &mut Self::Node) {
        if node.axis != self.axis {
            node.axis = self.axis;
        }
        if node.size != self.size {
            node.size = self.size;
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::LAYOUT
    }
}

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