tessera_ui/

component_tree.rs

mod constraint;
mod node;
mod node_map;
mod pointer;
mod replay;
mod scene;

use std::{
    cell::Cell,
    collections::{BinaryHeap, VecDeque},
    num::NonZero,
    sync::Arc,
};

use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
use smallvec::SmallVec;
use tracing::{debug, warn};

use crate::{
    NodeId, PxRect,
    clipboard::{self, ClipboardInput, ClipboardResponse, QueuedClipboardAction},
    cursor::{CursorEventContent, MOUSE_POINTER_ID, PointerChange},
    focus::{
        FocusDirection, FocusHandleId, FocusOwner, PendingFocusCallbackInvocation, bind_focus_owner,
    },
    keyboard_state::QueuedInput,
    layout::{LayoutResult, RenderInput},
    modifier::{
        DrawModifierContent, DrawModifierContext, OrderedModifierAction, PointerInputModifierNode,
    },
    px::{PxPosition, PxSize},
    render_graph::RenderGraph,
    runtime::{
        LayoutDirtyNodes, RuntimePhase, StructureReconcileResult, TesseraRuntime,
        push_current_component_instance_key, push_current_node_with_instance_logic_id, push_phase,
    },
    time::Instant,
};

pub use constraint::{AxisConstraint, Constraint, ParentConstraint};
pub use node::{
    ComputedData, GloballyPositionedHandler, ImeInput, ImeInputHandlerFn, ImeRequest, ImeSession,
    KeyboardInput, KeyboardInputHandlerFn, MeasurementError, PointerEventPass, PointerInput,
    PointerInputHandlerFn,
};

pub(crate) use node::{
    ComponentNode, ComponentNodeMetaData, ComponentNodeMetaDatas, ComponentNodeTree, NodeRole,
    WindowDragRequest, WindowRequests, direct_layout_children, measure_node, sibling_index,
};
pub(crate) use scene::SceneRope;

#[cfg(feature = "profiling")]
use crate::profiler::{NodeMeta, Phase as ProfilerPhase, ScopeGuard as ProfilerScopeGuard};

#[derive(Clone)]
pub(crate) struct LayoutSnapshotEntry {
    pub constraint_key: Constraint,
    pub consumed_insets: crate::Insets,
    children: node::CachedLayoutChildren,
    pub layout_result: LayoutResult,
    pub base_placements: Option<Arc<[(u64, PxPosition)]>>,
    pub intrinsic_dependencies: bool,
    pub draw_layout: NodeDrawLayout,
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct DrawLayoutBounds {
    pub position: PxPosition,
    pub size: ComputedData,
}

#[derive(Clone, PartialEq)]
pub(crate) struct NodeDrawLayout {
    // Cached frames share immutable layer bounds instead of allocating a copy
    // for every restored node.
    pub layers: Option<Arc<[Option<DrawLayoutBounds>]>>,
    pub base_constraint: Constraint,
    pub base_size: ComputedData,
}

impl Default for NodeDrawLayout {
    fn default() -> Self {
        Self {
            layers: None,
            base_constraint: Constraint::NONE,
            base_size: ComputedData::ZERO,
        }
    }
}

#[derive(Default)]
pub(crate) struct LayoutSnapshotMap {
    entries: HashMap<u64, Arc<LayoutSnapshotEntry>>,
    deferred: HashMap<u64, DeferredLayoutInvalidation>,
}

#[derive(Clone, Default)]
pub(crate) struct DeferredLayoutInvalidation {
    pub measure: bool,
    pub placement: bool,
    pub children: HashSet<u64>,
}

impl LayoutSnapshotMap {
    pub(crate) fn clear(&mut self) {
        self.entries.clear();
        self.deferred.clear();
    }

    pub(crate) fn remove(&mut self, instance_key: &u64) -> Option<Arc<LayoutSnapshotEntry>> {
        self.deferred.remove(instance_key);
        self.entries.remove(instance_key)
    }

    pub(crate) fn insert(
        &mut self,
        instance_key: u64,
        entry: LayoutSnapshotEntry,
    ) -> Option<Arc<LayoutSnapshotEntry>> {
        self.deferred.remove(&instance_key);
        self.entries.insert(instance_key, Arc::new(entry))
    }

    pub(crate) fn get_cloned(&self, instance_key: &u64) -> Option<Arc<LayoutSnapshotEntry>> {
        self.entries.get(instance_key).cloned()
    }
}

pub(crate) fn nearest_replay_boundary_instance_key(
    node_id: NodeId,
    tree: &ComponentNodeTree,
) -> u64 {
    let mut current_id = node_id;
    let mut fallback = 0;

    loop {
        let Some(node_ref) = tree.get(current_id) else {
            return fallback;
        };
        let node = node_ref.get();
        if fallback == 0 {
            fallback = node.instance_key;
        }
        if node.replay_boundary {
            return node.instance_key;
        }
        let Some(parent_id) = node_ref.parent() else {
            return fallback;
        };
        current_id = parent_id;
    }
}

pub(crate) fn clear_layout_snapshots() {
    TesseraRuntime::with_mut(|runtime| {
        runtime.component_tree.clear_layout_snapshots();
    });
}

/// Invokes globally positioned callbacks collected by the last compute pass.
///
/// Must be called after the runtime borrow used by `compute` is released so
/// callbacks can freely update state.
pub(crate) fn flush_pending_globally_positioned_callbacks() {
    let invocations = TesseraRuntime::with_mut(|runtime| {
        runtime
            .component_tree
            .take_pending_globally_positioned_invocations()
    });
    for (handler, rect) in invocations {
        handler.call(rect);
    }
    TesseraRuntime::with_mut(|runtime| runtime.component_tree.focus_owner_mut().finish_layout());
}

#[derive(Clone, Copy)]
pub(crate) struct LayoutContext<'a> {
    pub consumed_insets: &'a Cell<crate::Insets>,
    pub state_reader_instance_key: Option<u64>,
    snapshots: *mut LayoutSnapshotMap,
    dirty_paths: Option<&'a HashMap<NodeId, DirtyLayoutPath>>,
    diagnostics: *mut LayoutDiagnosticsCollector,
    pub intrinsic: bool,
}

struct DirtyLayoutPath {
    measure: bool,
    placement: bool,
    children: SmallVec<[NodeId; 1]>,
}

#[cfg_attr(not(feature = "profiling"), allow(dead_code))]
#[derive(Clone, Copy, Debug, Default)]
/// Layout work observed during one frame.
///
/// Work counts include every settling pass; only pointer dispatch nodes are distinct.
pub struct LayoutFrameDiagnostics {
    /// Number of nodes whose window geometry was resolved in this frame.
    pub geometry_nodes_updated: u64,
    /// Geometry traversal entries, including entries that immediately reused a
    /// cache.
    pub geometry_nodes_visited: u64,
    /// Dirty direct children checked for cached size dependencies.
    pub measure_dirty_children_checked: u64,
    /// Nodes examined while refreshing pointer geometry and dispatch plans.
    pub pointer_nodes_updated: u64,
    /// Distinct pointer nodes selected for dispatch in this frame.
    pub pointer_nodes_dispatched: u64,
    /// Spatial candidates checked for exact pointer hits.
    pub pointer_hit_test_candidates: u64,
    /// Nodes whose draw commands were recorded.
    pub paint_nodes_recorded: u64,
    /// Persistent scene branches updated, including affected ancestors.
    pub scene_nodes_updated: u64,
    /// Nodes examined while updating the semantic index.
    pub accessibility_nodes_updated: u64,
    /// Nodes with changed measurement or child-placement inputs.
    pub dirty_nodes_param: u64,
    /// Nodes whose direct layout children changed.
    pub dirty_nodes_structural: u64,
    /// Invalidated layout nodes and the ancestors that measure them.
    pub dirty_nodes_with_ancestors: u64,
    /// Time spent identifying affected ancestors, in nanoseconds.
    pub dirty_expand_ns: u64,
    /// Measurement entrypoint calls, including cache lookups.
    pub measure_node_calls: u64,
    /// Cache hits that skipped an unchanged subtree.
    pub cache_hits_direct: u64,
    /// Cache hits after checking changed descendants or updating placements.
    pub cache_hits_boundary: u64,
    /// Cache misses without a reusable size snapshot.
    pub cache_miss_no_entry: u64,
    /// Cache misses caused by changed parent constraints.
    pub cache_miss_constraint: u64,
    /// Cache misses caused by the node's own layout inputs.
    pub cache_miss_dirty_self: u64,
    /// Cache misses caused by child size dependencies.
    pub cache_miss_child_size: u64,
    /// Measured or repositioned layouts saved for reuse.
    pub cache_store_count: u64,
    /// Layouts excluded from caching because child measurements were incomplete
    /// or inconsistent.
    pub cache_drop_non_cacheable_count: u64,
}

impl LayoutFrameDiagnostics {
    pub(crate) fn accumulate_pass(&mut self, pass: Self) {
        self.geometry_nodes_updated += pass.geometry_nodes_updated;
        self.geometry_nodes_visited += pass.geometry_nodes_visited;
        self.measure_dirty_children_checked += pass.measure_dirty_children_checked;
        self.pointer_nodes_updated += pass.pointer_nodes_updated;
        // Pointer selection is already deduplicated across the frame.
        self.pointer_nodes_dispatched = pass.pointer_nodes_dispatched;
        self.pointer_hit_test_candidates += pass.pointer_hit_test_candidates;
        self.paint_nodes_recorded += pass.paint_nodes_recorded;
        self.scene_nodes_updated += pass.scene_nodes_updated;
        self.accessibility_nodes_updated += pass.accessibility_nodes_updated;
        self.dirty_nodes_param += pass.dirty_nodes_param;
        self.dirty_nodes_structural += pass.dirty_nodes_structural;
        self.dirty_nodes_with_ancestors += pass.dirty_nodes_with_ancestors;
        self.dirty_expand_ns += pass.dirty_expand_ns;
        self.measure_node_calls += pass.measure_node_calls;
        self.cache_hits_direct += pass.cache_hits_direct;
        self.cache_hits_boundary += pass.cache_hits_boundary;
        self.cache_miss_no_entry += pass.cache_miss_no_entry;
        self.cache_miss_constraint += pass.cache_miss_constraint;
        self.cache_miss_dirty_self += pass.cache_miss_dirty_self;
        self.cache_miss_child_size += pass.cache_miss_child_size;
        self.cache_store_count += pass.cache_store_count;
        self.cache_drop_non_cacheable_count += pass.cache_drop_non_cacheable_count;
    }
}

#[derive(Default)]
pub(crate) struct LayoutDiagnosticsCollector {
    measure_dirty_children_checked: u64,
    measure_node_calls: u64,
    cache_hits_direct: u64,
    cache_hits_boundary: u64,
    cache_miss_no_entry: u64,
    cache_miss_constraint: u64,
    cache_miss_dirty_self: u64,
    cache_miss_child_size: u64,
    cache_store_count: u64,
    cache_drop_non_cacheable_count: u64,
}

impl LayoutDiagnosticsCollector {
    fn snapshot(
        &self,
        dirty_nodes_param: u64,
        dirty_nodes_structural: u64,
        dirty_nodes_with_ancestors: u64,
        dirty_expand_ns: u64,
    ) -> LayoutFrameDiagnostics {
        let cache_hits_direct = self.cache_hits_direct;
        let cache_hits_boundary = self.cache_hits_boundary;
        LayoutFrameDiagnostics {
            geometry_nodes_updated: 0,
            geometry_nodes_visited: 0,
            measure_dirty_children_checked: self.measure_dirty_children_checked,
            pointer_nodes_updated: 0,
            pointer_nodes_dispatched: 0,
            pointer_hit_test_candidates: 0,
            paint_nodes_recorded: 0,
            scene_nodes_updated: 0,
            accessibility_nodes_updated: 0,
            dirty_nodes_param,
            dirty_nodes_structural,
            dirty_nodes_with_ancestors,
            dirty_expand_ns,
            measure_node_calls: self.measure_node_calls,
            cache_hits_direct,
            cache_hits_boundary,
            cache_miss_no_entry: self.cache_miss_no_entry,
            cache_miss_constraint: self.cache_miss_constraint,
            cache_miss_dirty_self: self.cache_miss_dirty_self,
            cache_miss_child_size: self.cache_miss_child_size,
            cache_store_count: self.cache_store_count,
            cache_drop_non_cacheable_count: self.cache_drop_non_cacheable_count,
        }
    }
}

impl LayoutContext<'_> {
    pub(crate) fn with_consumed_insets<R>(
        &self,
        insets: crate::Insets,
        measure: impl FnOnce() -> R,
    ) -> R {
        struct Restore<'a>(&'a Cell<crate::Insets>, crate::Insets);
        impl Drop for Restore<'_> {
            fn drop(&mut self) {
                self.0.set(self.1);
            }
        }
        let _restore = Restore(self.consumed_insets, self.consumed_insets.replace(insets));
        measure()
    }

    fn new<'a>(
        consumed_insets: &'a Cell<crate::Insets>,
        snapshots: &'a mut LayoutSnapshotMap,
        dirty_paths: &'a HashMap<NodeId, DirtyLayoutPath>,
        diagnostics: &'a mut LayoutDiagnosticsCollector,
    ) -> LayoutContext<'a> {
        LayoutContext {
            consumed_insets,
            state_reader_instance_key: None,
            snapshots,
            dirty_paths: Some(dirty_paths),
            diagnostics,
            intrinsic: false,
        }
    }

    pub(crate) fn intrinsic_probe<'a>(
        consumed_insets: &'a Cell<crate::Insets>,
        snapshots: &'a mut LayoutSnapshotMap,
        diagnostics: &'a mut LayoutDiagnosticsCollector,
        parent: Option<&'a LayoutContext<'_>>,
    ) -> LayoutContext<'a> {
        LayoutContext {
            consumed_insets,
            state_reader_instance_key: crate::runtime::current_measured_node_instance_key(),
            snapshots,
            dirty_paths: None,
            diagnostics: parent.map_or(diagnostics, |parent| parent.diagnostics),
            intrinsic: true,
        }
    }

    #[inline]
    pub(crate) fn snapshot(&self, instance_key: u64) -> Option<Arc<LayoutSnapshotEntry>> {
        // SAFETY: Layout snapshots are owned by the single-threaded compute
        // pass. The pointer is created from a unique mutable borrow for the
        // duration of the pass and only accessed on the same thread.
        unsafe { (*self.snapshots).get_cloned(&instance_key) }
    }

    #[inline]
    pub(crate) fn deferred_invalidation(
        &self,
        instance_key: u64,
    ) -> Option<DeferredLayoutInvalidation> {
        // SAFETY: See `snapshot`.
        unsafe { (*self.snapshots).deferred.get(&instance_key).cloned() }
    }

    #[inline]
    pub(crate) fn acknowledge_deferred_invalidation(&self, instance_key: u64) {
        // SAFETY: See `snapshot`.
        unsafe {
            (*self.snapshots).deferred.remove(&instance_key);
        }
    }

    #[inline]
    pub(crate) fn insert_snapshot(&self, instance_key: u64, entry: LayoutSnapshotEntry) {
        // SAFETY: See `snapshot`.
        unsafe {
            (*self.snapshots).insert(instance_key, entry);
        }
    }

    #[inline]
    pub(crate) fn remove_snapshot(&self, instance_key: u64) {
        // SAFETY: See `snapshot`.
        unsafe {
            (*self.snapshots).remove(&instance_key);
        }
    }

    #[inline]
    pub(crate) fn inc_measure_node_calls(&self) {
        // SAFETY: Layout diagnostics are owned by the single-threaded compute
        // pass. The pointer is created from a unique mutable borrow for
        // the duration of that pass and is only accessed on the same
        // thread during recursive layout measurement.
        unsafe {
            (*self.diagnostics).measure_node_calls += 1;
        }
    }

    pub(crate) fn inc_dirty_child_checked(&self) {
        // SAFETY: See `inc_measure_node_calls`.
        unsafe {
            (*self.diagnostics).measure_dirty_children_checked += 1;
        }
    }

    #[inline]
    pub(crate) fn inc_cache_hit_direct(&self) {
        unsafe {
            (*self.diagnostics).cache_hits_direct += 1;
        }
    }

    #[inline]
    pub(crate) fn inc_cache_hit_boundary(&self) {
        unsafe {
            (*self.diagnostics).cache_hits_boundary += 1;
        }
    }

    #[inline]
    pub(crate) fn inc_cache_miss_no_entry(&self) {
        unsafe {
            (*self.diagnostics).cache_miss_no_entry += 1;
        }
    }

    #[inline]
    pub(crate) fn inc_cache_miss_constraint(&self) {
        unsafe {
            (*self.diagnostics).cache_miss_constraint += 1;
        }
    }

    #[inline]
    pub(crate) fn inc_cache_miss_dirty_self(&self) {
        unsafe {
            (*self.diagnostics).cache_miss_dirty_self += 1;
        }
    }

    #[inline]
    pub(crate) fn inc_cache_miss_child_size(&self) {
        unsafe {
            (*self.diagnostics).cache_miss_child_size += 1;
        }
    }

    #[inline]
    pub(crate) fn inc_cache_store_count(&self) {
        unsafe {
            (*self.diagnostics).cache_store_count += 1;
        }
    }

    #[inline]
    pub(crate) fn inc_cache_drop_non_cacheable_count(&self) {
        unsafe {
            (*self.diagnostics).cache_drop_non_cacheable_count += 1;
        }
    }
}

/// Parameters for the compute function
pub(crate) struct ComputeParams {
    pub screen_size: PxSize,
    pub cursor_position: Option<PxPosition>,
    pub pointer_changes: Vec<PointerChange>,
    pub keyboard_events: Vec<QueuedInput>,
    pub ime_events: Vec<QueuedInput<crate::ime_state::ImeEvent>>,
    pub retry_focus_move: Option<FocusDirection>,
    pub retry_focus_reveal: bool,
    pub modifiers: winit::keyboard::ModifiersState,
    pub layout_dirty_nodes: LayoutDirtyNodes,
}

#[derive(Debug)]
pub(crate) enum ComputeMode {
    Full,
    #[cfg(any(test, feature = "testing"))]
    LayoutOnly,
}

struct GlobalPositionSnapshot {
    geometry: node::GeometryObservation,
    handlers: SmallVec<[GloballyPositionedHandler; 2]>,
}

enum QueuedFocusedInput {
    Keyboard(QueuedInput),
    Clipboard(QueuedClipboardAction),
    Ime(QueuedInput<crate::ime_state::ImeEvent>),
}

impl QueuedFocusedInput {
    fn sequence(&self) -> u64 {
        match self {
            Self::Keyboard(event) => event.sequence,
            Self::Clipboard(event) => event.sequence,
            Self::Ime(event) => event.sequence,
        }
    }
}

/// Respents a component tree
pub struct ComponentTree {
    /// We use indextree as the tree structure
    tree: indextree::Arena<ComponentNode>,
    /// Components' metadatas
    metadatas: ComponentNodeMetaDatas,
    layout_snapshots: LayoutSnapshotMap,
    frame_scene: scene::FrameScene,
    pointer_index: pointer::PointerIndex,
    accessibility_index: crate::accessibility::AccessibilityIndex,
    #[cfg(feature = "profiling")]
    profiler_nodes_cache: HashMap<NodeId, NodeMeta>,
    #[cfg(feature = "profiling")]
    profiler_dirty_nodes: HashSet<NodeId>,
    scale_factor_bits: u64,
    /// Used to remember the current node
    node_queue: Vec<indextree::NodeId>,
    replay_range: Option<ReplayRange>,
    replay_insertions: ReplayInsertions,
    replay_ancestry: replay::ReplayAncestry,
    replay_changed_parents: HashSet<NodeId>,
    node_ids_by_instance_key: HashMap<u64, indextree::NodeId>,
    changed_frame_nodes: HashSet<NodeId>,
    removed_frame_nodes: HashSet<NodeId>,
    previous_structure_change_counts: [usize; 2],
    removed_focus_owners: HashSet<u64>,
    /// Active pointer hit paths keyed by pointer id.
    /// Each path stores node instance keys from root to leaf.
    active_pointer_paths: HashMap<u64, Vec<u64>>,
    active_pointer_positions: HashMap<u64, Option<PxPosition>>,
    pointer_work: (u64, HashSet<u64>),
    /// Per-tree focus owner used for keyboard and IME routing.
    focus_owner: FocusOwner,
    pending_focused_input: VecDeque<QueuedFocusedInput>,
    /// Last reported window-space bounds for nodes with globally positioned
    /// callbacks, keyed by instance key.
    last_global_rects: HashMap<u64, GlobalPositionSnapshot>,
    observer_viewport: Option<PxSize>,
    position_observer_nodes: HashSet<NodeId>,
    window_observer_nodes: HashSet<NodeId>,
    pending_position_observers: HashSet<NodeId>,
    observer_spaces: HashMap<NodeId, u64>,
    space_observers: HashMap<u64, HashSet<NodeId>>,
    /// Globally positioned callbacks collected during compute and invoked
    /// after the runtime borrow is released.
    pending_globally_positioned_invocations:
        Vec<(GloballyPositionedHandler, node::GeometryObservation)>,
}

#[derive(Clone, PartialEq)]
pub(crate) enum ReplayReplaceError {
    NodeNotFound,
    RootNodeNotReplaceable,
    ReplayDidNotCreateRoot,
}

#[derive(Default)]
pub(crate) struct ReplayReplaceResult {
    pub removed_instance_keys: HashSet<u64>,
    pub removed_instance_logic_ids: HashSet<u64>,
    insertions: ReplayInsertions,
}

impl ReplayReplaceResult {
    fn clear(&mut self) {
        clear_replay_set(&mut self.removed_instance_keys);
        clear_replay_set(&mut self.removed_instance_logic_ids);
        self.insertions.clear();
    }

    pub(crate) fn executed_keys(&self) -> impl Iterator<Item = u64> + '_ {
        self.insertions
            .rebuilt
            .iter()
            .filter_map(|&(key, _)| (!self.insertions.retained.keys.contains(&key)).then_some(key))
    }

    pub(crate) fn recomposed_logic_ids(&self) -> impl Iterator<Item = u64> + '_ {
        self.insertions.rebuilt.iter().filter_map(|&(_, logic_id)| {
            (!self.insertions.retained.logic_ids.contains(&logic_id)).then_some(logic_id)
        })
    }

    pub(crate) fn retained_count(&self) -> usize {
        self.insertions.retained.keys.len()
    }

    pub(crate) fn inserted_count(&self) -> usize {
        self.insertions.rebuilt.len() + self.retained_count()
    }
}

// A large replacement should not keep large scratch buffers for later small replays.
const MAX_REPLAY_SCRATCH_CAPACITY: usize = 256;
const INLINE_REPLAY_INSERTIONS: usize = 8;

fn clear_replay_set(set: &mut HashSet<u64>) {
    if set.capacity() > MAX_REPLAY_SCRATCH_CAPACITY {
        *set = HashSet::default();
    } else {
        set.clear();
    }
}

#[derive(Default)]
struct ReplayIdentities {
    keys: HashSet<u64>,
    logic_ids: HashSet<u64>,
}

impl ReplayIdentities {
    fn insert(&mut self, key: u64, logic_id: u64) {
        self.keys.insert(key);
        self.logic_ids.insert(logic_id);
    }
}

#[derive(Default)]
struct ReplayInsertions {
    rebuilt: SmallVec<[(u64, u64); INLINE_REPLAY_INSERTIONS]>,
    retained: ReplayIdentities,
}

impl ReplayInsertions {
    fn clear(&mut self) {
        if self.rebuilt.capacity() > MAX_REPLAY_SCRATCH_CAPACITY {
            self.rebuilt = SmallVec::new();
        } else {
            self.rebuilt.clear();
        }
        clear_replay_set(&mut self.retained.keys);
        clear_replay_set(&mut self.retained.logic_ids);
    }
}

struct ReplayRange {
    parent: NodeId,
    next_sibling: Option<NodeId>,
}

pub(crate) struct ReplayReplaceContext {
    parent_id: indextree::NodeId,
    previous_sibling: Option<indextree::NodeId>,
    previous_queue: Option<Vec<indextree::NodeId>>,
}

pub(crate) struct PreviousBuildNode {
    pub(crate) node: ComponentNode,
    same_parent: bool,
    defer_consumer_change: bool,
}

fn has_frame_consumers(node: &ComponentNode) -> bool {
    node.role == NodeRole::Layout
        || node.interaction.is_some()
        || !node.modifier.is_empty()
        || node.layout_coordinate_space
        || node.children_scale != 1.0
}

impl Default for ComponentTree {
    fn default() -> Self {
        Self::new()
    }
}

impl ComponentTree {
    /// Create a new ComponentTree
    pub fn new() -> Self {
        let tree = indextree::Arena::new();
        let node_queue = Vec::new();
        let metadatas = ComponentNodeMetaDatas::new();
        Self {
            tree,
            node_queue,
            metadatas,
            layout_snapshots: LayoutSnapshotMap::default(),
            frame_scene: scene::FrameScene::default(),
            pointer_index: pointer::PointerIndex::default(),
            accessibility_index: crate::accessibility::AccessibilityIndex::default(),
            #[cfg(feature = "profiling")]
            profiler_nodes_cache: HashMap::default(),
            #[cfg(feature = "profiling")]
            profiler_dirty_nodes: HashSet::default(),
            scale_factor_bits: crate::dp::scale_factor().to_bits(),
            replay_range: None,
            replay_insertions: ReplayInsertions::default(),
            replay_ancestry: replay::ReplayAncestry::default(),
            replay_changed_parents: HashSet::default(),
            node_ids_by_instance_key: HashMap::default(),
            changed_frame_nodes: HashSet::default(),
            removed_frame_nodes: HashSet::default(),
            previous_structure_change_counts: [0; 2],
            removed_focus_owners: HashSet::default(),
            active_pointer_paths: HashMap::default(),
            active_pointer_positions: HashMap::default(),
            pointer_work: (0, HashSet::default()),
            focus_owner: FocusOwner::new(),
            pending_focused_input: VecDeque::new(),
            last_global_rects: HashMap::default(),
            observer_viewport: None,
            position_observer_nodes: HashSet::default(),
            window_observer_nodes: HashSet::default(),
            pending_position_observers: HashSet::default(),
            observer_spaces: HashMap::default(),
            space_observers: HashMap::default(),
            pending_globally_positioned_invocations: Vec::new(),
        }
    }

    /// Clear the component tree
    pub fn clear(&mut self) {
        crate::runtime::remove_layout_structure(
            &self.node_ids_by_instance_key.keys().copied().collect(),
        );
        self.removed_focus_owners
            .extend(self.node_ids_by_instance_key.keys().copied());
        self.removed_frame_nodes
            .extend(self.node_ids_by_instance_key.values().copied());
        self.changed_frame_nodes.clear();
        self.previous_structure_change_counts = [0; 2];
        #[cfg(feature = "profiling")]
        {
            self.profiler_nodes_cache.clear();
            self.profiler_dirty_nodes.clear();
        }
        self.tree.clear();
        self.metadatas.clear();
        self.layout_snapshots.clear();
        self.frame_scene = scene::FrameScene::default();
        self.pointer_index = pointer::PointerIndex::default();
        self.stop_accessibility_updates();
        self.node_queue.clear();
        self.replay_range = None;
        self.replay_insertions.clear();
        self.replay_ancestry = replay::ReplayAncestry::default();
        self.replay_changed_parents.clear();
        self.node_ids_by_instance_key.clear();
        self.last_global_rects.clear();
        self.observer_viewport = None;
        self.position_observer_nodes.clear();
        self.window_observer_nodes.clear();
        self.pending_position_observers.clear();
        self.observer_spaces.clear();
        self.space_observers.clear();
        self.pending_globally_positioned_invocations.clear();
    }

