//! Hit-test result types for determining which DOM nodes are under the cursor,

//! scroll state tracking, and pipeline/document identification. These types

//! feed into the event dispatch system.

use alloc::collections::BTreeMap;

use core::{

    fmt,

    sync::atomic::{AtomicU32, Ordering as AtomicOrdering},

};

use crate::{

    dom::{DomId, DomNodeHash, DomNodeId, OptionDomNodeId, ScrollTagId, ScrollbarOrientation, TagId},

    geom::{LogicalPosition, LogicalRect, LogicalSize},

    id::NodeId,

    resources::IdNamespace,

    window::MouseCursorType,

    OrderedMap,

};

/// Result of a hit test against a single DOM, containing all nodes hit

/// by the cursor along with scroll, scrollbar, and cursor-type information.

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]

pub struct HitTest {

    pub regular_hit_test_nodes: BTreeMap<NodeId, HitTestItem>,

    pub scroll_hit_test_nodes: BTreeMap<NodeId, ScrollHitTestItem>,

    /// Hit test results for scrollbar components.

    pub scrollbar_hit_test_nodes: BTreeMap<ScrollbarHitId, ScrollbarHitTestItem>,

    /// Hit test results for cursor areas (text runs with cursor property).

    /// Maps `NodeId` to (`CursorType`, `hit_depth`) - the cursor type and z-depth of the hit.

    pub cursor_hit_test_nodes: BTreeMap<NodeId, CursorHitTestItem>,

}

/// Hit test item for cursor areas (determines which cursor icon to show).

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd)]

#[repr(C)]

pub struct CursorHitTestItem {

    pub cursor_type: CursorType,

    pub hit_depth: u32,

    pub point_in_viewport: LogicalPosition,

}

impl HitTest {

}

/// Unique identifier for a specific component of a scrollbar.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C, u8)]

pub enum ScrollbarHitId {

    VerticalTrack(DomId, NodeId),

    VerticalThumb(DomId, NodeId),

    HorizontalTrack(DomId, NodeId),

    HorizontalThumb(DomId, NodeId),

}

/// Hit test item specifically for scrollbar components.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd)]

#[repr(C)]

pub struct ScrollbarHitTestItem {

    pub point_in_viewport: LogicalPosition,

    pub point_relative_to_item: LogicalPosition,

    pub orientation: ScrollbarOrientation,

}

/// Scroll frame identifier combining a unique `u64` tag with its owning `PipelineId`.

#[derive(Copy, Clone, Eq, Hash, PartialEq, Ord, PartialOrd)]

#[repr(C)]

pub struct ExternalScrollId(pub u64, pub PipelineId);

impl ::core::fmt::Display for ExternalScrollId {

}

impl ::core::fmt::Debug for ExternalScrollId {

}

/// A node whose content overflows its parent, requiring scroll handling.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd)]

pub struct OverflowingScrollNode {

    pub parent_rect: LogicalRect,

    pub child_rect: LogicalRect,

    pub virtual_child_rect: LogicalRect,

    pub parent_external_scroll_id: ExternalScrollId,

    pub parent_dom_hash: DomNodeHash,

    pub scroll_tag_id: ScrollTagId,

}

impl Default for OverflowingScrollNode {

        use crate::dom::TagId;

}

/// Extra source identifier within a pipeline, allowing multiple independent

/// subsystems to generate `PipelineId` values without collision.

///

/// All pipelines still share the same `IdNamespace` and `DocumentId`.

pub type PipelineSourceId = u32;

/// Information about a scroll frame, given to the user by the framework.

///

/// The two rects are NOT in the same coordinate space — never subtract one

/// origin from the other. That silent ambiguity put the scrollbar thumb

/// partway down the track for every container not at the window origin.

/// See `ScrollManager::get_scroll_states_for_dom` for the producer.

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd)]

pub struct ScrollPosition {

    /// The scroll container's border box in ABSOLUTE window coordinates.

    /// `size` is the scrollport ("how big is the parent container", so

    /// "scroll to left edge" can be implemented); `origin` is where that

    /// container sits on screen and is only meaningful to scroll-into-view.

    pub parent_rect: LogicalRect,

    /// `size` = the scrollable content ("the union of all children", or the

    /// `VirtualView` virtual size when one was reported).

    /// `origin` = the SCROLL OFFSET ITSELF — distance already scrolled from

    /// the scroll origin, normally clamped to `[0, content − container]`.

