┌─────────────────────────────────────────────────────────────────────────────┐
│                           HIT-TEST PIPELINE                                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. DISPLAY LIST BUILDING (layout/src/solver3/display_list.rs)              │
│     ┌─────────────────────────────────────────────────────────┐             │
│     │ paint_node_content()      → push_hit_test_area()        │             │
│     │ paint_inline_shape()      → push_hit_test_area() [HACK] │             │
│     │ generate_for_stacking_context() → push_hit_test_area()  │             │
│     └─────────────────────────────────────────────────────────┘             │
│                              ↓                                              │
│  2. TAG-ID ASSIGNMENT (core/src/prop_cache.rs)                              │
│     ┌─────────────────────────────────────────────────────────┐             │
│     │ CssPropertyCache::restyle() → creates TagIdToNodeIdMapping            │
│     │ Nodes get tags if they have:                            │             │
│     │   - Callbacks (onClick, onHover, etc.)                  │             │
│     │   - :hover/:active/:focus CSS pseudo-classes            │             │
│     │   - Non-default cursor: property                        │             │
│     │   - overflow: scroll/auto                               │             │
│     │   - Selectable text children [HACK]                     │             │
│     └─────────────────────────────────────────────────────────┘             │
│                              ↓                                              │
│  3. WEBRENDER HIT-TEST (dll/src/desktop/wr_translate2.rs)                   │
│     ┌─────────────────────────────────────────────────────────┐             │
│     │ fullhittest_new_webrender()                             │             │
│     │   - Calls WebRender's hit_test(physical_pos)            │             │
│     │   - Results are FRONT-TO-BACK (depth 0 = frontmost)     │             │
│     │   - Maps tags back to NodeIds via TagIdToNodeIdMapping  │             │
│     │   - Stores hit_depth from enumerate() index             │             │
│     └─────────────────────────────────────────────────────────┘             │
│                              ↓                                              │
│  4. CURSOR TYPE RESOLUTION (layout/src/hit_test.rs)                         │
│     ┌─────────────────────────────────────────────────────────┐             │
│     │ CursorTypeHitTest::new()                                │             │
│     │   - Iterates all hit nodes                              │             │
│     │   - Finds node with cursor: property                    │             │
│     │   - PROBLEM: Uses WRONG depth comparison                │             │
│     └─────────────────────────────────────────────────────────┘             │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

// AKTUELLER BUGGY CODE:
let mut best_depth: u32 = 0;  // ← Initialisiert auf 0

// ...später...
if node_depth >= best_depth {  // ← Bevorzugt HÖHERE depths
    cursor_node = Some((*dom_id, *node_id));
    cursor_icon = translated;
    best_depth = node_depth;
}

DOM 0: 3 hit nodes
  NodeId=3 depth=0 type=Text      ← Text im Button (VORDERSTER)
  NodeId=2 depth=1 type=Button    ← Button
  NodeId=0 depth=2 type=Body      ← Body (HINTERSTER)
    -> text child NodeId=1 text_depth=3  ← HACK fügt depth hinzu!
  RESULT: cursor_icon=Text        ← FALSCH! Sollte Pointer sein

let mut best_depth: u32 = u32::MAX;  // ← u32::MAX statt 0

if node_depth < best_depth {  // ← KLEINER statt größer
    cursor_node = Some((*dom_id, *node_id));
    cursor_icon = translated;
    best_depth = node_depth;
}

// Für jeden gehitteten Node, schaue ob er Text-Kinder hat
let hier = &node_hierarchy[*node_id];
if let Some(first_child) = hier.first_child_id(*node_id) {
    let mut child_id = Some(first_child);
    while let Some(cid) = child_id {
        let child_data = &node_data_container[cid];
        if matches!(child_data.get_node_type(), NodeType::Text(_)) {
            // Text-Kind gefunden → erhöhe Depth um 1
            let text_depth = node_depth + 1;  // ← KÜNSTLICHE DEPTH-ERHÖHUNG
            if text_depth > best_depth {
                // Setze Cursor auf Text-Child's cursor (I-beam)
                cursor_icon = translate_cursor(css_cursor);
            }
        }
    }
}

