orinium_browser/engine/input/

mod.rs

//! 入力処理とヒットテスト。クリック位置の要素判定を行う。

use std::sync::Arc;

use crate::engine::layouter::types::TextFlowStyle;

use super::layouter::types::{ContainerStyle, InfoNode, NodeKind, TextStyle};
use super::renderer_model::{AffineTransform, StickyViewport, is_scrollport, sticky_offset};
use super::ui::PointerEvent;
use super::ui::custom_node::CustomNode;
use super::ui::input_text_types::InputTextEvent;
use ui_layout::{BoxModel, LayoutNode, Position};
/// ヒットしたノード情報
#[derive(Clone, Debug)]
pub struct HitItem<'a> {
    pub layout: &'a LayoutNode,
    pub info: &'a InfoNode,
}

/// ヒットパス（子→親の順）
pub type HitPath<'a> = Vec<HitItem<'a>>;

/// Returns the innermost custom node on a hit path, if any.
///
/// The hit path is ordered child→parent, so the first `Custom` node found is
/// the deepest node under the pointer.
pub fn hit_custom_node<'a>(path: &'a HitPath<'a>) -> Option<&'a Arc<dyn CustomNode>> {
    path.iter().find_map(|hit| match &hit.info.kind {
        NodeKind::Custom { node, .. } => Some(node),
        _ => None,
    })
}

/// Returns the innermost DOM node id on a hit path, if any.
///
/// The hit path is ordered child→parent, so the first node carrying a
/// [`InfoNode::dom_id`] is the deepest DOM-backed element under the pointer.
pub fn hit_dom_id(path: &HitPath<'_>) -> Option<u32> {
    path.iter().find_map(|hit| hit.info.dom_id)
}

/// Returns the root-to-target DOM node id path for the hit, if any.
///
/// The path is derived from the hit path (innermost first) and contains every
/// DOM-backed node id from root to the hit target, preserving ancestor
/// propagation for pseudo-classes such as `:hover` and `:active`.
pub fn hit_dom_path(path: &HitPath<'_>) -> Vec<u32> {
    let mut out: Vec<u32> = path
        .iter()
        .rev()
        .filter_map(|hit| hit.info.dom_id)
        .collect();
    out.dedup();
    out
}

fn is_inline(layout: &LayoutNode) -> bool {
    matches!(layout.layout_box, ui_layout::LayoutBox::InlineBox(_))
}

fn is_inline_container(layout: &LayoutNode, info: &InfoNode) -> bool {
    is_inline(layout) && matches!(&info.kind, NodeKind::Container { .. })
}

fn node_style(info: &InfoNode) -> ContainerStyle {
    match &info.kind {
        NodeKind::Container { style, .. }
        | NodeKind::Custom { style, .. }
        | NodeKind::Svg { style, .. } => style.clone(),
        _ => ContainerStyle::default(),
    }
}

fn establishes_inline_box_space(layout: &LayoutNode) -> bool {
    is_inline(layout)
        && layout.style.display.outer() == Some(ui_layout::OuterDisplay::Inline)
        && layout.style.display.inner() == Some(ui_layout::InnerDisplay::FlowRoot)
}

fn child_viewport(
    layout: &LayoutNode,
    info: &InfoNode,
    parent_viewport: StickyViewport,
    is_root: bool,
) -> StickyViewport {
    if is_root || is_scrollport(&info.kind) {
        let bm = layout.layout_box.iter().next();
        let (scroll_x, scroll_y) = info.kind.scroll_offsets();
        StickyViewport {
            top_left: bm.as_ref().map_or((0.0, 0.0), |b| {
                (
                    b.padding_box.x - b.content_box.x - scroll_x,
                    b.padding_box.y - b.content_box.y + scroll_y,
                )
            }),
            size: if is_root {
                parent_viewport.size
            } else {
                bm.map_or(parent_viewport.size, |b| {
                    (b.padding_box.width, b.padding_box.height)
                })
            },
        }
    } else {
        let bm = layout.layout_box.iter().next();
        StickyViewport {
            top_left: bm.map_or(parent_viewport.top_left, |b| {
                (
                    parent_viewport.top_left.0 - b.content_box.x,
                    parent_viewport.top_left.1 - b.content_box.y,
                )
            }),
            size: parent_viewport.size,
        }
    }
}

fn child_containing(layout: &LayoutNode, parent_containing: (f32, f32)) -> (f32, f32) {
    layout
        .layout_box
        .iter()
        .next()
        .map_or(parent_containing, |b| {
            (b.content_box.width, b.content_box.height)
        })
}

fn element_transform(
    style: &ContainerStyle,
    border_box: &ui_layout::Rect,
) -> Option<AffineTransform> {
    let t = style.transform?;
    if t == AffineTransform::identity() {
        return None;
    }
    let center_x = border_box.width / 2.0;
    let center_y = border_box.height / 2.0;
    Some(
        AffineTransform::translate(center_x, center_y)
            .then(&t)
            .then(&AffineTransform::translate(-center_x, -center_y)),
    )
}

/// Maps a point from a box's parent-content space into the space where the
/// box's children/custom content live, mirroring renderer `push_box_model`
/// transform order (border translate, element CSS transform, content translate,
/// scroll translate). Returns `None` when the point is outside the box's
/// interactive padding box in visual space or when a transform is
/// non-invertible.
fn map_to_box_local(
    point: (f32, f32),
    box_model: &BoxModel,
    style: &ContainerStyle,
    scroll: (f32, f32),
    is_inline_box: bool,
) -> Option<(f32, f32)> {
    let mut p = point;
    if !is_inline_box {
        // border translate
        p.0 -= box_model.border_box.x;
        p.1 -= box_model.border_box.y;
        // element CSS transform (centered in border-box space)
        if let Some(t) = element_transform(style, &box_model.border_box) {
            let inv = t.inverse()?;
            p = inv.apply(p.0, p.1);
        }
    }
    // padding-box hit area in this (possibly transformed) border-box-local space
    let rect = if is_inline_box {
        box_model.padding_box
    } else {
        ui_layout::Rect {
            x: box_model.padding_box.x - box_model.border_box.x,
            y: box_model.padding_box.y - box_model.border_box.y,
            width: box_model.padding_box.width,
            height: box_model.padding_box.height,
        }
    };
    if p.0 < rect.x || p.1 < rect.y || p.0 > rect.x + rect.width || p.1 > rect.y + rect.height {
        return None;
    }
    if is_inline_box {
        Some(p)
    } else {
        // content translate + scroll translate
        let dx = box_model.content_box.x - box_model.border_box.x;
        let dy = box_model.content_box.y - box_model.border_box.y;
        Some((p.0 - dx + scroll.0, p.1 - dy + scroll.1))
    }
}

/// Map a point into a custom node's content-box local space for
/// pointer/popup dispatch, including border/content/scroll/transform but not
/// padding-box hit rejection (caller decides containment).
fn map_to_content_local(
    point: (f32, f32),
    box_model: &BoxModel,
    style: &ContainerStyle,
    scroll: (f32, f32),
) -> Option<(f32, f32)> {
    let mut p = point;
    p.0 -= box_model.border_box.x;
    p.1 -= box_model.border_box.y;
    if let Some(t) = element_transform(style, &box_model.border_box) {
        let inv = t.inverse()?;
        p = inv.apply(p.0, p.1);
    }
    let dx = box_model.content_box.x - box_model.border_box.x;
    let dy = box_model.content_box.y - box_model.border_box.y;
    p.0 = p.0 - dx + scroll.0;
    p.1 = p.1 - dy + scroll.1;
    Some(p)
}

/// Converts page-space pointer coordinates into the local content-box space of
/// the custom node at `path[target]`.
///
/// Mirrors renderer traversal/order: fixed scroll cancellation, sticky offsets,
/// border/content/scroll transforms and CSS element transforms.
fn local_pointer_coords(path: &HitPath<'_>, target: usize, x: f32, y: f32) -> (f32, f32) {
    let mut p = (x, y);
    let mut accumulated_scroll = (0.0f32, 0.0f32);
    let mut viewport = StickyViewport {
        top_left: (0.0, 0.0),
        size: (f32::INFINITY, f32::INFINITY),
    };
    let mut containing = (f32::INFINITY, f32::INFINITY);
    if let Some(root) = path.last() {
        let size = root
            .layout
            .layout_box
            .iter()
            .next()
            .map_or((f32::INFINITY, f32::INFINITY), |b| {
                (b.content_box.width, b.content_box.height)
            });
        let (sx, sy) = root.info.kind.scroll_offsets();
        viewport = StickyViewport {
            top_left: (-sx, sy),
            size,
        };
        containing = size;
    }

    // Walk root -> ... -> target, transforming `p` into each level's space.
    for step in 0..path.len() {
        let index = path.len() - 1 - step; // root-first
        if index < target {
            break;
        }
        let hit = &path[index];
        let is_root = step == 0;
        let is_fixed = hit.layout.style.position.kind == Position::Fixed;
        let is_sticky = hit.layout.style.position.kind == Position::Sticky;
        let shares_parent_layout =
            index + 1 < path.len() && std::ptr::eq(hit.layout, path[index + 1].layout);
        let inline_container = is_inline_container(hit.layout, hit.info);

        if is_fixed {
            p.0 -= accumulated_scroll.0;
            p.1 -= accumulated_scroll.1;
        }
        if is_sticky
            && !is_fixed
            && let Some(bm) = hit.layout.layout_box.iter().next()
            && let Some(edges) = bm.sticky_edges
        {
            let (dx, dy) = sticky_offset(&edges, &bm.border_box, viewport, containing);
            p.0 -= dx;
            p.1 -= dy;
        }

        let own_scroll = hit.info.kind.scroll_offsets();
        let style = node_style(hit.info);

        if index == target {
            if !shares_parent_layout
                && !inline_container
                && let Some(bm) = hit.layout.layout_box.iter().next()
                && let Some(lp) = map_to_content_local(p, &bm, &style, own_scroll)
            {
                p = lp;
            }
            return p;
        }

        // Descend into this node's child space.
        if !shares_parent_layout
            && !inline_container
            && let Some(bm) = hit.layout.layout_box.iter().next()
            && let Some(lp) = map_to_content_local(p, &bm, &style, own_scroll)
        {
            p = lp;
        }

        let next_index = index - 1;
        if next_index < target {
            break;
        }
        let next = &path[next_index];
        let next_shares = std::ptr::eq(next.layout, hit.layout);
        if !next_shares && establishes_inline_box_space(hit.layout) && inline_container {
            // flow-root inline container: renderer translates descendants by box X offset
            if let Some(bm) = hit.layout.layout_box.iter().next() {
                p.0 -= bm.content_box.x;
            }
        }

        let child_scroll = if is_fixed {
            own_scroll
        } else {
            (
                accumulated_scroll.0 + own_scroll.0,
                accumulated_scroll.1 + own_scroll.1,
            )
        };
        viewport = child_viewport(hit.layout, hit.info, viewport, is_root);
        containing = child_containing(hit.layout, containing);
        accumulated_scroll = child_scroll;
        let _ = next;
    }

    p
}