    /// It is NOT an absolute position and NOT relative to

    /// `parent_rect.origin`; content paints at `position − origin`.

    pub children_rect: LogicalRect,

}

/// Identifies a document within a namespace, used for multi-document rendering.

#[derive(Copy, Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]

pub struct DocumentId {

    pub namespace_id: IdNamespace,

    pub id: u32,

}

impl ::core::fmt::Display for DocumentId {

            self.namespace_id, self.id

        )

}

impl ::core::fmt::Debug for DocumentId {

}

/// Identifies a rendering pipeline by source and sequence number.

#[derive(Copy, Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]

pub struct PipelineId(pub PipelineSourceId, pub u32);

impl ::core::fmt::Display for PipelineId {

}

impl ::core::fmt::Debug for PipelineId {

}

static LAST_PIPELINE_ID: AtomicU32 = AtomicU32::new(0);

impl Default for PipelineId {

}

impl PipelineId {

    pub const DUMMY: Self = Self(0, 0);

}

/// A single hit-test result for a regular (non-scroll) DOM node.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd)]

pub struct HitTestItem {

    /// The hit point in the coordinate space of the "viewport" of the display item.

    /// The viewport is the scroll node formed by the root reference frame of the display item's

    /// pipeline.

    pub point_in_viewport: LogicalPosition,

    /// The coordinates of the original hit test point relative to the origin of this item.

    /// This is useful for calculating things like text offsets in the client.

    pub point_relative_to_item: LogicalPosition,

    /// Necessary to easily get the nearest `VirtualView` node

    pub is_focusable: bool,

    /// If this hit is a `VirtualView` node, stores the `VirtualViews` `DomId` + the origin of the `VirtualView`

    pub is_virtual_view_hit: Option<(DomId, LogicalPosition)>,

    /// Z-order depth from `WebRender` hit test (0 = frontmost/topmost in z-order).

    /// Lower values are closer to the user. This preserves the ordering from

    /// `WebRender`'s hit test results which returns items front-to-back.

    pub hit_depth: u32,

}

/// A hit-test result for a scrollable DOM node.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd)]

pub struct ScrollHitTestItem {

    /// The hit point in the coordinate space of the "viewport" of the display item.

    /// The viewport is the scroll node formed by the root reference frame of the display item's

    /// pipeline.

    pub point_in_viewport: LogicalPosition,

    /// The coordinates of the original hit test point relative to the origin of this item.

    /// This is useful for calculating things like text offsets in the client.

    pub point_relative_to_item: LogicalPosition,

    /// If this hit is a `VirtualView` node, stores the `VirtualViews` `DomId` + the origin of the `VirtualView`

    pub scroll_node: OverflowingScrollNode,

}

/// Map of active scroll states, keyed by their external scroll ID.

#[derive(Debug, Default)]

pub struct ScrollStates(pub OrderedMap<ExternalScrollId, ScrollState>);

impl ScrollStates {

    /// Set the scroll amount - does not update the `entry.used_this_frame`,

    /// since that is only relevant when we are actually querying the renderer.

    /// Updating (add to) the existing scroll amount does not update the

    /// `entry.used_this_frame`, since that is only relevant when we are

    /// actually querying the renderer.

}

/// Compute the maximum scrollable range for a scroll node.

///

/// The maximum scroll offset is `content − viewport` (`child_rect − parent_rect`),

/// clamped to `>= 0`. Previously the scroll position was clamped to the full

/// content size, which let the content scroll entirely out of view. The returned

/// rect keeps `child_rect.origin` and stores the max offset in `size`.

        ),

    )

/// Current scroll position for a single scroll frame.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd)]

#[repr(C)]

pub struct ScrollState {

    /// Amount in pixel that the current node is scrolled

    pub scroll_position: LogicalPosition,

}

impl_option!(

    ScrollState,

    OptionScrollState,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd]

);

impl ScrollState {

    /// Return the current position of the scroll state

    /// Add a scroll X / Y onto the existing scroll state.

    ///

    /// `max_scroll_rect` is the *scroll range* rect: its size is the maximum

    /// scrollable offset (`content − viewport`, clamped to `>= 0`), NOT the full

    /// content size. See [`ScrollStates::scroll_node`]. Clamping via `.max(0.0)`

    /// first also collapses any NaN input to `0.0` (`f32::max` returns the

    /// non-NaN operand), so a NaN delta can never poison the scroll position.