    /// Reset the entire component tree, including focus ownership state.
    pub fn reset(&mut self) {
        self.clear();
        self.active_pointer_paths.clear();
        self.active_pointer_positions.clear();
        self.pointer_work.1.clear();
        self.focus_owner.reset();
        self.pending_focused_input.clear();
        clipboard::clear_requests();
    }

    pub(crate) fn begin_frame_diagnostics(&mut self) {
        self.pointer_work.1.clear();
    }

    pub(crate) fn refresh_scale_factor(&mut self) -> bool {
        let current = crate::dp::scale_factor().to_bits();
        let changed = self.scale_factor_bits != current;
        self.scale_factor_bits = current;
        changed
    }

    /// Get node by NodeId
    pub(crate) fn get(&self, node_id: indextree::NodeId) -> Option<&ComponentNode> {
        self.tree
            .get(node_id)
            .filter(|node| !node.is_removed())
            .map(|node| node.get())
    }

    /// Get mutable node by NodeId
    pub(crate) fn get_mut(&mut self, node_id: indextree::NodeId) -> Option<&mut ComponentNode> {
        self.tree
            .get_mut(node_id)
            .filter(|node| !node.is_removed())
            .map(|node| node.get_mut())
    }

    /// Find a node id by stable instance key.
    pub(crate) fn find_node_id_by_instance_key(
        &self,
        instance_key: u64,
    ) -> Option<indextree::NodeId> {
        self.node_ids_by_instance_key.get(&instance_key).copied()
    }

    fn sync_accessibility(&mut self, root: NodeId, immediate: bool) -> usize {
        self.accessibility_index
            .invalidate_geometry(&self.metadatas.geometry_changed);
        self.accessibility_index
            .invalidate_placement_order(&self.metadatas.placement_order_changed);
        self.accessibility_index
            .invalidate(&self.metadatas.paint_changed, &HashSet::default());
        if immediate {
            self.accessibility_index
                .update(&self.tree, &self.metadatas, root)
        } else {
            0
        }
    }

    pub(crate) fn accessibility_update(
        &mut self,
        label: Option<&str>,
        full: bool,
    ) -> Option<accesskit::TreeUpdate> {
        let root = self.tree.get_node_id_at(NonZero::new(1)?)?;
        self.accessibility_index.set_label(label, root);
        self.accessibility_index
            .update(&self.tree, &self.metadatas, root);
        self.accessibility_index.tree_update(
            &self.tree,
            self.focus_owner.active_component_node_id(),
            full,
        )
    }

    pub(crate) fn stop_accessibility_updates(&mut self) {
        self.accessibility_index = crate::accessibility::AccessibilityIndex::default();
    }

    pub(crate) fn take_removed_focus_owners(&mut self) -> HashSet<u64> {
        std::mem::take(&mut self.removed_focus_owners)
    }

    #[cfg(test)]
    pub(crate) fn begin_replace_subtree_by_instance_key(
        &mut self,
        instance_key: u64,
    ) -> Result<ReplayReplaceContext, ReplayReplaceError> {
        let Some(target_node_id) = self.find_node_id_by_instance_key(instance_key) else {
            return Err(ReplayReplaceError::NodeNotFound);
        };
        self.begin_replace_subtree(target_node_id)
    }

    pub(crate) fn begin_replace_subtree(
        &mut self,
        target_node_id: NodeId,
    ) -> Result<ReplayReplaceContext, ReplayReplaceError> {
        let node = self
            .tree
            .get(target_node_id)
            .filter(|node| !node.is_removed())
            .ok_or(ReplayReplaceError::NodeNotFound)?;
        let parent_id = node
            .parent()
            .ok_or(ReplayReplaceError::RootNodeNotReplaceable)?;

        let previous_sibling = target_node_id.previous_sibling(&self.tree);
        let next_sibling = target_node_id.next_sibling(&self.tree);
        self.replay_range = Some(ReplayRange {
            parent: parent_id,
            next_sibling,
        });

        self.queue_replay_children(parent_id, target_node_id, next_sibling);

        let previous_queue =
            (!self.node_queue.is_empty()).then(|| std::mem::take(&mut self.node_queue));
        self.node_queue.push(parent_id);
        Ok(ReplayReplaceContext {
            parent_id,
            previous_sibling,
            previous_queue,
        })
    }

    pub(crate) fn finish_replace_subtree(
        &mut self,
        context: ReplayReplaceContext,
        result: &mut ReplayReplaceResult,
    ) -> Result<(), ReplayReplaceError> {
        result.clear();
        let ReplayReplaceContext {
            parent_id,
            previous_sibling,
            previous_queue,
        } = context;
        if let Some(previous_queue) = previous_queue {
            self.restore_build_queue(previous_queue);
        } else {
            self.node_queue.clear();
        }

        self.detach_replay_suffix(parent_id);
        let next_sibling = self
            .replay_range
            .take()
            .and_then(|range| range.next_sibling);
        let first_inserted = match previous_sibling {
            Some(child) => child.next_sibling(&self.tree),
            None => parent_id.first_child(&self.tree),
        };
        if first_inserted.is_none() || first_inserted == next_sibling {
            self.replay_ancestry = replay::ReplayAncestry::default();
            self.replay_insertions.clear();
            return Err(ReplayReplaceError::ReplayDidNotCreateRoot);
        }

        std::mem::swap(&mut self.replay_insertions, &mut result.insertions);
        let ReplayReplaceResult {
            removed_instance_keys,
            removed_instance_logic_ids,
            insertions,
        } = result;
        let rebuilt = &insertions.rebuilt;
        let retained = &insertions.retained;
        let rebuilt_index = (!self.replay_ancestry.detached_roots.is_empty()
            && rebuilt.len() > INLINE_REPLAY_INSERTIONS)
            .then(|| {
                let mut identities = ReplayIdentities::default();
                for &(key, logic_id) in rebuilt {
                    identities.insert(key, logic_id);
                }
                identities
            });

        let mut detached_node_ids = SmallVec::<[_; 8]>::new();
        for &root in self.replay_ancestry.detached_roots.keys() {
            detached_node_ids.extend(root.descendants(&self.tree));
        }
        for &old_id in &detached_node_ids {
            let old = &self.tree[old_id];
            let instance_key = old.get().instance_key;
            let instance_logic_id = old.get().instance_logic_id;
            let previous = self.metadatas.remove(&old_id);
            let logic_id_survives = retained.logic_ids.contains(&instance_logic_id)
                || rebuilt_index.as_ref().map_or_else(
                    || rebuilt.iter().any(|&(_, id)| id == instance_logic_id),
                    |index| index.logic_ids.contains(&instance_logic_id),
                );
            let key_survives = retained.keys.contains(&instance_key)
                || rebuilt_index.as_ref().map_or_else(
                    || rebuilt.iter().any(|&(key, _)| key == instance_key),
                    |index| index.keys.contains(&instance_key),
                );
            if !logic_id_survives {
                removed_instance_logic_ids.insert(instance_logic_id);
            }
            if !key_survives {
                removed_instance_keys.insert(instance_key);
            } else if instance_key != 0
                && let Some(previous) = previous
            {
                let new_id = self.node_ids_by_instance_key[&instance_key];
                let new = &self.tree[new_id];
                let input_geometry_changed =
                    !old.get().modifier.input_geometry_eq(&new.get().modifier);
                let old_parent = old
                    .parent()
                    .or_else(|| self.replay_ancestry.detached_roots.get(&old_id).copied());
                let parent_key = |id: NodeId| self.tree[id].get().instance_key;
                let same_parent = old_parent.map(parent_key) == new.parent().map(parent_key);
                let metadata = self.metadatas.entry_or_default(new_id);
                metadata.computed_data = previous.computed_data;
                metadata.draw_layout = previous.draw_layout;
                metadata.rel_position = previous.rel_position;
                metadata.placement_order = previous.placement_order;
                metadata.base_abs_position = previous.base_abs_position;
                metadata.local_to_window = previous.local_to_window;
                metadata.input_transforms = previous.input_transforms;
                metadata.event_clip_bounds = previous.event_clip_bounds;
                metadata.abs_position = previous.abs_position;
                metadata.prepared_layout = previous.prepared_layout;
                metadata.clip_regions = previous.clip_regions;
                metadata.geometry_initialized =
                    previous.geometry_initialized && !input_geometry_changed;
                metadata.clips_children = previous.clips_children;
                metadata.opacity = previous.opacity;
                metadata.has_shape_clipping = previous.has_shape_clipping;
                if same_parent && metadata.geometry_initialized {
                    self.metadatas.geometry_dirty.remove(&new_id);
                }
            }
            self.remove_position_observer(old_id);
            self.removed_frame_nodes.insert(old_id);
            self.changed_frame_nodes.remove(&old_id);
        }
        for key in removed_instance_keys.iter() {
            self.last_global_rects.remove(key);
            self.node_ids_by_instance_key.remove(key);
        }
        self.removed_focus_owners
            .extend(removed_instance_keys.iter().copied());
        crate::runtime::remove_layout_structure(removed_instance_keys);
        for &root in self.replay_ancestry.detached_roots.keys() {
            root.remove_subtree(&mut self.tree);
        }
        self.replay_ancestry.clear_detached();

        self.replay_changed_parents.insert(parent_id);
        Ok(())
    }

    pub(crate) fn finish_replay_round(&mut self) {
        let mut scheduled = std::mem::take(&mut self.replay_changed_parents);
        // Flattened layout children must be current before refreshing their parent.
        let mut pending: BinaryHeap<_> = scheduled
            .iter()
            .map(|&id| (id.ancestors(&self.tree).count(), id))
            .collect();
        while let Some((depth, id)) = pending.pop() {
            #[cfg(feature = "profiling")]
            let previous_len = self.tree[id].get().subtree_len;
            let changed = self.refresh_changed_layout_children(id);
            let node = &self.tree[id];
            let propagate = changed && node.get().role == NodeRole::Composition;
            #[cfg(feature = "profiling")]
            let propagate = propagate || previous_len != node.get().subtree_len;
            if propagate
                && let Some(parent) = node.parent()
                && scheduled.insert(parent)
            {
                pending.push((depth - 1, parent));
            }
        }
        scheduled.clear();
        self.replay_changed_parents = scheduled;
        self.finish_replay_ancestry();
    }

    pub(crate) fn replace_build_parent(&mut self, parent: Option<NodeId>) -> Option<Vec<NodeId>> {
        if self.node_queue.last().copied() == parent {
            None
        } else {
            Some(std::mem::replace(
                &mut self.node_queue,
                parent.into_iter().collect(),
            ))
        }
    }

    pub(crate) fn restore_build_queue(&mut self, queue: Vec<NodeId>) {
        self.node_queue = queue;
    }

    pub(crate) fn current_build_node_id(&self) -> Option<NodeId> {
        self.node_queue.last().copied()
    }

    /// Get current node
    pub(crate) fn current_node(&self) -> Option<&ComponentNode> {
        self.node_queue
            .last()
            .and_then(|node_id| self.get(*node_id))
    }

    /// Get mutable current node
    pub(crate) fn current_node_mut(&mut self) -> Option<&mut ComponentNode> {
        let node_id = self.node_queue.last()?;
        self.get_mut(*node_id)
    }

    pub(crate) fn attach_retained_subtree(
        &mut self,
        instance_key: u64,
        instance_logic_id: u64,
    ) -> Option<NodeId> {
        let candidate = self.claim_replay_candidate(instance_key, |node| {
            node.instance_logic_id == instance_logic_id
        })?;
        let id = candidate.id;
        self.capture_reused_ancestry(id);
        self.attach_replayed_node(candidate, true);
        Some(id)
    }

    /// Add a new node to the tree
    /// Nodes now store their intrinsic constraints in their metadata.
    /// The `node_component` itself primarily holds the layout policy, render
    /// policy, and handlers.
    pub(crate) fn add_node(&mut self, node_component: ComponentNode) -> indextree::NodeId {
        let instance_key = node_component.instance_key;
        let needs_geometry = node_component.role == NodeRole::Layout || self.node_queue.is_empty();
        let new_node_id = self.tree.new_node(node_component);
        if instance_key != 0 || self.node_queue.is_empty() {
            self.node_ids_by_instance_key
                .insert(instance_key, new_node_id);
        }
        if needs_geometry {
            self.metadatas.entry_or_default(new_node_id);
        }
        self.attach_build_node(new_node_id, false);
        new_node_id
    }

    pub(crate) fn rebuild_node(
        &mut self,
        mut node: ComponentNode,
    ) -> (NodeId, Option<PreviousBuildNode>) {
        let reusable = self.claim_replay_candidate(node.instance_key, |old| {
            old.role == node.role && old.instance_logic_id == node.instance_logic_id
        });
        let Some(candidate) = reusable else {
            return (self.add_node(node), None);
        };
        let id = candidate.id;

        self.preserve_replay_children(id);
        let same_parent = candidate.keeps_link || {
            let previous_parent = self.tree[id]
                .parent()
                .or_else(|| self.replay_ancestry.detached_roots.get(&id).copied());
            let new_parent = self.current_build_node_id();
            let parent_key = |id: NodeId| self.tree[id].get().instance_key;
            previous_parent.map(parent_key) == new_parent.map(parent_key)
        };
        self.remove_position_observer(id);
        let old = self.tree[id].get_mut();
        node.layout_children = old.layout_children.take();
        node.layout_children_dirty = old.layout_children_dirty;
        node.sibling_index = old.sibling_index;
        #[cfg(feature = "profiling")]
        {
            node.subtree_len = old.subtree_len;
        }
        let previous = std::mem::replace(old, node);
        let metadata = self.metadatas.get_mut(&id);
        let defer_consumer_change =
            candidate.keeps_link && metadata.is_none() && !has_frame_consumers(&previous);
        if let Some(metadata) = metadata {
            metadata.begin_accessibility_rebuild();
        }
        if defer_consumer_change {
            self.enter_build_node(id, false, false);
        } else {
            self.attach_replayed_node(candidate, false);
        }
        if previous.role == NodeRole::Layout {
            self.metadatas.mark_paint_dirty(id);
        } else {
            // Reusing a composition ID can leave retained drawing behind a
            // rebuilt overlay. Even an empty fragment may become drawable.
            for descendant in id.descendants(&self.tree) {
                if self.tree[descendant].get().role == NodeRole::Layout {
                    self.metadatas.mark_paint_dirty(descendant);
                }
            }
        }
        (
            id,
            Some(PreviousBuildNode {
                node: previous,
                same_parent,
                defer_consumer_change,
            }),
        )
    }

    pub(crate) fn reconcile_build_node(&mut self, id: NodeId, previous: &PreviousBuildNode) {
        let metadata = self.metadatas.get_mut(&id);
        let node = self.tree[id].get();
        if previous.defer_consumer_change
            && (metadata.is_some()
                || has_frame_consumers(node)
                || previous.node.fn_name != node.fn_name)
        {
            self.changed_frame_nodes.insert(id);
        }
        let Some(metadata) = metadata else {
            return;
        };
        metadata.finish_accessibility_rebuild();
        let input_changed = !previous.node.modifier.input_geometry_eq(&node.modifier);
        metadata.geometry_initialized &= !input_changed;
        if input_changed
            || !previous.same_parent
            || previous.node.children_scale != node.children_scale
        {
            self.metadatas.mark_geometry_dirty(id);
        }
    }

    fn attach_replayed_node(&mut self, candidate: replay::ReplayCandidate, retained: bool) {
        let replay::ReplayCandidate { id, keeps_link } = candidate;
        if keeps_link {
            self.enter_build_node(id, retained, true);
            return;
        }
        self.replay_ancestry.detached_roots.remove(&id);
        if let Some(parent) = self.tree[id].parent() {
            self.tree[parent].get_mut().layout_children_dirty = true;
        }
        id.detach(&mut self.tree);
        self.attach_build_node(id, retained);
    }

    fn attach_build_node(&mut self, id: NodeId, retained: bool) {
        if let Some(&parent) = self.node_queue.last() {
            self.tree[parent].get_mut().layout_children_dirty = true;
            let next = self.next_replay_child(parent).or_else(|| {
                self.replay_range
                    .as_ref()
                    .filter(|range| parent == range.parent)
                    .and_then(|range| range.next_sibling)
            });
            if let Some(sibling) = next {
                sibling.insert_before(id, &mut self.tree);
            } else {
                parent.append(id, &mut self.tree);
            }
        }
        self.enter_build_node(id, retained, true);
    }

    fn enter_build_node(&mut self, id: NodeId, retained: bool, consumer_changed: bool) {
        if self.replay_range.is_some() {
            let node = self.tree[id].get();
            if retained {
                self.replay_insertions
                    .retained
                    .insert(node.instance_key, node.instance_logic_id);
            } else {
                self.replay_insertions
                    .rebuilt
                    .push((node.instance_key, node.instance_logic_id));
            }
        }
        if consumer_changed {
            self.changed_frame_nodes.insert(id);
        }
        self.node_queue.push(id);
    }

    /// Pop the last node from the queue
    pub(crate) fn pop_node(&mut self) {
        if let Some(node_id) = self.node_queue.pop() {
            self.detach_replay_suffix(node_id);
            self.refresh_changed_layout_children(node_id);
            let node = self.tree[node_id].get();
            let interaction = node.interaction();
            let position_observers = &interaction.globally_positioned_handlers;
            let observes_window = position_observers
                .iter()
                .any(|handler| !matches!(handler, GloballyPositionedHandler::Size(_)));
            if let Some(metadata) = self.metadatas.get_mut(&node_id) {
                metadata.observes_size = position_observers
                    .iter()
                    .any(|handler| matches!(handler, GloballyPositionedHandler::Size(_)));
                metadata.observes_geometry = interaction.observes_input_geometry()
                    || observes_window
                    || node.layout_coordinate_space
                    || node.modifier.has_input_geometry();
            }
            if !position_observers.is_empty() {
                self.position_observer_nodes.insert(node_id);
                self.pending_position_observers.insert(node_id);
                if observes_window {
                    self.window_observer_nodes.insert(node_id);
                }
            }
        }
    }

    fn refresh_changed_layout_children(&mut self, node_id: NodeId) -> bool {
        if !self.tree[node_id].get().layout_children_dirty {
            return false;
        }
        self.refresh_layout_children(node_id)
    }

    fn refresh_layout_children(&mut self, node_id: indextree::NodeId) -> bool {
        #[cfg(feature = "profiling")]
        let previous_subtree_len = self.tree[node_id].get().subtree_len;
        let mut children = SmallVec::<[NodeId; 4]>::new();
        let mut shared_children = None;
        #[cfg(feature = "profiling")]
        let mut subtree_len = 1_usize;
        let first_child = node_id.first_child(&self.tree);
        let mut next_child = first_child;
        let mut index = NonZero::<usize>::MIN;
        while let Some(child_id) = next_child {
            next_child = child_id.next_sibling(&self.tree);
            if self.tree[child_id]
                .get_mut()
                .sibling_index
                .replace(index)
                .is_some_and(|previous| previous != index)
            {
                self.metadatas.placement_order_dirty.insert(child_id);
                self.metadatas.mark_geometry_dirty(child_id);
            }
            index = index.saturating_add(1);
            let child = self.tree[child_id].get();
            #[cfg(feature = "profiling")]
            {
                subtree_len = subtree_len.saturating_add(child.subtree_len);
            }
            if child.role == NodeRole::Layout {
                children.push(child_id);
            } else {
                let descendants = direct_layout_children(child_id, &self.tree);
                if first_child == Some(child_id) && next_child.is_none() {
                    shared_children = Some(descendants);
                } else {
                    children.extend_from_slice(&descendants);
                }
            }
        }
        let child_ids = shared_children.as_deref().unwrap_or(children.as_slice());
        let node_ref = &self.tree[node_id];
        let node = node_ref.get();
        let changed = node.layout_children.as_deref() != Some(child_ids);
        if changed && (node.role == NodeRole::Layout || node_ref.parent().is_none()) {
            self.frame_scene.invalidate_structure(node_id);
            crate::runtime::record_layout_structure(
                node.instance_key,
                child_ids.iter().map(|id| self.tree[*id].get().instance_key),
            );
        }
        let node = self.tree[node_id].get_mut();
        node.layout_children_dirty = false;
        #[cfg(feature = "profiling")]
        {
            node.subtree_len = subtree_len;
        }
        if changed {
            node.layout_children =
                Some(shared_children.unwrap_or_else(|| node::LayoutChildren::new(&children)));
        }
        let propagate = changed && node.role == NodeRole::Composition;
        #[cfg(feature = "profiling")]
        let propagate = propagate || previous_subtree_len != node.subtree_len;
        if propagate && let Some(parent) = self.tree[node_id].parent() {
            self.tree[parent].get_mut().layout_children_dirty = true;
        }
        changed
    }

    /// Get a reference to the underlying tree structure.
    ///
    /// This is used for accessibility tree building and other introspection
    /// needs.
    pub(crate) fn tree(&self) -> &indextree::Arena<ComponentNode> {
        &self.tree
    }