/// Dispatches a pointer event to the innermost custom node on the hit path.
///
/// Event coordinates are translated from page space into the node's local
/// content-box space before delivery.
pub fn dispatch_pointer(path: &HitPath<'_>, event: PointerEvent) -> bool {
    for (target, hit) in path.iter().enumerate() {
        if let NodeKind::Custom {
            node,
            text_style,
            text_flow_style,
            ..
        } = &hit.info.kind
        {
            let (px, py) = match event {
                PointerEvent::Move { x, y } => (x, y),
                PointerEvent::Down { x, y } => (x, y),
                PointerEvent::Up { x, y } => (x, y),
                PointerEvent::Leave => (0.0, 0.0), // no coordinates for Leave
            };
            let (lx, ly) = local_pointer_coords(path, target, px, py);
            let local_event = match event {
                PointerEvent::Move { .. } => PointerEvent::Move { x: lx, y: ly },
                PointerEvent::Down { .. } => PointerEvent::Down { x: lx, y: ly },
                PointerEvent::Up { .. } => PointerEvent::Up { x: lx, y: ly },
                PointerEvent::Leave => PointerEvent::Leave,
            };

            // An open popup intercepts pointer events over it. Its rect is in
            // the same content-box space as the local coordinates.
            if let Some(popup) = node.popup(text_style, text_flow_style) {
                let in_popup = lx >= popup.rect.x
                    && ly >= popup.rect.y
                    && lx <= popup.rect.x + popup.rect.width
                    && ly <= popup.rect.y + popup.rect.height;
                // Popup events are expressed relative to the popup's own
                // top-left corner (`popup.rect` origin).
                let popup_event = match local_event {
                    PointerEvent::Move { x, y } => PointerEvent::Move {
                        x: x - popup.rect.x,
                        y: y - popup.rect.y,
                    },
                    PointerEvent::Down { x, y } => PointerEvent::Down {
                        x: x - popup.rect.x,
                        y: y - popup.rect.y,
                    },
                    PointerEvent::Up { x, y } => PointerEvent::Up {
                        x: x - popup.rect.x,
                        y: y - popup.rect.y,
                    },
                    PointerEvent::Leave => PointerEvent::Leave,
                };

                if in_popup {
                    return node.on_popup_pointer_event(popup_event);
                }
            }
            return node.on_pointer_event(local_event);
        }
    }
    false
}

/// Dismisses every open popup whose owner is not under the pointer press.
///
/// Implements top-layer dismissal: a press whose hit path already contains a
/// popup's owner is that owner's responsibility (the event is routed to the
/// popup, or to the owning box which closes it), while every other open popup
/// is closed. Returns whether any popup was dismissed.
pub fn dismiss_open_popups(info: &InfoNode, path: &HitPath<'_>, px: f32, py: f32) -> bool {
    let mut dismissed = false;
    dismiss_open_popups_inner(info, path, px, py, &mut dismissed);
    dismissed
}

fn dismiss_open_popups_inner(
    info: &InfoNode,
    path: &HitPath<'_>,
    px: f32,
    py: f32,
    dismissed: &mut bool,
) {
    if let NodeKind::Custom { node, .. } = &info.kind
        && let Some(popup) = node.popup(&TextStyle::default(), &TextFlowStyle::default())
    {
        let owner_in_path = path.iter().any(|hit| {
            matches!(&hit.info.kind, NodeKind::Custom { node: owner, .. } if Arc::ptr_eq(node, owner))
        });
        let press_in_popup = if let Some((target, _)) = path.iter().enumerate().find(|(_, hit)| {
            matches!(&hit.info.kind, NodeKind::Custom { node: owner, .. } if Arc::ptr_eq(node, owner))
        }) {
            let (lx, ly) = local_pointer_coords(path, target, px, py);
            lx >= popup.rect.x
                && ly >= popup.rect.y
                && lx <= popup.rect.x + popup.rect.width
                && ly <= popup.rect.y + popup.rect.height
        } else {
            false
        };
        if !owner_in_path && !press_in_popup {
            node.dismiss_popup();
            *dismissed = true;
        }
    }
    for child in &info.children {
        dismiss_open_popups_inner(child, path, px, py, dismissed);
    }
}

/// Updates the hover state of custom nodes after a pointer move.
///
/// Clears hover from the previously hovered node (if different) and sets it on
/// the node under the pointer. Returns whether the hover target changed.
pub fn update_hover(path: &HitPath<'_>, previous: Option<&Arc<dyn CustomNode>>) -> bool {
    let current = hit_custom_node(path);
    match (previous, current) {
        (Some(prev), Some(curr)) if Arc::ptr_eq(prev, curr) => false,
        (Some(prev), _) => {
            prev.set_hovered(false);
            if let Some(curr) = current {
                curr.set_hovered(true);
            }
            true
        }
        (None, Some(curr)) => {
            curr.set_hovered(true);
            true
        }
        (None, None) => false,
    }
}

pub fn hit_test<'a>(layout: &'a LayoutNode, info: &'a InfoNode, x: f32, y: f32) -> HitPath<'a> {
    // Open popups are top-layer overlays: they render above every box and
    // escape all ancestor clips, so they are tested first and shadow the box
    // tree at their position.
    if let Some(path) = hit_test_popup(layout, info, x, y) {
        return path;
    }
    let size = layout
        .layout_box
        .iter()
        .next()
        .map_or((f32::INFINITY, f32::INFINITY), |b| {
            (b.content_box.width, b.content_box.height)
        });
    let (sx, sy) = info.kind.scroll_offsets();
    let root_viewport = StickyViewport {
        top_left: (-sx, sy),
        size,
    };
    hit_test_inner(layout, info, (x, y), (0.0, 0.0), root_viewport, size, true)
}

#[allow(clippy::too_many_arguments)]
fn hit_test_inner<'a>(
    layout: &'a LayoutNode,
    info: &'a InfoNode,
    point: (f32, f32),
    accumulated_scroll: (f32, f32),
    viewport: StickyViewport,
    containing: (f32, f32),
    is_root: bool,
) -> HitPath<'a> {
    if layout.layout_box.is_empty() {
        return Vec::new();
    }

    let inline = is_inline(layout);
    let inline_container = is_inline_container(layout, info);

    let is_fixed = layout.style.position.kind == Position::Fixed;
    let mut p = point;
    if is_fixed {
        p.0 -= accumulated_scroll.0;
        p.1 -= accumulated_scroll.1;
    }
    let is_sticky = layout.style.position.kind == Position::Sticky;
    let mut sticky_shift = (0.0, 0.0);
    if is_sticky
        && !is_fixed
        && let Some(bm) = layout.layout_box.iter().next()
        && let Some(edges) = bm.sticky_edges
    {
        sticky_shift = sticky_offset(&edges, &bm.border_box, viewport, containing);
        p.0 -= sticky_shift.0;
        p.1 -= sticky_shift.1;
    }

    let own_scroll = info.kind.scroll_offsets();
    let child_scroll = if is_fixed {
        own_scroll
    } else {
        (
            accumulated_scroll.0 + own_scroll.0,
            accumulated_scroll.1 + own_scroll.1,
        )
    };
    let child_vp = child_viewport(layout, info, viewport, is_root);
    let child_cont = child_containing(layout, containing);
    let style = node_style(info);

    // Walk boxes in reverse (front to back).
    let boxes: Vec<_> = layout.layout_box.iter().collect();
    for box_model in boxes.into_iter().rev() {
        let Some((local_x, local_y)) = map_to_box_local(p, &box_model, &style, own_scroll, inline)
        else {
            continue;
        };

        // Inline containers push no transform and live in parent's coordinates.
        let mut child_x = if inline_container { p.0 } else { local_x };
        let child_y = if inline_container { p.1 } else { local_y };

        if establishes_inline_box_space(layout) && !inline_container {
            child_x -= box_model.content_box.x;
        }

        // 3. Children in front-to-back order.
        for (child_layout, child_info) in layout.children.iter().zip(&info.children).rev() {
            if let Some(child_node) = child_layout.node() {
                let mut path = hit_test_inner(
                    child_node,
                    child_info,
                    (child_x, child_y),
                    child_scroll,
                    child_vp,
                    child_cont,
                    false,
                );
                if !path.is_empty() {
                    path.push(HitItem { layout, info });
                    return path;
                }
            } else if let Some(result) = child_layout.custom_result()
                && result.spans.iter().any(|span| {
                    child_x >= span.line_pos.0
                        && child_x <= span.line_pos.0 + span.width()
                        && child_y >= span.line_pos.1
                        && child_y <= span.line_pos.1 + result.box_model.content_box.height
                })
            {
                return vec![
                    HitItem {
                        layout,
                        info: child_info,
                    },
                    HitItem { layout, info },
                ];
            }
        }

        // 4. No child hit -> this box.
        let _ = sticky_shift;
        return vec![HitItem { layout, info }];
    }

    Vec::new()
}