    /// Set the scroll state to a new position.

    ///

    /// `max_scroll_rect` is the *scroll range* rect (see [`ScrollState::add`]).

}

impl Default for ScrollState {

}

/// Complete hit-test result across all DOMs, including the currently focused node.

#[derive(Debug, Clone, PartialEq, Eq)]

pub struct FullHitTest {

    pub hovered_nodes: BTreeMap<DomId, HitTest>,

    pub focused_node: OptionDomNodeId,

}

impl FullHitTest {

    /// Create an empty hit-test result

    /// Returns `true` if no nodes were hovered (ignores `focused_node`).

}

/// Result of determining which mouse cursor icon to display based on hit-test results.

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]

pub struct CursorTypeHitTest {

    /// closest-node is used for determining the cursor: property

    /// The node is guaranteed to have a non-default cursor: property,

    /// so that the cursor icon can be set accordingly

    pub cursor_node: Option<(DomId, NodeId)>,

    /// Mouse cursor type to set (if `cursor_node` is None, this is set to

    /// `MouseCursorType::Default`)

    pub cursor_icon: MouseCursorType,

}

// ============================================================================

// Type-safe hit-test tag system (merged from the former `hit_test_tag` module).

//

// Encodes WebRender's ItemTag = (u64, u16): the tag *type* lives in the upper

// byte of tag.1 (DOM node / scrollbar / selection / cursor / scroll-container),

// keeping tag types free of bit-level conflicts. See the TAG_TYPE_* constants.

// ============================================================================

// ============================================================================

// Tag Type Markers (stored in upper byte of ItemTag.1)

// ============================================================================

/// Marker for DOM node tags (regular UI elements with callbacks, focus, etc.)

pub const TAG_TYPE_DOM_NODE: u16 = 0x0100;

/// Marker for scrollbar component tags

pub const TAG_TYPE_SCROLLBAR: u16 = 0x0200;

/// Marker for text selection hit-test areas (determines text selection regions)

///

/// These are pushed for text runs to enable text selection without affecting

/// other hit-test logic. Selection may trigger re-rendering.

///

/// NOTE: Text selection hit-testing currently uses `TAG_TYPE_CURSOR` (0x0400).

/// This constant is used by the `HitTestTag::Selection` variant for encoding

/// selection-specific tags (e.g., text run selection areas).

pub const TAG_TYPE_SELECTION: u16 = 0x0300;

/// Marker for cursor hit-test areas (determines which cursor icon to show)

///

/// These are separate from DOM node tags to allow efficient cursor resolution

/// without iterating over all DOM nodes. Cursor changes never require re-rendering.

pub const TAG_TYPE_CURSOR: u16 = 0x0400;

/// Marker for scroll container hit-test areas (for trackpad/wheel scrolling)

///

/// These identify scrollable containers even when no DOM node callbacks are registered.

/// Scroll containers push this tag so the scroll manager can find them during wheel events.

pub const TAG_TYPE_SCROLL_CONTAINER: u16 = 0x0500;

// ============================================================================

// Scrollbar Component Types (stored in lower byte of ItemTag.1 for scrollbar tags)

// ============================================================================

/// Scrollbar component type identifier.

///

/// Each scrollable container can have up to 2 scrollbars (vertical + horizontal),

/// and each scrollbar has 2 main hit regions (track + thumb).

///

/// Future extensions could add:

/// - `UpButton`, `DownButton`, `LeftButton`, `RightButton` for scroll arrows

/// - `PageUp`, `PageDown` for page-scroll regions

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(u8)]

pub enum ScrollbarComponent {

    /// The vertical scrollbar track (background area)

    VerticalTrack = 0,

    /// The vertical scrollbar thumb (draggable handle)

    VerticalThumb = 1,

    /// The horizontal scrollbar track (background area)

    HorizontalTrack = 2,

    /// The horizontal scrollbar thumb (draggable handle)

    HorizontalThumb = 3,

    // Future: scroll arrow buttons

    // VerticalUpButton = 4,

    // VerticalDownButton = 5,

    // HorizontalLeftButton = 6,

    // HorizontalRightButton = 7,

}

impl ScrollbarComponent {

    /// Convert from raw u8 value

        }

}

// ============================================================================

// WebRender Hit-Test Tag (unified type-safe representation)

// ============================================================================

/// Unified, type-safe representation of a `WebRender` hit-test tag.

///

/// This enum represents all possible types of hit-test targets. Each variant