    /// Get a reference to the node metadatas.
    ///
    /// This is used for accessibility tree building and other introspection
    /// needs.
    #[cfg(any(
        test,
        feature = "testing",
        all(feature = "headless", not(target_family = "wasm")),
        feature = "debug-dirty-overlay"
    ))]
    pub(crate) fn metadatas(&self) -> &ComponentNodeMetaDatas {
        &self.metadatas
    }

    pub(crate) fn metadatas_mut(&mut self) -> &mut ComponentNodeMetaDatas {
        &mut self.metadatas
    }

    pub(crate) fn clear_layout_snapshots(&mut self) {
        self.layout_snapshots.clear();
    }

    fn remove_layout_snapshots(&mut self, keys: &HashSet<u64>) {
        if keys.is_empty() {
            return;
        }
        for key in keys {
            self.layout_snapshots.remove(key);
        }
    }

    fn defer_unplaced_layout_paths(
        &mut self,
        keys: impl Iterator<Item = u64>,
        placement_only: bool,
    ) {
        if self.layout_snapshots.entries.is_empty() {
            return;
        }
        let mut visited = HashSet::default();
        for key in keys {
            let Some(&node_id) = self.node_ids_by_instance_key.get(&key) else {
                continue;
            };
            let mut child = None;
            for id in node_id.ancestors(&self.tree) {
                let node = &self.tree[id];
                if node.get().role != NodeRole::Layout && node.parent().is_some() {
                    continue;
                }
                if self
                    .metadatas
                    .get(&id)
                    .is_some_and(|metadata| metadata.abs_position.is_some())
                {
                    break;
                }
                let key = node.get().instance_key;
                if self.layout_snapshots.entries.contains_key(&key) {
                    let invalidation = self.layout_snapshots.deferred.entry(key).or_default();
                    if let Some(child) = child {
                        if !invalidation.measure {
                            invalidation.children.insert(child);
                        }
                    } else if placement_only {
                        invalidation.placement = true;
                    } else {
                        invalidation.measure = true;
                        invalidation.children.clear();
                    }
                }
                if !visited.insert(id) {
                    break;
                }
                child = Some(key);
            }
        }
    }

    pub(crate) fn focus_owner(&self) -> &FocusOwner {
        &self.focus_owner
    }

    pub(crate) fn focus_owner_mut(&mut self) -> &mut FocusOwner {
        &mut self.focus_owner
    }

    pub(crate) fn has_pending_focus_reveal(&self) -> bool {
        self.focus_owner.has_pending_reveal()
    }

    pub(crate) fn accessibility_dispatch_context(
        &mut self,
    ) -> (&ComponentNodeTree, &ComponentNodeMetaDatas, &mut FocusOwner) {
        (&self.tree, &self.metadatas, &mut self.focus_owner)
    }

    fn remove_position_observer(&mut self, node_id: NodeId) {
        self.position_observer_nodes.remove(&node_id);
        self.window_observer_nodes.remove(&node_id);
        self.pending_position_observers.remove(&node_id);
        self.forget_observer_space(node_id);
    }

    fn forget_observer_space(&mut self, node_id: NodeId) {
        if let Some(space) = self.observer_spaces.remove(&node_id)
            && let Some(observers) = self.space_observers.get_mut(&space)
        {
            observers.remove(&node_id);
            if observers.is_empty() {
                self.space_observers.remove(&space);
            }
        }
    }

    fn sync_observer_space(&mut self, node_id: NodeId) {
        let space = self.tree.get(node_id).and_then(|node| {
            node.get()
                .interaction()
                .globally_positioned_handlers
                .iter()
                .any(|handler| matches!(handler, GloballyPositionedHandler::InSpace(_)))
                .then(|| {
                    node_id.ancestors(&self.tree).find_map(|id| {
                        let node = self.tree[id].get();
                        (node.role == NodeRole::Layout && node.layout_coordinate_space)
                            .then_some(node.instance_key)
                    })
                })
                .flatten()
        });
        if self.observer_spaces.get(&node_id).copied() == space {
            return;
        }
        self.forget_observer_space(node_id);
        if let Some(space) = space {
            self.observer_spaces.insert(node_id, space);
            self.space_observers
                .entry(space)
                .or_default()
                .insert(node_id);
        }
    }

    fn collect_globally_positioned_invocations(&mut self, viewport: PxSize) {
        let mut candidates = std::mem::take(&mut self.pending_position_observers);
        for &node_id in &candidates {
            self.sync_observer_space(node_id);
        }
        if self.observer_viewport != Some(viewport) {
            candidates.extend(
                self.window_observer_nodes
                    .iter()
                    .filter(|id| {
                        self.tree.get(**id).is_some_and(|node| {
                            node.get()
                                .interaction()
                                .globally_positioned_handlers
                                .iter()
                                .any(|handler| {
                                    matches!(handler, GloballyPositionedHandler::Visible(_))
                                })
                        })
                    })
                    .copied(),
            );
            self.observer_viewport = Some(viewport);
        }
        let changed = &self.metadatas.geometry_changed;
        // Counter-translated descendants can retain window geometry while
        // changing their position within a moving coordinate space.
        if self.space_observers.len() < changed.len() {
            for (space, observers) in &self.space_observers {
                if self
                    .node_ids_by_instance_key
                    .get(space)
                    .is_some_and(|id| changed.contains(id))
                {
                    candidates.extend(observers.iter().copied());
                }
            }
        } else {
            for &node_id in changed {
                if let Some(observers) = self
                    .tree
                    .get(node_id)
                    .and_then(|node| self.space_observers.get(&node.get().instance_key))
                {
                    candidates.extend(observers.iter().copied());
                }
            }
        }
        if self.window_observer_nodes.len() < changed.len() {
            candidates.extend(
                self.window_observer_nodes
                    .iter()
                    .filter(|id| changed.contains(id))
                    .copied(),
            );
        } else {
            candidates.extend(
                changed
                    .iter()
                    .filter(|id| self.window_observer_nodes.contains(id))
                    .copied(),
            );
        }
        candidates.extend(self.metadatas.size_changed.iter().copied());
        let observer_candidates = candidates.len();
        let mut invocations = Vec::new();
        for node_id in candidates {
            let Some(node_ref) = self.tree.get(node_id) else {
                continue;
            };
            let node = node_ref.get();
            if node.interaction().globally_positioned_handlers.is_empty() {
                continue;
            }
            let Some(metadata) = self.metadatas.get(&node_id) else {
                continue;
            };
            let Some(position) = metadata.abs_position else {
                if let Some(previous) = self.last_global_rects.remove(&node.instance_key) {
                    let mut geometry = previous.geometry;
                    geometry.visible = None;
                    for handler in &node.interaction().globally_positioned_handlers {
                        if matches!(handler, GloballyPositionedHandler::Visible(_))
                            && previous.geometry.visible.is_some()
                        {
                            invocations.push((*handler, geometry));
                        }
                    }
                }
                continue;
            };
            let size = metadata.computed_data.unwrap_or(ComputedData::ZERO);
            let rect = PxRect {
                x: position.x_px(),
                y: position.y_px(),
                width: size.width,
                height: size.height,
            };
            let transform = metadata
                .local_to_window
                .unwrap_or_else(|| crate::LocalToWindow::new(1.0, position).unwrap());
            let precise = transform.map_rect(crate::FloatRect::from_position_size(
                PxPosition::ZERO,
                PxSize::new(size.width, size.height),
            ));
            let geometry = node::GeometryObservation {
                rounded: if transform.scale() == 1.0 {
                    rect
                } else {
                    precise.outward()
                },
                precise,
                visible: precise
                    .intersection(metadata.event_clip_bounds.unwrap_or(precise))
                    .and_then(|bounds| {
                        bounds.intersection(crate::FloatRect::from_position_size(
                            PxPosition::ZERO,
                            viewport,
                        ))
                    }),
                transform,
                coordinates: crate::LayoutCoordinates {
                    local_size: PxSize::new(size.width, size.height),
                    local_to_window: transform,
                },
                in_space: if node
                    .interaction()
                    .globally_positioned_handlers
                    .iter()
                    .any(|handler| matches!(handler, GloballyPositionedHandler::InSpace(_)))
                {
                    layout_rect_in_space(&self.tree, &self.metadatas, node_id).unwrap_or(precise)
                } else {
                    precise
                },
            };
            let previous = self.last_global_rects.get(&node.instance_key);
            for handler in &node.interaction().globally_positioned_handlers {
                if previous.is_none_or(|previous| {
                    handler.changed(previous.geometry, geometry)
                        || !previous.handlers.contains(handler)
                }) {
                    invocations.push((*handler, geometry));
                }
            }
            self.last_global_rects.insert(
                node.instance_key,
                GlobalPositionSnapshot {
                    geometry,
                    handlers: node
                        .interaction()
                        .globally_positioned_handlers
                        .iter()
                        .copied()
                        .collect(),
                },
            );
        }
        tracing::debug!(
            target: "tessera_ui::frame_cost",
            callbacks = invocations.len(),
            candidates = observer_candidates,
            size_changes = self.metadatas.size_changed.len(),
            "position_observer_work"
        );
        self.pending_globally_positioned_invocations
            .extend(invocations);
    }

    pub(crate) fn take_pending_globally_positioned_invocations(
        &mut self,
    ) -> Vec<(GloballyPositionedHandler, node::GeometryObservation)> {
        std::mem::take(&mut self.pending_globally_positioned_invocations)
    }

    pub(crate) fn take_pending_focus_callback_invocations(
        &mut self,
    ) -> Vec<PendingFocusCallbackInvocation> {
        let notifications = self.focus_owner.take_pending_notifications();
        let mut invocations = Vec::new();

        for notification in notifications {
            let Some(node_id) = self
                .focus_owner
                .component_node_id_of(notification.handle_id)
            else {
                continue;
            };
            let Some(node_ref) = self.tree.get(node_id) else {
                continue;
            };
            let node = node_ref.get();

            if notification.changed
                && let Some(handler) = &node.interaction().focus_changed_handler
            {
                invocations.push(PendingFocusCallbackInvocation::new(
                    *handler,
                    notification.state,
                    notification.direction,
                ));
            }
            if let Some(handler) = &node.interaction().focus_event_handler {
                invocations.push(PendingFocusCallbackInvocation::new(
                    *handler,
                    notification.state,
                    notification.direction,
                ));
            }
        }

        invocations
    }

    /// Collect per-node metadata for profiling output.
    #[cfg(feature = "profiling")]
    pub fn profiler_nodes(&mut self) -> Vec<NodeMeta> {
        self.profiler_dirty_nodes
            .extend(std::mem::take(&mut self.metadatas.profiling_dirty));
        self.profiler_dirty_nodes
            .extend(self.metadatas.geometry_changed.iter().copied());
        for node_id in std::mem::take(&mut self.profiler_dirty_nodes) {
            let Some(node) = self.tree.get(node_id).filter(|node| !node.is_removed()) else {
                self.profiler_nodes_cache.remove(&node_id);
                continue;
            };
            let metadata = self.metadatas.get(&node_id);
            self.profiler_nodes_cache.insert(
                node_id,
                NodeMeta {
                    node_id: node_id.to_string(),
                    parent: node.parent().map(|id| id.to_string()),
                    fn_name: Some(node.get().fn_name.to_owned()),
                    abs_pos: metadata
                        .and_then(|metadata| metadata.abs_position)
                        .map(|position| (position.x_px().0, position.y_px().0)),
                    size: metadata
                        .and_then(|metadata| metadata.computed_data)
                        .map(|size| (size.width.0, size.height.0)),
                    layout_cache_hit: metadata.map(|metadata| metadata.layout_cache_hit),
                },
            );
        }
        self.profiler_nodes_cache.values().cloned().collect()
    }

    /// Dispatches pointer input across the tree and returns the window requests
    /// raised by the handlers (currently the hover cursor icon).
    fn dispatch_pointer_input(
        &mut self,
        root_node: indextree::NodeId,
        pointer_changes: &mut [PointerChange],
        cursor_position: &mut Option<PxPosition>,
        modifiers: winit::keyboard::ModifiersState,
    ) -> WindowRequests {
        let mut window_requests = WindowRequests::default();
        self.pointer_index.invalidate(
            &self.tree,
            &self.changed_frame_nodes,
            &self.removed_frame_nodes,
        );
        self.pointer_work.0 = self.pointer_index.update(&self.tree, &self.metadatas) as u64;
        self.pointer_index.begin_dispatch();
        self.active_pointer_paths.retain(|_, path| {
            path.last().is_some_and(|key| {
                self.node_ids_by_instance_key.get(key).is_some_and(|id| {
                    self.metadatas
                        .get(id)
                        .is_some_and(|metadata| metadata.abs_position.is_some())
                })
            })
        });
        self.active_pointer_positions
            .retain(|pointer, _| self.active_pointer_paths.contains_key(pointer));
        let dirty = crate::runtime::take_pointer_dirty_nodes();
        let mut selected: HashSet<_> = dirty
            .into_iter()
            .filter_map(|key| self.node_ids_by_instance_key.get(&key).copied())
            .collect();
        for path in self.active_pointer_paths.values() {
            selected.extend(
                path.iter()
                    .filter_map(|key| self.node_ids_by_instance_key.get(key).copied()),
            );
        }
        for change in pointer_changes.iter() {
            selected.extend(self.pointer_index.sample_targets(
                &self.tree,
                &self.metadatas,
                change.resolved_position(*cursor_position),
            ));
            selected.extend(self.pointer_index.hit_path(
                &self.tree,
                &self.metadatas,
                change.resolved_position(*cursor_position),
            ));
        }
        let final_position = *cursor_position;
        let path = self
            .pointer_index
            .hit_path(&self.tree, &self.metadatas, final_position);
        window_requests.cursor_icon = path
            .into_iter()
            .rev()
            .find_map(|id| {
                let node = self.tree.get(id)?.get();
                let metadata = self.metadatas.get(&id)?;
                resolve_node_hover_cursor_icon(
                    node,
                    metadata.base_abs_position?,
                    metadata.computed_data?,
                    final_position?,
                    metadata
                        .local_to_window
                        .map_or(1.0, |transform| transform.scale()),
                    metadata.input_transforms.as_deref(),
                )
            })
            .unwrap_or_default();
        let plan = self.pointer_index.plan(
            &self.tree,
            &self.metadatas,
            final_position,
            selected.into_iter(),
        );
        self.pointer_work
            .1
            .extend(plan.nodes.values().map(|node| node.context.instance_key));
        for node in plan.nodes.values() {
            crate::runtime::clear_phase_state_reads(
                node.context.instance_key,
                crate::runtime::ReadPhase::Pointer,
            );
        }
        let mut last_position = None;
        for change in pointer_changes {
            if matches!(&change.content, CursorEventContent::Pressed(_)) {
                self.focus_owner.observe_pointer_press(change.timestamp);
            }
            if matches!(change.content, CursorEventContent::Scroll(_))
                && change.scroll_discrete.is_none()
            {
                change.scroll_discrete = Some(change.is_discrete_scroll());
            }
            if matches!(
                &change.content,
                CursorEventContent::Scroll(scroll)
                    if scroll.delta_x.is_finite()
                        && scroll.delta_y.is_finite()
                        && (scroll.delta_x != 0.0 || scroll.delta_y != 0.0)
            ) {
                self.focus_owner.cancel_pending_reveal_for_scroll();
            }
            let mut position = change.resolved_position(final_position);
            last_position = Some(position);
            self.dispatch_pointer_sample(
                root_node,
                std::slice::from_mut(change),
                &mut position,
                modifiers,
                &plan,
                &mut window_requests,
            );
        }
        if last_position != Some(final_position) {
            self.dispatch_pointer_sample(
                root_node,
                &mut [],
                cursor_position,
                modifiers,
                &plan,
                &mut window_requests,
            );
        }
        window_requests
    }

    fn dispatch_pointer_sample(
        &mut self,
        _root_node: indextree::NodeId,
        pointer_changes: &mut [PointerChange],
        cursor_position: &mut Option<PxPosition>,
        modifiers: winit::keyboard::ModifiersState,
        plan: &PointerDispatchPlan,
        window_requests: &mut WindowRequests,
    ) {
        let node_ids_preorder = &plan.preorder;
        let node_ids_postorder = &plan.postorder;
        let pointer_change_paths = build_pointer_change_paths(
            &self.pointer_index,
            &self.tree,
            &self.metadatas,
            pointer_changes,
            *cursor_position,
            &mut self.active_pointer_paths,
        );
        for change in pointer_changes.iter() {
            if self.active_pointer_paths.contains_key(&change.pointer_id) {
                self.active_pointer_positions.insert(
                    change.pointer_id,
                    change.resolved_position(*cursor_position),
                );
            } else {
                self.active_pointer_positions.remove(&change.pointer_id);
            }
        }

        for node_id in node_ids_preorder.iter().copied() {
            let Some(node) = self.tree.get(node_id).map(|n| n.get()) else {
                continue;
            };
            let mut dispatch_ctx = PointerInputDispatchContext {
                tree: &self.tree,
                metadatas: &self.metadatas,
                cursor_position: &mut *cursor_position,
                pointer_changes: &mut *pointer_changes,
                pointer_change_paths: &pointer_change_paths,
                nodes: &plan.nodes,
                active_pointer_paths: &self.active_pointer_paths,
                active_pointer_positions: &self.active_pointer_positions,
                modifiers,
                window_requests: &mut *window_requests,
                focus_owner: &mut self.focus_owner,
            };
            dispatch_pointer_modifiers_for_node_pass(
                &mut dispatch_ctx,
                node_id,
                PointerEventPass::Initial,
            );
            let handlers = &node.interaction().pointer_preview_handlers;
            for handler in handlers {
                let mut dispatch_ctx = PointerInputDispatchContext {
                    tree: &self.tree,
                    metadatas: &self.metadatas,
                    cursor_position: &mut *cursor_position,
                    pointer_changes: &mut *pointer_changes,
                    pointer_change_paths: &pointer_change_paths,
                    nodes: &plan.nodes,
                    active_pointer_paths: &self.active_pointer_paths,
                    active_pointer_positions: &self.active_pointer_positions,
                    modifiers,
                    window_requests: &mut *window_requests,
                    focus_owner: &mut self.focus_owner,
                };
                run_pointer_handler_for_node(
                    &mut dispatch_ctx,
                    node_id,
                    PointerEventPass::Initial,
                    handler.as_ref(),
                );
            }
        }

        for node_id in node_ids_postorder.iter().copied() {
            let Some(node) = self.tree.get(node_id).map(|n| n.get()) else {
                continue;
            };
            let mut dispatch_ctx = PointerInputDispatchContext {
                tree: &self.tree,
                metadatas: &self.metadatas,
                cursor_position: &mut *cursor_position,
                pointer_changes: &mut *pointer_changes,
                pointer_change_paths: &pointer_change_paths,
                nodes: &plan.nodes,
                active_pointer_paths: &self.active_pointer_paths,
                active_pointer_positions: &self.active_pointer_positions,
                modifiers,
                window_requests: &mut *window_requests,
                focus_owner: &mut self.focus_owner,
            };
            dispatch_pointer_modifiers_for_node_pass(
                &mut dispatch_ctx,
                node_id,
                PointerEventPass::Main,
            );
            let handlers = &node.interaction().pointer_handlers;
            for handler in handlers {
                let mut dispatch_ctx = PointerInputDispatchContext {
                    tree: &self.tree,
                    metadatas: &self.metadatas,
                    cursor_position: &mut *cursor_position,
                    pointer_changes: &mut *pointer_changes,
                    pointer_change_paths: &pointer_change_paths,
                    nodes: &plan.nodes,
                    active_pointer_paths: &self.active_pointer_paths,
                    active_pointer_positions: &self.active_pointer_positions,
                    modifiers,
                    window_requests: &mut *window_requests,
                    focus_owner: &mut self.focus_owner,
                };
                run_pointer_handler_for_node(
                    &mut dispatch_ctx,
                    node_id,
                    PointerEventPass::Main,
                    handler.as_ref(),
                );
            }
        }

        for node_id in node_ids_preorder.iter().copied() {
            let Some(node) = self.tree.get(node_id).map(|n| n.get()) else {
                continue;
            };
            let mut dispatch_ctx = PointerInputDispatchContext {
                tree: &self.tree,
                metadatas: &self.metadatas,
                cursor_position: &mut *cursor_position,
                pointer_changes: &mut *pointer_changes,
                pointer_change_paths: &pointer_change_paths,
                nodes: &plan.nodes,
                active_pointer_paths: &self.active_pointer_paths,
                active_pointer_positions: &self.active_pointer_positions,
                modifiers,
                window_requests: &mut *window_requests,
                focus_owner: &mut self.focus_owner,
            };
            dispatch_pointer_modifiers_for_node_pass(
                &mut dispatch_ctx,
                node_id,
                PointerEventPass::Final,
            );
            let handlers = &node.interaction().pointer_final_handlers;
            for handler in handlers {
                let mut dispatch_ctx = PointerInputDispatchContext {
                    tree: &self.tree,
                    metadatas: &self.metadatas,
                    cursor_position: &mut *cursor_position,
                    pointer_changes: &mut *pointer_changes,
                    pointer_change_paths: &pointer_change_paths,
                    nodes: &plan.nodes,
                    active_pointer_paths: &self.active_pointer_paths,
                    active_pointer_positions: &self.active_pointer_positions,
                    modifiers,
                    window_requests: &mut *window_requests,
                    focus_owner: &mut self.focus_owner,
                };
                run_pointer_handler_for_node(
                    &mut dispatch_ctx,
                    node_id,
                    PointerEventPass::Final,
                    handler.as_ref(),
                );
            }
        }
    }

    fn dispatch_keyboard_event(
        &mut self,
        root_node: NodeId,
        queued: QueuedInput,
        window_requests: &mut WindowRequests,
    ) -> Option<FocusDirection> {
        let path = collect_focus_chain_node_ids(root_node, &self.tree, &self.focus_owner);
        let mut events = vec![queued.event];
        let mut context = KeyboardInputDispatchContext {
            tree: &self.tree,
            metadatas: &self.metadatas,
            keyboard_events: &mut events,
            modifiers: queued.modifiers,
            ime_client: self.focus_owner.active_handle_id(),
            window_requests,
            focus_owner: &mut self.focus_owner,
        };
        for node_id in path.iter().copied() {
            let Some(node) = context.tree.get(node_id).map(|node| node.get()) else {
                continue;
            };
            for action in node.modifier.ordered_actions() {
                if let OrderedModifierAction::KeyboardPreviewInput(modifier) = action {
                    run_keyboard_input_for_node(&mut context, node_id, |input| {
                        modifier.on_keyboard_input(input)
                    });
                }
            }
            for handler in &node.interaction().keyboard_preview_handlers {
                run_keyboard_input_for_node(&mut context, node_id, handler.as_ref());
            }
        }
        for node_id in path.iter().rev().copied() {
            let Some(node) = context.tree.get(node_id).map(|node| node.get()) else {
                continue;
            };
            for action in node.modifier.ordered_actions() {
                if let OrderedModifierAction::KeyboardInput(modifier) = action {
                    run_keyboard_input_for_node(&mut context, node_id, |input| {
                        modifier.on_keyboard_input(input)
                    });
                }
            }
            for handler in &node.interaction().keyboard_handlers {
                run_keyboard_input_for_node(&mut context, node_id, handler.as_ref());
            }
        }
        dispatch_default_focus_keyboard_navigation(
            context.tree,
            context.keyboard_events,
            context.modifiers,
            context.focus_owner,
        )
    }

    fn dispatch_clipboard_action(&mut self, root_node: NodeId, request: QueuedClipboardAction) {
        let path = collect_focus_chain_node_ids(root_node, &self.tree, &self.focus_owner);
        let mut response = None;
        for node_id in path.into_iter().rev() {
            let Some(context) = resolve_node_input_context(&self.tree, &self.metadatas, node_id)
            else {
                continue;
            };
            let node = self.tree.get(node_id).expect("focused node").get();
            for action in node.modifier.ordered_actions() {
                if let OrderedModifierAction::ClipboardInput(modifier) = action {
                    let boundary = nearest_replay_boundary_instance_key(node_id, &self.tree);
                    let _node = push_current_node_with_instance_logic_id(
                        node_id,
                        context.instance_logic_id,
                        context.fn_name,
                    );
                    let _instance = push_current_component_instance_key(boundary);
                    let _phase = push_phase(RuntimePhase::Input);
                    let _focus = bind_focus_owner(&mut self.focus_owner);
                    modifier.on_clipboard_input(ClipboardInput {
                        action: &request.action,
                        response: &mut response,
                    });
                    if response.is_some() {
                        break;
                    }
                }
            }
            if response.is_some() {
                break;
            }
        }
        (request.reply)(response.unwrap_or(ClipboardResponse::Ignored));
    }

    fn dispatch_ime_input(
        &mut self,
        root_node: NodeId,
        events: &mut Vec<crate::ime_state::ImeEvent>,
        window_requests: &mut WindowRequests,
    ) {
        let path = collect_focus_chain_node_ids(root_node, &self.tree, &self.focus_owner);
        let client = self.focus_owner.active_handle_id();
        let mut pending = std::mem::take(events)
            .into_iter()
            .filter_map(|(source, event)| {
                source
                    .is_none_or(|source| Some(source) == client)
                    .then_some(event)
            })
            .collect();
        for node_id in path.iter().copied() {
            let Some(node) = self.tree.get(node_id).map(|node| node.get()) else {
                continue;
            };
            for action in node.modifier.ordered_actions() {
                if let OrderedModifierAction::ImePreviewInput(modifier) = action {
                    run_ime_input_for_node(
                        &self.tree,
                        &self.metadatas,
                        node_id,
                        &mut pending,
                        window_requests,
                        &mut self.focus_owner,
                        client,
                        |input| modifier.on_ime_input(input),
                    );
                }
            }
            for handler in &node.interaction().ime_preview_handlers {
                run_ime_input_for_node(
                    &self.tree,
                    &self.metadatas,
                    node_id,
                    &mut pending,
                    window_requests,
                    &mut self.focus_owner,
                    client,
                    handler.as_ref(),
                );
            }
        }
        for node_id in path.iter().rev().copied() {
            let Some(node) = self.tree.get(node_id).map(|node| node.get()) else {
                continue;
            };
            for action in node.modifier.ordered_actions() {
                if let OrderedModifierAction::ImeInput(modifier) = action {
                    run_ime_input_for_node(
                        &self.tree,
                        &self.metadatas,
                        node_id,
                        &mut pending,
                        window_requests,
                        &mut self.focus_owner,
                        client,
                        |input| modifier.on_ime_input(input),
                    );
                }
            }
            for handler in &node.interaction().ime_handlers {
                run_ime_input_for_node(
                    &self.tree,
                    &self.metadatas,
                    node_id,
                    &mut pending,
                    window_requests,
                    &mut self.focus_owner,
                    client,
                    handler.as_ref(),
                );
            }
        }
    }

    fn queue_focused_input(
        &mut self,
        keyboard: Vec<QueuedInput>,
        ime: Vec<QueuedInput<crate::ime_state::ImeEvent>>,
    ) {
        self.pending_focused_input
            .extend(keyboard.into_iter().map(QueuedFocusedInput::Keyboard));
        self.pending_focused_input
            .extend(ime.into_iter().map(QueuedFocusedInput::Ime));
        self.pending_focused_input.extend(
            clipboard::take_requests()
                .into_iter()
                .map(QueuedFocusedInput::Clipboard),
        );
        self.pending_focused_input
            .make_contiguous()
            .sort_by_key(QueuedFocusedInput::sequence);
    }

    fn dispatch_pending_focused_input(
        &mut self,
        root: NodeId,
        requests: &mut WindowRequests,
    ) -> Option<FocusDirection> {
        let mut events = std::mem::take(&mut self.pending_focused_input);
        let retry = if self.focus_owner.keyboard_is_deferred() {
            None
        } else {
            drain_pending_focused_input(&mut events, |event| {
                let cause = match &event {
                    QueuedFocusedInput::Ime(event) => {
                        let (client, event) = &event.event;
                        (client.is_none_or(|client| {
                            Some(client) == self.focus_owner.active_handle_id()
                        }) && !matches!(
                            event,
                            winit::event::Ime::Enabled | winit::event::Ime::Disabled
                        ))
                        .then_some(winit::event::ImeChangeCause::InputMethod)
                    }
                    _ => Some(winit::event::ImeChangeCause::Other),
                };
                let retry = match event {
                    QueuedFocusedInput::Keyboard(event) => {
                        self.dispatch_keyboard_event(root, event, requests)
                    }
                    QueuedFocusedInput::Clipboard(request) => {
                        self.dispatch_clipboard_action(root, request);
                        None
                    }
                    QueuedFocusedInput::Ime(event) => {
                        self.dispatch_ime_input(root, &mut vec![event.event], requests);
                        None
                    }
                };
                if let (Some(request), Some(cause)) = (&mut requests.ime_request, cause) {
                    request.change_cause = cause;
                }
                self.focus_owner.commit_pending();
                (retry, self.focus_owner.keyboard_is_deferred())
            })
        };
        self.pending_focused_input = events;
        if retry.is_some()
            || self.focus_owner.keyboard_is_deferred()
            || self.focus_owner.has_pending_navigation()
        {
            requests.ime_request = None;
        } else {
            let cause = requests
                .ime_request
                .as_ref()
                .map_or(winit::event::ImeChangeCause::Other, |request| {
                    request.change_cause
                });
            self.dispatch_ime_input(root, &mut Vec::new(), requests);
            if let Some(request) = &mut requests.ime_request {
                request.change_cause = cause;
            }
        }
        retry
    }

    pub(crate) fn flush_focused_input(
        &mut self,
        cursor: &mut crate::cursor::CursorState,
        modifiers: winit::keyboard::ModifiersState,
        keyboard: Vec<QueuedInput>,
        ime: Vec<QueuedInput<crate::ime_state::ImeEvent>>,
    ) -> WindowRequests {
        self.queue_focused_input(keyboard, ime);
        let Some(root) = self.tree.get_node_id_at(NonZero::new(1).unwrap()) else {
            return WindowRequests::default();
        };
        if self
            .metadatas
            .get(&root)
            .is_none_or(|metadata| metadata.computed_data.is_none())
        {
            return WindowRequests::default();
        }
        let mut pointer = cursor.take_events();
        let mut position = cursor.position();
        let mut requests =
            self.dispatch_pointer_input(root, &mut pointer, &mut position, modifiers);
        self.focus_owner.commit_pending();
        if self.focus_owner.keyboard_is_deferred() || self.focus_owner.has_pending_navigation() {
            requests.ime_request = None;
            return requests;
        }
        let retry = self.dispatch_pending_focused_input(root, &mut requests);
        self.focus_owner.retain_navigation_retry(retry);
        requests
    }

    fn clear_frame_structure_changes(&mut self) {
        let live_nodes = self.node_ids_by_instance_key.len();
        for (nodes, previous_count) in
            [&mut self.changed_frame_nodes, &mut self.removed_frame_nodes]
                .into_iter()
                .zip(&mut self.previous_structure_change_counts)
        {
            // Large journals pay for retained capacity only when the work recurs.
            let recent_count = nodes
                .len()
                .min(std::mem::replace(previous_count, nodes.len()));
            let capacity_limit = recent_count.min(live_nodes).max(64).saturating_mul(2);
            if nodes.capacity() > capacity_limit {
                *nodes = HashSet::default();
            } else {
                nodes.clear();
            }
        }
    }

    /// Compute the ComponentTree into a render graph
    ///
    /// This method processes the component tree through three main phases:
    /// 1. **Measure Phase**: Calculate sizes and positions for all components
    /// 2. **Graph Generation**: Extract render fragments from component
    ///    metadata
    /// 3. **State Handling**: Process user interactions and events
    ///
    /// Returns a tuple of (graph, window_requests) where the graph contains
    /// the render ops for the current frame.
    #[tracing::instrument(level = "debug", skip(self, params))]
    pub(crate) fn compute(
        &mut self,
        params: ComputeParams,
        mode: ComputeMode,
    ) -> (
        RenderGraph,
        WindowRequests,
        LayoutFrameDiagnostics,
        std::time::Duration,
        Option<FocusDirection>,
        bool,
        bool,
    ) {
        let mut stage_timer =
            tracing::enabled!(target: "tessera_ui::frame_cost", tracing::Level::DEBUG)
                .then(Instant::now);
        self.metadatas.geometry_visits = 0;
        self.metadatas.geometry_changed.clear();
        self.metadatas.size_changed.clear();
        self.metadatas.placement_order_changed.clear();
        self.metadatas.paint_changed.clear();
        self.focus_owner.begin_layout();
        let ComputeParams {
            screen_size,
            mut cursor_position,
            mut pointer_changes,
            keyboard_events,
            ime_events,
            retry_focus_move,
            retry_focus_reveal,
            modifiers,
            layout_dirty_nodes,
        } = params;
        let Some(root_node) = self
            .tree
            .get_node_id_at(NonZero::new(1).expect("root node index must be non-zero"))
        else {
            return (
                RenderGraph::default(),
                WindowRequests::default(),
                LayoutFrameDiagnostics {
                    pointer_nodes_dispatched: self.pointer_work.1.len() as u64,
                    ..Default::default()
                },
                std::time::Duration::ZERO,
                None,
                false,
                false,
            );
        };
        let screen_constraint = Constraint::exact(screen_size.width, screen_size.height);
        for key in &layout_dirty_nodes.transform_nodes {
            if let Some(&node_id) = self.node_ids_by_instance_key.get(key) {
                self.metadatas.mark_geometry_dirty(node_id);
            }
        }
        for key in &layout_dirty_nodes.paint_nodes {
            if let Some(&node_id) = self.node_ids_by_instance_key.get(key) {
                self.metadatas.mark_paint_dirty(node_id);
            }
        }
        let StructureReconcileResult {
            changed_nodes: structural_dirty_nodes,
            removed_nodes,
        } = crate::runtime::take_layout_structure_changes();
        self.remove_layout_snapshots(&removed_nodes);
        // Layout nodes dropped from the tree must also drop the state-read
        // dependencies they registered during measurement, otherwise recycled
        // instance keys would keep stale placement dirtiness alive.
        crate::runtime::remove_layout_state_read_dependencies(&removed_nodes);

        let mut measure_self_nodes = layout_dirty_nodes.measure_self_nodes;
        for key in &layout_dirty_nodes.parent_data_nodes {
            if let Some(&node_id) = self.node_ids_by_instance_key.get(key) {
                let mut parent = self.tree.get(node_id).and_then(|node| node.parent());
                while let Some(parent_id) = parent {
                    let node = &self.tree[parent_id];
                    if node.get().role == NodeRole::Layout || node.parent().is_none() {
                        measure_self_nodes.insert(node.get().instance_key);
                        break;
                    }
                    parent = node.parent();
                }
            }
        }
        let dirty_nodes_param = (measure_self_nodes.len()
            + layout_dirty_nodes
                .placement_self_nodes
                .difference(&measure_self_nodes)
                .count()) as u64;
        let dirty_nodes_structural = structural_dirty_nodes.len() as u64;
        let dirty_prepare_start = Instant::now();
        // Remeasure structural changes so placements use the current child set.
        measure_self_nodes.extend(structural_dirty_nodes);
        let dirty_paths = collect_dirty_layout_paths(
            &self.tree,
            &self.node_ids_by_instance_key,
            &measure_self_nodes,
            &layout_dirty_nodes.placement_self_nodes,
        );
        let dirty_expand_ns = dirty_prepare_start.elapsed().as_nanos() as u64;
        record_frame_stage(&mut stage_timer, "layout_dirty_paths");
        let mut diagnostics = LayoutDiagnosticsCollector::default();

        tracing::debug!(
            target: "tessera_ui::frame_cost",
            changed = self.changed_frame_nodes.len(),
            removed = self.removed_frame_nodes.len(),
            "frame_consumer_candidates"
        );

        #[cfg(feature = "profiling")]
        {
            self.profiler_dirty_nodes
                .extend(self.changed_frame_nodes.iter().copied());
            self.profiler_dirty_nodes
                .extend(self.removed_frame_nodes.iter().copied());
            self.profiler_dirty_nodes
                .extend(dirty_paths.keys().copied());
            self.profiler_dirty_nodes.insert(root_node);
        }
        self.pointer_index.invalidate(
            &self.tree,
            &self.changed_frame_nodes,
            &self.removed_frame_nodes,
        );
        self.accessibility_index
            .invalidate(&self.changed_frame_nodes, &self.removed_frame_nodes);
        self.focus_owner.sync_changes(
            &self.tree,
            &self.changed_frame_nodes,
            &self.removed_frame_nodes,
        );
        self.focus_owner.commit_pending();

        record_frame_stage(&mut stage_timer, "consumer_attachments");
        {
            let consumed_insets = Cell::new(crate::Insets::default());
            let layout_ctx = LayoutContext::new(
                &consumed_insets,
                &mut self.layout_snapshots,
                &dirty_paths,
                &mut diagnostics,
            );

            let measure_timer = Instant::now();
            debug!("Start measuring the component tree...");

            match measure_node(
                root_node,
                &screen_constraint,
                &self.tree,
                &mut self.metadatas,
                Some(&layout_ctx),
            ) {
                Ok(_root_computed_data) => {
                    debug!("Component tree measured in {:?}", measure_timer.elapsed());
                }
                Err(e) => {
                    panic!(
                        "Root node ({root_node:?}) measurement failed: {e:?}. Aborting draw command computation."
                    );
                }
            }
        }

        record_frame_stage(&mut stage_timer, "measure");
        let mut diagnostics_snapshot = diagnostics.snapshot(
            dirty_nodes_param,
            dirty_nodes_structural,
            dirty_paths.len() as u64,
            dirty_expand_ns,
        );
        diagnostics_snapshot.geometry_nodes_updated =
            populate_layout_metadata(root_node, &self.tree, &mut self.metadatas);
        self.defer_unplaced_layout_paths(measure_self_nodes.iter().copied(), false);
        self.defer_unplaced_layout_paths(
            layout_dirty_nodes.placement_self_nodes.iter().copied(),
            true,
        );
        for key in &layout_dirty_nodes.transform_nodes {
            if let Some(id) = self.node_ids_by_instance_key.get(key)
                && let Some(metadata) = self.metadatas.get_mut(id)
                && metadata.abs_position.is_none()
            {
                metadata.geometry_initialized = false;
            }
        }
        record_frame_stage(&mut stage_timer, "geometry");

        match mode {
            ComputeMode::Full => {}
            #[cfg(any(test, feature = "testing"))]
            ComputeMode::LayoutOnly => {
                self.frame_scene.clear_structure_changes();
                self.collect_globally_positioned_invocations(screen_size);
                diagnostics_snapshot.accessibility_nodes_updated =
                    self.sync_accessibility(root_node, true) as u64;
                self.focus_owner.sync_geometry_changes(
                    &self.tree,
                    &self.metadatas,
                    &self.metadatas.geometry_changed,
                    &self.changed_frame_nodes,
                );
                self.clear_frame_structure_changes();
                let _ = self.dispatch_pointer_input(
                    root_node,
                    pointer_changes.as_mut_slice(),
                    &mut cursor_position,
                    modifiers,
                );
                diagnostics_snapshot.geometry_nodes_visited = self.metadatas.geometry_visits;
                diagnostics_snapshot.pointer_nodes_updated = self.pointer_work.0;
                diagnostics_snapshot.pointer_nodes_dispatched = self.pointer_work.1.len() as u64;
                diagnostics_snapshot.pointer_hit_test_candidates =
                    self.pointer_index.hit_candidates.get();
                return (
                    RenderGraph::default(),
                    WindowRequests::default(),
                    diagnostics_snapshot,
                    std::time::Duration::ZERO,
                    None,
                    false,
                    false,
                );
            }
        };

        let record_timer = Instant::now();
        let _focus_owner_guard = bind_focus_owner(&mut self.focus_owner);
        record_layout_commands(root_node, &self.tree, &mut self.metadatas);
        let record_cost = record_timer.elapsed();
        record_frame_stage(&mut stage_timer, "paint");
        diagnostics_snapshot.geometry_nodes_updated +=
            populate_layout_metadata(root_node, &self.tree, &mut self.metadatas);
        record_frame_stage(&mut stage_timer, "geometry_after_paint");
        tracing::debug!(
            target: "tessera_ui::frame_cost",
            geometry_journal_nodes = self.metadatas.geometry_changed.len(),
            "geometry_journal"
        );
        self.collect_globally_positioned_invocations(screen_size);
        record_frame_stage(&mut stage_timer, "position_observers");
        diagnostics_snapshot.accessibility_nodes_updated =
            self.sync_accessibility(root_node, false) as u64;
        record_frame_stage(&mut stage_timer, "accessibility");
        diagnostics_snapshot.paint_nodes_recorded = self.metadatas.paint_changed.len() as u64;

        let compute_draw_timer = Instant::now();
        debug!("Start computing render graph...");
        let (graph, scene_updates) = self.frame_scene.update(
            root_node,
            &self.tree,
            &self.metadatas,
            &self.changed_frame_nodes,
            &self.removed_frame_nodes,
            screen_size,
        );
        diagnostics_snapshot.scene_nodes_updated = scene_updates;
        record_frame_stage(&mut stage_timer, "scene");
        self.focus_owner.sync_geometry_changes(
            &self.tree,
            &self.metadatas,
            &self.metadatas.geometry_changed,
            &self.changed_frame_nodes,
        );
        self.clear_frame_structure_changes();
        record_frame_stage(&mut stage_timer, "focus_geometry");
        debug!(
            "Render graph built in {:?}, total ops: {}",
            compute_draw_timer.elapsed(),
            graph.ops().len()
        );

        let input_dispatch_timer = Instant::now();
        debug!("Start executing typed input dispatch...");
        let mut window_requests = self.dispatch_pointer_input(
            root_node,
            pointer_changes.as_mut_slice(),
            &mut cursor_position,
            modifiers,
        );
        record_frame_stage(&mut stage_timer, "pointer");

        diagnostics_snapshot.geometry_nodes_visited = self.metadatas.geometry_visits;
        diagnostics_snapshot.pointer_nodes_updated = self.pointer_work.0;
        diagnostics_snapshot.pointer_nodes_dispatched = self.pointer_work.1.len() as u64;
        diagnostics_snapshot.pointer_hit_test_candidates = self.pointer_index.hit_candidates.get();
        self.focus_owner.commit_pending();
        let requested_move = self
            .focus_owner
            .take_pending_navigation()
            .or(retry_focus_move);
        let pending_focus_move_retry = requested_move.and_then(|direction| {
            match try_dispatch_focus_move_request(&self.tree, direction, &mut self.focus_owner) {
                FocusMoveRequestResult::Retry(direction) => Some(direction),
                FocusMoveRequestResult::Moved | FocusMoveRequestResult::NotHandled => None,
            }
        });
        self.queue_focused_input(keyboard_events, ime_events);
        let pending_focus_move_retry = pending_focus_move_retry
            .or_else(|| self.dispatch_pending_focused_input(root_node, &mut window_requests));
        self.focus_owner
            .retain_navigation_retry(pending_focus_move_retry);
        let pending_keyboard_retry =
            needs_deferred_focus_retry(&self.focus_owner, !self.pending_focused_input.is_empty());
        let pending_focus_reveal_retry =
            if pending_focus_move_retry.is_none() && !self.focus_owner.keyboard_is_deferred() {
                dispatch_pending_focus_reveal_request(
                    &self.tree,
                    &self.metadatas,
                    &mut self.focus_owner,
                    retry_focus_reveal,
                )
            } else {
                false
            };

        debug!(
            "Typed input dispatch executed in {:?}",
            input_dispatch_timer.elapsed()
        );
        record_frame_stage(&mut stage_timer, "focused_input");
        (
            graph,
            window_requests,
            diagnostics_snapshot,
            record_cost,
            pending_focus_move_retry,
            pending_focus_reveal_retry,
            pending_keyboard_retry,
        )
    }
}