/// Returns the hit path (child→parent) of the topmost open popup containing
/// `(x, y)`, or `None`.
fn hit_test_popup<'a>(
    layout: &'a LayoutNode,
    info: &'a InfoNode,
    x: f32,
    y: f32,
) -> Option<HitPath<'a>> {
    let mut best: Option<HitPath<'a>> = None;
    let mut prefix: HitPath<'a> = Vec::new();
    let size = layout
        .layout_box
        .iter()
        .next()
        .map_or((f32::INFINITY, f32::INFINITY), |b| {
            (b.content_box.width, b.content_box.height)
        });
    let (sx, sy) = info.kind.scroll_offsets();
    let root_viewport = StickyViewport {
        top_left: (-sx, sy),
        size,
    };
    hit_test_popup_inner(
        layout,
        info,
        (x, y),
        (0.0, 0.0),
        root_viewport,
        size,
        true,
        &mut prefix,
        &mut best,
    );
    best
}

/// Recursive top-layer popup scan. `prefix` holds the root→current hit path;
/// matches recorded later (tree order) overwrite earlier ones.
#[allow(clippy::too_many_arguments)]
fn hit_test_popup_inner<'a>(
    layout: &'a LayoutNode,
    info: &'a InfoNode,
    point: (f32, f32),
    accumulated_scroll: (f32, f32),
    viewport: StickyViewport,
    containing: (f32, f32),
    is_root: bool,
    prefix: &mut HitPath<'a>,
    best: &mut Option<HitPath<'a>>,
) {
    if layout.layout_box.is_empty() {
        return;
    }

    let inline_container = is_inline_container(layout, info);

    let is_fixed = layout.style.position.kind == Position::Fixed;
    let mut p = point;
    if is_fixed {
        p.0 -= accumulated_scroll.0;
        p.1 -= accumulated_scroll.1;
    }
    let is_sticky = layout.style.position.kind == Position::Sticky;
    if is_sticky
        && !is_fixed
        && let Some(bm) = layout.layout_box.iter().next()
        && let Some(edges) = bm.sticky_edges
    {
        let (dx, dy) = sticky_offset(&edges, &bm.border_box, viewport, containing);
        p.0 -= dx;
        p.1 -= dy;
    }

    let own_scroll = info.kind.scroll_offsets();
    let child_scroll = if is_fixed {
        own_scroll
    } else {
        (
            accumulated_scroll.0 + own_scroll.0,
            accumulated_scroll.1 + own_scroll.1,
        )
    };
    let child_vp = child_viewport(layout, info, viewport, is_root);
    let child_cont = child_containing(layout, containing);
    let style = node_style(info);

    let (local_x, local_y) = if inline_container {
        p
    } else if let Some(bm) = layout.layout_box.iter().next() {
        map_to_content_local(p, &bm, &style, own_scroll).unwrap_or(p)
    } else {
        p
    };

    if let NodeKind::Custom {
        node,
        text_style,
        text_flow_style,
        ..
    } = &info.kind
        && let Some(popup) = node.popup(text_style, text_flow_style)
        && local_x >= popup.rect.x
        && local_y >= popup.rect.y
        && local_x <= popup.rect.x + popup.rect.width
        && local_y <= popup.rect.y + popup.rect.height
    {
        let mut path = prefix.clone();
        path.push(HitItem { layout, info });
        path.reverse();
        *best = Some(path);
    }

    // child space for descendants
    let mut child_x = if inline_container { p.0 } else { local_x };
    let child_y = if inline_container { p.1 } else { local_y };
    if establishes_inline_box_space(layout)
        && inline_container
        && let Some(bm) = layout.layout_box.iter().next()
    {
        child_x -= bm.content_box.x;
    }

    prefix.push(HitItem { layout, info });
    for (child_layout, child_info) in layout.children.iter().zip(&info.children) {
        if let Some(child_node) = child_layout.node() {
            hit_test_popup_inner(
                child_node,
                child_info,
                (child_x, child_y),
                child_scroll,
                child_vp,
                child_cont,
                false,
                prefix,
                best,
            );
        }
    }
    prefix.pop();
}

/// Marker returned from [`scroll_at`] when a container scrolled but carries no
/// snapshot dom id (so no `scroll` event can be dispatched to it). Callers can
/// treat any `Some(..)` as "scrolled" and use this value to skip dispatch.
pub const NO_SCROLL_DOM_ID: u32 = u32::MAX;

/// Scrolls the innermost scrollable container under `(x, y)` by `(dx, dy)`.
pub fn scroll_at(
    layout: &LayoutNode,
    info: &mut InfoNode,
    viewport: (f32, f32),
    x: f32,
    y: f32,
    dx: f32,
    dy: f32,
) -> Option<u32> {
    let size = layout
        .layout_box
        .iter()
        .next()
        .map_or((f32::INFINITY, f32::INFINITY), |b| {
            (b.content_box.width, b.content_box.height)
        });
    let (sx, sy) = info.kind.scroll_offsets();
    let root_viewport = StickyViewport {
        top_left: (-sx, sy),
        size,
    };
    scroll_at_inner(
        layout,
        info,
        viewport,
        (x, y),
        dx,
        dy,
        (0.0, 0.0),
        root_viewport,
        size,
        true,
    )
}

#[allow(clippy::too_many_arguments)]
fn scroll_at_inner(
    layout: &LayoutNode,
    info: &mut InfoNode,
    window_viewport: (f32, f32),
    point: (f32, f32),
    dx: f32,
    dy: f32,
    accumulated_scroll: (f32, f32),
    viewport: StickyViewport,
    containing: (f32, f32),
    is_root: bool,
) -> Option<u32> {
    if layout.layout_box.is_empty() {
        return None;
    }

    let inline = is_inline(layout);
    let inline_container = is_inline_container(layout, info);

    let is_fixed = layout.style.position.kind == Position::Fixed;
    let mut p = point;
    if is_fixed {
        p.0 -= accumulated_scroll.0;
        p.1 -= accumulated_scroll.1;
    }
    let is_sticky = layout.style.position.kind == Position::Sticky;
    if is_sticky
        && !is_fixed
        && let Some(bm) = layout.layout_box.iter().next()
        && let Some(edges) = bm.sticky_edges
    {
        let (sdx, sdy) = sticky_offset(&edges, &bm.border_box, viewport, containing);
        p.0 -= sdx;
        p.1 -= sdy;
    }

    let own_scroll = info.kind.scroll_offsets();
    let child_scroll = if is_fixed {
        own_scroll
    } else {
        (
            accumulated_scroll.0 + own_scroll.0,
            accumulated_scroll.1 + own_scroll.1,
        )
    };
    let child_vp = child_viewport(layout, info, viewport, is_root);
    let child_cont = child_containing(layout, containing);
    let style = node_style(info);

    let boxes: Vec<_> = layout.layout_box.iter().collect();
    for box_model in boxes.into_iter().rev() {
        let Some((local_x, local_y)) = map_to_box_local(p, &box_model, &style, own_scroll, inline)
        else {
            continue;
        };
        let mut child_x = if inline_container { p.0 } else { local_x };
        let child_y = if inline_container { p.1 } else { local_y };

        if establishes_inline_box_space(layout) && !inline_container {
            child_x -= box_model.content_box.x;
        }

        // children front-to-back
        let mut i = info.children.len();
        while i > 0 {
            i -= 1;
            let Some(child_node) = layout.children.get(i).and_then(|c| c.node()) else {
                continue;
            };
            if let Some(scrolled_id) = scroll_at_inner(
                child_node,
                &mut info.children[i],
                window_viewport,
                (child_x, child_y),
                dx,
                dy,
                child_scroll,
                child_vp,
                child_cont,
                false,
            ) {
                return Some(scrolled_id);
            }
        }

        let scrolled = match &mut info.kind {
            NodeKind::Container {
                scroll_x,
                scroll_y,
                scroll_offset_x,
                scroll_offset_y,
                ..
            }
            | NodeKind::Custom {
                scroll_x,
                scroll_y,
                scroll_offset_x,
                scroll_offset_y,
                ..
            } => {
                let mut changed = false;
                let (vw, vh) = window_viewport;

                if *scroll_y {
                    let max_scroll = (box_model.children_box.height
                        - box_model.content_box.height.min(vh))
                    .max(0.0);
                    let next = (*scroll_offset_y + dy).clamp(0.0, max_scroll);
                    if (next - *scroll_offset_y).abs() > f32::EPSILON {
                        changed = true;
                    }
                    *scroll_offset_y = next;
                }
                if *scroll_x {
                    let max_scroll = (box_model.children_box.width
                        - box_model.content_box.width.min(vw))
                    .max(0.0);
                    let next = (*scroll_offset_x + dx).clamp(0.0, max_scroll);
                    if (next - *scroll_offset_x).abs() > f32::EPSILON {
                        changed = true;
                    }
                    *scroll_offset_x = next;
                }
                changed
            }
            _ => false,
        };
        if scrolled {
            return Some(info.dom_id.unwrap_or(NO_SCROLL_DOM_ID));
        }
    }

    None
}