/// can be encoded to and decoded from `WebRender`'s `(u64, u16)` `ItemTag` format.

///

/// ## Namespace Separation

///

/// Different tag types are kept in separate namespaces to:

/// - Enable efficient hit-test queries (only iterate over relevant tags)

/// - Get automatic depth sorting from `WebRender` per namespace

/// - Prevent accidental collisions between different hit-test purposes

///

/// | Namespace | Purpose                              |

/// |-----------|--------------------------------------|

/// | 0x0100    | DOM nodes (callbacks, focus, hover)  |

/// | 0x0200    | Scrollbar components                 |

/// | 0x0300    | Selection areas (text selection)     |

/// | 0x0400    | Cursor areas (cursor icon display)     |

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]

pub enum HitTestTag {

    /// A regular DOM node (button, div, text container, etc.)

    ///

    /// These are nodes that have callbacks, are focusable, or have hover styles.

    /// The `TagId` is a sequential counter assigned during DOM styling.

    DomNode {

        /// The unique tag ID assigned to this DOM node

        tag_id: TagId,

    },

    /// A scrollbar component (track or thumb)

    ///

    /// Each scrollable container can have up to 2 scrollbars.

    /// The scrollbar is identified by the `DomId` and `NodeId` of the scrollable container.

    Scrollbar {

        /// The DOM that contains the scrollable container

        dom_id: DomId,

        /// The `NodeId` of the scrollable container (not the scrollbar itself)

        node_id: NodeId,

        /// Which component of the scrollbar was hit

        component: ScrollbarComponent,

    },

    /// A cursor hit-test area (determines which cursor icon to display)

    ///

    /// These are pushed separately from DOM nodes to allow efficient cursor

    /// resolution. The cursor type is encoded in the lower byte of tag.1.

    Cursor {

        /// The DOM node this cursor area belongs to

        dom_id: DomId,

        /// The `NodeId` of the element with the cursor property

        node_id: NodeId,

        /// The cursor type to display when hovering over this area

        cursor_type: CursorType,

    },

    /// A text selection hit-test area

    ///

    /// These are pushed for text runs to enable text selection.

    /// Separate from DOM nodes to prevent interference with other hit-testing.

    Selection {

        /// The DOM containing the text

        dom_id: DomId,

        /// The `NodeId` of the text container (not the Text node itself)

        container_node_id: NodeId,

        /// The index of the text run within the container (for multi-line text)

        text_run_index: u16,

    },

}

/// Cursor type encoded in cursor hit-test tags.

/// Stored in the lower byte of the ItemTag.1 field.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]

#[repr(u8)]

pub enum CursorType {

    #[default]

    Default = 0,

    Pointer = 1,

    Text = 2,

    Crosshair = 3,

    Move = 4,

    NotAllowed = 5,

    Grab = 6,

    Grabbing = 7,

    EResize = 8,

    WResize = 9,

    NResize = 10,

    SResize = 11,

    EwResize = 12,

    NsResize = 13,

    NeswResize = 14,

    NwseResize = 15,

    ColResize = 16,

    RowResize = 17,

    Wait = 18,

    Help = 19,

    Progress = 20,

    // Add more as needed, up to 255

}

impl CursorType {

    /// Convert from raw u8 value

    // Explicit u8 -> variant table documenting every discriminant; `0 => Default`

    // intentionally mirrors the `_ => Default` fallback (the `#[default]` is 0).

    #[allow(clippy::match_same_arms)]

        }

}

impl HitTestTag {

    /// Encode this tag to `WebRender`'s `ItemTag` format.

    ///

    /// Returns `(u64, u16)` suitable for passing to `WebRender`'s `push_hit_test`.

                // tag.0 = TagId.inner (the sequential counter)