fn drain_pending_focused_input<E>(
    queue: &mut VecDeque<E>,
    mut dispatch: impl FnMut(E) -> (Option<FocusDirection>, bool),
) -> Option<FocusDirection> {
    while let Some(event) = queue.pop_front() {
        let (retry, defer) = dispatch(event);
        if let Some(direction) = retry {
            return Some(direction);
        }
        if defer {
            return None;
        }
    }
    None
}

#[derive(Clone)]
struct NodeInputContext {
    local_to_window: crate::LocalToWindow,
    input_transforms: Option<node::InputTransforms>,
    event_clip_bounds: Option<crate::FloatRect>,
    base_abs_pos: PxPosition,
    abs_pos: PxPosition,
    event_clip_rect: Option<PxRect>,
    node_computed_data: ComputedData,
    instance_logic_id: u64,
    instance_key: u64,
    fn_name: &'static str,
    parent_id: Option<indextree::NodeId>,
}

fn resolve_node_input_context(
    tree: &ComponentNodeTree,
    metadatas: &ComponentNodeMetaDatas,
    node_id: indextree::NodeId,
) -> Option<NodeInputContext> {
    let Some(node_ref) = tree.get(node_id) else {
        warn!("Node not found for node {node_id:?}; skipping input handling");
        return None;
    };
    let node = node_ref.get();
    if node.role != NodeRole::Layout {
        return None;
    }

    let Some(metadata) = metadatas.get(&node_id) else {
        warn!("Input metadata missing for node {node_id:?}; skipping input handling");
        return None;
    };
    let Some(base_abs_pos) = metadata.base_abs_position else {
        warn!("Base absolute position missing for node {node_id:?}; skipping input handling");
        return None;
    };
    let Some(abs_pos) = metadata.abs_position else {
        warn!("Absolute position missing for node {node_id:?}; skipping input handling");
        return None;
    };
    let event_clip_rect = metadata.event_clip_rect();
    let Some(node_computed_data) = metadata.computed_data else {
        warn!(
            "Computed data not found for node {:?} during input dispatch.",
            node_id
        );
        return None;
    };
    let instance_logic_id = node.instance_logic_id;
    let instance_key = node.instance_key;
    let parent_id = node_ref.parent();

    Some(NodeInputContext {
        local_to_window: metadata
            .local_to_window
            .unwrap_or_else(|| crate::LocalToWindow::new(1.0, abs_pos).unwrap()),
        input_transforms: metadata.input_transforms.as_deref().cloned(),
        event_clip_bounds: metadata.event_clip_bounds,
        base_abs_pos,
        abs_pos,
        event_clip_rect,
        node_computed_data,
        instance_logic_id,
        instance_key,
        fn_name: node.fn_name,
        parent_id,
    })
}

fn attach_ime_position_if_needed(
    window_requests: &mut WindowRequests,
    transform: crate::LocalToWindow,
    source: Option<crate::focus::FocusHandleId>,
    active: Option<crate::focus::FocusHandleId>,
) {
    let Some(request) = window_requests.ime_request.as_mut() else {
        return;
    };
    let source = if request.position.is_none() {
        source
    } else {
        request.client_id
    };
    if source.is_none() || source != active {
        window_requests.ime_request = None;
        return;
    }
    if request.position.is_none() {
        request.client_id = source;
        request.position = Some(transform.map_point(request.local_position));
        let size = transform.map_size(request.size);
        request.size = PxSize::new(
            crate::Px(size[0].ceil() as i32),
            crate::Px(size[1].ceil() as i32),
        );
    }
}

fn inside_shape_clips(
    tree: &ComponentNodeTree,
    metadatas: &ComponentNodeMetaDatas,
    node_id: indextree::NodeId,
    position: PxPosition,
) -> bool {
    if !metadatas
        .get(&node_id)
        .is_some_and(|metadata| metadata.has_shape_clipping)
    {
        return true;
    }
    node_id.ancestors(tree).all(|ancestor| {
        let Some(metadata) = metadatas.get(&ancestor) else {
            return true;
        };
        let (Some(&region), Some(origin)) = (metadata.clip_region(), metadata.abs_position) else {
            return true;
        };
        let transform = metadata
            .local_to_window
            .unwrap_or_else(|| crate::LocalToWindow::new(1.0, origin).unwrap());
        map_clip_region(region, transform).contains(position)
    })
}

fn bounds_hit_path(
    node_id: indextree::NodeId,
    tree: &ComponentNodeTree,
    metadatas: &ComponentNodeMetaDatas,
    position: PxPosition,
) -> Option<indextree::NodeId> {
    let node = tree.get(node_id)?;
    if node.get().role != NodeRole::Layout {
        return None;
    }
    let metadata = metadatas.get(&node_id)?;
    let base_abs_pos = metadata.base_abs_position?;
    let abs_pos = metadata.abs_position?;
    let size = metadata.computed_data?;
    if size.width.0 <= 0 || size.height.0 <= 0 {
        return None;
    }
    if metadata
        .event_clip_bounds
        .is_some_and(|bounds| !bounds.contains(position))
    {
        return None;
    }
    if let Some(clip_rect) = metadata.event_clip_rect()
        && !clip_rect.contains(position)
    {
        return None;
    }
    if !inside_shape_clips(tree, metadatas, node_id, position) {
        return None;
    }
    let transform = metadata
        .local_to_window
        .unwrap_or_else(|| crate::LocalToWindow::new(1.0, abs_pos).unwrap());
    let bounds = transform.map_rect(crate::FloatRect::from_position_size(
        PxPosition::ZERO,
        PxSize::new(size.width, size.height),
    ));
    let node_data = node.get();
    let has_pointer_modifier = node_data.modifier.ordered_actions().iter().any(|action| {
        matches!(
            action,
            OrderedModifierAction::Cursor(_)
                | OrderedModifierAction::PointerPreviewInput(_)
                | OrderedModifierAction::PointerInput(_)
                | OrderedModifierAction::PointerFinalInput(_)
        )
    });
    let has_pointer_handler = node_data.interaction().has_pointer_handlers();
    if !has_pointer_modifier && !has_pointer_handler {
        return None;
    }
    let node_handles_hover = has_pointer_modifier
        && node_handles_pointer_at_position(
            node_data,
            base_abs_pos,
            size,
            position,
            transform.scale(),
            metadata.input_transforms.as_deref(),
        )
        || bounds.contains(position) && has_pointer_handler;
    node_handles_hover.then_some(node_id)
}

fn node_handles_pointer_at_position(
    node: &crate::component_tree::ComponentNode,
    base_abs_pos: PxPosition,
    size: ComputedData,
    position: PxPosition,
    scale: f32,
    transforms: Option<&node::InputTransforms>,
) -> bool {
    let mut current_abs_pos = base_abs_pos;
    let size = PxSize::new(size.width, size.height);
    for (index, action) in node.modifier.ordered_actions().into_iter().enumerate() {
        if let Some(transform) = transforms.and_then(|transforms| transforms.get(index)) {
            current_abs_pos = transform.translation();
        }
        match action {
            OrderedModifierAction::Placement(placement) => {
                if transforms.is_none() {
                    crate::work::record(
                        node.instance_logic_id,
                        crate::WorkPhase::Transform,
                        placement.node().diagnostic_name(),
                    );
                    current_abs_pos = placement.node().transform_position(current_abs_pos);
                }
            }
            OrderedModifierAction::Cursor(_)
            | OrderedModifierAction::PointerPreviewInput(_)
            | OrderedModifierAction::PointerInput(_)
            | OrderedModifierAction::PointerFinalInput(_) => {
                let bounds = crate::LocalToWindow::new(scale, current_abs_pos)
                    .unwrap()
                    .map_rect(crate::FloatRect::from_position_size(PxPosition::ZERO, size));
                if bounds.contains(position) {
                    return true;
                }
            }
            _ => {}
        }
    }
    false
}

fn resolve_node_hover_cursor_icon(
    node: &crate::component_tree::ComponentNode,
    base_abs_pos: PxPosition,
    size: ComputedData,
    position: PxPosition,
    scale: f32,
    transforms: Option<&node::InputTransforms>,
) -> Option<winit::window::CursorIcon> {
    let mut current_abs_pos = base_abs_pos;
    let size = PxSize::new(size.width, size.height);
    let mut resolved = None;
    for (index, action) in node.modifier.ordered_actions().into_iter().enumerate() {
        if let Some(transform) = transforms.and_then(|transforms| transforms.get(index)) {
            current_abs_pos = transform.translation();
        }
        match action {
            OrderedModifierAction::Placement(placement) => {
                if transforms.is_none() {
                    crate::work::record(
                        node.instance_logic_id,
                        crate::WorkPhase::Transform,
                        placement.node().diagnostic_name(),
                    );
                    current_abs_pos = placement.node().transform_position(current_abs_pos);
                }
            }
            OrderedModifierAction::Cursor(cursor) => {
                let bounds = crate::LocalToWindow::new(scale, current_abs_pos)
                    .unwrap()
                    .map_rect(crate::FloatRect::from_position_size(PxPosition::ZERO, size));
                if bounds.contains(position) {
                    resolved = Some(cursor.cursor_icon());
                }
            }
            _ => {}
        }
    }
    resolved
}

fn build_pointer_change_paths(
    index: &pointer::PointerIndex,
    tree: &ComponentNodeTree,
    metadatas: &ComponentNodeMetaDatas,
    pointer_changes: &[PointerChange],
    cursor_position: Option<PxPosition>,
    active_pointer_paths: &mut HashMap<u64, Vec<u64>>,
) -> Vec<Vec<u64>> {
    let mut paths = Vec::with_capacity(pointer_changes.len());
    for change in pointer_changes {
        let debug_position = change.resolved_position(cursor_position);
        let path = match &change.content {
            CursorEventContent::Pressed(_) => {
                let computed_path = hit_path_instance_keys(index, tree, metadatas, debug_position);
                if computed_path.is_empty() {
                    active_pointer_paths.remove(&change.pointer_id);
                } else {
                    active_pointer_paths.insert(change.pointer_id, computed_path.clone());
                }
                computed_path
            }
            CursorEventContent::Moved(position) => active_pointer_paths
                .get(&change.pointer_id)
                .cloned()
                .unwrap_or_else(|| hit_path_instance_keys(index, tree, metadatas, Some(*position))),
            CursorEventContent::Released(_) | CursorEventContent::Cancelled(_) => {
                let computed = active_pointer_paths
                    .get(&change.pointer_id)
                    .cloned()
                    .unwrap_or_else(|| {
                        hit_path_instance_keys(index, tree, metadatas, debug_position)
                    });
                active_pointer_paths.remove(&change.pointer_id);
                computed
            }
            CursorEventContent::Scroll(_) => active_pointer_paths
                .get(&change.pointer_id)
                .cloned()
                .unwrap_or_else(|| hit_path_instance_keys(index, tree, metadatas, debug_position)),
        };
        paths.push(path);
    }
    paths
}

fn hit_path_instance_keys(
    index: &pointer::PointerIndex,
    tree: &ComponentNodeTree,
    metadatas: &ComponentNodeMetaDatas,
    position: Option<PxPosition>,
) -> Vec<u64> {
    index
        .hit_path(tree, metadatas, position)
        .into_iter()
        .filter_map(|node_id| tree.get(node_id).map(|node| node.get().instance_key))
        .collect()
}

fn collect_focus_chain_node_ids(
    root_node: indextree::NodeId,
    tree: &ComponentNodeTree,
    focus_owner: &FocusOwner,
) -> Vec<indextree::NodeId> {
    fn live_node(
        tree: &ComponentNodeTree,
        node_id: indextree::NodeId,
    ) -> Option<&indextree::Node<ComponentNode>> {
        tree.get(node_id).filter(|node| !node.is_removed())
    }

    let Some(focused_node_id) = focus_owner.active_component_node_id() else {
        return Vec::new();
    };
    if live_node(tree, focused_node_id).is_none() {
        return Vec::new();
    }

    let mut chain = Vec::new();
    let mut current = Some(focused_node_id);
    while let Some(node_id) = current {
        chain.push(node_id);
        if node_id == root_node {
            break;
        }
        current = live_node(tree, node_id).and_then(|node| node.parent());
    }
    if chain.last().copied() != Some(root_node) {
        return Vec::new();
    }
    chain.reverse();
    chain
}

#[derive(Clone)]
struct PointerNodePlan {
    context: NodeInputContext,
    actions: Vec<OrderedModifierAction>,
}

struct PointerDispatchPlan {
    preorder: Vec<indextree::NodeId>,
    postorder: Vec<indextree::NodeId>,
    nodes: HashMap<indextree::NodeId, Arc<PointerNodePlan>>,
}

struct PointerInputDispatchContext<'a> {
    tree: &'a ComponentNodeTree,
    metadatas: &'a ComponentNodeMetaDatas,
    cursor_position: &'a mut Option<PxPosition>,
    pointer_changes: &'a mut [PointerChange],
    pointer_change_paths: &'a [Vec<u64>],
    nodes: &'a HashMap<indextree::NodeId, Arc<PointerNodePlan>>,
    active_pointer_paths: &'a HashMap<u64, Vec<u64>>,
    active_pointer_positions: &'a HashMap<u64, Option<PxPosition>>,
    modifiers: winit::keyboard::ModifiersState,
    window_requests: &'a mut WindowRequests,
    focus_owner: &'a mut FocusOwner,
}

fn dispatch_pointer_modifiers_for_node_pass(
    dispatch_ctx: &mut PointerInputDispatchContext<'_>,
    node_id: indextree::NodeId,
    pass: PointerEventPass,
) {
    let nodes = dispatch_ctx.nodes;
    let Some(plan) = nodes.get(&node_id) else {
        return;
    };
    let mut current_abs_pos = plan.context.base_abs_pos;
    for (index, action) in plan.actions.iter().enumerate() {
        if let Some(transform) = plan
            .context
            .input_transforms
            .as_ref()
            .and_then(|transforms| transforms.get(index))
        {
            current_abs_pos = transform.translation();
        }
        match action {
            OrderedModifierAction::Placement(placement) => {
                if plan.context.input_transforms.is_none() {
                    crate::work::record(
                        plan.context.instance_logic_id,
                        crate::WorkPhase::Transform,
                        placement.node().diagnostic_name(),
                    );
                    current_abs_pos = placement.node().transform_position(current_abs_pos);
                }
            }
            OrderedModifierAction::PointerPreviewInput(modifier)
                if pass == PointerEventPass::Initial =>
            {
                run_pointer_modifier_for_node(
                    dispatch_ctx,
                    node_id,
                    pass,
                    current_abs_pos,
                    modifier.as_ref(),
                );
            }
            OrderedModifierAction::PointerInput(modifier) if pass == PointerEventPass::Main => {
                run_pointer_modifier_for_node(
                    dispatch_ctx,
                    node_id,
                    pass,
                    current_abs_pos,
                    modifier.as_ref(),
                );
            }
            OrderedModifierAction::PointerFinalInput(modifier)
                if pass == PointerEventPass::Final =>
            {
                run_pointer_modifier_for_node(
                    dispatch_ctx,
                    node_id,
                    pass,
                    current_abs_pos,
                    modifier.as_ref(),
                );
            }
            _ => {}
        }
    }
}

fn run_pointer_handler_for_node(
    dispatch_ctx: &mut PointerInputDispatchContext<'_>,
    node_id: indextree::NodeId,
    pass: PointerEventPass,
    pointer_handler: &PointerInputHandlerFn,
) {
    let Some(abs_pos) = dispatch_ctx
        .nodes
        .get(&node_id)
        .map(|node| node.context.abs_pos)
    else {
        return;
    };
    run_pointer_input_for_node(dispatch_ctx, node_id, pass, abs_pos, pointer_handler);
}

fn run_pointer_modifier_for_node(
    dispatch_ctx: &mut PointerInputDispatchContext<'_>,
    node_id: indextree::NodeId,
    pass: PointerEventPass,
    abs_pos_override: PxPosition,
    pointer_modifier: &dyn PointerInputModifierNode,
) {
    run_pointer_input_for_node(dispatch_ctx, node_id, pass, abs_pos_override, |input| {
        pointer_modifier.on_pointer_input(input)
    });
}