// Check for selectable text - nodes that contain text children and 
// user-select != none need hit-test tags for text selection support
let node_has_selectable_text = {
    // Check if this node has immediate text children
    let has_text_children = {
        let hier = node_hierarchy.as_container()[node_id];
        let mut has_text = false;
        if let Some(first_child) = hier.first_child_id(node_id) {
            let mut child_id = Some(first_child);
            while let Some(cid) = child_id {
                let child_data = &node_data_container[cid.index()];
                if matches!(child_data.get_node_type(), NodeType::Text(_)) {
                    has_text = true;
                    break;
                }
                child_id = node_hierarchy.as_container()[cid].next_sibling_id();
            }
        }
        has_text
    };
    
    if has_text_children {
        // Prüfe user-select property
        !matches!(user_select, StyleUserSelect::None)
    } else {
        false
    }
};

if node_has_selectable_text {
    node_should_have_tag = true;  // ← CONTAINER bekommt Tag, nicht Text-Node
}

Body (NodeId=0)
  ├── Text "Hello " (NodeId=1)
  ├── Button (NodeId=2)
  │     └── Text "Click me" (NodeId=3)
  └── ...

1. Text "Click me" (NodeId=3) - depth=0 - VORDERSTER
2. Button (NodeId=2)          - depth=1 - cursor:pointer
3. Body (NodeId=0)            - depth=2 - HINTERSTER

best_depth = 0  // Initial

NodeId=3 (Text, depth=0):
  - Hat cursor:text (aus UA CSS)
  - depth=0 >= best_depth=0 → NICHT AUSGEWÄHLT (weil Code >= und nicht > nutzt)

NodeId=2 (Button, depth=1):
  - Hat cursor:pointer (aus UA CSS)  
  - depth=1 >= best_depth=0 → AUSGEWÄHLT
  - best_depth = 1

NodeId=0 (Body, depth=2):
  - Kein cursor property auf Body selbst
  - ABER: Text-Child-Hack schaut nach Kindern
  - Findet Text (NodeId=1) → text_depth = 2+1 = 3
  - 3 > best_depth=1 → Text-Child "GEWINNT"!
  - cursor_icon = Text (I-beam)

ERGEBNIS: cursor=Text, node=Body
ERWARTET: cursor=Pointer, node=Button

// layout/src/hit_test.rs

impl CursorTypeHitTest {
    pub fn new(hit_test: &FullHitTest, layout_window: &LayoutWindow) -> Self {
        let mut cursor_node = None;
        let mut cursor_icon = MouseCursorType::Default;
        let mut best_depth: u32 = u32::MAX;  // ← ÄNDERN

        for (dom_id, hit_nodes) in hit_test.hovered_nodes.iter() {
            // ...
            for (node_id, hit_item) in hit_nodes.regular_hit_test_nodes.iter() {
                let node_depth = hit_item.hit_depth;
                
                // FIX: Kleinere depth = weiter vorne = höhere Priorität
                if node_depth < best_depth {  // ← ÄNDERN
                    if let Some(cursor_prop) = cursor_prop_opt {
                        cursor_node = Some((*dom_id, *node_id));
                        cursor_icon = translate_cursor(css_cursor);
                        best_depth = node_depth;
                    }
                }
            }
        }
        // ...
    }
}

Hit nodes: Text(3,depth=0), Button(2,depth=1), Body(0,depth=2)
Text(3) hat cursor:text, depth=0 < u32::MAX → AUSGEWÄHLT
ERGEBNIS: cursor=Text (I-beam) über Text

Hit nodes: Button(2,depth=0), Body(0,depth=1)
Button(2) hat cursor:pointer, depth=0 < u32::MAX → AUSGEWÄHLT
ERGEBNIS: cursor=Pointer über Button

Hit nodes: Text(1,depth=0), Body(0,depth=1)
Text(1) hat cursor:text, depth=0 < u32::MAX → AUSGEWÄHLT
ERGEBNIS: cursor=Text (I-beam) über Text

Hit nodes: Body(0,depth=0)
Body(0) hat kein cursor property → cursor=Default
ERGEBNIS: cursor=Default über Body-Hintergrund