                // tag.1 = TAG_TYPE_DOM_NODE marker

            }

            Self::Scrollbar {

            } => {

                // tag.0 = DomId (upper 32 bits) | NodeId (lower 32 bits)

                // tag.1 = TAG_TYPE_SCROLLBAR | component type in lower byte

            }

            Self::Cursor {

            } => {

                // tag.0 = DomId (upper 32 bits) | NodeId (lower 32 bits)

                // tag.1 = TAG_TYPE_CURSOR | cursor type in lower byte

            }

            Self::Selection {

            } => {

                // tag.0 = DomId (upper 16 bits) | NodeId (middle 32 bits) | text_run_index (lower 16 bits)

                // AUDIT: mask each field to its bit width so an out-of-range DomId /

                // NodeId can never bleed into an adjacent field (silent cross-field

                // corruption). Masking clamps consistently in debug and release —

                // a >16-bit DomId is absurd but must degrade gracefully, not panic.

            }

        }

    /// Decode a `WebRender` `ItemTag` back to a typed `HitTestTag`.

    ///

    /// Returns `None` if the tag format is invalid or unrecognized.

        // Extract tag type from upper byte

            TAG_TYPE_DOM_NODE => {

                // DOM node tag: tag.0 is the TagId

            }

            TAG_TYPE_SCROLLBAR => {

                // Scrollbar tag: decode DomId, NodeId, and component

            }

            TAG_TYPE_CURSOR => {

                // Cursor tag: decode DomId, NodeId, and cursor type

            }

            TAG_TYPE_SELECTION => {

                // Selection tag: decode DomId, NodeId, and text run index

            }

            _ => {

                // Unknown tag type - could be a legacy tag or corruption

                // For backwards compatibility, treat tags with tag_type == 0

                // as legacy DOM node tags (old format before type markers)

                } else {

                }

            }

        }

    /// Check if this is a DOM node tag

    /// Check if this is a scrollbar tag

    /// Check if this is a cursor tag

    /// Check if this is a selection tag

    /// Get the `TagId` if this is a DOM node tag

        }

    /// Get cursor info if this is a cursor tag

            Self::Cursor {

        }

    /// Get selection info if this is a selection tag

            Self::Selection {

        }

    /// Get scrollbar info if this is a scrollbar tag

            Self::Scrollbar {

        }

}

impl fmt::Display for HitTestTag {

            }

            Self::Scrollbar {

            } => {

                    dom_id.inner,

                    component

                )

            }

            Self::Cursor {

            } => {

                    dom_id.inner,

                    cursor_type

                )

            }

            Self::Selection {

            } => {

                    dom_id.inner,

                    text_run_index

                )

            }

        }

}

#[cfg(test)]

#[allow(clippy::float_cmp)] // exact-value assertions on computed layout floats

mod tests {

    use super::*;

    #[test]

    #[test]

    #[test]

        // A DOM node tag with value 673 should NOT be decoded as a scrollbar

        // Verify it has the correct type marker

        // Verify it decodes correctly

    #[test]

        // Old format tags had tag.1 == 0

        // They should be treated as DOM node tags for backwards compatibility

    #[test]

        // content 300 tall, viewport 100 tall -> max scroll offset = 200

    #[test]

        // content == viewport -> zero scroll range

    #[test]

    #[test]

        // A DomId > 0xFFFF must not bleed into the NodeId field. The masked

        // encode/decode round-trips within the 16-bit DomId window.

        // NodeId field (bits 16..48) is exactly 5, uncorrupted by the overflow.

        // DomId field is the low 16 bits of the input (0x0007).

}

#[cfg(test)]

#[allow(

    clippy::float_cmp,

    clippy::cast_lossless,

    clippy::cast_possible_truncation,

    clippy::unreadable_literal

)]

mod autotest_generated {

    use super::*;

    // ------------------------------------------------------------------

    // helpers

    // ------------------------------------------------------------------

    fn r(x: f32, y: f32, w: f32, h: f32) -> LogicalRect {

        LogicalRect::new(LogicalPosition::new(x, y), LogicalSize::new(w, h))

    }

    /// An `OverflowingScrollNode` with only the two rects that `max_scroll_rect`

    /// actually reads set; everything else stays at its `Default`.

    fn scroll_node_of(parent: LogicalRect, child: LogicalRect) -> OverflowingScrollNode {

        OverflowingScrollNode {

            parent_rect: parent,

            child_rect: child,

            ..Default::default()

        }

    }

    fn ext_id(raw: u64) -> ExternalScrollId {

        ExternalScrollId(raw, PipelineId::DUMMY)

    }

    const ALL_CURSORS: [CursorType; 21] = [

        CursorType::Default,

        CursorType::Pointer,

        CursorType::Text,

        CursorType::Crosshair,

        CursorType::Move,

        CursorType::NotAllowed,

        CursorType::Grab,

        CursorType::Grabbing,

        CursorType::EResize,

        CursorType::WResize,

        CursorType::NResize,

        CursorType::SResize,

        CursorType::EwResize,

        CursorType::NsResize,

        CursorType::NeswResize,

        CursorType::NwseResize,

        CursorType::ColResize,

        CursorType::RowResize,

        CursorType::Wait,

        CursorType::Help,

        CursorType::Progress,

    ];