fn run_pointer_input_for_node<F>(
    dispatch_ctx: &mut PointerInputDispatchContext<'_>,
    node_id: indextree::NodeId,
    pass: PointerEventPass,
    abs_pos_override: PxPosition,
    dispatch: F,
) where
    F: FnOnce(PointerInput<'_>),
{
    let nodes = dispatch_ctx.nodes;
    let Some(NodeInputContext {
        local_to_window,
        input_transforms: _,
        event_clip_bounds,
        base_abs_pos: _,
        abs_pos: _,
        event_clip_rect,
        node_computed_data,
        instance_logic_id,
        instance_key,
        fn_name,
        parent_id,
    }) = nodes.get(&node_id).map(|node| &node.context)
    else {
        return;
    };
    let event_clip_rect = *event_clip_rect;
    let node_computed_data = *node_computed_data;
    let instance_logic_id = *instance_logic_id;
    let instance_key = *instance_key;
    let parent_id = *parent_id;
    #[cfg(not(feature = "profiling"))]
    let _ = parent_id;

    let abs_pos = abs_pos_override;
    let transform = crate::LocalToWindow::new(local_to_window.scale(), abs_pos).unwrap();

    let owns_sample = dispatch_ctx
        .pointer_change_paths
        .iter()
        .any(|path| path.contains(&instance_key));
    let captured_position = if owns_sample {
        None
    } else {
        dispatch_ctx
            .active_pointer_paths
            .iter()
            .filter_map(|(&pointer_id, path)| {
                if pointer_id == MOUSE_POINTER_ID || !path.contains(&instance_key) {
                    return None;
                }
                dispatch_ctx
                    .active_pointer_positions
                    .get(&pointer_id)
                    .map(|position| (pointer_id, *position))
            })
            .min_by_key(|(pointer_id, _)| *pointer_id)
            .map(|(_, position)| position)
    };
    let mut captured_cursor_position = captured_position.flatten();
    let mut cursor_position_ref = if captured_position.is_some() {
        &mut captured_cursor_position
    } else {
        &mut *dispatch_ctx.cursor_position
    };
    let mut dummy_cursor_position = None;
    if let (Some(cursor_pos), Some(clip_rect)) = (*cursor_position_ref, event_clip_rect)
        && !clip_rect.contains(cursor_pos)
    {
        cursor_position_ref = &mut dummy_cursor_position;
    }
    if let Some(position) = *cursor_position_ref
        && !inside_shape_clips(dispatch_ctx.tree, dispatch_ctx.metadatas, node_id, position)
    {
        cursor_position_ref = &mut dummy_cursor_position;
    }
    if let (Some(position), Some(bounds)) = (*cursor_position_ref, *event_clip_bounds) {
        if !bounds.contains(position) {
            cursor_position_ref = &mut dummy_cursor_position;
        }
    }
    let current_cursor_position = cursor_position_ref.map(|pos| transform.inverse_point(pos));
    let mut selected_change_indices = Vec::new();
    let mut local_pointer_changes = Vec::new();
    for (index, change) in dispatch_ctx.pointer_changes.iter().enumerate() {
        if change.is_consumed() {
            continue;
        }
        let Some(path) = dispatch_ctx.pointer_change_paths.get(index) else {
            continue;
        };
        if path.contains(&instance_key) {
            selected_change_indices.push(index);
            let mut local_change = change.clone();
            if transform.scale() != 1.0
                && let CursorEventContent::Scroll(scroll) = &mut local_change.content
            {
                scroll.normalize_to_pixels();
                scroll.delta_x /= transform.scale();
                scroll.delta_y /= transform.scale();
            }
            local_pointer_changes.push(local_change);
        }
    }
    #[cfg(feature = "profiling")]
    let mut profiler_guard = Some(ProfilerScopeGuard::new(
        ProfilerPhase::Input,
        Some(node_id),
        parent_id,
        Some(fn_name),
    ));
    let replay_boundary_instance_key =
        nearest_replay_boundary_instance_key(node_id, dispatch_ctx.tree);
    let _node_ctx_guard =
        push_current_node_with_instance_logic_id(node_id, instance_logic_id, fn_name);
    let _instance_ctx_guard = push_current_component_instance_key(replay_boundary_instance_key);
    let _phase_guard = push_phase(RuntimePhase::Input);
    let _focus_owner_guard = bind_focus_owner(dispatch_ctx.focus_owner);
    let input = PointerInput {
        pass,
        local_to_window: transform,
        computed_data: node_computed_data,
        cursor_position_rel: current_cursor_position,
        cursor_position_abs: cursor_position_ref,
        pointer_changes: &mut local_pointer_changes,
        key_modifiers: dispatch_ctx.modifiers,
        ime_request: &mut dispatch_ctx.window_requests.ime_request,
        request_window_drag: &mut dispatch_ctx.window_requests.request_window_drag,
    };
    crate::runtime::with_pointer_state_reader(instance_key, || dispatch(input));
    for (local_change, &original_index) in local_pointer_changes
        .iter()
        .zip(selected_change_indices.iter())
    {
        if let Some(original) = dispatch_ctx.pointer_changes.get_mut(original_index) {
            let mut window_change = local_change.clone();
            if let CursorEventContent::Scroll(scroll) = &mut window_change.content {
                scroll.delta_x *= transform.scale();
                scroll.delta_y *= transform.scale();
            }
            *original = window_change;
        }
    }

    #[cfg(feature = "profiling")]
    {
        let abs_tuple = (abs_pos.x_px().0, abs_pos.y_px().0);
        if let Some(g) = &mut profiler_guard {
            g.set_positions(Some(abs_tuple));
        }
        let _ = profiler_guard.take();
    }
    let ime_client = dispatch_ctx
        .window_requests
        .ime_request
        .as_ref()
        .filter(|request| request.position.is_none())
        .and_then(|_| dispatch_ctx.focus_owner.active_component_node_id())
        .filter(|focused| {
            focused
                .ancestors(dispatch_ctx.tree)
                .any(|owner| owner == node_id)
                || node_id
                    .ancestors(dispatch_ctx.tree)
                    .any(|owner| owner == *focused)
        })
        .and(dispatch_ctx.focus_owner.active_handle_id());
    attach_ime_position_if_needed(
        dispatch_ctx.window_requests,
        transform,
        ime_client,
        dispatch_ctx.focus_owner.active_handle_id(),
    );
}

struct KeyboardInputDispatchContext<'a> {
    tree: &'a ComponentNodeTree,
    metadatas: &'a ComponentNodeMetaDatas,
    keyboard_events: &'a mut Vec<crate::KeyboardEvent>,
    modifiers: winit::keyboard::ModifiersState,
    ime_client: Option<FocusHandleId>,
    window_requests: &'a mut WindowRequests,
    focus_owner: &'a mut FocusOwner,
}

fn run_keyboard_input_for_node<F>(
    dispatch_ctx: &mut KeyboardInputDispatchContext<'_>,
    node_id: indextree::NodeId,
    dispatch: F,
) where
    F: FnOnce(KeyboardInput<'_>),
{
    let Some(NodeInputContext {
        local_to_window: transform,
        abs_pos,
        event_clip_rect: _,
        node_computed_data,
        instance_logic_id,
        instance_key: _,
        fn_name,
        parent_id,
        ..
    }) = resolve_node_input_context(dispatch_ctx.tree, dispatch_ctx.metadatas, node_id)
    else {
        return;
    };
    #[cfg(not(feature = "profiling"))]
    let _ = (parent_id, abs_pos);

    #[cfg(feature = "profiling")]
    let mut profiler_guard = Some(ProfilerScopeGuard::new(
        ProfilerPhase::Input,
        Some(node_id),
        parent_id,
        Some(fn_name),
    ));
    let replay_boundary_instance_key =
        nearest_replay_boundary_instance_key(node_id, dispatch_ctx.tree);
    let _node_ctx_guard =
        push_current_node_with_instance_logic_id(node_id, instance_logic_id, fn_name);
    let _instance_ctx_guard = push_current_component_instance_key(replay_boundary_instance_key);
    let _phase_guard = push_phase(RuntimePhase::Input);
    let _focus_owner_guard = bind_focus_owner(dispatch_ctx.focus_owner);
    let input = KeyboardInput {
        computed_data: node_computed_data,
        keyboard_events: dispatch_ctx.keyboard_events,
        key_modifiers: dispatch_ctx.modifiers,
        ime_request: &mut dispatch_ctx.window_requests.ime_request,
    };
    dispatch(input);

    #[cfg(feature = "profiling")]
    {
        let abs_tuple = (abs_pos.x_px().0, abs_pos.y_px().0);
        if let Some(g) = &mut profiler_guard {
            g.set_positions(Some(abs_tuple));
        }
        let _ = profiler_guard.take();
    }
    attach_ime_position_if_needed(
        dispatch_ctx.window_requests,
        transform,
        dispatch_ctx.ime_client,
        dispatch_ctx.focus_owner.active_handle_id(),
    );
}

fn run_ime_input_for_node<F>(
    tree: &ComponentNodeTree,
    metadatas: &ComponentNodeMetaDatas,
    node_id: indextree::NodeId,
    ime_events: &mut Vec<winit::event::Ime>,
    window_requests: &mut WindowRequests,
    focus_owner: &mut FocusOwner,
    ime_client: Option<FocusHandleId>,
    dispatch: F,
) where
    F: FnOnce(ImeInput<'_>),
{
    let Some(NodeInputContext {
        local_to_window: transform,
        abs_pos,
        event_clip_rect: _,
        node_computed_data,
        instance_logic_id,
        instance_key: _,
        fn_name,
        parent_id,
        ..
    }) = resolve_node_input_context(tree, metadatas, node_id)
    else {
        return;
    };
    #[cfg(not(feature = "profiling"))]
    let _ = (parent_id, abs_pos);

    #[cfg(feature = "profiling")]
    let mut profiler_guard = Some(ProfilerScopeGuard::new(
        ProfilerPhase::Input,
        Some(node_id),
        parent_id,
        Some(fn_name),
    ));
    let replay_boundary_instance_key = nearest_replay_boundary_instance_key(node_id, tree);
    let _node_ctx_guard =
        push_current_node_with_instance_logic_id(node_id, instance_logic_id, fn_name);
    let _instance_ctx_guard = push_current_component_instance_key(replay_boundary_instance_key);
    let _phase_guard = push_phase(RuntimePhase::Input);
    let _focus_owner_guard = bind_focus_owner(focus_owner);
    let input = ImeInput {
        computed_data: node_computed_data,
        ime_events,
        ime_request: &mut window_requests.ime_request,
    };
    dispatch(input);

    #[cfg(feature = "profiling")]
    {
        let abs_tuple = (abs_pos.x_px().0, abs_pos.y_px().0);
        if let Some(g) = &mut profiler_guard {
            g.set_positions(Some(abs_tuple));
        }
        let _ = profiler_guard.take();
    }
    attach_ime_position_if_needed(
        window_requests,
        transform,
        ime_client,
        focus_owner.active_handle_id(),
    );
}

fn dispatch_default_focus_keyboard_navigation(
    tree: &ComponentNodeTree,
    keyboard_events: &mut Vec<crate::KeyboardEvent>,
    modifiers: winit::keyboard::ModifiersState,
    focus_owner: &mut FocusOwner,
) -> Option<FocusDirection> {
    if keyboard_events.is_empty() {
        return None;
    }

    let mut pending_focus_move_retry = None;
    keyboard_events.retain(|event| {
        if pending_focus_move_retry.is_some() {
            return false;
        }
        let Some(direction) = default_focus_navigation_direction(event, modifiers) else {
            return true;
        };
        match try_dispatch_focus_move_request(tree, direction, focus_owner) {
            FocusMoveRequestResult::Moved => false,
            FocusMoveRequestResult::Retry(direction) => {
                pending_focus_move_retry = Some(direction);
                false
            }
            FocusMoveRequestResult::NotHandled => true,
        }
    });
    pending_focus_move_retry
}

fn default_focus_navigation_direction(
    event: &crate::KeyboardEvent,
    modifiers: winit::keyboard::ModifiersState,
) -> Option<FocusDirection> {
    if event.state != winit::event::ElementState::Pressed {
        return None;
    }

    if modifiers.control_key() || modifiers.alt_key() || modifiers.super_key() {
        return None;
    }

    match &event.logical_key {
        winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab) => {
            if modifiers.shift_key() {
                Some(FocusDirection::Previous)
            } else {
                Some(FocusDirection::Next)
            }
        }
        winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowLeft) => {
            (!modifiers.shift_key()).then_some(FocusDirection::Left)
        }
        winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowRight) => {
            (!modifiers.shift_key()).then_some(FocusDirection::Right)
        }
        winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowUp) => {
            (!modifiers.shift_key()).then_some(FocusDirection::Up)
        }
        winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowDown) => {
            (!modifiers.shift_key()).then_some(FocusDirection::Down)
        }
        _ => None,
    }
}

enum FocusMoveRequestResult {
    NotHandled,
    Moved,
    Retry(FocusDirection),
}

fn try_dispatch_focus_move_request(
    tree: &ComponentNodeTree,
    direction: FocusDirection,
    focus_owner: &mut FocusOwner,
) -> FocusMoveRequestResult {
    if !focus_owner.allows_navigation() {
        return FocusMoveRequestResult::NotHandled;
    }
    if focus_owner.move_focus(direction) {
        return FocusMoveRequestResult::Moved;
    }
    if dispatch_focus_beyond_bounds_request(tree, direction, focus_owner) {
        return FocusMoveRequestResult::Retry(direction);
    }
    FocusMoveRequestResult::NotHandled
}

fn dispatch_focus_beyond_bounds_request(
    tree: &ComponentNodeTree,
    direction: FocusDirection,
    focus_owner: &FocusOwner,
) -> bool {
    let mut current = focus_owner.active_component_node_id();
    while let Some(node_id) = current {
        let Some(node_ref) = tree.get(node_id) else {
            break;
        };
        let node = node_ref.get();
        if let Some(handler) = &node.interaction().focus_beyond_bounds_handler
            && handler.call(direction)
        {
            return true;
        }
        current = node_ref.parent();
    }
    false
}

fn needs_deferred_focus_retry(focus_owner: &FocusOwner, has_queued_input: bool) -> bool {
    focus_owner.keyboard_is_deferred() && (has_queued_input || focus_owner.has_pending_reveal())
}

pub(crate) fn dispatch_pending_focus_reveal_request(
    tree: &ComponentNodeTree,
    metadatas: &ComponentNodeMetaDatas,
    focus_owner: &mut FocusOwner,
    retry_active_focus: bool,
) -> bool {
    let handle_id = focus_owner.take_pending_reveal().or_else(|| {
        retry_active_focus
            .then(|| focus_owner.active_handle_id())
            .flatten()
    });
    let Some(handle_id) = handle_id else {
        return false;
    };
    dispatch_focus_reveal_request(tree, metadatas, focus_owner, handle_id)
}

fn dispatch_focus_reveal_request(
    tree: &ComponentNodeTree,
    metadatas: &ComponentNodeMetaDatas,
    focus_owner: &FocusOwner,
    handle_id: FocusHandleId,
) -> bool {
    let Some(target_node_id) = focus_owner.component_node_id_of(handle_id) else {
        return false;
    };
    let Some(target_bounds) = component_node_bounds_precise(metadatas, target_node_id) else {
        return false;
    };

    let mut current = Some(target_node_id);
    while let Some(node_id) = current {
        let Some(node_ref) = tree.get(node_id) else {
            break;
        };
        let Some(viewport_rect) = component_node_viewport_rect(metadatas, node_id) else {
            current = node_ref.parent();
            continue;
        };
        let node = node_ref.get();
        if let Some(handler) = &node.interaction().focus_reveal_handler {
            let metadata = metadatas
                .get(&node_id)
                .expect("Reveal container must have metadata");
            let origin = metadata.abs_position.unwrap_or(PxPosition::ZERO);
            let transform = metadata
                .local_to_window
                .unwrap_or_else(|| crate::LocalToWindow::new(1.0, origin).unwrap());
            let viewport_bounds = component_node_bounds_precise(metadatas, node_id)
                .and_then(|bounds| {
                    metadata
                        .event_clip_bounds
                        .map_or(Some(bounds), |clip| clip.intersection(bounds))
                })
                .unwrap_or_else(|| viewport_rect.into());
            let handled = handler.call(crate::focus::FocusRevealRequest::with_geometry(
                target_bounds,
                viewport_bounds,
                transform,
            ));
            if handled {
                return true;
            }
        }
        current = node_ref.parent();
    }
    false
}

fn component_node_bounds_precise(
    metadatas: &ComponentNodeMetaDatas,
    node_id: NodeId,
) -> Option<crate::FloatRect> {
    let metadata = metadatas.get(&node_id)?;
    let origin = metadata.abs_position?;
    let size = metadata.computed_data?;
    let transform = metadata
        .local_to_window
        .unwrap_or_else(|| crate::LocalToWindow::new(1.0, origin).unwrap());
    Some(transform.map_rect(crate::FloatRect::from_position_size(
        PxPosition::ZERO,
        PxSize::new(size.width, size.height),
    )))
}

fn component_node_bounds_rect(
    metadatas: &ComponentNodeMetaDatas,
    node_id: indextree::NodeId,
) -> Option<PxRect> {
    let metadata = metadatas.get(&node_id)?;
    let _ = metadata;
    component_node_bounds_precise(metadatas, node_id).map(crate::FloatRect::outward)
}

fn component_node_viewport_rect(
    metadatas: &ComponentNodeMetaDatas,
    node_id: indextree::NodeId,
) -> Option<PxRect> {
    let node_rect = component_node_bounds_rect(metadatas, node_id)?;
    let metadata = metadatas.get(&node_id)?;
    Some(
        metadata
            .event_clip_rect()
            .and_then(|clip_rect| clip_rect.intersection(&node_rect))
            .unwrap_or(node_rect),
    )
}

fn collect_dirty_layout_paths(
    tree: &ComponentNodeTree,
    node_ids: &HashMap<u64, indextree::NodeId>,
    measure_self: &HashSet<u64>,
    placement_self: &HashSet<u64>,
) -> HashMap<NodeId, DirtyLayoutPath> {
    use std::collections::hash_map::Entry;

    let mut paths: HashMap<_, DirtyLayoutPath> = HashMap::default();
    for dirty_key in measure_self
        .iter()
        .chain(placement_self.difference(measure_self))
    {
        let mut current = node_ids.get(dirty_key).copied();
        let mut layout_child = None;
        while let Some(node_id) = current {
            let Some(node) = tree.get(node_id) else { break };
            let data = node.get();
            current = node.parent();
            if data.role != NodeRole::Layout && current.is_some() {
                continue;
            }
            let (path, new) = match paths.entry(node_id) {
                Entry::Occupied(entry) => (entry.into_mut(), false),
                Entry::Vacant(entry) => (
                    entry.insert(DirtyLayoutPath {
                        measure: measure_self.contains(&data.instance_key),
                        placement: placement_self.contains(&data.instance_key),
                        children: SmallVec::new(),
                    }),
                    true,
                ),
            };
            if let Some(child) = layout_child
                && !path.measure
            {
                path.children.push(child);
            }
            // A previously visited parent already carries its own path to the root.
            if !new {
                break;
            }
            layout_child = Some(node_id);
        }
    }
    paths
}

fn record_layout_commands(
    root_node: indextree::NodeId,
    tree: &ComponentNodeTree,
    metadatas: &mut ComponentNodeMetaDatas,
) {
    struct DrawModifierChainContent<'a> {
        instance: u64,
        draw_nodes: &'a [(Arc<dyn crate::modifier::DrawModifierNode>, DrawLayoutBounds)],
        node_draw: &'a dyn crate::modifier::DrawModifierNode,
        node_bounds: Option<DrawLayoutBounds>,
        parent_bounds: DrawLayoutBounds,
        pending_start: usize,
    }

    struct TerminalDrawContent;

    impl DrawModifierContent for TerminalDrawContent {
        fn draw(&mut self, _input: &mut RenderInput<'_>) {}
    }

    impl DrawModifierContent for DrawModifierChainContent<'_> {
        fn draw(&mut self, input: &mut RenderInput<'_>) {
            input.finish_draw_range(self.pending_start, self.parent_bounds);
            if let Some(((draw_modifier, bounds), remaining)) = self.draw_nodes.split_first() {
                input.draw_bounds = *bounds;
                let start = input.recorded_op_count();
                let mut draw_ctx = DrawModifierContext {
                    render_input: input,
                };
                let mut next = DrawModifierChainContent {
                    instance: self.instance,
                    draw_nodes: remaining,
                    node_draw: self.node_draw,
                    node_bounds: self.node_bounds,
                    parent_bounds: *bounds,
                    pending_start: start,
                };
                crate::work::record(
                    self.instance,
                    crate::WorkPhase::Paint,
                    draw_modifier.diagnostic_name(),
                );
                draw_modifier.draw(&mut draw_ctx, &mut next);
                input.finish_draw_range(next.pending_start, *bounds);
            } else if let Some(bounds) = self.node_bounds {
                input.draw_bounds = bounds;
                let start = input.recorded_op_count();
                let mut draw_ctx = DrawModifierContext {
                    render_input: input,
                };
                crate::work::record(
                    self.instance,
                    crate::WorkPhase::Paint,
                    self.node_draw.diagnostic_name(),
                );
                self.node_draw.draw(&mut draw_ctx, &mut TerminalDrawContent);
                input.finish_draw_range(start, bounds);
            }
            input.draw_bounds = self.parent_bounds;
            self.pending_start = input.recorded_op_count();
        }
    }

    let pending = std::mem::take(&mut metadatas.paint_dirty_nodes);
    for node_id in pending {
        let Some(node) = tree.get(node_id).filter(|node| !node.is_removed()) else {
            continue;
        };
        let visible = node_id.ancestors(tree).all(|ancestor| {
            tree[ancestor].get().role != NodeRole::Layout
                || metadatas.get(&ancestor).is_some_and(|metadata| {
                    metadata.computed_data.is_some()
                        && (ancestor == root_node || metadata.rel_position.is_some())
                })
        });
        if !visible {
            continue;
        }
        let _phase = push_phase(RuntimePhase::Paint);
        let _instance = push_current_component_instance_key(node.get().instance_key);
        crate::runtime::clear_phase_state_reads(
            node.get().instance_key,
            crate::runtime::ReadPhase::Paint,
        );
        #[cfg(feature = "profiling")]
        let _record_profiler_guard = {
            let parent_id = node.parent();
            Some(ProfilerScopeGuard::new(
                ProfilerPhase::Record,
                Some(node_id),
                parent_id,
                Some(node.get().fn_name),
            ))
        };
        // Recording also runs on layout cache hits, so visual state must be
        // reset independently of measurement invalidation.
        let previous_visual = metadatas.get(&node_id).map(|metadata| {
            (
                metadata.clips_children,
                metadata.clip_region().copied(),
                metadata.opacity,
            )
        });
        if let Some(metadata) = metadatas.get_mut(&node_id) {
            metadata.fragment = Default::default();
            metadata.clips_children = false;
            metadata.set_clip_region(None);
            metadata.opacity = 1.0;
        }
        let mut input = RenderInput::new(node_id, metadatas);
        let node_ref = node.get();
        let mut bounds = Some(input.draw_bounds);
        let mut layer_index = 0;
        let mut draw_nodes = Vec::new();
        let layers = input.draw_layers();
        for action in node_ref.modifier.ordered_actions() {
            match action {
                OrderedModifierAction::Layout => {
                    bounds = layers.get(layer_index).copied().flatten();
                    layer_index += 1;
                }
                OrderedModifierAction::Draw(node) => {
                    if let Some(bounds) = bounds {
                        draw_nodes.push((node, bounds));
                    }
                }
                _ => {}
            }
        }
        let mut content = DrawModifierChainContent {
            instance: node_ref.instance_logic_id,
            draw_nodes: &draw_nodes,
            node_draw: node_ref.draw_node.as_ref(),
            node_bounds: bounds,
            parent_bounds: input.draw_bounds,
            pending_start: 0,
        };
        content.draw(&mut input);
        metadatas.paint_changed.insert(node_id);
        if let Some(metadata) = metadatas.get_mut(&node_id) {
            metadata.paint_dirty = false;
        }
        let next_visual = metadatas.get(&node_id).map(|metadata| {
            (
                metadata.clips_children,
                metadata.clip_region().copied(),
                metadata.opacity,
            )
        });
        if previous_visual != next_visual {
            metadatas.mark_geometry_dirty(node_id);
        }
    }
}

#[derive(Clone, Copy, PartialEq)]
struct PreparedLayoutMetadata {
    local_position: PxPosition,
    local_to_window: crate::LocalToWindow,
    child_local_to_window: crate::LocalToWindow,
    child_clip_bounds: Option<crate::FloatRect>,
    size: PxSize,
    clips_children: bool,
    cumulative_opacity: f32,
    has_shape_clipping: bool,
}

impl PreparedLayoutMetadata {
    fn child_geometry_eq(&self, other: &Self) -> bool {
        self.child_local_to_window == other.child_local_to_window
            && self.child_clip_bounds == other.child_clip_bounds
            && self.cumulative_opacity == other.cumulative_opacity
            && self.has_shape_clipping == other.has_shape_clipping
    }
}

fn map_clip_region(
    mut region: crate::ClipRegion,
    transform: crate::LocalToWindow,
) -> crate::ClipRegion {
    region.position = transform.map_point(region.position);
    region.size = [
        region.size[0] * transform.scale(),
        region.size[1] * transform.scale(),
    ];
    if let crate::ClipShape::RoundedRectangle { ref mut radii, .. } = region.shape {
        for radius in radii {
            *radius *= transform.scale();
        }
    }
    region
}

fn record_frame_stage(timer: &mut Option<Instant>, stage: &'static str) {
    if let Some(start) = timer {
        tracing::debug!(target: "tessera_ui::frame_cost", stage, duration_ns = start.elapsed().as_nanos(), "frame_stage_cpu");
        *start = Instant::now();
    }
}

fn geometry_parent(tree: &ComponentNodeTree, node_id: NodeId) -> Option<NodeId> {
    node_id
        .ancestors(tree)
        .skip(1)
        .find(|&id| tree[id].get().role == NodeRole::Layout || tree[id].parent().is_none())
}

fn layout_rect_in_space(
    tree: &ComponentNodeTree,
    metadata: &ComponentNodeMetaDatas,
    node_id: NodeId,
) -> Option<crate::FloatRect> {
    let size = metadata.get(&node_id)?.prepared_layout?.size;
    let mut transform = crate::LocalToWindow::IDENTITY;
    let mut child_position = None;
    for id in node_id.ancestors(tree) {
        let node = tree[id].get();
        if node.role != NodeRole::Layout {
            continue;
        }
        let prepared = metadata.get(&id)?.prepared_layout?;
        if let Some(position) = child_position {
            transform = crate::LocalToWindow::new(node.children_scale, PxPosition::ZERO)?
                .with_local_origin(position)
                .compose(transform)?;
        }
        if node.layout_coordinate_space {
            return Some(
                transform.map_rect(crate::FloatRect::from_position_size(PxPosition::ZERO, size)),
            );
        }
        child_position = Some(prepared.local_position);
    }
    None
}