/// Focuses `target` and clears focus from every other text input.
///
/// Returns whether a text input received focus.
pub fn focus_text_input(info: &InfoNode, target: Option<&Arc<dyn CustomNode>>) -> bool {
    let mut focused = false;
    if let NodeKind::Custom { node, .. } = &info.kind
        && node.accepts_text_input()
    {
        let is_target = target.is_some_and(|target| Arc::ptr_eq(node, target));
        node.set_focused(is_target);
        focused |= is_target;
    }
    for child in &info.children {
        focused |= focus_text_input(child, target);
    }
    focused
}

/// Sends an editing event to the focused text input, if one exists.
pub fn dispatch_text_input(info: &InfoNode, event: InputTextEvent) -> bool {
    if let NodeKind::Custom { node, .. } = &info.kind
        && node.accepts_text_input()
        && node.is_focused()
    {
        return node.handle_text_input(event);
    }
    for child in &info.children {
        if dispatch_text_input(child, event.clone()) {
            return true;
        }
    }
    false
}

/// Returns whether the focused text input has an active IME composition.
pub fn focused_text_input_is_composing(info: &InfoNode) -> bool {
    if let NodeKind::Custom { node, .. } = &info.kind
        && node.accepts_text_input()
        && node.is_focused()
    {
        return node.is_composing();
    }
    info.children.iter().any(focused_text_input_is_composing)
}