    const ALL_SCROLLBAR_COMPONENTS: [ScrollbarComponent; 4] = [

        ScrollbarComponent::VerticalTrack,

        ScrollbarComponent::VerticalThumb,

        ScrollbarComponent::HorizontalTrack,

        ScrollbarComponent::HorizontalThumb,

    ];

    // ------------------------------------------------------------------

    // HitTest / FullHitTest — constructors + predicates

    // ------------------------------------------------------------------

    #[test]

    fn hit_test_empty_is_neutral_element() {

        let h = HitTest::empty();

        assert!(h.is_empty());

        assert_eq!(h.regular_hit_test_nodes.len(), 0);

        assert_eq!(h.scroll_hit_test_nodes.len(), 0);

        assert_eq!(h.scrollbar_hit_test_nodes.len(), 0);

        assert_eq!(h.cursor_hit_test_nodes.len(), 0);

        // repeated construction is stable / equal

        assert_eq!(HitTest::empty(), HitTest::empty());

    }

    #[test]

    fn hit_test_is_empty_false_if_any_single_map_is_populated() {

        // Each of the four maps must independently flip `is_empty()` to false,

        // otherwise a hit in (say) only the cursor map would be silently dropped.

        let mut a = HitTest::empty();

        a.regular_hit_test_nodes.insert(

            NodeId::ZERO,

            HitTestItem {

                point_in_viewport: LogicalPosition::zero(),

                point_relative_to_item: LogicalPosition::zero(),

                is_focusable: false,

                is_virtual_view_hit: None,

                hit_depth: 0,

            },

        );

        assert!(!a.is_empty());

        let mut b = HitTest::empty();

        b.scroll_hit_test_nodes.insert(

            NodeId::new(usize::MAX),

            ScrollHitTestItem {

                point_in_viewport: LogicalPosition::zero(),

                point_relative_to_item: LogicalPosition::zero(),

                scroll_node: OverflowingScrollNode::default(),

            },

        );

        assert!(!b.is_empty());

        let mut c = HitTest::empty();

        c.scrollbar_hit_test_nodes.insert(

            ScrollbarHitId::VerticalTrack(DomId::ROOT_ID, NodeId::ZERO),

            ScrollbarHitTestItem {

                point_in_viewport: LogicalPosition::zero(),

                point_relative_to_item: LogicalPosition::zero(),

                orientation: ScrollbarOrientation::Vertical,

            },

        );

        assert!(!c.is_empty());

        let mut d = HitTest::empty();

        d.cursor_hit_test_nodes.insert(

            NodeId::ZERO,

            CursorHitTestItem {

                cursor_type: CursorType::Default,

                hit_depth: u32::MAX,

                point_in_viewport: LogicalPosition::new(f32::NAN, f32::INFINITY),

            },

        );

        assert!(!d.is_empty());

    }

    #[test]

    fn full_hit_test_empty_is_empty_regardless_of_focused_node() {

        let none = FullHitTest::empty(None);

        assert!(none.is_empty());

        assert!(none.focused_node.is_none());

        // `is_empty()` is documented to ignore `focused_node` — a focused node

        // must NOT make an unhovered hit test look non-empty.

        let focused = FullHitTest::empty(Some(DomNodeId::ROOT));

        assert!(focused.is_empty());

        assert!(focused.focused_node.is_some());

        assert_eq!(focused.hovered_nodes.len(), 0);

    }

    #[test]

    fn full_hit_test_is_empty_false_once_a_dom_is_hovered() {

        let mut f = FullHitTest::empty(None);

        f.hovered_nodes.insert(DomId::ROOT_ID, HitTest::empty());

        // NOTE: an *empty* HitTest inserted under a DomId still counts as

        // "hovered" — `is_empty()` only looks at the outer map's length.

        assert!(!f.is_empty());

    }

    // ------------------------------------------------------------------

    // PipelineId / DocumentId / ExternalScrollId — constructors + serializers

    // ------------------------------------------------------------------

    #[test]