fn prepare_layout_metadata_for_node(
    node: &ComponentNode,
    metadata: &mut ComponentNodeMetaData,
    parent_transform: crate::LocalToWindow,
    is_root: bool,
    parent_clip_bounds: Option<crate::FloatRect>,
    current_opacity: f32,
    parent_has_shape_clipping: bool,
    reuse_local_placement: bool,
) -> (Option<PreparedLayoutMetadata>, bool) {
    metadata.has_shape_clipping = parent_has_shape_clipping || metadata.clip_region().is_some();
    let rel_pos = match metadata.rel_position {
        Some(pos) => pos,
        None if is_root => PxPosition::ZERO,
        _ => {
            metadata.base_abs_position = None;
            metadata.abs_position = None;
            metadata.local_to_window = None;
            metadata.event_clip_bounds = None;
            metadata.prepared_layout = None;
            metadata.set_prepared_clip_region(None);
            metadata.geometry_initialized = true;
            return (None, false);
        }
    };
    let base_self_position = parent_transform.map_point(rel_pos);
    let cached_position = reuse_local_placement
        .then(|| {
            metadata
                .prepared_layout
                .as_ref()
                .map(|previous| previous.local_position)
        })
        .flatten();
    let local_position = if let Some(position) = cached_position {
        if let Some(transforms) = &mut metadata.input_transforms {
            transforms.parent = parent_transform;
        }
        position
    } else {
        let _phase = push_phase(RuntimePhase::Place);
        let _instance = push_current_component_instance_key(node.instance_key);
        crate::runtime::clear_phase_state_reads(
            node.instance_key,
            crate::runtime::ReadPhase::Transform,
        );
        let (position, inputs) = node
            .modifier
            .resolve_placement(rel_pos, node.instance_logic_id);
        metadata.set_input_transforms(parent_transform, inputs);
        position
    };
    let local_to_window = parent_transform.with_local_origin(local_position);
    let self_position = local_to_window.translation();
    let child_scale = node.children_scale;
    let child_local_to_window = if child_scale == 1.0 {
        local_to_window
    } else {
        local_to_window
            .compose(
                crate::LocalToWindow::new(child_scale, PxPosition::ZERO)
                    .expect("Child scale must be finite and positive"),
            )
            .expect("Composed child transform must remain finite and invertible")
    };
    metadata.local_to_window = Some(local_to_window);
    let cumulative_opacity = current_opacity * metadata.opacity;
    metadata.base_abs_position = Some(base_self_position);
    metadata.abs_position = Some(self_position);
    metadata.event_clip_bounds = parent_clip_bounds;

    let size = metadata
        .computed_data
        .map(|d| PxSize {
            width: d.width,
            height: d.height,
        })
        .unwrap_or_default();
    let clips_children = metadata.clips_children;
    let clip_region = metadata
        .clip_region()
        .map(|&region| map_clip_region(region, local_to_window));
    let previous_shape = metadata
        .prepared_layout
        .as_ref()
        .filter(|layout| layout.clips_children)
        .and(metadata.prepared_clip_region());
    let next_shape = clips_children.then_some(clip_region.as_ref()).flatten();
    let shape_changed = previous_shape != next_shape;
    let child_clip_bounds = if clips_children {
        let own_clip_bounds = clip_region
            .map(|region| crate::FloatRect {
                x: region.position.x,
                y: region.position.y,
                width: region.size[0],
                height: region.size[1],
            })
            .unwrap_or_else(|| {
                local_to_window
                    .map_rect(crate::FloatRect::from_position_size(PxPosition::ZERO, size))
            });
        Some(parent_clip_bounds.map_or(own_clip_bounds, |parent| {
            parent
                .intersection(own_clip_bounds)
                .unwrap_or(crate::FloatRect::ZERO)
        }))
    } else {
        parent_clip_bounds
    };
    let prepared = PreparedLayoutMetadata {
        local_position,
        local_to_window,
        child_local_to_window,
        child_clip_bounds,
        size,
        clips_children,
        cumulative_opacity,
        has_shape_clipping: metadata.has_shape_clipping,
    };
    metadata.prepared_layout = Some(prepared);
    metadata.set_prepared_clip_region(clip_region);
    metadata.geometry_initialized = true;
    (Some(prepared), shape_changed)
}

fn populate_layout_metadata(
    root_node: indextree::NodeId,
    tree: &ComponentNodeTree,
    metadatas: &mut ComponentNodeMetaDatas,
) -> u64 {
    let order_dirty = std::mem::take(&mut metadatas.placement_order_dirty);
    for id in order_dirty {
        if let Some(node) = tree.get(id).filter(|node| !node.is_removed()) {
            let id = if node.get().role == NodeRole::Layout || id == root_node {
                Some(id)
            } else {
                geometry_parent(tree, id)
            };
            if let Some(id) = id {
                metadatas.placement_order_dirty.insert(id);
                metadatas.geometry_dirty.insert(id);
            }
        }
    }
    let requested = std::mem::take(&mut metadatas.geometry_dirty);
    let mut dirty: HashSet<_> = requested
        .into_iter()
        .filter_map(|id| {
            let node = tree.get(id).filter(|node| !node.is_removed())?;
            if node.get().role == NodeRole::Layout || id == root_node {
                Some(id)
            } else {
                None
            }
        })
        .collect();
    let mut dirty_children: HashMap<NodeId, HashSet<NodeId>> = HashMap::default();
    for mut id in dirty.iter().copied().collect::<Vec<_>>() {
        while let Some(parent) = geometry_parent(tree, id) {
            dirty_children.entry(parent).or_default().insert(id);
            if !dirty.insert(parent) {
                break;
            }
            id = parent;
        }
    }
    fn visit(
        tree: &ComponentNodeTree,
        metadatas: &mut ComponentNodeMetaDatas,
        dirty: &HashSet<indextree::NodeId>,
        dirty_children: &HashMap<NodeId, HashSet<NodeId>>,
        parent_transform: crate::LocalToWindow,
        is_root: bool,
        node_id: indextree::NodeId,
        clip_bounds: Option<crate::FloatRect>,
        current_opacity: f32,
        parent_has_shape_clipping: bool,
        inherited_order_changed: bool,
        inherited_shape_clip_changed: bool,
        inherited_changed: bool,
        updates: &mut u64,
    ) {
        metadatas.geometry_visits += 1;
        let Some(node) = tree.get(node_id).map(|node| node.get()) else {
            return;
        };
        let self_dirty = dirty.contains(&node_id);
        let (
            previous,
            was_hidden,
            initialized,
            paint_dirty,
            prepared,
            publishes_geometry,
            size_changed,
            own_shape_changed,
        ) = if let Some(metadata) = metadatas.get_mut(&node_id) {
            let initialized = metadata.geometry_initialized;
            if initialized && !inherited_changed && !self_dirty {
                return;
            }
            let previous = metadata.prepared_layout;
            let was_placed = metadata.abs_position.is_some();
            let was_hidden = metadata.prepared_layout.is_none();
            let paint_dirty = metadata.paint_dirty;
            let (prepared, own_shape_changed) = prepare_layout_metadata_for_node(
                node,
                metadata,
                parent_transform,
                is_root,
                clip_bounds,
                current_opacity,
                parent_has_shape_clipping,
                initialized && !self_dirty,
            );
            let publishes_geometry = metadata.observes_geometry
                || metadata.accessibility.is_some()
                || metadata.clips_children
                || !metadata.fragment.ops().is_empty();
            let size_changed = metadata.observes_size
                && (was_placed != prepared.is_some()
                    || previous.map(|layout| layout.size) != prepared.map(|layout| layout.size));
            (
                previous,
                was_hidden,
                initialized,
                paint_dirty,
                prepared,
                publishes_geometry,
                size_changed,
                own_shape_changed,
            )
        } else {
            (None, true, false, false, None, false, false, false)
        };
        *updates += 1;
        if size_changed {
            metadatas.size_changed.insert(node_id);
        }
        if initialized && was_hidden && prepared.is_none() && !self_dirty {
            return;
        }
        let order_changed = metadatas.placement_order_dirty.remove(&node_id);
        let order_changed = order_changed || inherited_order_changed;
        if order_changed {
            metadatas.placement_order_changed.insert(node_id);
        }
        let changed = inherited_changed
            || !initialized
            || prepared != previous
            || order_changed
            || own_shape_changed;
        if changed && publishes_geometry {
            metadatas.geometry_changed.insert(node_id);
        }
        if prepared.is_some() && paint_dirty {
            metadatas.paint_dirty_nodes.insert(node_id);
        }
        if prepared.is_none() && node.role == NodeRole::Layout {
            for descendant in node_id.descendants(tree) {
                let size_hidden = if let Some(metadata) = metadatas.get_mut(&descendant) {
                    let size_hidden = metadata.observes_size && metadata.abs_position.is_some();
                    metadata.base_abs_position = None;
                    metadata.abs_position = None;
                    metadata.local_to_window = None;
                    metadata.event_clip_bounds = None;
                    size_hidden
                } else {
                    false
                };
                if size_hidden {
                    metadatas.size_changed.insert(descendant);
                }
                metadatas.geometry_changed.insert(descendant);
            }
            return;
        }
        let (transform, clip, opacity) = prepared.map_or(
            (parent_transform, clip_bounds, current_opacity),
            |prepared| {
                (
                    prepared.child_local_to_window,
                    prepared.child_clip_bounds,
                    prepared.cumulative_opacity,
                )
            },
        );
        let has_shape_clipping = prepared.map_or(parent_has_shape_clipping, |prepared| {
            prepared.has_shape_clipping
        });
        // Shape changes can invalidate descendant hit tests without changing
        // their rectangular clip bounds or coordinate transforms.
        let shape_clip_changed = inherited_shape_clip_changed || own_shape_changed;
        let children_changed = !initialized
            || order_changed
            || shape_clip_changed
            || match (previous, prepared) {
                (Some(previous), Some(prepared)) => !previous.child_geometry_eq(&prepared),
                (None, None) => false,
                _ => true,
            };
        let mut visit_child = |child| {
            visit(
                tree,
                metadatas,
                dirty,
                dirty_children,
                transform,
                false,
                child,
                clip,
                opacity,
                has_shape_clipping,
                order_changed,
                shape_clip_changed,
                children_changed,
                updates,
            );
        };
        if children_changed {
            if let Some(children) = node.layout_children.as_ref() {
                for &child in children.iter() {
                    visit_child(child);
                }
            } else {
                for &child in direct_layout_children(node_id, tree).iter() {
                    visit_child(child);
                }
            }
        } else if let Some(children) = dirty_children.get(&node_id) {
            for &child in children {
                visit_child(child);
            }
        }
    }
    let mut updates = 0;
    visit(
        tree,
        metadatas,
        &dirty,
        &dirty_children,
        crate::LocalToWindow::IDENTITY,
        true,
        root_node,
        None,
        1.0,
        false,
        false,
        false,
        false,
        &mut updates,
    );
    updates
}

#[cfg(test)]
fn build_render_graph(
    root: NodeId,
    tree: &ComponentNodeTree,
    metadata: &mut ComponentNodeMetaDatas,
    viewport: PxSize,
) -> RenderGraph {
    let changed = root.descendants(tree).collect();
    scene::FrameScene::default()
        .update(
            root,
            tree,
            metadata,
            &changed,
            &HashSet::default(),
            viewport,
        )
        .0
}

#[cfg(test)]
mod tests {
    use super::*;

    use crate::{
        Px,
        component_tree::{ComponentNode, NodeRole},
    };

    fn node_with_role(
        name: &'static str,
        role: NodeRole,
        instance_logic_id: u64,
        instance_key: u64,
    ) -> ComponentNode {
        ComponentNode {
            instance_logic_id,
            instance_key,
            ..ComponentNode::new(name, role)
        }
    }

    fn node(name: &'static str, instance_logic_id: u64, instance_key: u64) -> ComponentNode {
        node_with_role(name, NodeRole::Layout, instance_logic_id, instance_key)
    }

    #[test]
    fn unchanged_child_coordinates_stop_geometry_propagation_but_shape_changes_reach_inputs() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        let moving = tree.add_node(node("moving", 2, 2));
        let pinned = tree.add_node(node("pinned", 3, 3));
        let inner = tree.add_node(node("inner", 4, 4));
        let mut control = node("control", 5, 5);
        control
            .interaction_mut()
            .pointer_handlers
            .push(Box::new(|_| {}));
        let leaf = tree.add_node(control);
        for _ in 0..5 {
            tree.pop_node();
        }
        for id in [root, moving, pinned, inner, leaf] {
            let metadata = tree.metadatas.entry_or_default(id);
            metadata.computed_data = Some(ComputedData {
                width: Px(100),
                height: Px(100),
            });
            metadata.rel_position = Some(PxPosition::ZERO);
            metadata.placement_order = Some(0);
        }
        node::place_node(leaf, PxPosition::new(Px(2), Px(2)), 0, &mut tree.metadatas);
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        tree.metadatas.geometry_changed.clear();
        tree.metadatas.geometry_visits = 0;

        node::place_node(
            moving,
            PxPosition::new(Px(35), Px(0)),
            0,
            &mut tree.metadatas,
        );
        node::place_node(
            pinned,
            PxPosition::new(Px(-35), Px(0)),
            0,
            &mut tree.metadatas,
        );
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        assert_eq!(
            tree.metadatas.get(&leaf).unwrap().abs_position,
            Some(PxPosition::new(Px(2), Px(2)))
        );
        assert!(
            !tree.metadatas.geometry_changed.contains(&leaf),
            "a counter-translated branch must not invalidate unchanged descendant input geometry"
        );
        assert_eq!(tree.metadatas.geometry_visits, 3);

        tree.metadatas.geometry_changed.clear();
        tree.metadatas.entry_or_default(pinned).computed_data = Some(ComputedData {
            width: Px(120),
            height: Px(100),
        });
        tree.metadatas.mark_geometry_dirty(pinned);
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        assert!(
            !tree.metadatas.geometry_changed.contains(&leaf),
            "an unclipped parent's size must not invalidate unchanged child coordinates"
        );

        node::place_node(leaf, PxPosition::new(Px(3), Px(3)), 0, &mut tree.metadatas);
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        assert_eq!(
            tree.metadatas.get(&leaf).unwrap().abs_position,
            Some(PxPosition::new(Px(3), Px(3)))
        );
        assert!(tree.metadatas.geometry_changed.contains(&leaf));

        let clip = crate::ClipRegion {
            position: PxPosition::ZERO,
            size: [100.0, 100.0],
            shape: crate::ClipShape::RoundedRectangle {
                radii: [0.0; 4],
                exponents: [2.0; 4],
            },
        };
        let metadata = tree.metadatas.entry_or_default(root);
        metadata.clips_children = true;
        metadata.set_clip_region(Some(clip));
        tree.metadatas.mark_geometry_dirty(root);
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        assert!(inside_shape_clips(
            &tree.tree,
            &tree.metadatas,
            leaf,
            PxPosition::new(Px(4), Px(4))
        ));
        tree.metadatas.geometry_changed.clear();

        tree.metadatas
            .entry_or_default(root)
            .set_clip_region(Some(crate::ClipRegion {
                shape: crate::ClipShape::RoundedRectangle {
                    radii: [40.0; 4],
                    exponents: [2.0; 4],
                },
                ..clip
            }));
        tree.metadatas.mark_geometry_dirty(root);
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        assert!(tree.metadatas.geometry_changed.contains(&leaf));
        assert!(!inside_shape_clips(
            &tree.tree,
            &tree.metadatas,
            leaf,
            PxPosition::new(Px(4), Px(4))
        ));

        tree.metadatas.geometry_changed.clear();
        tree.metadatas.entry_or_default(root).set_clip_region(None);
        tree.metadatas.mark_geometry_dirty(root);
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        assert!(tree.metadatas.geometry_changed.contains(&leaf));
        assert!(inside_shape_clips(
            &tree.tree,
            &tree.metadatas,
            leaf,
            PxPosition::new(Px(4), Px(4))
        ));