/// Returns whether any custom node in the tree reports a pending repaint.
///
/// Consumes the repaint flags of the nodes it visits, so callers should only
/// invoke this once per frame, right before deciding whether to redraw.
pub fn any_custom_node_needs_repaint(info: &InfoNode) -> bool {
    if let NodeKind::Custom { node, .. } = &info.kind
        && node.needs_repaint()
    {
        return true;
    }
    info.children.iter().any(any_custom_node_needs_repaint)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::engine::bridge::text::{FallbackTextMeasurer, TextMeasurer};
    use crate::engine::layouter::types::{ContainerRole, ContainerStyle, TextStyle};
    use crate::engine::renderer_model::{DrawCommand, Rect};
    use crate::engine::ui::button::ButtonComponent;
    use crate::engine::ui::input_text::InputTextComponent;
    use crate::engine::ui::input_text_types::InputTextEvent;
    use crate::engine::ui::{ContentSize, Popup};
    use std::sync::Arc;
    use std::sync::Mutex;
    use std::sync::atomic::{AtomicBool, Ordering};
    use ui_layout::{LayoutChild, Style};

    const VIEWPORT_WIDTH: f32 = 800.0;
    const VIEWPORT_HEIGHT: f32 = 600.0;

    fn input_info(node: Arc<dyn CustomNode>) -> InfoNode {
        InfoNode {
            kind: NodeKind::Custom {
                node,
                scroll_x: false,
                scroll_y: false,
                scroll_offset_x: 0.0,
                scroll_offset_y: 0.0,
                style: ContainerStyle::default(),
                layout_style: ui_layout::Style::default(),
                text_style: TextStyle::default(),
                text_flow_style: TextFlowStyle::default(),
            },
            children: Vec::new(),
            dom_id: None,
        }
    }

    #[test]
    fn focus_and_dispatch_target_one_input() {
        let measurer: Arc<dyn TextMeasurer> = Arc::new(FallbackTextMeasurer);
        let first: Arc<dyn CustomNode> =
            Arc::new(InputTextComponent::new("", "", Arc::clone(&measurer)));
        let second: Arc<dyn CustomNode> = Arc::new(InputTextComponent::new("", "", measurer));
        let root = InfoNode {
            kind: NodeKind::LineBreak,
            children: vec![
                input_info(Arc::clone(&first)),
                input_info(Arc::clone(&second)),
            ],
            dom_id: None,
        };

        assert!(focus_text_input(&root, Some(&second)));
        assert!(!first.is_focused());
        assert!(second.is_focused());
        assert!(dispatch_text_input(
            &root,
            InputTextEvent::Commit("日本".into())
        ));
    }

    #[test]
    fn hit_custom_node_finds_innermost_custom() {
        let node: Arc<dyn CustomNode> = Arc::new(InputTextComponent::new(
            "",
            "",
            Arc::new(FallbackTextMeasurer),
        ));
        let info = input_info(Arc::clone(&node));
        let layout = LayoutNode::new(ui_layout::Style::default());
        let path = vec![
            HitItem {
                layout: &layout,
                info: &info,
            },
            HitItem {
                layout: &layout,
                info: &info,
            },
        ];
        assert!(Arc::ptr_eq(hit_custom_node(&path).unwrap(), &node));
    }

    #[test]
    fn update_hover_switches_target() {
        let measurer: Arc<dyn TextMeasurer> = Arc::new(FallbackTextMeasurer);
        let a: Arc<dyn CustomNode> = Arc::new(ButtonComponent::new("A", Arc::clone(&measurer)));
        let b: Arc<dyn CustomNode> = Arc::new(ButtonComponent::new("B", measurer));
        let info_a = input_info(Arc::clone(&a));
        let info_b = input_info(Arc::clone(&b));
        let layout = LayoutNode::new(ui_layout::Style::default());
        let path_a = vec![HitItem {
            layout: &layout,
            info: &info_a,
        }];
        let path_b = vec![HitItem {
            layout: &layout,
            info: &info_b,
        }];

        assert!(update_hover(&path_a, None));
        assert!(a.is_hovered());
        assert!(!b.is_hovered());

        assert!(update_hover(&path_b, Some(&a)));
        assert!(!a.is_hovered());
        assert!(b.is_hovered());

        assert!(!update_hover(&path_b, Some(&b)));
    }

    #[test]
    fn any_custom_node_needs_repaint_tracks_dirty_nodes() {
        let measurer: Arc<dyn TextMeasurer> = Arc::new(FallbackTextMeasurer);
        let a: Arc<dyn CustomNode> = Arc::new(ButtonComponent::new("A", Arc::clone(&measurer)));
        let info_a = input_info(Arc::clone(&a));

        // Fresh nodes are dirty (initial paint).
        assert!(any_custom_node_needs_repaint(&info_a));
        assert!(!any_custom_node_needs_repaint(&info_a));

        // A pointer event that changes visual state marks it dirty again.
        a.on_pointer_event(PointerEvent::Down { x: 0.0, y: 0.0 });
        assert!(any_custom_node_needs_repaint(&info_a));
        assert!(!any_custom_node_needs_repaint(&info_a));
    }

    fn box_model(
        x: f32,
        y: f32,
        width: f32,
        height: f32,
        children_width: f32,
        children_height: f32,
    ) -> ui_layout::BoxModel {
        let rect = ui_layout::Rect {
            x,
            y,
            width,
            height,
        };
        ui_layout::BoxModel {
            sticky_edges: None,
            border_box: rect,
            padding_box: rect,
            content_box: rect,
            children_box: ui_layout::Rect {
                x,
                y,
                width: children_width,
                height: children_height,
            },
        }
    }

    fn scrollable_info() -> InfoNode {
        InfoNode {
            kind: NodeKind::Container {
                scroll_x: false,
                scroll_y: true,
                scroll_offset_x: 0.0,
                scroll_offset_y: 0.0,
                style: ContainerStyle::default(),
                role: crate::engine::layouter::types::ContainerRole::Normal,
            },
            children: Vec::new(),
            dom_id: None,
        }
    }

    fn container_info(scroll_y: bool, dom_id: Option<u32>) -> InfoNode {
        InfoNode {
            kind: NodeKind::Container {
                scroll_x: false,
                scroll_y,
                scroll_offset_x: 0.0,
                scroll_offset_y: 0.0,
                style: ContainerStyle::default(),
                role: crate::engine::layouter::types::ContainerRole::Normal,
            },
            children: Vec::new(),
            dom_id,
        }
    }

    /// An inline container laid out in its parent's content space: its box
    /// model and line spans use absolute coordinates (mirroring how the flow
    /// engine positions inline content).
    fn inline_node(children: Vec<LayoutChild>) -> LayoutNode {
        let mut node = LayoutNode::with_children(ui_layout::Style::default(), children);
        node.layout_box = ui_layout::LayoutBox::InlineBox(ui_layout::InlineBox {
            box_model: box_model(10.0, 10.0, 200.0, 20.0, 200.0, 20.0),
            line_spans: vec![ui_layout::LineSpan {
                x_range: 0.0..200.0,
                line_pos: (10.0, 10.0),
                line_index: 0,
            }],
        });
        node
    }

    fn scroll_offset_y_of(info: &InfoNode) -> f32 {
        let NodeKind::Container {
            scroll_offset_y, ..
        } = &info.kind
        else {
            panic!("expected container");
        };
        *scroll_offset_y
    }

    fn set_vertical_scroll(info: &mut InfoNode, offset: f32) {
        let NodeKind::Container {
            scroll_offset_y, ..
        } = &mut info.kind
        else {
            panic!("expected container");
        };
        *scroll_offset_y = offset;
    }

    fn fixed_child_layout(children_height: f32) -> LayoutNode {
        let mut style = ui_layout::Style::default();
        style.position.kind = Position::Fixed;
        let mut child = LayoutNode::new(style);
        child.layout_box = ui_layout::LayoutBox::BlockBox(box_model(
            10.0,
            10.0,
            30.0,
            20.0,
            30.0,
            children_height,
        ));
        child
    }

    #[test]
    fn hit_test_fixed_child_ignores_ancestor_scroll() {
        let mut layout =
            LayoutNode::with_children(ui_layout::Style::default(), [fixed_child_layout(20.0)]);
        layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 100.0, 200.0, 300.0));

        let mut info = scrollable_info();
        set_vertical_scroll(&mut info, 50.0);
        let mut fixed_info = scrollable_info();
        fixed_info.dom_id = Some(42);
        info.children.push(fixed_info);

        let path = hit_test(&layout, &info, 15.0, 15.0);
        assert_eq!(hit_dom_id(&path), Some(42));
    }

    #[test]
    fn scroll_at_fixed_child_ignores_ancestor_scroll() {
        let mut layout =
            LayoutNode::with_children(ui_layout::Style::default(), [fixed_child_layout(80.0)]);
        layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 100.0, 200.0, 300.0));

        let mut info = scrollable_info();
        set_vertical_scroll(&mut info, 50.0);
        info.children.push(scrollable_info());

        assert!(
            scroll_at(
                &layout,
                &mut info,
                (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
                15.0,
                15.0,
                0.0,
                10.0
            )
            .is_some()
        );
        let NodeKind::Container {
            scroll_offset_y: child_scroll,
            ..
        } = &info.children[0].kind
        else {
            panic!("expected fixed child container");
        };
        assert_eq!(*child_scroll, 10.0);
        let NodeKind::Container {
            scroll_offset_y: parent_scroll,
            ..
        } = &info.kind
        else {
            panic!("expected parent container");
        };
        assert_eq!(*parent_scroll, 50.0);
    }

    #[test]
    fn scroll_at_scrolls_under_point_clamped_to_range() {
        let mut layout = LayoutNode::new(ui_layout::Style::default());
        layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 100.0, 200.0, 300.0));
        let mut info = scrollable_info();

        // Cursor inside the box. Positive dy scrolls down.
        assert!(
            scroll_at(
                &layout,
                &mut info,
                (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
                50.0,
                50.0,
                0.0,
                100.0
            )
            .is_some()
        );
        let NodeKind::Container {
            scroll_offset_y, ..
        } = &info.kind
        else {
            panic!("expected container");
        };
        assert_eq!(*scroll_offset_y, 100.0);

        // Clamp to children_box.height - content_box.height = 200.
        assert!(
            scroll_at(
                &layout,
                &mut info,
                (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
                50.0,
                50.0,
                0.0,
                300.0
            )
            .is_some()
        );
        let NodeKind::Container {
            scroll_offset_y, ..
        } = &info.kind
        else {
            panic!("expected container");
        };
        assert_eq!(*scroll_offset_y, 200.0);

        // Cannot scroll past 0 (negative dy scrolls up).
        assert!(
            scroll_at(
                &layout,
                &mut info,
                (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
                50.0,
                50.0,
                0.0,
                -500.0
            )
            .is_some()
        );
        let NodeKind::Container {
            scroll_offset_y, ..
        } = &info.kind
        else {
            panic!("expected container");
        };
        assert_eq!(*scroll_offset_y, 0.0);
    }

    #[test]
    fn scroll_at_ignores_cursor_outside_box() {
        let mut layout = LayoutNode::new(ui_layout::Style::default());
        layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 100.0, 200.0, 300.0));
        let mut info = scrollable_info();

        assert!(
            scroll_at(
                &layout,
                &mut info,
                (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
                250.0,
                50.0,
                0.0,
                -100.0
            )
            .is_none()
        );
    }

    #[test]
    fn scroll_at_ignores_non_scrollable_containers() {
        let mut layout = LayoutNode::new(ui_layout::Style::default());
        layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 100.0, 200.0, 300.0));
        let mut info = InfoNode {
            kind: NodeKind::Container {
                scroll_x: false,
                scroll_y: false,
                scroll_offset_x: 0.0,
                scroll_offset_y: 0.0,
                style: ContainerStyle::default(),
                role: crate::engine::layouter::types::ContainerRole::Normal,
            },
            children: Vec::new(),
            dom_id: None,
        };

        assert!(
            scroll_at(
                &layout,
                &mut info,
                (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
                50.0,
                50.0,
                0.0,
                -100.0
            )
            .is_none()
        );
        let NodeKind::Container {
            scroll_offset_y, ..
        } = &info.kind
        else {
            panic!("expected container");
        };
        assert_eq!(*scroll_offset_y, 0.0);
    }

    #[test]
    fn scroll_at_prefers_innermost_scrollable_container() {
        // Outer container with scrollable content; inner container is
        // scrollable and sits inside it. A scroll over the inner container
        // should move the inner one, not the outer.
        let outer_children_box = box_model(0.0, 0.0, 400.0, 300.0, 400.0, 900.0);
        let inner_children_box = box_model(10.0, 10.0, 100.0, 80.0, 100.0, 240.0);

        let mut outer_layout = LayoutNode::with_children(
            ui_layout::Style::default(),
            [LayoutNode::new(ui_layout::Style::default())],
        );
        outer_layout.layout_box = ui_layout::LayoutBox::BlockBox(outer_children_box);

        let mut inner_layout = LayoutNode::new(ui_layout::Style::default());
        inner_layout.layout_box = ui_layout::LayoutBox::BlockBox(inner_children_box);

        outer_layout.children[0] = ui_layout::LayoutChild::Node(Box::new(inner_layout));

        let mut outer_info = scrollable_info();
        let inner_info = scrollable_info();
        outer_info.children.push(inner_info);

        // Cursor over the inner container. Positive dy scrolls down.
        assert!(
            scroll_at(
                &outer_layout,
                &mut outer_info,
                (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
                50.0,
                50.0,
                0.0,
                30.0
            )
            .is_some()
        );
        let NodeKind::Container {
            scroll_offset_y, ..
        } = &outer_info.children[0].kind
        else {
            panic!("expected inner container");
        };
        assert_eq!(*scroll_offset_y, 30.0);
        let NodeKind::Container {
            scroll_offset_y: outer_off,
            ..
        } = &outer_info.kind
        else {
            panic!("expected outer container");
        };
        assert_eq!(*outer_off, 0.0);
    }

    #[test]
    fn scroll_at_reports_the_scrolled_containers_dom_id() {
        // Outer (dom 7) with scrollable inner (dom 9): scrolling over the inner
        // reports the inner's dom id.
        let outer_children_box = box_model(0.0, 0.0, 400.0, 300.0, 400.0, 900.0);
        let inner_children_box = box_model(10.0, 10.0, 100.0, 80.0, 100.0, 240.0);

        let mut outer_layout = LayoutNode::with_children(
            ui_layout::Style::default(),
            [LayoutNode::new(ui_layout::Style::default())],
        );
        outer_layout.layout_box = ui_layout::LayoutBox::BlockBox(outer_children_box);
        let mut inner_layout = LayoutNode::new(ui_layout::Style::default());
        inner_layout.layout_box = ui_layout::LayoutBox::BlockBox(inner_children_box);
        outer_layout.children[0] = ui_layout::LayoutChild::Node(Box::new(inner_layout));

        let mut outer_info = container_info(true, Some(7));
        let inner_info = container_info(true, Some(9));
        outer_info.children.push(inner_info);

        let scrolled = scroll_at(
            &outer_layout,
            &mut outer_info,
            (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
            50.0,
            50.0,
            0.0,
            30.0,
        );
        assert_eq!(scrolled, Some(9));
    }

    #[test]
    fn scroll_at_reports_marker_when_scrolled_container_has_no_dom_id() {
        let mut layout = LayoutNode::new(ui_layout::Style::default());
        layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 100.0, 200.0, 300.0));
        let mut info = container_info(true, None);
        let scrolled = scroll_at(
            &layout,
            &mut info,
            (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
            50.0,
            50.0,
            0.0,
            10.0,
        );
        assert_eq!(scrolled, Some(NO_SCROLL_DOM_ID));
    }

    /// Records pointer events for asserting `dispatch_pointer` coordinates.
    #[derive(Debug)]
    struct RecordingNode {
        pointer_events: Mutex<Vec<PointerEvent>>,
        popup_events: Mutex<Vec<PointerEvent>>,
        popup_rect: Rect,
        popup_open: AtomicBool,
        dismissed: AtomicBool,
    }

    impl RecordingNode {
        fn new(popup_rect: Rect) -> Self {
            RecordingNode {
                pointer_events: Mutex::new(Vec::new()),
                popup_events: Mutex::new(Vec::new()),
                popup_rect,
                popup_open: AtomicBool::new(true),
                dismissed: AtomicBool::new(false),
            }
        }

        fn events(&self) -> Vec<PointerEvent> {
            self.pointer_events.lock().unwrap().clone()
        }

        fn popup_events(&self) -> Vec<PointerEvent> {
            self.popup_events.lock().unwrap().clone()
        }
    }

    impl CustomNode for RecordingNode {
        fn draw_sized(
            &self,
            _cmd_buf: &mut Vec<DrawCommand>,
            _text_style: &TextStyle,
            _text_flow_style: &TextFlowStyle,
            _style: &Style,
            _size: ContentSize,
        ) {
        }

        fn intrinsic_size(&self) -> ContentSize {
            ContentSize {
                width: 120.0,
                height: 28.0,
            }
        }

        fn on_pointer_event(&self, event: PointerEvent) -> bool {
            self.pointer_events.lock().unwrap().push(event);
            true
        }

        fn popup(
            &self,
            _text_style: &TextStyle,
            _text_flow_style: &TextFlowStyle,
        ) -> Option<Popup> {
            self.popup_open.load(Ordering::Relaxed).then(|| Popup {
                rect: self.popup_rect,
                commands: Vec::new(),
            })
        }

        fn on_popup_pointer_event(&self, event: PointerEvent) -> bool {
            self.popup_events.lock().unwrap().push(event);
            true
        }

        fn dismiss_popup(&self) {
            self.dismissed.store(true, Ordering::Relaxed);
        }
    }

    /// Tree: root (0,0,200,200) → container (10,20,160,100, scroll_y) →
    /// custom node (5,0,120,28) with an open popup at (0,28,120,84).
    fn make_tree(a_scroll_y: f32) -> (LayoutNode, InfoNode, Arc<RecordingNode>) {
        let node: Arc<RecordingNode> = Arc::new(RecordingNode::new(Rect {
            x: 0.0,
            y: 28.0,
            width: 120.0,
            height: 84.0,
        }));
        let custom_info = input_info(Arc::clone(&node) as Arc<dyn CustomNode>);

        let mut a_layout = LayoutNode::new(ui_layout::Style::default());
        a_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(10.0, 20.0, 160.0, 100.0, 160.0, 300.0));
        let mut custom_layout = LayoutNode::new(ui_layout::Style::default());
        custom_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(5.0, 0.0, 120.0, 28.0, 120.0, 28.0));
        a_layout.children = vec![LayoutChild::Node(Box::new(custom_layout))];

        let mut root_layout = LayoutNode::with_children(ui_layout::Style::default(), [a_layout]);
        root_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 200.0, 200.0, 200.0));

        let a_info = InfoNode {
            kind: NodeKind::Container {
                scroll_x: false,
                scroll_y: true,
                scroll_offset_x: 0.0,
                scroll_offset_y: a_scroll_y,
                style: ContainerStyle::default(),
                role: ContainerRole::Normal,
            },
            children: vec![custom_info],
            dom_id: None,
        };
        let root_info = InfoNode {
            kind: NodeKind::Container {
                scroll_x: false,
                scroll_y: false,
                scroll_offset_x: 0.0,
                scroll_offset_y: 0.0,
                style: ContainerStyle::default(),
                role: ContainerRole::Normal,
            },
            children: vec![a_info],
            dom_id: None,
        };

        (root_layout, root_info, node)
    }

    /// Builds the child→parent hit path matching `make_tree`.
    fn build_path<'a>(root_layout: &'a LayoutNode, root_info: &'a InfoNode) -> HitPath<'a> {
        let a_layout = match &root_layout.children[0] {
            LayoutChild::Node(node) => node,
            _ => unreachable!("expected container child"),
        };
        let custom_layout = match &a_layout.children[0] {
            LayoutChild::Node(node) => node,
            _ => unreachable!("expected custom child"),
        };
        let a_info = &root_info.children[0];
        let custom_info = &a_info.children[0];
        vec![
            HitItem {
                layout: custom_layout,
                info: custom_info,
            },
            HitItem {
                layout: a_layout,
                info: a_info,
            },
            HitItem {
                layout: root_layout,
                info: root_info,
            },
        ]
    }

    #[test]
    fn dispatch_pointer_uses_node_local_coords() {
        let (root_layout, root_info, node) = make_tree(0.0);
        node.popup_open.store(false, Ordering::Relaxed);
        let path = build_path(&root_layout, &root_info);

        // Content origin (15,20); no scroll: (20,25) → local (5,5).
        dispatch_pointer(&path, PointerEvent::Down { x: 20.0, y: 25.0 });
        assert_eq!(node.events(), vec![PointerEvent::Down { x: 5.0, y: 5.0 }]);
    }

    #[test]
    fn dispatch_pointer_folds_ancestor_scroll_into_local_coords() {
        let (root_layout, root_info, node) = make_tree(50.0);
        node.popup_open.store(false, Ordering::Relaxed);
        let path = build_path(&root_layout, &root_info);

        // Same click with a 50px ancestor scroll: local y += 50.
        dispatch_pointer(&path, PointerEvent::Move { x: 20.0, y: 25.0 });
        assert_eq!(node.events(), vec![PointerEvent::Move { x: 5.0, y: 55.0 }]);
    }

    #[test]
    fn popup_events_use_popup_local_coords() {
        let (root_layout, root_info, node) = make_tree(0.0);
        let path = build_path(&root_layout, &root_info);

        // Global (20,60) → local (5,40) → inside popup (y in 28..112) →
        // popup-local (5, 40-28=12).
        dispatch_pointer(&path, PointerEvent::Down { x: 20.0, y: 60.0 });
        assert_eq!(
            node.popup_events(),
            vec![PointerEvent::Down { x: 5.0, y: 12.0 }]
        );
        assert!(node.events().is_empty());
        assert!(!node.dismissed.load(Ordering::Relaxed));
    }

    #[test]
    fn down_outside_popup_routes_to_node() {
        let (root_layout, root_info, node) = make_tree(0.0);
        let path = build_path(&root_layout, &root_info);

        // Global (20,30) → local (5,10), above the popup: the node receives
        // the press (dismissal is handled globally by `dismiss_open_popups`).
        dispatch_pointer(&path, PointerEvent::Down { x: 20.0, y: 30.0 });
        assert!(!node.dismissed.load(Ordering::Relaxed));
        assert_eq!(node.events(), vec![PointerEvent::Down { x: 5.0, y: 10.0 }]);
        assert!(node.popup_events().is_empty());
    }

    #[test]
    fn move_outside_popup_routes_to_node() {
        let (root_layout, root_info, node) = make_tree(0.0);
        let path = build_path(&root_layout, &root_info);

        // Global (20,30) → local (5,10), above the popup: the node receives
        // the move and the popup stays open.
        dispatch_pointer(&path, PointerEvent::Move { x: 20.0, y: 30.0 });
        assert!(!node.dismissed.load(Ordering::Relaxed));
        assert_eq!(node.events(), vec![PointerEvent::Move { x: 5.0, y: 10.0 }]);
        assert!(node.popup_events().is_empty());
    }

    fn popup_hit_assert(
        root_layout: &LayoutNode,
        root_info: &InfoNode,
        node: &Arc<RecordingNode>,
        x: f32,
        y: f32,
    ) {
        let path = hit_test(root_layout, root_info, x, y);
        let hit = hit_custom_node(&path).unwrap();
        assert!(std::ptr::eq(hit.as_ref(), node.as_ref() as &dyn CustomNode));
    }

    #[test]
    fn hit_test_finds_open_popup() {
        let (root_layout, root_info, node) = make_tree(0.0);
        // Custom page origin (15,20); popup page rect (15,48)-(135,132).
        // Global (20,60) → local (5,40), inside the popup (y in 28..112).
        popup_hit_assert(&root_layout, &root_info, &node, 20.0, 60.0);
    }

    #[test]
    fn hit_test_ignores_closed_popup() {
        let (root_layout, root_info, node) = make_tree(0.0);
        node.popup_open.store(false, Ordering::Relaxed);
        // Local (5,40) is below the custom box (y in 0..28); with the popup
        // closed the click lands on the container instead.
        let path = hit_test(&root_layout, &root_info, 20.0, 60.0);
        assert_eq!(path.len(), 2);
        assert!(hit_custom_node(&path).is_none());
    }

    #[test]
    fn hit_test_finds_popup_escaping_ancestor_box() {
        let (root_layout, root_info, node) = make_tree(0.0);
        // The container box ends at y=120 but the popup reaches y=132. A click
        // past the container is still a popup hit because popups render above
        // ancestor boxes and clips.
        popup_hit_assert(&root_layout, &root_info, &node, 20.0, 125.0);
    }

    #[test]
    fn hit_test_folds_scroll_into_popup_hit() {
        let (root_layout, root_info, node) = make_tree(50.0);
        // With the 50px ancestor scroll, a click at page y=25 maps to local
        // (5,55), inside the popup (y in 28..112).
        popup_hit_assert(&root_layout, &root_info, &node, 20.0, 25.0);
    }

    #[test]
    fn dismiss_open_popups_closes_popup_on_outside_press() {
        let (root_layout, root_info, node) = make_tree(0.0);
        // (10,25) lands on the container, outside the custom box and popup.
        let path = hit_test(&root_layout, &root_info, 10.0, 25.0);
        assert!(dismiss_open_popups(&root_info, &path, 50.0, 50.0));
        assert!(node.dismissed.load(Ordering::Relaxed));
    }

    #[test]
    fn dismiss_open_popups_keeps_popup_under_press() {
        let (root_layout, root_info, node) = make_tree(0.0);
        // Press on the open popup itself.
        let path = hit_test(&root_layout, &root_info, 20.0, 60.0);
        assert!(!dismiss_open_popups(&root_info, &path, 50.0, 50.0));
        assert!(!node.dismissed.load(Ordering::Relaxed));
    }

    #[test]
    fn dismiss_open_popups_keeps_popup_when_press_on_owner_box() {
        let (root_layout, root_info, node) = make_tree(0.0);
        // Press on the owning box (not the popup): the owner closes it itself,
        // so no separate dismissal happens.
        let path = hit_test(&root_layout, &root_info, 20.0, 30.0);
        assert!(!dismiss_open_popups(&root_info, &path, 50.0, 50.0));
        assert!(!node.dismissed.load(Ordering::Relaxed));
    }

    #[test]
    fn dismiss_open_popups_ignores_closed_popup() {
        let (root_layout, root_info, node) = make_tree(0.0);
        node.popup_open.store(false, Ordering::Relaxed);
        let path = hit_test(&root_layout, &root_info, 10.0, 25.0);
        assert!(!dismiss_open_popups(&root_info, &path, 50.0, 50.0));
        assert!(!node.dismissed.load(Ordering::Relaxed));
    }

    /// Tree: block `b` (0,0,300,100) → inline `i` (line box 10,10,200,20) →
    /// block child `c` (30,10,50,20). Inline content shares the block's
    /// content space, so `c` sits at absolute (30,10) inside `b`.
    fn make_inline_tree() -> (LayoutNode, InfoNode) {
        let mut c = LayoutNode::new(ui_layout::Style::default());
        c.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(30.0, 10.0, 50.0, 20.0, 50.0, 20.0));
        let mut b =
            LayoutNode::with_children(ui_layout::Style::default(), [inline_node(vec![c.into()])]);
        b.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 300.0, 100.0, 300.0, 100.0));

        let c_info = container_info(false, Some(7));
        let mut i_info = container_info(false, None);
        i_info.children.push(c_info);
        let mut b_info = container_info(false, None);
        b_info.children.push(i_info);

        (b, b_info)
    }

    #[test]
    fn hit_test_inside_inline_keeps_parent_coords() {
        let (b, b_info) = make_inline_tree();
        // Inline boxes push no transform, so the child's coordinates are
        // resolved in the block's content space: (40,15) falls inside `c` at
        // (30,10,50,20) even though `i`'s content origin is (10,10).
        let path = hit_test(&b, &b_info, 40.0, 15.0);
        assert_eq!(hit_dom_id(&path), Some(7));
        assert_eq!(path.len(), 3);
    }

    #[test]
    fn hit_test_inside_inline_but_outside_child_hits_inline() {
        let (b, b_info) = make_inline_tree();
        // (12,12) is inside `i`'s line box but left of `c`; the inline
        // container itself is hit instead.
        let path = hit_test(&b, &b_info, 12.0, 12.0);
        assert_eq!(path.len(), 2);
        assert_eq!(hit_dom_id(&path), None);
    }

    #[test]
    fn hit_test_outside_inline_line_boxes_falls_back_to_parent() {
        let (b, b_info) = make_inline_tree();
        // (40,50) is inside `b` but below `i`'s line box (10..30).
        let path = hit_test(&b, &b_info, 40.0, 50.0);
        assert_eq!(path.len(), 1);
        assert_eq!(hit_dom_id(&path), None);
    }

    #[test]
    fn dispatch_pointer_to_inline_custom_keeps_parent_content_coords() {
        let node: Arc<RecordingNode> = Arc::new(RecordingNode::new(Rect {
            x: 0.0,
            y: 28.0,
            width: 120.0,
            height: 84.0,
        }));
        let custom_info = input_info(Arc::clone(&node) as Arc<dyn CustomNode>);

        let mut inline_layout = LayoutNode::new(ui_layout::Style::default());
        inline_layout.layout_box = ui_layout::LayoutBox::InlineBox(ui_layout::InlineBox {
            box_model: box_model(10.0, 20.0, 160.0, 100.0, 160.0, 100.0),
            line_spans: vec![ui_layout::LineSpan {
                x_range: 0.0..160.0,
                line_pos: (10.0, 20.0),
                line_index: 0,
            }],
        });
        let mut block_layout = LayoutNode::new(ui_layout::Style::default());
        block_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 200.0, 200.0, 200.0));

        let inline_info = container_info(false, None);
        let root_info = container_info(false, None);

        node.popup_open.store(false, Ordering::Relaxed);
        let path = vec![
            HitItem {
                layout: &inline_layout,
                info: &custom_info,
            },
            HitItem {
                layout: &inline_layout,
                info: &inline_info,
            },
            HitItem {
                layout: &block_layout,
                info: &root_info,
            },
        ];

        // Inline boxes contribute no content-origin offset, so the event is
        // delivered in the block's content space, not shifted by `i`'s (10,20)
        // content origin.
        dispatch_pointer(&path, PointerEvent::Down { x: 30.0, y: 35.0 });
        assert_eq!(node.events(), vec![PointerEvent::Down { x: 30.0, y: 35.0 }]);
    }

    #[test]
    fn scroll_at_inside_inline_scrolls_child_in_parent_coords() {
        let mut c = LayoutNode::new(ui_layout::Style::default());
        c.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(30.0, 10.0, 50.0, 80.0, 50.0, 240.0));
        let mut b =
            LayoutNode::with_children(ui_layout::Style::default(), [inline_node(vec![c.into()])]);
        b.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 100.0, 200.0, 300.0));

        let c_info = container_info(true, None);
        let mut i_info = container_info(false, None);
        i_info.children.push(c_info);
        let mut b_info = scrollable_info();
        b_info.children.push(i_info);

        assert!(
            scroll_at(
                &b,
                &mut b_info,
                (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
                40.0,
                15.0,
                0.0,
                10.0
            )
            .is_some()
        );
        // The child under the cursor scrolls; the block parent does not.
        assert_eq!(scroll_offset_y_of(&b_info.children[0].children[0]), 10.0);
        assert_eq!(scroll_offset_y_of(&b_info), 0.0);
    }

    fn sticky_box_model(
        x: f32,
        y: f32,
        width: f32,
        height: f32,
        children_width: f32,
        children_height: f32,
        edges: ui_layout::EdgeOption,
    ) -> ui_layout::BoxModel {
        let mut bm = box_model(x, y, width, height, children_width, children_height);
        bm.sticky_edges = Some(edges);
        bm
    }

    #[test]
    fn hit_test_sticky_element_uses_visual_position() {
        // Scrollable container (scrolled 100px, viewport height 150) -> sticky child
        // naturally at y=80 with top:0. Sticky offset dy=20 => child content-space
        // y becomes 100..130, which appears at visual/screen y = 0..30 due to the
        // container scroll transform.
        let mut container_layout = LayoutNode::with_children(
            ui_layout::Style::default(),
            [LayoutNode::new({
                let mut s = ui_layout::Style::default();
                s.position.kind = Position::Sticky;
                s
            })],
        );
        container_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 150.0, 200.0, 400.0));
        let mut child_layout = LayoutNode::new({
            let mut s = ui_layout::Style::default();
            s.position.kind = Position::Sticky;
            s
        });
        child_layout.layout_box = ui_layout::LayoutBox::BlockBox(sticky_box_model(
            10.0,
            80.0,
            40.0,
            30.0,
            40.0,
            30.0,
            ui_layout::EdgeOption {
                top: Some(0.0),
                right: None,
                bottom: None,
                left: None,
            },
        ));
        container_layout.children[0] = ui_layout::LayoutChild::Node(Box::new(child_layout));

        let mut root_layout =
            LayoutNode::with_children(ui_layout::Style::default(), [container_layout]);
        root_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 150.0, 200.0, 150.0));

        let mut scroll_container_info = scrollable_info();
        set_vertical_scroll(&mut scroll_container_info, 100.0);
        let mut child_info = container_info_child(Some(77));
        if let NodeKind::Container { scroll_y, .. } = &mut child_info.kind {
            *scroll_y = false;
        }
        scroll_container_info.children = vec![child_info];
        let mut root_info = container_info(false, None);
        root_info.children = vec![scroll_container_info];

        // Natural/layout position (y=80) is off-screen at scroll 100.
        let natural = hit_test(&root_layout, &root_info, 20.0, 90.0);
        assert_ne!(hit_dom_id(&natural), Some(77));
        // Visual stuck position appears near top of scrollport.
        let visual = hit_test(&root_layout, &root_info, 20.0, 15.0);
        assert_eq!(hit_dom_id(&visual), Some(77));
    }

    fn container_info_child(dom_id: Option<u32>) -> InfoNode {
        InfoNode {
            kind: NodeKind::Container {
                scroll_x: false,
                scroll_y: false,
                scroll_offset_x: 0.0,
                scroll_offset_y: 0.0,
                style: ContainerStyle::default(),
                role: ContainerRole::Normal,
            },
            children: Vec::new(),
            dom_id,
        }
    }

    #[test]
    fn scroll_at_sticky_element_uses_visual_position() {
        let mut container_layout = LayoutNode::with_children(
            ui_layout::Style::default(),
            [LayoutNode::new({
                let mut s = ui_layout::Style::default();
                s.position.kind = Position::Sticky;
                s
            })],
        );
        container_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 150.0, 200.0, 400.0));
        let mut child_layout = LayoutNode::new({
            let mut s = ui_layout::Style::default();
            s.position.kind = Position::Sticky;
            s
        });
        child_layout.layout_box = ui_layout::LayoutBox::BlockBox(sticky_box_model(
            10.0,
            80.0,
            40.0,
            30.0,
            40.0,
            120.0,
            ui_layout::EdgeOption {
                top: Some(0.0),
                right: None,
                bottom: None,
                left: None,
            },
        ));
        container_layout.children[0] = ui_layout::LayoutChild::Node(Box::new(child_layout));

        let mut root_layout =
            LayoutNode::with_children(ui_layout::Style::default(), [container_layout]);
        root_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 200.0, 150.0, 200.0, 150.0));

        let mut scroll_container_info = scrollable_info();
        set_vertical_scroll(&mut scroll_container_info, 100.0);
        let child_info = container_info(true, Some(77));
        scroll_container_info.children = vec![child_info];
        let mut root_info = container_info(false, None);
        root_info.children = vec![scroll_container_info];

        // Scroll at stuck visual position should target the sticky child.
        let scrolled = scroll_at(
            &root_layout,
            &mut root_info,
            (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
            20.0,
            15.0,
            0.0,
            10.0,
        );
        assert_eq!(scrolled, Some(77));
        assert_eq!(scroll_offset_y_of(&root_info.children[0].children[0]), 10.0);
        assert_eq!(scroll_offset_y_of(&root_info.children[0]), 100.0);
    }

    fn transformed_container_info(
        transform: crate::engine::renderer_model::AffineTransform,
    ) -> InfoNode {
        InfoNode {
            kind: NodeKind::Container {
                scroll_x: false,
                scroll_y: true,
                scroll_offset_x: 0.0,
                scroll_offset_y: 0.0,
                style: ContainerStyle {
                    transform: Some(transform),
                    ..ContainerStyle::default()
                },
                role: ContainerRole::Normal,
            },
            children: Vec::new(),
            dom_id: None,
        }
    }

    #[test]
    fn hit_test_and_scroll_translated_element_use_visual_position() {
        // Child block at (50,50,40,30) translated by (60,0) => visual (110,50).
        let mut root_layout = LayoutNode::with_children(
            ui_layout::Style::default(),
            [LayoutNode::new(ui_layout::Style::default())],
        );
        root_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 300.0, 200.0, 300.0, 200.0));
        let mut child_layout = LayoutNode::new(ui_layout::Style::default());
        child_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(50.0, 50.0, 40.0, 30.0, 40.0, 120.0));
        root_layout.children[0] = ui_layout::LayoutChild::Node(Box::new(child_layout));

        let mut root_info = container_info(false, None);
        let mut child_info = transformed_container_info(
            crate::engine::renderer_model::AffineTransform::translate(60.0, 0.0),
        );
        child_info.dom_id = Some(88);
        root_info.children.push(child_info);

        // Natural position misses transformed visual placement.
        assert_ne!(
            hit_dom_id(&hit_test(&root_layout, &root_info, 60.0, 60.0)),
            Some(88)
        );
        // Visual position hits.
        assert_eq!(
            hit_dom_id(&hit_test(&root_layout, &root_info, 120.0, 60.0)),
            Some(88)
        );

        let scrolled = scroll_at(
            &root_layout,
            &mut root_info,
            (VIEWPORT_WIDTH, VIEWPORT_HEIGHT),
            120.0,
            60.0,
            0.0,
            10.0,
        );
        assert_eq!(scrolled, Some(88));
        assert_eq!(scroll_offset_y_of(&root_info.children[0]), 10.0);
    }

    #[test]
    fn dispatch_pointer_to_translated_custom_uses_visual_inverse() {
        let node: Arc<RecordingNode> = Arc::new(RecordingNode::new(Rect {
            x: 0.0,
            y: 0.0,
            width: 0.0,
            height: 0.0,
        }));
        node.popup_open.store(false, Ordering::Relaxed);
        let mut custom_info = input_info(Arc::clone(&node) as Arc<dyn CustomNode>);
        if let NodeKind::Custom { style, .. } = &mut custom_info.kind {
            style.transform = Some(crate::engine::renderer_model::AffineTransform::translate(
                60.0, 0.0,
            ));
        }

        let mut root_layout = LayoutNode::with_children(
            ui_layout::Style::default(),
            [LayoutNode::new(ui_layout::Style::default())],
        );
        root_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 300.0, 200.0, 300.0, 200.0));
        let mut child_layout = LayoutNode::new(ui_layout::Style::default());
        child_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(50.0, 50.0, 40.0, 30.0, 40.0, 30.0));
        root_layout.children[0] = ui_layout::LayoutChild::Node(Box::new(child_layout));
        let mut root_info = container_info(false, None);
        root_info.children.push(custom_info);

        let path = hit_test(&root_layout, &root_info, 120.0, 60.0);
        assert!(hit_custom_node(&path).is_some());
        dispatch_pointer(&path, PointerEvent::Down { x: 120.0, y: 60.0 });
        // Visual (120,60) is local (10,10) inside the 40x30 box at content origin.
        assert_eq!(node.events(), vec![PointerEvent::Down { x: 10.0, y: 10.0 }]);
    }

    #[test]
    fn hit_test_scaled_element_uses_visual_inverse() {
        // Box at (100,100,40,40), center (120,120). scale(2) makes visual (80,80)-(160,160).
        let mut root_layout = LayoutNode::with_children(
            ui_layout::Style::default(),
            [LayoutNode::new(ui_layout::Style::default())],
        );
        root_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 300.0, 300.0, 300.0, 300.0));
        let mut child_layout = LayoutNode::new(ui_layout::Style::default());
        child_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(100.0, 100.0, 40.0, 40.0, 40.0, 40.0));
        root_layout.children[0] = ui_layout::LayoutChild::Node(Box::new(child_layout));

        let mut root_info = container_info(false, None);
        let mut child_info = transformed_container_info(
            crate::engine::renderer_model::AffineTransform::scale(2.0, 2.0),
        );
        child_info.dom_id = Some(99);
        // make non-scrollable for simple hit
        if let NodeKind::Container { scroll_y, .. } = &mut child_info.kind {
            *scroll_y = false;
        }
        root_info.children.push(child_info);

        // (90,120) is outside natural box (100..140) but inside scaled visual box.
        assert_eq!(
            hit_dom_id(&hit_test(&root_layout, &root_info, 90.0, 120.0)),
            Some(99)
        );
        // (170,120) is outside scaled visual box.
        assert_ne!(
            hit_dom_id(&hit_test(&root_layout, &root_info, 170.0, 120.0)),
            Some(99)
        );
    }

    #[test]
    fn popup_hit_and_dispatch_on_translated_custom_use_visual_coords() {
        // Custom box at (50,50,40,30), translated +60x. Popup at local (0,30,40,20)
        // should be hittable/dispatchable at translated visual position.
        let node: Arc<RecordingNode> = Arc::new(RecordingNode::new(Rect {
            x: 0.0,
            y: 30.0,
            width: 40.0,
            height: 20.0,
        }));
        let mut custom_info = input_info(Arc::clone(&node) as Arc<dyn CustomNode>);
        if let NodeKind::Custom { style, .. } = &mut custom_info.kind {
            style.transform = Some(crate::engine::renderer_model::AffineTransform::translate(
                60.0, 0.0,
            ));
        }

        let mut root_layout = LayoutNode::with_children(
            ui_layout::Style::default(),
            [LayoutNode::new(ui_layout::Style::default())],
        );
        root_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 300.0, 200.0, 300.0, 200.0));
        let mut child_layout = LayoutNode::new(ui_layout::Style::default());
        child_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(50.0, 50.0, 40.0, 30.0, 40.0, 30.0));
        root_layout.children[0] = ui_layout::LayoutChild::Node(Box::new(child_layout));
        let mut root_info = container_info(false, None);
        root_info.children.push(custom_info);

        // Visual popup area: local popup (0,30)-(40,50) -> box local (50,80)-(90,100)
        // -> translated to (110,80)-(150,100).
        let path = hit_test(&root_layout, &root_info, 120.0, 90.0);
        assert!(hit_custom_node(&path).is_some());
        dispatch_pointer(&path, PointerEvent::Down { x: 120.0, y: 90.0 });
        assert_eq!(
            node.popup_events(),
            vec![PointerEvent::Down { x: 10.0, y: 10.0 }]
        );
        assert!(node.events().is_empty());
    }

    #[test]
    fn popup_hit_and_dispatch_on_inline_custom_node() {
        let node: Arc<RecordingNode> = Arc::new(RecordingNode::new(Rect {
            x: 0.0,
            y: 30.0,
            width: 100.0,
            height: 60.0,
        }));
        let custom_info = input_info(Arc::clone(&node) as Arc<dyn CustomNode>);

        let mut root_layout = LayoutNode::with_children(
            ui_layout::Style::default(),
            [LayoutNode::new(ui_layout::Style::default())],
        );
        root_layout.layout_box =
            ui_layout::LayoutBox::BlockBox(box_model(0.0, 0.0, 400.0, 400.0, 400.0, 400.0));

        let mut inline_custom_layout = LayoutNode::new(ui_layout::Style::default());
        inline_custom_layout.layout_box = ui_layout::LayoutBox::InlineBox(ui_layout::InlineBox {
            box_model: box_model(40.0, 50.0, 100.0, 30.0, 100.0, 30.0),
            line_spans: vec![ui_layout::LineSpan {
                x_range: 40.0..140.0,
                line_pos: (40.0, 50.0),
                line_index: 0,
            }],
        });
        root_layout.children[0] = ui_layout::LayoutChild::Node(Box::new(inline_custom_layout));

        let mut root_info = container_info(false, None);
        root_info.children.push(custom_info);

        // Global (60, 95): inside popup at (40, 80)-(140, 140).
        // Custom content local: (60-40, 95-50) = (20, 45).
        // Popup local: (20, 45-30) = (20, 15).
        let path = hit_test(&root_layout, &root_info, 60.0, 95.0);
        assert!(hit_custom_node(&path).is_some());
        assert!(!dismiss_open_popups(&root_info, &path, 60.0, 95.0));
        dispatch_pointer(&path, PointerEvent::Down { x: 60.0, y: 95.0 });
        assert_eq!(
            node.popup_events(),
            vec![PointerEvent::Down { x: 20.0, y: 15.0 }]
        );
        assert!(node.events().is_empty());
    }

    #[test]
    fn popup_escaping_ancestor_box_receives_dispatch() {
        let (root_layout, root_info, node) = make_tree(0.0);
        // Container box ends at y=120, popup reaches y=132.
        // Click at (20, 125): inside popup, outside container.
        let path = hit_test(&root_layout, &root_info, 20.0, 125.0);
        assert!(hit_custom_node(&path).is_some());
        assert!(!dismiss_open_popups(&root_info, &path, 20.0, 125.0));

        // Global (20, 125) -> local (20-15, 125-20) = (5, 105)
        // -> inside popup (y in 28..112) -> popup local (5, 105-28=77).
        dispatch_pointer(&path, PointerEvent::Down { x: 20.0, y: 125.0 });
        assert_eq!(
            node.popup_events(),
            vec![PointerEvent::Down { x: 5.0, y: 77.0 }]
        );
        assert!(node.events().is_empty());
    }
}