    fn pipeline_id_new_is_monotonic_and_second_field_is_zero() {

        let a = PipelineId::new();

        let b = PipelineId::new();

        let c = PipelineId::default();

        // The counter only ever moves forward (other tests in this binary may

        // bump it concurrently, so assert ordering, not adjacency).

        assert!(b.0 > a.0);

        assert!(c.0 > b.0);

        assert_eq!(a.1, 0);

        assert_eq!(b.1, 0);

        assert_eq!(PipelineId::DUMMY, PipelineId(0, 0));

    }

    #[test]

    fn pipeline_id_display_and_debug_agree_on_edge_values() {

        assert_eq!(alloc::format!("{}", PipelineId::DUMMY), "PipelineId(0, 0)");

        let maxed = PipelineId(u32::MAX, u32::MAX);

        let shown = alloc::format!("{maxed}");

        assert_eq!(shown, "PipelineId(4294967295, 4294967295)");

        assert_eq!(alloc::format!("{maxed:?}"), shown);

    }

    #[test]

    fn document_id_display_handles_min_and_max() {

        let zero = DocumentId {

            namespace_id: IdNamespace(0),

            id: 0,

        };

        let maxed = DocumentId {

            namespace_id: IdNamespace(u32::MAX),

            id: u32::MAX,

        };

        for d in [zero, maxed] {

            let shown = alloc::format!("{d}");

            assert!(!shown.is_empty());

            assert!(shown.starts_with("DocumentId {"));

            // Debug delegates to Display, so the two must be byte-identical.

            assert_eq!(alloc::format!("{d:?}"), shown);

        }

        assert!(alloc::format!("{maxed}").contains("4294967295"));

    }

    #[test]

    fn external_scroll_id_display_omits_the_pipeline_but_keys_stay_distinct() {

        let a = ExternalScrollId(7, PipelineId(1, 0));

        let b = ExternalScrollId(7, PipelineId(2, 0));

        // Display/Debug only render `.0` — they are deliberately lossy, so two

        // *different* IDs can format identically. Guard that this laxness never

        // leaks into equality/ordering (which is what BTreeMap keys rely on).

        assert_eq!(alloc::format!("{a}"), "ExternalScrollId(7)");

        assert_eq!(alloc::format!("{a:?}"), alloc::format!("{b:?}"));

        assert_ne!(a, b);

        let mut states = ScrollStates::new();

        states.0.insert(a, ScrollState::default());

        states.0.insert(b, ScrollState::default());

        assert_eq!(states.0.len(), 2);

    }

    #[test]

    fn external_scroll_id_display_no_panic_at_u64_max() {

        let shown = alloc::format!("{}", ExternalScrollId(u64::MAX, PipelineId::DUMMY));

        assert_eq!(shown, "ExternalScrollId(18446744073709551615)");

    }

    // ------------------------------------------------------------------

    // max_scroll_rect — numeric edge cases

    // ------------------------------------------------------------------

    #[test]

    fn max_scroll_rect_is_content_minus_viewport_and_keeps_origin() {

        let max = max_scroll_rect(&scroll_node_of(

            r(0.0, 0.0, 100.0, 100.0),

            r(-12.5, 7.25, 400.0, 300.0),

        ));

        assert_eq!(max.size.width, 300.0);

        assert_eq!(max.size.height, 200.0);

        // documented: the returned rect keeps `child_rect.origin`

        assert_eq!(max.origin.x, -12.5);

        assert_eq!(max.origin.y, 7.25);

    }

    #[test]

    fn max_scroll_rect_clamps_negative_range_to_zero() {

        // viewport larger than content -> nothing to scroll (must not go negative)

        let max = max_scroll_rect(&scroll_node_of(

            r(0.0, 0.0, 500.0, 500.0),

            r(0.0, 0.0, 100.0, 100.0),

        ));

        assert_eq!(max.size.width, 0.0);

        assert_eq!(max.size.height, 0.0);

    }

    #[test]