        tree.metadatas.entry_or_default(pinned).rel_position = None;
        tree.metadatas.mark_geometry_dirty(pinned);
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        assert!(tree.metadatas.get(&leaf).unwrap().abs_position.is_none());
        tree.metadatas.entry_or_default(inner).geometry_initialized = false;
        node::place_node(
            pinned,
            PxPosition::new(Px(-35), Px(0)),
            0,
            &mut tree.metadatas,
        );
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        assert_eq!(
            tree.metadatas.get(&leaf).unwrap().abs_position,
            Some(PxPosition::new(Px(3), Px(3)))
        );
    }

    #[derive(Clone, Default, PartialEq)]
    struct RevealProbe {
        handler: crate::testing::TestProbe<
            Option<crate::CallbackWith<crate::focus::FocusRevealRequest, bool>>,
        >,
        scroll: crate::testing::TestProbe<i32>,
        rects: crate::testing::TestProbe<Vec<crate::PxRect>>,
    }

    #[crate::tessera(crate)]
    fn retry_reveal_callback_fixture(probe: RevealProbe) {
        let handler = crate::CallbackWith::new({
            let probe = probe.clone();
            move |request: crate::focus::FocusRevealRequest| {
                probe
                    .rects
                    .with_mut(|rects| rects.push(request.target_rect));
                probe.scroll.set(-request.target_rect.y.0);
                true
            }
        });
        probe.handler.set(Some(handler));
        crate::layout::layout();
    }

    fn reveal_viewport_tree(
        probe: RevealProbe,
    ) -> (
        ComponentTree,
        NodeId,
        crate::focus::FocusRegistration,
        crate::testing::LayoutTestSession<impl Fn()>,
    ) {
        use crate::focus::{FocusNode, FocusRegistration};

        let mut session = crate::testing::start_layout_test_session(crate::testing::layout_test({
            let probe = probe.clone();
            move || retry_reveal_callback_fixture(probe.clone())
        }));
        crate::testing::pump_layout_test_session(&mut session, 0);
        probe.rects.with_mut(Vec::clear);
        probe.scroll.set(0);
        let mut tree = ComponentTree::new();
        let mut viewport = node("viewport", 1, 1);
        viewport.interaction_mut().focus_reveal_handler = probe.handler.get();
        let root = tree.add_node(viewport);
        let focus = FocusRegistration::target(FocusNode::new());
        let mut target = node("focused control", 2, 2);
        target.interaction_mut().focus_registration = Some(focus);
        let target = tree.add_node(target);
        tree.pop_node();
        tree.pop_node();
        for (id, y, width, height) in [(root, 0, 200, 100), (target, 300, 80, 24)] {
            let metadata = tree.metadatas.get_mut(&id).unwrap();
            metadata.abs_position = Some(PxPosition::new(Px::ZERO, Px(y)));
            metadata.base_abs_position = metadata.abs_position;
            metadata.computed_data = Some(ComputedData {
                width: Px(width),
                height: Px(height),
            });
        }
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        (tree, root, focus, session)
    }

    #[test]
    fn pending_focus_reveal_retries_a_keyboard_barrier_without_queued_input() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let probe = RevealProbe::default();
        use crate::focus::{FocusManager, bind_focus_owner};

        let (mut tree, _, focus, _session) = reveal_viewport_tree(probe.clone());
        {
            let _binding = bind_focus_owner(&mut tree.focus_owner);
            FocusManager::current().defer_keyboard_until_layout();
        }
        assert!(
            !needs_deferred_focus_retry(&tree.focus_owner, false),
            "a barrier without pending work must not schedule an idle retry"
        );
        tree.focus_owner.request_focus(focus.id);
        assert!(
            needs_deferred_focus_retry(&tree.focus_owner, false),
            "a pending reveal must schedule another pass even without keyboard or IME events"
        );
        tree.focus_owner.begin_layout();
        assert!(needs_deferred_focus_retry(&tree.focus_owner, false));
        tree.focus_owner.finish_layout();
        assert!(
            tree.has_pending_focus_reveal(),
            "post-layout scheduling must still retry an unconsumed reveal even after the barrier clears"
        );
        assert!(tree.pending_focused_input.is_empty());
        assert!(dispatch_pending_focus_reveal_request(
            &tree.tree,
            &tree.metadatas,
            &mut tree.focus_owner,
            false
        ));
        assert_eq!(
            probe.scroll.get(),
            -300,
            "the settled barrier must allow the real viewport handler to reveal the pending target"
        );
        assert_eq!(
            probe.rects.with(|rects| rects.clone()),
            [crate::PxRect::new(Px::ZERO, Px(300), Px(80), Px(24))]
        );
        assert!(!needs_deferred_focus_retry(&tree.focus_owner, false));
        assert!(
            !tree.has_pending_focus_reveal(),
            "the post-flush scheduler must stop retrying once the viewport has handled the request"
        );
    }

    #[test]
    fn reveal_retry_consumes_the_request_before_a_later_pointer_frame() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let probe = RevealProbe::default();
        let (mut tree, root, focus, _session) = reveal_viewport_tree(probe.clone());
        tree.focus_owner.request_focus(focus.id);
        assert!(dispatch_pending_focus_reveal_request(
            &tree.tree,
            &tree.metadatas,
            &mut tree.focus_owner,
            true
        ));
        assert_eq!(
            probe.scroll.get(),
            -300,
            "the retry must deliver the actual pending reveal to the viewport handler"
        );
        assert_eq!(
            probe.rects.with(|rects| rects.clone()),
            [crate::PxRect::new(Px::ZERO, Px(300), Px(80), Px(24))]
        );
        probe.scroll.set(-600);
        let mut pointer = Some(PxPosition::new(Px(180), Px(50)));
        let mut changes = [crate::PointerChange {
            timestamp: crate::time::Instant::now(),
            pointer_id: crate::MOUSE_POINTER_ID,
            content: crate::CursorEventContent::Moved(pointer.unwrap()),
            gesture_state: crate::GestureState::TapCandidate,
            sampled_position: Default::default(),
            consumed: false,
            tap_claimed: false,
            scroll_discrete: None,
        }];
        tree.dispatch_pointer_input(
            root,
            &mut changes,
            &mut pointer,
            winit::keyboard::ModifiersState::empty(),
        );
        assert!(
            !dispatch_pending_focus_reveal_request(
                &tree.tree,
                &tree.metadatas,
                &mut tree.focus_owner,
                false
            ),
            "an ordinary pointer frame must not repeat a reveal already handled by the retry"
        );
        assert_eq!(
            probe.scroll.get(),
            -600,
            "the later pointer frame preserves the user's new scroll position"
        );
        assert_eq!(probe.rects.with(Vec::len), 1);
        assert!(
            dispatch_pending_focus_reveal_request(
                &tree.tree,
                &tree.metadatas,
                &mut tree.focus_owner,
                true
            ),
            "an explicit retry without a new request still visits the active target"
        );
        assert_eq!(probe.rects.with(Vec::len), 2);
    }

    #[test]
    fn newer_nonzero_scroll_suppresses_only_the_reveal_of_an_older_deferred_focus_command() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let probe = RevealProbe::default();
        use crate::focus::{FocusNode, FocusRegistration};

        for delta_y in [0.0, -24.0] {
            for newer_request_before_attach in [false, true] {
                let (mut tree, root, original, _session) = reveal_viewport_tree(probe.clone());
                let original_node = tree.focus_owner.component_node_id_of(original.id).unwrap();
                let delayed = FocusRegistration::target(FocusNode::new());
                tree.focus_owner.request_focus(delayed.id);
                let mut pointer = Some(PxPosition::new(Px(180), Px(50)));
                let mut changes = [crate::PointerChange {
                    timestamp: crate::time::Instant::now(),
                    pointer_id: crate::MOUSE_POINTER_ID,
                    content: crate::CursorEventContent::Scroll(crate::cursor::ScrollEventContent {
                        delta_x: 0.0,
                        delta_y,
                        unit: crate::cursor::ScrollDeltaUnit::Pixel,
                        source: crate::cursor::ScrollEventSource::Wheel,
                    }),
                    gesture_state: crate::GestureState::TapCandidate,
                    sampled_position: Default::default(),
                    consumed: false,
                    tap_claimed: false,
                    scroll_discrete: None,
                }];
                tree.dispatch_pointer_input(
                    root,
                    &mut changes,
                    &mut pointer,
                    winit::keyboard::ModifiersState::empty(),
                );
                if newer_request_before_attach {
                    tree.focus_owner.request_focus(original.id);
                }

                let mut target = node("delayed focus target", 3, 3);
                target.interaction_mut().focus_registration = Some(delayed);
                let target = tree.add_node(target);
                tree.pop_node();
                root.append(target, &mut tree.tree);
                let metadata = tree.metadatas.get_mut(&target).unwrap();
                metadata.abs_position = Some(PxPosition::new(Px(0), Px(500)));
                metadata.base_abs_position = metadata.abs_position;
                metadata.computed_data = Some(ComputedData {
                    width: Px(80),
                    height: Px(24),
                });
                tree.focus_owner.sync_from_component_tree(root, &tree.tree);
                tree.focus_owner.commit_pending();
                assert_eq!(
                    tree.focus_owner.active_component_node_id(),
                    Some(if newer_request_before_attach {
                        original_node
                    } else {
                        target
                    })
                );
                assert_eq!(
                    dispatch_pending_focus_reveal_request(
                        &tree.tree,
                        &tree.metadatas,
                        &mut tree.focus_owner,
                        false,
                    ),
                    newer_request_before_attach || delta_y == 0.0,
                    "a zero scroll must preserve the deferred reveal; a newer nonzero scroll must suppress it"
                );
                assert_eq!(
                    probe.rects.with(Vec::len),
                    usize::from(newer_request_before_attach || delta_y == 0.0)
                );

                tree.focus_owner
                    .request_focus(if newer_request_before_attach {
                        delayed.id
                    } else {
                        original.id
                    });
                assert!(dispatch_pending_focus_reveal_request(
                    &tree.tree,
                    &tree.metadatas,
                    &mut tree.focus_owner,
                    false,
                ));
                let revealed_y = if newer_request_before_attach {
                    500
                } else {
                    300
                };
                assert_eq!(probe.scroll.get(), -revealed_y);
                assert_eq!(
                    probe.rects.with(|rects| rects.last().copied()),
                    Some(crate::PxRect::new(Px(0), Px(revealed_y), Px(80), Px(24)))
                );
            }
        }
    }

    #[test]
    fn retained_scene_keeps_child_drawing_when_parent_paint_appears_and_disappears() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        #[derive(Clone)]
        struct Marker(u32);
        impl crate::DrawCommand for Marker {
            fn apply_opacity(&mut self, _: f32) {}
        }
        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        let wrapper = tree.add_node(node("wrapper", 2, 2));
        let visual = tree.add_node(node("visual", 3, 3));
        let label = tree.add_node(node("label", 4, 4));
        tree.pop_node();
        tree.pop_node();
        tree.pop_node();
        let sibling = tree.add_node(node("sibling", 5, 5));
        tree.pop_node();
        tree.pop_node();
        for id in [root, wrapper, visual, label, sibling] {
            let metadata = tree.metadatas.entry_or_default(id);
            metadata.computed_data = Some(ComputedData {
                width: Px(32),
                height: Px(32),
            });
            metadata.rel_position = Some(PxPosition::ZERO);
        }
        tree.metadatas
            .entry_or_default(label)
            .fragment
            .push_draw_command(Marker(1));
        tree.metadatas
            .entry_or_default(sibling)
            .fragment
            .push_draw_command(Marker(2));
        tree.metadatas.entry_or_default(label).rel_position = None;
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        let mut scene = scene::FrameScene::default();
        let viewport = PxSize::new(Px(100), Px(100));
        scene.update(
            root,
            &tree.tree,
            &tree.metadatas,
            &root.descendants(&tree.tree).collect(),
            &HashSet::default(),
            viewport,
        );
        tree.metadatas.geometry_changed.clear();
        node::place_node(label, PxPosition::ZERO, 0, &mut tree.metadatas);
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        let (revealed, _) = scene.update(
            root,
            &tree.tree,
            &tree.metadatas,
            &HashSet::default(),
            &HashSet::default(),
            viewport,
        );
        assert_eq!(revealed.ops().len(), 2);
        tree.metadatas.geometry_changed.clear();
        for painted in [true, false, true, false] {
            let metadata = tree.metadatas.entry_or_default(visual);
            metadata.fragment = Default::default();
            if painted {
                metadata.fragment.push_draw_command(Marker(3));
            }
            tree.metadatas.paint_changed.insert(visual);
            let (graph, _) = scene.update(
                root,
                &tree.tree,
                &tree.metadatas,
                &HashSet::default(),
                &HashSet::default(),
                viewport,
            );
            let values = graph
                .ops()
                .iter()
                .filter_map(|op| op.command.downcast_draw_ref::<Marker>())
                .map(|marker| marker.0)
                .collect::<Vec<_>>();
            assert_eq!(values, if painted { vec![3, 1, 2] } else { vec![1, 2] });
            tree.metadatas.paint_changed.clear();
        }
    }

    #[test]
    fn retained_scene_reuses_fragment_commands_on_translation_and_refreshes_paint() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::testing::TestProbe;

        struct Marker {
            clones: TestProbe<usize>,
            value: u32,
            opacity: f32,
        }

        impl Clone for Marker {
            fn clone(&self) -> Self {
                self.clones.with_mut(|clones| *clones += 1);
                Self {
                    clones: self.clones.clone(),
                    value: self.value,
                    opacity: self.opacity,
                }
            }
        }

        impl crate::DrawCommand for Marker {
            fn apply_opacity(&mut self, opacity: f32) {
                self.opacity *= opacity;
            }
        }

        let clones = TestProbe::new(0usize);
        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        let leaf = tree.add_node(node("leaf", 2, 2));
        tree.pop_node();
        let outside = tree.add_node(node("outside", 3, 3));
        tree.pop_node();
        let sibling = tree.add_node(node("sibling", 4, 4));
        tree.pop_node();
        tree.pop_node();
        for id in [root, leaf, outside, sibling] {
            let metadata = tree.metadatas.entry_or_default(id);
            metadata.computed_data = Some(ComputedData {
                width: Px(32),
                height: Px(32),
            });
            metadata.rel_position = Some(PxPosition::ZERO);
        }
        let outside_clones = TestProbe::new(0usize);
        let metadata = tree.metadatas.entry_or_default(outside);
        metadata.rel_position = Some(PxPosition::from_f32_xy(150.0, 0.0));
        metadata.fragment.push_draw_command(Marker {
            clones: outside_clones.clone(),
            value: 3,
            opacity: 1.0,
        });
        tree.metadatas
            .entry_or_default(sibling)
            .fragment
            .push_draw_command(Marker {
                clones: TestProbe::new(0usize),
                value: 5,
                opacity: 1.0,
            });
        tree.metadatas
            .entry_or_default(leaf)
            .fragment
            .push_draw_command(Marker {
                clones: clones.clone(),
                value: 1,
                opacity: 1.0,
            });
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        let viewport = PxSize::new(Px(100), Px(100));
        let mut scene = scene::FrameScene::default();
        scene.update(
            root,
            &tree.tree,
            &tree.metadatas,
            &root.descendants(&tree.tree).collect(),
            &HashSet::default(),
            viewport,
        );
        clones.set(0);
        tree.metadatas.geometry_changed.clear();
        let metadata = tree.metadatas.entry_or_default(outside);
        metadata.fragment = Default::default();
        metadata.fragment.push_draw_command(Marker {
            clones: outside_clones,
            value: 4,
            opacity: 1.0,
        });
        tree.metadatas.paint_changed.insert(outside);
        let (graph, _) = scene.update(
            root,
            &tree.tree,
            &tree.metadatas,
            &HashSet::default(),
            &HashSet::default(),
            viewport,
        );
        assert_eq!(
            clones.get(),
            0,
            "offscreen paint must not reassemble unchanged visible commands"
        );
        assert_eq!(
            graph
                .ops()
                .iter()
                .filter_map(|op| op.command.downcast_draw_ref::<Marker>())
                .map(|marker| marker.value)
                .collect::<Vec<_>>(),
            vec![1, 5]
        );
        tree.metadatas.paint_changed.clear();
        tree.metadatas.geometry_changed.insert(leaf);
        scene.update(
            root,
            &tree.tree,
            &tree.metadatas,
            &HashSet::default(),
            &HashSet::default(),
            viewport,
        );
        assert_eq!(
            clones.get(),
            0,
            "an unchanged draw in the geometry journal must retain its visible output"
        );
        for (offset, opacity) in [(1.25, 1.0), (2.5, 0.5), (3.75, 0.5)] {
            clones.set(0);
            tree.metadatas.geometry_changed.clear();
            tree.metadatas.mark_geometry_dirty(root);
            let metadata = tree.metadatas.entry_or_default(root);
            metadata.rel_position = Some(PxPosition::from_f32_xy(offset, 0.0));
            metadata.opacity = opacity;
            populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
            assert!(
                !tree.metadatas.geometry_changed.contains(&root),
                "a passive layout must not publish geometry notifications for its own translation"
            );
            assert_eq!(
                tree.metadatas.get(&root).unwrap().abs_position,
                Some(PxPosition::from_f32_xy(offset, 0.0)),
                "passive layout coordinates must remain available for inspection"
            );
            assert!(tree.metadatas.geometry_changed.contains(&leaf));
            let (graph, _) = scene.update(
                root,
                &tree.tree,
                &tree.metadatas,
                &HashSet::default(),
                &HashSet::default(),
                viewport,
            );
            assert_eq!(
                clones.get(),
                1,
                "translation must copy the command only into the frame output"
            );
            let op = graph
                .ops()
                .iter()
                .find(|op| op.command.downcast_draw_ref::<Marker>().is_some())
                .unwrap();
            let marker = op.command.downcast_draw_ref::<Marker>().unwrap();
            assert_eq!(marker.value, 1);
            assert_eq!(marker.opacity, opacity);
            assert_eq!(
                op.geometry.window_origin(),
                PxPosition::from_f32_xy(offset, 0.0)
            );
        }
        let metadata = tree.metadatas.entry_or_default(leaf);
        metadata.fragment = Default::default();
        metadata.fragment.push_draw_command(Marker {
            clones,
            value: 2,
            opacity: 1.0,
        });
        tree.metadatas.paint_changed.insert(leaf);
        let (graph, _) = scene.update(
            root,
            &tree.tree,
            &tree.metadatas,
            &HashSet::default(),
            &HashSet::default(),
            viewport,
        );
        let marker = graph
            .ops()
            .iter()
            .find_map(|op| op.command.downcast_draw_ref::<Marker>())
            .unwrap();
        assert_eq!(marker.value, 2);
        assert_eq!(marker.opacity, 0.5);
        tree.metadatas.paint_changed.clear();
        for (offset, width, visible) in [
            (150.0, 100, false),
            (160.0, 100, false),
            (160.0, 200, true),
            (160.0, 100, false),
            (0.25, 100, true),
        ] {
            tree.metadatas.geometry_changed.clear();
            tree.metadatas.mark_geometry_dirty(root);
            tree.metadatas.entry_or_default(root).rel_position =
                Some(PxPosition::from_f32_xy(offset, 0.0));
            populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
            let (graph, _) = scene.update(
                root,
                &tree.tree,
                &tree.metadatas,
                &HashSet::default(),
                &HashSet::default(),
                PxSize::new(Px(width), Px(100)),
            );
            assert_eq!(
                graph
                    .ops()
                    .iter()
                    .any(|op| op.command.downcast_draw_ref::<Marker>().is_some()),
                visible,
                "retained visibility must follow translation and viewport resizing"
            );
        }
        tree.metadatas.geometry_changed.clear();
        tree.metadatas.mark_geometry_dirty(outside);
        tree.metadatas.entry_or_default(outside).rel_position =
            Some(PxPosition::from_f32_xy(40.0, 0.0));
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        let (graph, _) = scene.update(
            root,
            &tree.tree,
            &tree.metadatas,
            &HashSet::default(),
            &HashSet::default(),
            viewport,
        );
        assert_eq!(
            graph
                .ops()
                .iter()
                .filter_map(|op| op.command.downcast_draw_ref::<Marker>())
                .map(|marker| marker.value)
                .collect::<Vec<_>>(),
            vec![2, 4, 5],
            "revealing an omitted branch must publish its latest paint in sibling order"
        );
    }

    #[test]
    fn unplaced_layout_subtrees_hide_geometry_input_drawing_semantics_and_focus() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::focus::{FocusNode, FocusRegistration};

        #[derive(Clone)]
        struct Marker;

        impl crate::DrawCommand for Marker {
            fn apply_opacity(&mut self, _opacity: f32) {}
        }

        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        tree.add_node(node_with_role("transparent", NodeRole::Composition, 2, 2));
        let panel = tree.add_node(node("panel", 3, 3));
        tree.add_node(node_with_role("content", NodeRole::Composition, 4, 4));
        let leaf_focus = FocusRegistration::target(FocusNode::new());
        let mut leaf_node = node("leaf", 5, 5);
        leaf_node.interaction_mut().focus_registration = Some(leaf_focus);
        let leaf = tree.add_node(leaf_node);
        for _ in 0..4 {
            tree.pop_node();
        }
        let outside_focus = FocusRegistration::target(FocusNode::new());
        let mut outside_node = node("outside", 6, 6);
        outside_node.interaction_mut().focus_registration = Some(outside_focus);
        let outside = tree.add_node(outside_node);
        tree.pop_node();
        tree.pop_node();
        for (id, length) in [(root, 200), (panel, 30), (leaf, 6), (outside, 6)] {
            tree.metadatas.entry_or_default(id).computed_data = Some(ComputedData {
                width: Px(length),
                height: Px(length),
            });
        }
        tree.metadatas.entry_or_default(leaf).rel_position = Some(PxPosition::new(Px(4), Px(5)));
        tree.metadatas.entry_or_default(outside).rel_position =
            Some(PxPosition::new(Px(240), Px(240)));
        tree.metadatas.entry_or_default(root).clips_children = true;
        tree.metadatas.entry_or_default(leaf).set_accessibility(
            Some(
                crate::accessibility::AccessibilityNode::new()
                    .with_role(accesskit::Role::Button)
                    .with_label("Panel action"),
            ),
            None,
        );
        for position in [Some(20), None, Some(40)] {
            tree.metadatas.mark_geometry_dirty(panel);
            tree.metadatas.entry_or_default(panel).rel_position =
                position.map(|position| PxPosition::new(Px(position), Px(position)));
            let metadata = tree.metadatas.entry_or_default(leaf);
            metadata.fragment = Default::default();
            metadata.fragment.push_draw_command(Marker);
            populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
            assert_eq!(
                tree.metadatas.get(&outside).unwrap().event_clip_rect(),
                Some(PxRect::new(Px::ZERO, Px::ZERO, Px(200), Px(200))),
                "the placed traversal target is outside its ancestor's clip"
            );
            tree.focus_owner.sync_from_component_tree(root, &tree.tree);
            tree.focus_owner
                .sync_layout_from_component_tree(&tree.tree, &tree.metadatas);
            if position.is_none() {
                assert_eq!(
                    tree.focus_owner.active_component_node_id(),
                    None,
                    "hiding the active subtree releases focus, including capture"
                );
            }
            tree.focus_owner.clear_focus_global(true);
            tree.focus_owner.request_focus(leaf_focus.id);
            tree.focus_owner.commit_pending();
            assert_eq!(
                tree.focus_owner.active_component_node_id(),
                position.map(|_| leaf),
                "unplaced descendants reject direct focus requests"
            );
            tree.focus_owner.clear_focus_global(true);
            assert!(tree.focus_owner.move_focus(FocusDirection::Next));
            assert_eq!(
                tree.focus_owner.active_component_node_id(),
                Some(if position.is_some() { leaf } else { outside }),
                "forward traversal skips the unplaced subtree"
            );
            if position.is_some() {
                assert!(tree.focus_owner.move_focus(FocusDirection::Next));
            }
            assert_eq!(
                tree.focus_owner.move_focus(FocusDirection::Previous),
                position.is_some(),
                "reverse traversal also skips the unplaced subtree"
            );
            assert_eq!(
                tree.focus_owner.active_component_node_id(),
                Some(if position.is_some() { leaf } else { outside })
            );
            if position.is_some() {
                tree.focus_owner.capture_focus(leaf_focus.id);
            }
            let graph = build_render_graph(
                root,
                &tree.tree,
                &mut tree.metadatas,
                PxSize::new(Px(200), Px(200)),
            );
            let expected =
                position.map(|position| PxPosition::new(Px(position + 4), Px(position + 5)));
            assert_eq!(tree.metadatas.get(&leaf).unwrap().abs_position, expected);
            assert_eq!(
                tree.metadatas.get(&leaf).unwrap().base_abs_position,
                expected
            );
            assert_eq!(
                resolve_node_input_context(&tree.tree, &tree.metadatas, leaf).is_some(),
                expected.is_some()
            );
            let marker_ops: Vec<_> = graph
                .ops()
                .iter()
                .filter(|op| op.type_id == std::any::TypeId::of::<Marker>())
                .collect();
            assert_eq!(marker_ops.len(), usize::from(expected.is_some()));
            let accessibility = crate::accessibility::build_tree_update(
                &tree.tree,
                &tree.metadatas,
                root,
                None,
                Some(leaf),
            )
            .expect("accessibility tree");
            assert_eq!(
                accessibility
                    .nodes
                    .iter()
                    .any(|(_, node)| node.label() == Some("Panel action")),
                expected.is_some()
            );
            assert_eq!(
                accessibility
                    .nodes
                    .iter()
                    .find(|(id, _)| *id == accessibility.focus)
                    .and_then(|(_, node)| node.label()),
                expected.map(|_| "Panel action")
            );
            if let Some(expected) = expected {
                assert_eq!(marker_ops[0].geometry.window_origin(), expected);
            } else {
                tree.metadatas.geometry_changed.clear();
                tree.metadatas.mark_geometry_dirty(root);
                tree.metadatas.entry_or_default(root).rel_position =
                    Some(PxPosition::from_f32_xy(0.25, 0.5));
                populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
                assert!(
                    !tree.metadatas.geometry_changed.contains(&leaf),
                    "moving an ancestor must not invalidate an already hidden subtree"
                );
                assert!(tree.metadatas.get(&leaf).unwrap().abs_position.is_none());
                tree.metadatas.entry_or_default(root).rel_position = None;
                tree.metadatas.mark_geometry_dirty(root);
            }
        }
    }

    #[test]
    fn pointer_samples_route_at_their_own_positions_and_complete_passes_in_order() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::cursor::{GestureState, MOUSE_POINTER_ID, PressKeyEventType};

        let log = Arc::new(std::sync::Mutex::new(Vec::new()));
        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        let origin = Instant::now();
        for index in 0..2 {
            let mut target = node("target", index + 2, index + 2);
            for pass in [
                PointerEventPass::Initial,
                PointerEventPass::Main,
                PointerEventPass::Final,
            ] {
                let log = Arc::clone(&log);
                let handler: Box<PointerInputHandlerFn> = Box::new(move |input| {
                    for change in input.pointer_changes.iter() {
                        log.lock().unwrap().push((
                            index,
                            pass,
                            change.timestamp.duration_since(origin).as_nanos(),
                            input.cursor_position_rel,
                        ));
                    }
                });
                match pass {
                    PointerEventPass::Initial => target
                        .interaction_mut()
                        .pointer_preview_handlers
                        .push(handler),
                    PointerEventPass::Main => {
                        target.interaction_mut().pointer_handlers.push(handler)
                    }
                    PointerEventPass::Final => target
                        .interaction_mut()
                        .pointer_final_handlers
                        .push(handler),
                }
            }
            let id = tree.add_node(target);
            let metadata = tree.metadatas.get_mut(&id).unwrap();
            let position = PxPosition::new(Px(index as i32 * 200), Px::ZERO);
            metadata.base_abs_position = Some(position);
            metadata.abs_position = Some(position);
            metadata.computed_data = Some(ComputedData {
                width: Px(100),
                height: Px(100),
            });
            tree.pop_node();
        }
        tree.pop_node();
        let metadata = tree.metadatas.get_mut(&root).unwrap();
        metadata.base_abs_position = Some(PxPosition::ZERO);
        metadata.abs_position = Some(PxPosition::ZERO);
        metadata.computed_data = Some(ComputedData {
            width: Px(400),
            height: Px(100),
        });
        let left = PxPosition::new(Px(20), Px(20));
        let right = PxPosition::new(Px(220), Px(20));
        let outside = PxPosition::new(Px(500), Px(20));
        let mut events: Vec<_> = [
            (
                CursorEventContent::Pressed(PressKeyEventType::Left),
                Some(left),
            ),
            (
                CursorEventContent::Released(PressKeyEventType::Left),
                Some(left),
            ),
            (CursorEventContent::Moved(outside), Some(outside)),
            (
                CursorEventContent::Pressed(PressKeyEventType::Left),
                Some(right),
            ),
            (
                CursorEventContent::Released(PressKeyEventType::Left),
                Some(right),
            ),
            (CursorEventContent::Moved(outside), Some(outside)),
        ]
        .into_iter()
        .enumerate()
        .map(|(index, (content, position))| {
            PointerChange::new(
                origin + std::time::Duration::from_nanos(index as u64),
                MOUSE_POINTER_ID,
                content,
                GestureState::TapCandidate,
            )
            .with_position(position)
        })
        .collect();
        tree.dispatch_pointer_input(
            root,
            &mut events,
            &mut Some(outside),
            winit::keyboard::ModifiersState::empty(),
        );
        let expected: Vec<_> = [(0, 0), (0, 1), (1, 3), (1, 4)]
            .into_iter()
            .flat_map(|(index, sample)| {
                [
                    PointerEventPass::Initial,
                    PointerEventPass::Main,
                    PointerEventPass::Final,
                ]
                .map(|pass| (index, pass, sample, Some(left)))
            })
            .collect();
        assert_eq!(*log.lock().unwrap(), expected);
        assert!(tree.active_pointer_paths.is_empty());
        log.lock().unwrap().clear();
        let mut captured: Vec<_> = [
            (
                CursorEventContent::Pressed(PressKeyEventType::Left),
                Some(left),
            ),
            (CursorEventContent::Moved(outside), Some(outside)),
            (CursorEventContent::Released(PressKeyEventType::Left), None),
        ]
        .into_iter()
        .enumerate()
        .map(|(index, (content, position))| {
            PointerChange::new(
                origin + std::time::Duration::from_nanos(index as u64),
                MOUSE_POINTER_ID,
                content,
                GestureState::TapCandidate,
            )
            .with_position(position)
        })
        .collect();
        tree.dispatch_pointer_input(
            root,
            &mut captured,
            &mut Some(right),
            winit::keyboard::ModifiersState::empty(),
        );
        let expected: Vec<_> = [Some(left), Some(outside), None]
            .into_iter()
            .enumerate()
            .flat_map(|(sample, position)| {
                [
                    PointerEventPass::Initial,
                    PointerEventPass::Main,
                    PointerEventPass::Final,
                ]
                .map(|pass| (0, pass, sample as u128, position))
            })
            .collect();
        assert_eq!(
            *log.lock().unwrap(),
            expected,
            "capture delivers outside movement and an unavailable-position release to the original target"
        );
        assert!(tree.active_pointer_paths.is_empty());

        let mut press = [PointerChange::new(
            origin,
            MOUSE_POINTER_ID,
            CursorEventContent::Pressed(PressKeyEventType::Left),
            GestureState::TapCandidate,
        )
        .with_position(Some(left))];
        tree.dispatch_pointer_input(
            root,
            &mut press,
            &mut Some(left),
            winit::keyboard::ModifiersState::empty(),
        );
        let target = tree.find_node_id_by_instance_key(2).unwrap();
        tree.metadatas.get_mut(&target).unwrap().event_clip_bounds = Some(crate::FloatRect::ZERO);
        tree.metadatas.geometry_changed.insert(target);
        log.lock().unwrap().clear();
        let mut release = [PointerChange::new(
            origin + std::time::Duration::from_nanos(1),
            MOUSE_POINTER_ID,
            CursorEventContent::Released(PressKeyEventType::Left),
            GestureState::TapCandidate,
        )
        .with_position(Some(left))];
        tree.dispatch_pointer_input(
            root,
            &mut release,
            &mut Some(left),
            winit::keyboard::ModifiersState::empty(),
        );
        assert_eq!(
            *log.lock().unwrap(),
            [
                PointerEventPass::Initial,
                PointerEventPass::Main,
                PointerEventPass::Final
            ]
            .map(|pass| (0, pass, 1, None)),
            "a captured target scrolled outside its clip must still receive release"
        );
        assert!(tree.active_pointer_paths.is_empty());
    }

    #[test]
    fn recomposition_preserves_pointer_capture_but_runtime_reset_discards_it() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let mut tree = ComponentTree::new();
        tree.active_pointer_paths.insert(7, vec![1, 2]);
        tree.active_pointer_positions
            .insert(7, Some(PxPosition::ZERO));
        tree.clear();
        assert_eq!(tree.active_pointer_paths.get(&7), Some(&vec![1, 2]));
        assert_eq!(
            tree.active_pointer_positions.get(&7),
            Some(&Some(PxPosition::ZERO))
        );
        tree.reset();
        assert!(tree.active_pointer_paths.is_empty());
        assert!(tree.active_pointer_positions.is_empty());
    }

    fn focus_targets(attach: bool) -> (ComponentTree, Vec<(NodeId, FocusHandleId)>) {
        use crate::focus::{FocusNode, FocusRegistration};

        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        let mut targets = Vec::new();
        for index in 0..2 {
            let registration = FocusRegistration::target(FocusNode::new());
            let mut target = node("target", index + 2, index + 2);
            target.interaction_mut().focus_registration = Some(registration);
            let node_id = tree.add_node(target);
            targets.push((node_id, registration.id));
            tree.pop_node();
        }
        tree.pop_node();
        if attach {
            tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        }
        (tree, targets)
    }

    #[test]
    fn repeated_focus_request_does_not_replay_after_action_restores_another_target() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let (mut tree, targets) = focus_targets(true);
        let [(action, action_handle), (anchor, anchor_handle)] = targets.as_slice() else {
            unreachable!();
        };
        tree.focus_owner.request_focus(*action_handle);
        assert_eq!(tree.focus_owner.active_component_node_id(), Some(*action));
        tree.focus_owner.request_focus(*action_handle);
        tree.focus_owner.request_focus(*anchor_handle);
        tree.focus_owner.commit_pending();
        assert_eq!(tree.focus_owner.active_component_node_id(), Some(*anchor));
        tree.focus_owner.commit_pending();
        assert_eq!(tree.focus_owner.active_component_node_id(), Some(*anchor));
    }

    #[test]
    fn clearing_an_unfocused_attached_target_does_not_clear_its_future_focus() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let (mut tree, targets) = focus_targets(true);
        tree.focus_owner.request_focus(targets[1].1);
        tree.focus_owner.clear_focus(targets[0].1);
        tree.focus_owner.request_focus(targets[0].1);
        tree.focus_owner.commit_pending();
        assert_eq!(
            tree.focus_owner.active_component_node_id(),
            Some(targets[0].0)
        );
    }

    #[test]
    fn rejected_capture_does_not_capture_a_later_focus_request() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let (mut tree, targets) = focus_targets(true);
        tree.focus_owner.request_focus(targets[1].1);
        tree.focus_owner.capture_focus(targets[0].1);
        tree.focus_owner.request_focus(targets[0].1);
        tree.focus_owner.commit_pending();
        tree.focus_owner.request_focus(targets[1].1);
        tree.focus_owner.commit_pending();
        assert_eq!(
            tree.focus_owner.active_component_node_id(),
            Some(targets[1].0)
        );
    }

    #[test]
    fn redundant_free_does_not_release_a_later_capture() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let (mut tree, targets) = focus_targets(true);
        tree.focus_owner.request_focus(targets[0].1);
        tree.focus_owner.free_focus(targets[0].1);
        tree.focus_owner.capture_focus(targets[0].1);
        tree.focus_owner.commit_pending();
        tree.focus_owner.request_focus(targets[1].1);
        tree.focus_owner.commit_pending();
        assert_eq!(
            tree.focus_owner.active_component_node_id(),
            Some(targets[0].0)
        );
    }

    #[test]
    fn requests_before_attachment_are_consumed_once_the_target_is_attached() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let (mut tree, targets) = focus_targets(false);
        tree.focus_owner.request_focus(targets[0].1);
        tree.focus_owner.request_focus(targets[0].1);
        let root = tree.tree.get(targets[0].0).unwrap().parent().unwrap();
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        tree.focus_owner.commit_pending();
        assert_eq!(
            tree.focus_owner.active_component_node_id(),
            Some(targets[0].0)
        );
        tree.focus_owner.request_focus(targets[1].1);
        tree.focus_owner.commit_pending();
        assert_eq!(
            tree.focus_owner.active_component_node_id(),
            Some(targets[1].0)
        );
    }

    #[test]
    fn deferred_request_rejected_after_attachment_does_not_activate_on_enable() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let (mut tree, targets) = focus_targets(false);
        tree.focus_owner.request_focus(targets[0].1);
        let root = tree.tree.get(targets[0].0).unwrap().parent().unwrap();
        tree.tree
            .get_mut(targets[0].0)
            .unwrap()
            .get_mut()
            .interaction_mut()
            .focus_registration
            .as_mut()
            .unwrap()
            .properties
            .can_focus = false;
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        tree.focus_owner.commit_pending();
        assert_eq!(tree.focus_owner.active_component_node_id(), None);
        tree.tree
            .get_mut(targets[0].0)
            .unwrap()
            .get_mut()
            .interaction_mut()
            .focus_registration
            .as_mut()
            .unwrap()
            .properties
            .can_focus = true;
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        tree.focus_owner.commit_pending();
        assert_eq!(tree.focus_owner.active_component_node_id(), None);
    }

    #[test]
    fn queued_navigation_routes_activation_to_the_new_focus_chain() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::focus::{FocusNode, FocusRegistration};

        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        let mut trigger = node("trigger", 2, 2);
        trigger.interaction_mut().focus_registration =
            Some(FocusRegistration::target(FocusNode::new()));
        let trigger = tree.add_node(trigger);
        tree.pop_node();
        let popup = tree.add_node(node("popup", 3, 3));
        let mut action = node("action", 4, 4);
        action.interaction_mut().focus_registration =
            Some(FocusRegistration::target(FocusNode::new()));
        let action = tree.add_node(action);
        tree.pop_node();
        tree.pop_node();
        tree.pop_node();
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        assert!(tree.focus_owner.move_focus(FocusDirection::Next));
        let mut events = VecDeque::from(["Tab", "Enter", "Shift+Tab", "Enter"]);
        let mut activations = Vec::new();
        let retry = drain_pending_focused_input(&mut events, |event| {
            match event {
                "Tab" => assert!(tree.focus_owner.move_focus(FocusDirection::Next)),
                "Shift+Tab" => assert!(tree.focus_owner.move_focus(FocusDirection::Previous)),
                "Enter" => activations.push(collect_focus_chain_node_ids(
                    root,
                    &tree.tree,
                    &tree.focus_owner,
                )),
                _ => unreachable!(),
            }
            tree.focus_owner.commit_pending();
            (None, false)
        });
        assert_eq!(retry, None);
        assert!(events.is_empty());
        assert_eq!(
            activations,
            [vec![root, popup, action], vec![root, trigger]]
        );
    }

    #[test]
    fn skipped_focus_targets_anchor_navigation_without_becoming_destinations() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::focus::{FocusNode, FocusRegistration, FocusScopeNode};

        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        let scope = FocusRegistration::scope(FocusScopeNode::new());
        let mut container = node("scope", 2, 2);
        container.interaction_mut().focus_registration = Some(scope);
        tree.add_node(container);
        let mut targets = Vec::new();
        for index in 0..3 {
            let mut registration = FocusRegistration::target(FocusNode::new());
            registration.properties.skip_traversal = index == 1;
            let mut target = node("target", index + 3, index + 3);
            target.interaction_mut().focus_registration = Some(registration);
            targets.push((tree.add_node(target), registration.id));
            tree.pop_node();
        }
        tree.pop_node();
        tree.pop_node();
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        for scoped in [false, true] {
            for (direction, expected) in [(FocusDirection::Next, 2), (FocusDirection::Previous, 0)]
            {
                tree.focus_owner.request_focus(targets[1].1);
                assert_eq!(
                    tree.focus_owner.active_component_node_id(),
                    Some(targets[1].0)
                );
                assert!(if scoped {
                    tree.focus_owner
                        .move_focus_in_scope(scope.id, direction, true)
                } else {
                    tree.focus_owner.move_focus(direction)
                });
                assert_eq!(
                    tree.focus_owner.active_component_node_id(),
                    Some(targets[expected].0)
                );
            }
        }
        tree.focus_owner.request_focus(targets[0].1);
        assert!(tree.focus_owner.move_focus(FocusDirection::Next));
        assert_eq!(
            tree.focus_owner.active_component_node_id(),
            Some(targets[2].0)
        );
        for index in [0, 2] {
            tree.tree[targets[index].0]
                .get_mut()
                .interaction_mut()
                .focus_registration
                .as_mut()
                .unwrap()
                .properties
                .can_focus = false;
        }
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        tree.focus_owner.request_focus(targets[1].1);
        for direction in [FocusDirection::Next, FocusDirection::Previous] {
            assert!(
                !tree
                    .focus_owner
                    .move_focus_in_scope(scope.id, direction, true)
            );
        }
    }

    #[test]
    fn removing_unscoped_focus_does_not_activate_an_unrelated_control() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let (mut tree, targets) = focus_targets(true);
        tree.focus_owner.request_focus(targets[0].1);
        assert_eq!(
            tree.focus_owner.active_component_node_id(),
            Some(targets[0].0)
        );
        tree.focus_owner
            .remove_handles(&[targets[0].1].into_iter().collect(), &HashSet::default());
        assert_eq!(tree.focus_owner.active_component_node_id(), None);
    }

    #[test]
    fn removing_focused_handles_restores_to_a_surviving_scope_target() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::focus::{FocusNode, FocusRegistration, FocusRequester, FocusScopeNode};

        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        let scope = FocusRegistration::scope(FocusScopeNode::new());
        let fallback = FocusRequester::new();
        let mut container = node("scope", 2, 2);
        container.interaction_mut().focus_registration = Some(scope);
        container.interaction_mut().focus_restorer_fallback = Some(fallback);
        tree.add_node(container);
        let removed = FocusRegistration::target(FocusNode::new());
        let mut target = node("removed", 3, 3);
        target.interaction_mut().focus_registration = Some(removed);
        let removed_node = tree.add_node(target);
        tree.pop_node();
        let mut target = node("survivor", 4, 4);
        target.interaction_mut().focus_registration =
            Some(FocusRegistration::target(FocusNode::new()));
        target.interaction_mut().focus_requester_binding = Some(fallback);
        let survivor = tree.add_node(target);
        tree.pop_node();
        tree.pop_node();
        tree.pop_node();
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        tree.focus_owner.request_focus(removed.id);
        assert_eq!(
            tree.focus_owner.active_component_node_id(),
            Some(removed_node)
        );
        tree.focus_owner
            .remove_handles(&[removed.id].into_iter().collect(), &HashSet::default());
        assert_eq!(tree.focus_owner.active_component_node_id(), Some(survivor));
    }

    #[test]
    fn detached_focus_scopes_retain_their_target_through_layout_until_reattached() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::focus::{FocusNode, FocusRegistration, FocusScopeNode};

        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        let mut container = node_with_role("scope", NodeRole::Composition, 2, 2);
        container.interaction_mut().focus_registration =
            Some(FocusRegistration::scope(FocusScopeNode::new()));
        let scope = tree.add_node(container);
        let registration = FocusRegistration::target(FocusNode::new());
        let mut target = node("target", 3, 3);
        target.interaction_mut().focus_registration = Some(registration);
        let target = tree.add_node(target);
        for _ in 0..3 {
            tree.pop_node();
        }
        for id in [root, target] {
            let metadata = tree.metadatas.entry_or_default(id);
            metadata.computed_data = Some(ComputedData {
                width: Px(20),
                height: Px(20),
            });
            metadata.rel_position = Some(PxPosition::ZERO);
        }
        populate_layout_metadata(root, &tree.tree, &mut tree.metadatas);
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        tree.focus_owner
            .sync_layout_from_component_tree(&tree.tree, &tree.metadatas);
        tree.focus_owner.request_focus(registration.id);
        assert_eq!(tree.focus_owner.active_component_node_id(), Some(target));

        scope.detach(&mut tree.tree);
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        tree.focus_owner
            .sync_layout_from_component_tree(&tree.tree, &tree.metadatas);
        assert_eq!(tree.focus_owner.active_component_node_id(), None);
        root.append(scope, &mut tree.tree);
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        tree.focus_owner
            .sync_layout_from_component_tree(&tree.tree, &tree.metadatas);
        assert_eq!(tree.focus_owner.active_component_node_id(), Some(target));
    }

    #[test]
    fn redundant_scope_restore_does_not_pull_focus_back_from_another_scope() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::focus::{FocusNode, FocusRegistration, FocusScopeNode};

        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        let scope = FocusRegistration::scope(FocusScopeNode::new());
        let mut container = node("scope", 2, 2);
        container.interaction_mut().focus_registration = Some(scope);
        tree.add_node(container);
        let inside = FocusRegistration::target(FocusNode::new());
        let mut target = node("inside", 3, 3);
        target.interaction_mut().focus_registration = Some(inside);
        tree.add_node(target);
        tree.pop_node();
        tree.pop_node();
        let outside = FocusRegistration::target(FocusNode::new());
        let mut target = node("outside", 4, 4);
        target.interaction_mut().focus_registration = Some(outside);
        let outside_node = tree.add_node(target);
        tree.pop_node();
        tree.pop_node();
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        tree.focus_owner.request_focus(inside.id);
        tree.focus_owner.restore_focus(scope.id);
        tree.focus_owner.request_focus(outside.id);
        tree.focus_owner.commit_pending();
        assert_eq!(
            tree.focus_owner.active_component_node_id(),
            Some(outside_node)
        );
    }

    #[test]
    fn focus_retry_keeps_later_keys_before_newly_received_input() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let mut events = VecDeque::from(["Tab into lazy content", "Enter", "Shift+Tab"]);
        let mut dispatched = Vec::new();
        let retry = drain_pending_focused_input(&mut events, |event| {
            dispatched.push(event);
            (Some(FocusDirection::Next), false)
        });
        assert_eq!(retry, Some(FocusDirection::Next));
        assert_eq!(dispatched, ["Tab into lazy content"]);
        events.push_back("new input");
        assert_eq!(
            drain_pending_focused_input(&mut events, |event| {
                dispatched.push(event);
                (None, false)
            }),
            None
        );
        assert_eq!(
            dispatched,
            ["Tab into lazy content", "Enter", "Shift+Tab", "new input"]
        );
        assert!(events.is_empty());
    }

    #[test]
    fn keyboard_barrier_preserves_order_until_a_subsequent_layout_finishes() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::focus::{FocusManager, bind_focus_owner};

        let mut owner = FocusOwner::new();
        let mut events = VecDeque::from(["close popup", "Enter", "Tab"]);
        let mut delivered = Vec::new();
        assert_eq!(
            drain_pending_focused_input(&mut events, |event| {
                delivered.push(event);
                {
                    let _binding = bind_focus_owner(&mut owner);
                    FocusManager::current().defer_keyboard_until_layout();
                }
                (None, owner.keyboard_is_deferred())
            }),
            None
        );
        assert_eq!(delivered, ["close popup"]);
        assert_eq!(events, ["Enter", "Tab"]);
        owner.finish_layout();
        assert!(
            owner.keyboard_is_deferred(),
            "the old layout cannot release the barrier"
        );
        owner.begin_layout();
        assert!(
            owner.keyboard_is_deferred(),
            "focus callbacks still have to finish"
        );
        {
            let _binding = bind_focus_owner(&mut owner);
            FocusManager::current().defer_keyboard_until_layout();
        }
        owner.finish_layout();
        assert!(
            owner.keyboard_is_deferred(),
            "a new transition survives the old layout callback"
        );
        owner.begin_layout();
        owner.finish_layout();
        assert!(!owner.keyboard_is_deferred());
        events.push_back("new input");
        drain_pending_focused_input(&mut events, |event| {
            delivered.push(event);
            (None, owner.keyboard_is_deferred())
        });
        assert_eq!(delivered, ["close popup", "Enter", "Tab", "new input"]);
        assert!(events.is_empty());
    }

    #[test]
    fn recomposition_retains_deferred_input_but_runtime_reset_discards_it() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::focus::{FocusManager, bind_focus_owner};

        let mut tree = ComponentTree::new();
        {
            let _binding = bind_focus_owner(&mut tree.focus_owner);
            FocusManager::current().defer_keyboard_until_layout();
            assert!(FocusManager::current().request_move_focus(FocusDirection::Previous));
            assert!(FocusManager::current().request_move_focus(FocusDirection::Next));
        }
        assert_eq!(
            tree.focus_owner.take_pending_navigation(),
            Some(FocusDirection::Next)
        );
        tree.focus_owner
            .retain_navigation_retry(Some(FocusDirection::Next));
        let mut ime = crate::ime_state::ImeState::default();
        ime.push_event_for(None, winit::event::Ime::Commit("pending text".into()));
        tree.queue_focused_input(Vec::new(), ime.take_events());
        clipboard::request_clipboard_action(
            crate::clipboard::ClipboardAction::Paste("pending paste".into()),
            |_| panic!("reset clipboard request must not execute"),
        );
        tree.pending_focused_input.extend(
            clipboard::take_requests()
                .into_iter()
                .map(QueuedFocusedInput::Clipboard),
        );
        tree.clear();
        assert_eq!(tree.pending_focused_input.len(), 2);
        assert!(tree.focus_owner.has_pending_navigation());
        assert!(tree.focus_owner.keyboard_is_deferred());
        assert!(matches!(
            tree.pending_focused_input.front(),
            Some(QueuedFocusedInput::Ime(QueuedInput { event: (None, winit::event::Ime::Commit(text)), .. })) if text == "pending text"
        ));
        tree.focus_owner.set_owner_focused(false);
        assert!(!tree.focus_owner.has_pending_navigation());
        {
            let _binding = bind_focus_owner(&mut tree.focus_owner);
            assert!(!FocusManager::current().request_move_focus(FocusDirection::Previous));
        }
        tree.focus_owner.set_owner_focused(true);
        {
            let _binding = bind_focus_owner(&mut tree.focus_owner);
            assert!(FocusManager::current().request_move_focus(FocusDirection::Previous));
        }
        tree.reset();
        assert!(!tree.focus_owner.has_pending_navigation());
        assert!(!tree.focus_owner.keyboard_is_deferred());
        assert!(tree.pending_focused_input.is_empty());
    }

    #[test]
    fn ime_commit_is_delivered_once_to_its_focused_client() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        use crate::focus::{FocusNode, FocusRegistration};

        let delivered = Arc::new(std::sync::Mutex::new(Vec::new()));
        let mut tree = ComponentTree::new();
        let root = tree.add_node(node("root", 1, 1));
        for index in 0..2 {
            let mut input = node("input", index + 2, index + 2);
            input.interaction_mut().focus_registration =
                Some(FocusRegistration::target(FocusNode::new()));
            let keys = Arc::clone(&delivered);
            input
                .interaction_mut()
                .keyboard_handlers
                .push(Box::new(move |input| {
                    for _ in input.keyboard_events.drain(..) {
                        keys.lock().unwrap().push((index, "key".into()));
                    }
                }));
            let delivered = Arc::clone(&delivered);
            input
                .interaction_mut()
                .ime_handlers
                .push(Box::new(move |input| {
                    for event in input.ime_events.drain(..) {
                        if let winit::event::Ime::Commit(text) = event {
                            delivered.lock().unwrap().push((index, text));
                        }
                    }
                }));
            tree.add_node(input);
            if index == 1 {
                let mut content = node("content", 10, 10);
                content
                    .interaction_mut()
                    .pointer_handlers
                    .push(Box::new(|mut input| {
                        input
                            .ime_session()
                            .show(ImeRequest::new(PxSize::new(Px(1), Px(1))));
                    }));
                tree.add_node(content);
                tree.pop_node();
            }
            tree.pop_node();
        }
        tree.pop_node();
        for id in root.descendants(&tree.tree) {
            let metadata = tree.metadatas.get_mut(&id).unwrap();
            metadata.base_abs_position = Some(PxPosition::ZERO);
            metadata.abs_position = Some(PxPosition::ZERO);
            metadata.computed_data = Some(ComputedData {
                width: Px(100),
                height: Px(40),
            });
        }
        tree.focus_owner.sync_from_component_tree(root, &tree.tree);
        assert!(tree.focus_owner.move_focus(FocusDirection::Next));
        let stale_client = tree.focus_owner.active_handle_id();
        assert!(tree.focus_owner.move_focus(FocusDirection::Next));
        let requests = tree.dispatch_pointer_input(
            root,
            &mut [],
            &mut Some(PxPosition::new(Px(5), Px(5))),
            winit::keyboard::ModifiersState::empty(),
        );
        let request = requests.ime_request.unwrap();
        assert_eq!(request.client_id, tree.focus_owner.active_handle_id());
        assert!(request.show_keyboard);
        let mut events = vec![
            (stale_client, winit::event::Ime::Commit("stale text".into())),
            (
                tree.focus_owner.active_handle_id(),
                winit::event::Ime::Commit("composed text".into()),
            ),
        ];
        let mut requests = WindowRequests::default();
        tree.dispatch_ime_input(root, &mut events, &mut requests);
        tree.dispatch_ime_input(root, &mut events, &mut requests);
        assert_eq!(*delivered.lock().unwrap(), [(1, "composed text".into())]);
        let mut ime = crate::ime_state::ImeState::default();
        let mut keyboard = crate::keyboard_state::KeyboardState::default();
        ime.push_event_for(None, winit::event::Ime::Commit("before".into()));
        keyboard.push_event(crate::KeyboardEvent::named(
            winit::keyboard::NamedKey::Backspace,
            winit::event::ElementState::Pressed,
        ));
        ime.push_event_for(None, winit::event::Ime::Commit("after".into()));
        tree.flush_focused_input(
            &mut crate::cursor::CursorState::default(),
            winit::keyboard::ModifiersState::empty(),
            keyboard.take_events(),
            ime.take_events(),
        );
        assert_eq!(
            &delivered.lock().unwrap()[1..],
            [(1, "before".into()), (1, "key".into()), (1, "after".into())]
        );
        let inputs: Vec<_> = root.children(&tree.tree).collect();
        tree.tree
            .get_mut(inputs[0])
            .unwrap()
            .get_mut()
            .interaction_mut()
            .ime_handlers = vec![Box::new(|mut input| {
            assert!(crate::FocusManager::current().move_focus(FocusDirection::Next));
            input
                .ime_session()
                .update(ImeRequest::new(PxSize::new(Px(1), Px(1))));
            input.block_ime();
        })];
        tree.tree
            .get_mut(inputs[1])
            .unwrap()
            .get_mut()
            .interaction_mut()
            .ime_handlers
            .push(Box::new(|mut input| {
                input
                    .ime_session()
                    .update(ImeRequest::new(PxSize::new(Px(1), Px(1))));
            }));
        assert!(tree.focus_owner.move_focus(FocusDirection::Previous));
        events.push((
            tree.focus_owner.active_handle_id(),
            winit::event::Ime::Commit("switch".into()),
        ));
        tree.dispatch_ime_input(root, &mut events, &mut requests);
        assert!(requests.ime_request.is_none());
        events.push((
            tree.focus_owner.active_handle_id(),
            winit::event::Ime::Commit("next text".into()),
        ));
        tree.dispatch_ime_input(root, &mut events, &mut requests);
        assert_eq!(
            requests.ime_request.unwrap().client_id,
            tree.focus_owner.active_handle_id()
        );
        assert_eq!(
            delivered.lock().unwrap().last(),
            Some(&(1, "next text".into()))
        );
        requests = WindowRequests::default();
        tree.dispatch_ime_input(root, &mut events, &mut requests);
        assert_eq!(
            requests.ime_request.unwrap().client_id,
            tree.focus_owner.active_handle_id()
        );
        for (source, expected) in [
            (stale_client, winit::event::ImeChangeCause::Other),
            (
                tree.focus_owner.active_handle_id(),
                winit::event::ImeChangeCause::InputMethod,
            ),
        ] {
            let mut ime = crate::ime_state::ImeState::default();
            ime.push_event_for(source, winit::event::Ime::Commit("source".into()));
            let requests = tree.flush_focused_input(
                &mut crate::cursor::CursorState::default(),
                winit::keyboard::ModifiersState::empty(),
                Vec::new(),
                ime.take_events(),
            );
            assert_eq!(requests.ime_request.unwrap().change_cause, expected);
        }
        tree.tree
            .get_mut(inputs[0])
            .unwrap()
            .get_mut()
            .interaction_mut()
            .ime_handlers = vec![Box::new(|mut input| {
            input
                .ime_session()
                .update(ImeRequest::new(PxSize::new(Px(1), Px(1))));
        })];
        tree.tree
            .get_mut(root)
            .unwrap()
            .get_mut()
            .interaction_mut()
            .ime_preview_handlers = vec![Box::new(|_| {
            assert!(crate::FocusManager::current().move_focus(FocusDirection::Next));
        })];
        assert!(tree.focus_owner.move_focus(FocusDirection::Previous));
        requests = WindowRequests::default();
        tree.dispatch_ime_input(root, &mut events, &mut requests);
        assert!(requests.ime_request.is_none());
    }

    #[test]
    fn begin_replace_subtree_rejects_root_instance_key() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let mut tree = ComponentTree::new();

        let root = tree.add_node(node("root", 1, 1));
        tree.pop_node();

        let result = tree.begin_replace_subtree_by_instance_key(1);
        assert!(matches!(
            result,
            Err(ReplayReplaceError::RootNodeNotReplaceable)
        ));
        assert!(tree.get(root).is_some());
    }

    #[test]
    fn finish_replace_subtree_keeps_inserted_roots_before_next_sibling() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let mut tree = ComponentTree::new();

        let root = tree.add_node(node("root", 1, 1));

        let _first = tree.add_node(node("first", 2, 2));
        let _first_child = tree.add_node(node("first_child", 3, 3));
        tree.pop_node();
        tree.pop_node();

        let second = tree.add_node(node("second", 4, 4));

        let context = match tree.begin_replace_subtree_by_instance_key(2) {
            Ok(context) => context,
            Err(_) => panic!("replace context should be created"),
        };

        let new_a = tree.add_node(node("new_a", 2, 5));
        let _new_a_child = tree.add_node(node("new_a_child", 60, 6));
        tree.pop_node();
        tree.pop_node();
        let new_b = tree.add_node(node("new_b", 70, 7));
        tree.pop_node();

        let mut replace_result = ReplayReplaceResult::default();
        assert!(
            tree.finish_replace_subtree(context, &mut replace_result)
                .is_ok()
        );
        assert_eq!(tree.current_build_node_id(), Some(second));
        tree.pop_node();
        tree.pop_node();
        tree.finish_replay_round();

        let root_children = root.children(tree.tree()).collect::<Vec<_>>();
        assert_eq!(root_children, vec![new_a, new_b, second]);
        #[cfg(feature = "profiling")]
        assert_eq!(tree.get(root).unwrap().subtree_len, 5);

        assert!(replace_result.removed_instance_keys.contains(&2));
        assert!(replace_result.removed_instance_keys.contains(&3));
        assert_eq!(
            replace_result.executed_keys().collect::<HashSet<_>>(),
            [5, 6, 7].into_iter().collect()
        );
        assert_eq!(
            replace_result.removed_instance_logic_ids,
            [3].into_iter().collect()
        );
        assert_eq!(
            replace_result
                .recomposed_logic_ids()
                .collect::<HashSet<_>>(),
            [2, 60, 70].into_iter().collect()
        );

        assert!(tree.get(second).is_some());
    }

    #[test]
    fn finish_replace_subtree_keeps_reused_subtree_and_excludes_it_from_removed_sets() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let mut tree = ComponentTree::new();

        let root = tree.add_node(node("root", 1, 1));

        let _first = tree.add_node(node("first", 2, 2));
        let _first_child = tree.add_node(node("first_child", 3, 3));
        tree.pop_node();
        tree.pop_node();

        let second = tree.add_node(node("second", 4, 4));
        tree.pop_node();
        tree.pop_node();

        let context = match tree.begin_replace_subtree_by_instance_key(2) {
            Ok(context) => context,
            Err(_) => panic!("replace context should be created"),
        };

        assert_eq!(tree.attach_retained_subtree(2, 2), Some(_first));
        tree.pop_node();

        let mut replace_result = ReplayReplaceResult::default();
        assert!(
            tree.finish_replace_subtree(context, &mut replace_result)
                .is_ok()
        );
        tree.finish_replay_round();

        let root_children = root
            .children(tree.tree())
            .map(|id| tree.get(id).expect("child must exist").fn_name)
            .collect::<Vec<_>>();
        assert_eq!(root_children, vec!["first", "second"]);
        #[cfg(feature = "profiling")]
        assert_eq!(tree.get(root).unwrap().subtree_len, 4);
        assert!(tree.find_node_id_by_instance_key(3).is_some());
        assert!(tree.get(second).is_some());

        assert_eq!(replace_result.executed_keys().next(), None);
        assert_eq!(tree.find_node_id_by_instance_key(3), Some(_first_child));
        assert_eq!(replace_result.recomposed_logic_ids().next(), None);
        assert!(tree.removed_frame_nodes.is_empty());
        assert!(!replace_result.removed_instance_keys.contains(&2));
        assert!(!replace_result.removed_instance_keys.contains(&3));
        assert!(!replace_result.removed_instance_logic_ids.contains(&2));
        assert!(!replace_result.removed_instance_logic_ids.contains(&3));

        let Ok(context) = tree.begin_replace_subtree_by_instance_key(4) else {
            panic!("second replace context should be created");
        };
        tree.add_node(node("new_second", 5, 5));
        tree.pop_node();
        assert!(
            tree.finish_replace_subtree(context, &mut replace_result)
                .is_ok()
        );
        assert!(replace_result.executed_keys().eq([5]));
        assert!(replace_result.recomposed_logic_ids().eq([5]));
        assert_eq!(
            replace_result.removed_instance_keys,
            [4].into_iter().collect()
        );
    }

    #[test]
    fn replay_preserves_nested_layout_adjacency_and_ancestor_counts() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let mut tree = ComponentTree::new();
        let root = tree.add_node(node_with_role("root", NodeRole::Composition, 1, 1));
        let outer = tree.add_node(node("outer", 2, 2));
        let inner = tree.add_node(node("inner", 3, 3));
        tree.add_node(node_with_role("wrapper", NodeRole::Composition, 4, 4));
        let leaf = tree.add_node(node("leaf", 5, 5));
        for _ in 0..5 {
            tree.pop_node();
        }
        for add_extra in [true, false] {
            let context = tree
                .begin_replace_subtree_by_instance_key(4)
                .unwrap_or_else(|_| panic!("wrapper exists"));
            let wrapper = tree.add_node(node_with_role("wrapper", NodeRole::Composition, 4, 4));
            assert_eq!(tree.attach_retained_subtree(5, 5), Some(leaf));
            tree.pop_node();
            let extra = add_extra.then(|| {
                let extra = tree.add_node(node("extra", 6, 6));
                tree.pop_node();
                extra
            });
            tree.pop_node();
            assert!(
                tree.finish_replace_subtree(context, &mut ReplayReplaceResult::default())
                    .is_ok()
            );
            tree.finish_replay_round();
            assert_eq!(direct_layout_children(root, &tree.tree).as_ref(), &[outer]);
            assert_eq!(direct_layout_children(outer, &tree.tree).as_ref(), &[inner]);
            let expected = extra.map_or_else(|| vec![leaf], |extra| vec![leaf, extra]);
            let actual = direct_layout_children(inner, &tree.tree);
            assert_eq!(actual.as_ref(), expected.as_slice());
            let wrapped = direct_layout_children(wrapper, &tree.tree);
            match (extra, actual, wrapped) {
                (Some(_), node::LayoutChildren::Shared(a), node::LayoutChildren::Shared(b)) => {
                    assert!(Arc::ptr_eq(&a, &b));
                }
                (None, node::LayoutChildren::One(a), node::LayoutChildren::One(b)) => {
                    assert_eq!((a, b), (leaf, leaf));
                }
                _ => panic!("layout adjacency must store a singleton inline and share wider lists"),
            }
            #[cfg(feature = "profiling")]
            for (id, base) in [(root, 5), (outer, 4), (inner, 3), (wrapper, 2)] {
                assert_eq!(
                    tree.get(id).unwrap().subtree_len,
                    base + usize::from(add_extra)
                );
            }
        }
    }

    #[test]
    fn layout_adjacency_tracks_transparent_subtree_replacement() {
        let _runtime_session = crate::RuntimeSession::new();
        let _runtime_scope = _runtime_session.enter();
        let mut tree = ComponentTree::new();

        let root = tree.add_node(node_with_role("root", NodeRole::Composition, 1, 1));
        let layout_a = tree.add_node(node("layout_a", 2, 2));
        let size = ComputedData {
            width: Px(31),
            height: Px(17),
        };
        tree.metadatas.entry_or_default(layout_a).computed_data = Some(size);
        tree.pop_node();

        let composition = tree.add_node(node_with_role("wrapper", NodeRole::Composition, 3, 3));
        let layout_b = tree.add_node(node("layout_b", 4, 4));
        tree.pop_node();
        tree.pop_node();
        tree.pop_node();

        assert_eq!(composition.children(tree.tree()).count(), 1);
        assert_eq!(
            direct_layout_children(root, tree.tree()).as_ref(),
            &[layout_a, layout_b]
        );

        let context = tree
            .begin_replace_subtree_by_instance_key(3)
            .unwrap_or_else(|_| panic!("wrapper exists"));
        tree.add_node(node_with_role("replacement", NodeRole::Composition, 9, 9));
        assert_eq!(tree.attach_retained_subtree(4, 4), Some(layout_b));
        tree.pop_node();
        let layout_c = tree.add_node(node("layout_c", 10, 10));
        tree.pop_node();
        tree.pop_node();
        assert!(
            tree.finish_replace_subtree(context, &mut ReplayReplaceResult::default())
                .is_ok()
        );

        let context = tree
            .begin_replace_subtree_by_instance_key(2)
            .unwrap_or_else(|_| panic!("first layout exists"));
        let layout_a = tree.add_node(node("replaced_layout_a", 2, 2));
        tree.pop_node();
        assert!(
            tree.finish_replace_subtree(context, &mut ReplayReplaceResult::default())
                .is_ok()
        );
        assert_eq!(
            tree.metadatas.get(&layout_a).unwrap().computed_data,
            Some(size)
        );
        tree.finish_replay_round();
        assert_eq!(
            direct_layout_children(root, tree.tree()).as_ref(),
            &[layout_a, layout_b, layout_c]
        );

        let context = tree
            .begin_replace_subtree_by_instance_key(9)
            .unwrap_or_else(|_| panic!("replacement exists"));
        tree.add_node(node_with_role("reordered", NodeRole::Composition, 9, 9));
        for (key, id) in [(10, layout_c), (4, layout_b)] {
            assert_eq!(tree.attach_retained_subtree(key, key), Some(id));
            tree.pop_node();
        }
        tree.pop_node();
        assert!(
            tree.finish_replace_subtree(context, &mut ReplayReplaceResult::default())
                .is_ok()
        );
        tree.finish_replay_round();
        assert_eq!(
            direct_layout_children(root, tree.tree()).as_ref(),
            &[layout_a, layout_c, layout_b]
        );
    }
}

#[cfg(all(test, feature = "testing"))]
#[path = "replay_journal_tests.rs"]
mod replay_journal_tests;