    fn max_scroll_rect_nan_and_infinite_sizes_do_not_produce_nan() {

        // NaN content size: `NaN - x` is NaN, and `.max(0.0)` collapses it to 0.0.

        let nan = max_scroll_rect(&scroll_node_of(

            r(0.0, 0.0, 10.0, 10.0),

            r(0.0, 0.0, f32::NAN, f32::NAN),

        ));

        assert!(!nan.size.width.is_nan());

        assert!(!nan.size.height.is_nan());

        assert_eq!(nan.size.width, 0.0);

        assert_eq!(nan.size.height, 0.0);

        // inf - inf == NaN -> also collapses to 0.0 rather than poisoning scroll.

        let both_inf = max_scroll_rect(&scroll_node_of(

            r(0.0, 0.0, f32::INFINITY, f32::INFINITY),

            r(0.0, 0.0, f32::INFINITY, f32::INFINITY),

        ));

        assert_eq!(both_inf.size.width, 0.0);

        assert_eq!(both_inf.size.height, 0.0);

        // Infinite content over a finite viewport stays infinite (unbounded scroll).

        let inf = max_scroll_rect(&scroll_node_of(

            r(0.0, 0.0, 10.0, 10.0),

            r(0.0, 0.0, f32::INFINITY, f32::INFINITY),

        ));

        assert!(inf.size.width.is_infinite() && inf.size.width.is_sign_positive());

        assert!(inf.size.height.is_infinite() && inf.size.height.is_sign_positive());

    }

    #[test]

    fn max_scroll_rect_at_float_extremes_does_not_panic() {

        let max = max_scroll_rect(&scroll_node_of(

            r(f32::MIN, f32::MIN, f32::MIN_POSITIVE, f32::MAX),

            r(f32::MAX, f32::MAX, f32::MAX, f32::MIN_POSITIVE),

        ));

        assert!(max.size.width >= 0.0);

        assert!(max.size.height >= 0.0);

        assert!(!max.size.width.is_nan());

        assert!(!max.size.height.is_nan());

    }

    // ------------------------------------------------------------------

    // ScrollState — numeric (zero / negative / min-max / overflow / NaN)

    // ------------------------------------------------------------------

    #[test]

    fn scroll_state_default_and_get_round_trip() {

        let st = ScrollState::default();

        assert_eq!(st.get(), LogicalPosition::zero());

        let st = ScrollState {

            scroll_position: LogicalPosition::new(3.5, -4.25),

        };

        // `get` is a pure accessor: it must not clamp or normalize.

        assert_eq!(st.get().x, 3.5);

        assert_eq!(st.get().y, -4.25);

    }

    #[test]

    fn scroll_state_set_zero_is_identity_within_range() {

        let max = r(0.0, 0.0, 100.0, 200.0);

        let mut st = ScrollState::default();

        st.set(0.0, 0.0, &max);

        assert_eq!(st.get(), LogicalPosition::zero());

        st.set(50.0, 150.0, &max);

        assert_eq!(st.get().x, 50.0);

        assert_eq!(st.get().y, 150.0);

    }

    #[test]

    fn scroll_state_set_clamps_negative_to_zero_and_overshoot_to_max() {

        let max = r(0.0, 0.0, 100.0, 200.0);

        let mut st = ScrollState::default();

        st.set(-1.0, -f32::MAX, &max);

        assert_eq!(st.get().x, 0.0);

        assert_eq!(st.get().y, 0.0);

        st.set(f32::MAX, f32::MAX, &max);

        assert_eq!(st.get().x, 100.0);

        assert_eq!(st.get().y, 200.0);

        st.set(f32::INFINITY, f32::INFINITY, &max);

        assert_eq!(st.get().x, 100.0);

        assert_eq!(st.get().y, 200.0);

        st.set(f32::NEG_INFINITY, f32::NEG_INFINITY, &max);

        assert_eq!(st.get().x, 0.0);

        assert_eq!(st.get().y, 0.0);

    }

    #[test]

    fn scroll_state_set_nan_position_collapses_to_zero() {

        let max = r(0.0, 0.0, 100.0, 200.0);

        let mut st = ScrollState {

            scroll_position: LogicalPosition::new(40.0, 40.0),

        };

        st.set(f32::NAN, f32::NAN, &max);

        assert!(!st.get().x.is_nan());

        assert!(!st.get().y.is_nan());

        assert_eq!(st.get(), LogicalPosition::zero());

    }

    #[test]

    fn scroll_state_set_nan_max_range_collapses_to_zero() {

        // A NaN *range* must not leak into the position either: `NaN.max(0.0)`

        // is 0.0, so the position clamps to 0 rather than becoming NaN.

        let max = r(0.0, 0.0, f32::NAN, f32::NAN);

        let mut st = ScrollState::default();

        st.set(75.0, 75.0, &max);

        assert_eq!(st.get(), LogicalPosition::zero());

    }

    #[test]

    fn scroll_state_set_negative_max_range_collapses_to_zero() {

        let max = r(0.0, 0.0, -50.0, -50.0);

        let mut st = ScrollState::default();