cranpose_ui/

subcompose_layout.rs

use std::{
    cell::{Cell, Ref, RefCell, RefMut},
    rc::Rc,
};

use cranpose_core::{
    ApplierHost, CapturedCompositionContext, Composer, NodeError, NodeId, RuntimeHandle, SlotId,
    SlotTable, SlotsHost, SubcomposeState, collections::map::HashMap,
};
use cranpose_foundation::{
    InvalidationKind, ModifierInvalidation, ModifierInvalidations, NodeCapabilities,
    SemanticsConfiguration, lazy::LazyItemRoots,
};
pub use cranpose_ui_layout::{Constraints, MeasureResult, Placement};
use smallvec::SmallVec;
use web_time::Instant;

use crate::{
    layout::MeasuredNode,
    modifier::{Modifier, ModifierChainHandle, ModifierNodeSlices, Point, ResolvedModifiers, Size},
    render_state::AppContext,
    widgets::nodes::{ChildPlacement, LayoutNode, LayoutParts, LayoutState, NodeCache},
};

mod measure_scratch;
mod retained_measure_scope;
mod subcompose_child;

pub(crate) use measure_scratch::MeasureScratch;
pub(crate) use retained_measure_scope::RetainedMeasureScope;
pub(crate) use subcompose_child::SubcomposeChild;

fn subcompose_telemetry_enabled() -> bool {
    cranpose_core::DIAGNOSTICS.subcompose_telemetry.is_set()
}

pub(crate) enum RetainedSlotChildren {
    Clean,
    Remeasure {
        children: Vec<SubcomposeChild>,
        children_match: bool,
    },
}

pub(crate) type SubcomposePlaceable = cranpose_ui_layout::Placeable;

type RetainedMeasureLookup<'a> = Box<dyn FnMut(NodeId) -> Option<Rc<MeasuredNode>> + 'a>;

// The children a pass that composes measured, by node.
pub(crate) type MeasuredChildren = RefCell<HashMap<NodeId, Rc<MeasuredNode>>>;

// A measure scope that lays out lazy items' roots with their measurements:
// the scope of a pass that composes, and of one that keeps the slots of the
// last pass.
pub(crate) trait PlacedRootsScope: cranpose_ui_layout::MeasureScope {
    // How many slots wait in the reuse pools.
    fn reusable_slots_count(&self) -> usize;

    // The buffers the pass lays out into.
    fn scratch(&mut self) -> &mut MeasureScratch;

    // Like `SubcomposeMeasureScopeImpl::layout_with_placement_builder`, for a
    // policy that places lazy items: `build` pushes the placements of the
    // items' roots, in order, and the items' roots, whose measurements the
    // pass places the roots with instead of looking them up.
    fn layout_with_placed_roots(
        &mut self,
        width: f32,
        height: f32,
        build: impl FnOnce(&mut Vec<Placement>, &mut Vec<Rc<LazyItemRoots>>),
    ) -> MeasureResult {
        self.scratch()
            .layout_with_placed_roots(width, height, build)
    }
}

pub(crate) struct MeasureCallbacks<'a> {
    pub(crate) measurer: Box<dyn FnMut(NodeId, Constraints) -> SubcomposePlaceable + 'a>,
    pub(crate) retained_measure_lookup: RetainedMeasureLookup<'a>,
    pub(crate) error: &'a RefCell<Option<NodeError>>,
}

/// Base trait for measurement scopes.
pub trait SubcomposeLayoutScope: cranpose_ui_layout::MeasureScope {
    /// Returns the constraints that the parent passed to this layout.
    fn constraints(&self) -> Constraints;

    /// Builds a measure result of size `width` by `height`, in logical pixels, with the given
    /// `placements`.
    fn layout<I>(&mut self, width: f32, height: f32, placements: I) -> MeasureResult
    where
        I: IntoIterator<Item = Placement>,
    {
        MeasureResult::new(Size { width, height }, placements.into_iter().collect())
    }
}

/// Public trait exposed to measure policies for subcomposition.
pub trait SubcomposeMeasureScope: SubcomposeLayoutScope {
    /// Composes `content` into the slot, or reuses the retained composition
    /// when it is provably current.
    ///
    /// `key` must carry every value that flows into `content` from the
    /// measure policy itself rather than from reactive state — a scaffold's
    /// computed padding, a box's constraints. Such values never invalidate a
    /// recompose scope when they change, so an equal key is the caller's
    /// promise that the retained composition is not stale on that channel.
    /// Values read from reactive state inside `content` need no key entry:
    /// their writes invalidate the slot's scopes and block reuse. Content
    /// must not read a non-reactive container (`Cell`, `RefCell`) for a value
    /// that changes between measure passes unless that value is part of
    /// `key`; debug builds recompose skipped slots and panic when the
    /// retained topology diverges from a fresh composition.
    fn subcompose<K, Content>(
        &mut self,
        slot_id: SlotId,
        key: K,
        content: Content,
    ) -> Vec<SubcomposeChild>
    where
        K: PartialEq + 'static,
        Content: FnMut() + 'static;

    /// Measures a subcomposed child with the given constraints.
    fn measure(&mut self, child: SubcomposeChild, constraints: Constraints) -> SubcomposePlaceable;

    /// Checks if a node has no parent (is a root node).
    /// Used to filter subcompose results to only include true root nodes.
    fn node_has_no_parent(&self, node_id: NodeId) -> bool;
}

/// Concrete implementation of [`SubcomposeMeasureScope`].
pub struct SubcomposeMeasureScopeImpl<'a> {
    composer: Composer,
    density_scope: crate::density::DensityMeasureScope,
    state: &'a mut SubcomposeState,
    constraints: Constraints,
    measurer: Box<dyn FnMut(NodeId, Constraints) -> SubcomposePlaceable + 'a>,
    retained_measure_lookup: RetainedMeasureLookup<'a>,
    error: &'a RefCell<Option<NodeError>>,
    parent_handle: SubcomposeLayoutNodeHandle,
    root_id: NodeId,
    scratch: MeasureScratch,
    pending_commands_applied: bool,
    #[cfg(debug_assertions)]
    shadow_stash: Option<(Vec<NodeId>, Vec<NodeId>)>,
}

/// Activates `slot_id`'s retained composition in `state` for this pass and
/// hangs its slot hosts under `root_id`; returns the hosts.
fn activate_slot_hosts<'s>(
    state: &'s mut SubcomposeState,
    composer: &Composer,
    root_id: NodeId,
    slot_id: SlotId,
) -> Option<&'s [NodeId]> {
    let virtual_node_ids = state.activate_current_active_slot(slot_id)?;
    for &virtual_node_id in virtual_node_ids {
        let _ = composer.with_node_mut::<LayoutNode, _>(virtual_node_id, |node| {
            node.set_parent(root_id);
        });
    }
    Some(virtual_node_ids)
}

fn record_clean_slot_skip() {
    crate::thread_state::cells(|cells| {
        cells.clean_slot_skips.set(cells.clean_slot_skips.get() + 1);
    });
}

/// Number of subcompose measure passes on this thread that reused a retained
/// slot without a compose walk. Diagnostic surface for tests and telemetry;
/// see [`SubcomposeMeasureScope::subcompose`] for when a slot may skip.
pub fn clean_slot_skip_count() -> u64 {
    crate::thread_state::cells(|cells| cells.clean_slot_skips.get())
}

/// Number of subcompose measure passes on this thread that kept the slots of
/// their last pass as they were and composed nothing, as a lazy list's pass
/// for a scroll that keeps its items. Diagnostic surface for tests and
/// telemetry.
pub fn retained_measure_count() -> u64 {
    crate::thread_state::cells(|cells| cells.retained_measures.get())
}

struct SubcomposeMeasureScopeInit<'a> {
    composer: Composer,
    density: crate::density::Density,
    state: &'a mut SubcomposeState,
    constraints: Constraints,
    measurer: Box<dyn FnMut(NodeId, Constraints) -> SubcomposePlaceable + 'a>,
    retained_measure_lookup: RetainedMeasureLookup<'a>,
    error: &'a RefCell<Option<NodeError>>,
    parent_handle: SubcomposeLayoutNodeHandle,
    root_id: NodeId,
    scratch: MeasureScratch,
}

impl<'a> SubcomposeMeasureScopeImpl<'a> {
    pub(crate) fn root_id(&self) -> NodeId {
        self.root_id
    }

    fn new(init: SubcomposeMeasureScopeInit<'a>) -> Self {
        Self {
            composer: init.composer,
            density_scope: crate::density::DensityMeasureScope::new(init.density),
            state: init.state,
            constraints: init.constraints,
            measurer: init.measurer,
            retained_measure_lookup: init.retained_measure_lookup,
            error: init.error,
            parent_handle: init.parent_handle,
            root_id: init.root_id,
            scratch: init.scratch,
            pending_commands_applied: false,
            #[cfg(debug_assertions)]
            shadow_stash: None,
        }
    }

    fn into_scratch(self) -> MeasureScratch {
        self.scratch
    }

    pub(crate) fn layout_with_placement_builder(
        &mut self,
        width: f32,
        height: f32,
        build: impl FnOnce(&mut Vec<Placement>),
    ) -> MeasureResult {
        self.scratch.placements.clear();
        self.scratch.placed_roots.clear();
        build(&mut self.scratch.placements);
        MeasureResult::new(
            Size { width, height },
            std::mem::take(&mut self.scratch.placements),
        )
    }

    fn record_error(&self, err: NodeError) {
        let mut slot = self.error.borrow_mut();
        if slot.is_none() {
            log::warn!("[SubcomposeLayout] Error suppressed: {err:?}");
            *slot = Some(err);
        }
    }

    fn owner_chain_deactivation_epoch(&self) -> u64 {
        self.parent_handle
            .inner
            .borrow()
            .captured_context
            .as_ref()
            .map_or(
                0,
                CapturedCompositionContext::owner_chain_deactivation_epoch,
            )
    }

    fn ensure_pending_commands_applied(&mut self) -> bool {
        if self.pending_commands_applied {
            return true;
        }

        let telemetry_start = subcompose_telemetry_enabled().then(Instant::now);
        if let Err(err) = self.composer.apply_pending_commands() {
            self.record_error(err);
            return false;
        }
        if let Some(start) = telemetry_start {
            log::warn!(
                "[subcompose-telemetry] apply_pending_commands_ms={:.2}",
                start.elapsed().as_secs_f64() * 1000.0
            );
        }

        self.pending_commands_applied = true;
        true
    }

    fn perform_subcompose<Content>(&mut self, slot_id: SlotId, content: Content) -> Vec<NodeId>
    where
        Content: FnMut() + 'static,
    {
        let telemetry_start = subcompose_telemetry_enabled().then(Instant::now);
        // A slot's composition reads for itself, not for the measure that
        // asked for it, as Compose subcomposes without read observation.
        let context = crate::render_state::current_app_context();
        let _paused = context
            .as_ref()
            .map(|context| context.measure_reads.paused());
        let mut inner = self.parent_handle.inner.borrow_mut();

        let (virtual_node_id, is_rebound) =
            if let Some((node_id, rebound)) = self.state.take_node_from_reusables(slot_id) {
                (node_id, rebound)
            } else {
                let id = self
                    .composer
                    .create_virtual_node(Box::new(LayoutNode::new_virtual()));
                inner.children.push(id);
                (id, false)
            };

        drop(inner);

        let children = self.compose_into_slot(slot_id, virtual_node_id, content);
        if is_rebound {
            self.composer.record_rebound_slot_children(&children);
        }
        if let Some(start) = telemetry_start {
            log::warn!(
                "[subcompose-telemetry] slot={} reused={} children={} subcompose_ms={:.2}",
                slot_id.raw(),
                is_rebound,
                children.len(),
                start.elapsed().as_secs_f64() * 1000.0
            );
        }
        children
    }

    fn compose_into_slot<Content>(
        &mut self,
        slot_id: SlotId,
        virtual_node_id: NodeId,
        content: Content,
    ) -> Vec<NodeId>
    where
        Content: FnMut() + 'static,
    {
        let content_holder = self.state.callback_holder(slot_id);
        content_holder.update(content);

        let _ = self
            .composer
            .with_node_mut::<LayoutNode, _>(virtual_node_id, |node| {
                node.set_parent(self.root_id);
            });

        let slot_host = self.state.get_or_create_slots(slot_id);
        self.parent_handle.note_slot_host(&slot_host);
        let locals_stale = self.state.slot_locals_stale(slot_id);
        let scopes = self
            .composer
            .with_locals_changed(locals_stale, |composer| {
                composer.subcompose_slot(&slot_host, Some(virtual_node_id), move |_| {
                    compose_subcompose_slot_content(content_holder);
                })
            })
            .map(|((), scopes)| scopes)
            .unwrap_or_default();
        self.pending_commands_applied = false;

        let owner_epoch = self.owner_chain_deactivation_epoch();
        self.state
            .register_active(slot_id, &[virtual_node_id], &scopes);
        self.state.mark_slot_composed_current(slot_id, owner_epoch);

        self.composer.get_node_children(virtual_node_id).to_vec()
    }

    /// Whether `slot_id`'s retained composition is clean and its nodes are
    /// in place, so the pass may keep it without composing it.
    fn clean_slot_ready(&mut self, slot_id: SlotId) -> bool {
        !self.state.has_pending_precompositions(slot_id)
            && self
                .state
                .slot_content_generation_current(slot_id, self.owner_chain_deactivation_epoch())
            && self.ensure_pending_commands_applied()
    }

    /// Keeps `slot_id`'s composition for this pass as
    /// [`SubcomposeMeasureScope::subcompose`] does with a clean slot of
    /// `key`, without collecting its children. False when the slot needs a
    /// compose, which `subcompose` runs.
    pub(crate) fn keep_clean_retained_slot<K: PartialEq + 'static>(
        &mut self,
        slot_id: SlotId,
        key: &K,
    ) -> bool {
        let kept = self.state.retained_capture_key_matches(slot_id, key)
            && self.clean_slot_ready(slot_id)
            && activate_slot_hosts(&mut *self.state, &self.composer, self.root_id, slot_id)
                .is_some();
        if kept {
            record_clean_slot_skip();
        }
        kept
    }

    fn activate_clean_retained_slot(&mut self, slot_id: SlotId) -> Option<Vec<NodeId>> {
        if !self.clean_slot_ready(slot_id) {
            return None;
        }
        let virtual_node_ids =
            activate_slot_hosts(&mut *self.state, &self.composer, self.root_id, slot_id)?;

        let mut children = Vec::new();
        for virtual_node_id in virtual_node_ids {
            children.extend(self.composer.get_node_children(*virtual_node_id));
        }
        record_clean_slot_skip();

        #[cfg(debug_assertions)]
        {
            self.shadow_stash = Some((virtual_node_ids.to_vec(), children.clone()));
        }

        Some(children)
    }

    #[cfg(debug_assertions)]
    fn shadow_verify_clean_slot<Content>(&mut self, slot_id: SlotId, content: Content)
    where
        Content: FnMut() + 'static,
    {
        let Some((virtual_node_ids, skipped_children)) = self.shadow_stash.take() else {
            return;
        };
        if virtual_node_ids.len() != 1 {
            return;
        }
        let composed = self.compose_into_slot(slot_id, virtual_node_ids[0], content);
        assert!(
            composed == skipped_children,
            "clean-slot skip diverged for slot {slot_id:?}: recomposing produced root \
             children {composed:?} but the retained slot held {skipped_children:?}. The slot content \
             read a value that changed between measure passes without any \
             invalidation path — make that value reactive state, or part of \
             the subcompose capture key",
        );
    }

    pub(crate) fn activate_exact_retained_slot_with_known_children(
        &mut self,
        slot_id: SlotId,
        known_children: &[NodeId],
    ) -> Option<RetainedSlotChildren> {
        if !self.ensure_pending_commands_applied() {
            return None;
        }

        let activation = self.state.activate_exact_slot(slot_id)?;
        for &virtual_node_id in activation.nodes {
            if activation.was_recycled {
                let _ = self
                    .composer
                    .with_node_mut::<LayoutNode, _>(virtual_node_id, |node| {
                        node.set_parent(self.root_id);
                    });
            }
        }

        let mut expected = known_children.iter().copied();
        let mut children_match = true;
        let mut needs_relayout = false;
        for &virtual_node_id in activation.nodes {
            self.composer
                .visit_node_children(virtual_node_id, |child, child_needs_relayout| {
                    children_match &= expected.next() == Some(child);
                    needs_relayout |= child_needs_relayout;
                });
        }
        children_match &= expected.next().is_none();
        if children_match && !needs_relayout {
            return Some(RetainedSlotChildren::Clean);
        }

        let mut children = Vec::with_capacity(known_children.len());
        for &virtual_node_id in activation.nodes {
            children.extend(
                self.composer
                    .get_node_children(virtual_node_id)
                    .into_iter()
                    .map(SubcomposeChild::new),
            );
        }
        Some(RetainedSlotChildren::Remeasure {
            children,
            children_match,
        })
    }
}

impl SubcomposeLayoutScope for SubcomposeMeasureScopeImpl<'_> {
    fn constraints(&self) -> Constraints {
        self.constraints
    }

    fn layout<I>(&mut self, width: f32, height: f32, placements: I) -> MeasureResult
    where
        I: IntoIterator<Item = Placement>,
    {
        self.layout_with_placement_builder(width, height, |scratch| {
            scratch.extend(placements);
        })
    }
}

impl cranpose_ui_layout::MeasureScope for SubcomposeMeasureScopeImpl<'_> {
    fn density(&self) -> f32 {
        self.density_scope.density()
    }

    fn font_scale(&self) -> f32 {
        self.density_scope.font_scale()
    }
}

impl PlacedRootsScope for SubcomposeMeasureScopeImpl<'_> {
    fn reusable_slots_count(&self) -> usize {
        self.state.reusable_slots_count()
    }

    fn scratch(&mut self) -> &mut MeasureScratch {
        &mut self.scratch
    }
}

impl SubcomposeMeasureScope for SubcomposeMeasureScopeImpl<'_> {
    fn subcompose<K, Content>(
        &mut self,
        slot_id: SlotId,
        key: K,
        content: Content,
    ) -> Vec<SubcomposeChild>
    where
        K: PartialEq + 'static,
        Content: FnMut() + 'static,
    {
        if self.state.retained_capture_key_matches(slot_id, &key)
            && let Some(children) = self.activate_clean_retained_slot(slot_id)
        {
            #[cfg(debug_assertions)]
            self.shadow_verify_clean_slot(slot_id, content);
            return children.into_iter().map(SubcomposeChild::new).collect();
        }
        self.state.store_retained_capture_key(slot_id, key);
        let nodes = self.perform_subcompose(slot_id, content);
        nodes.into_iter().map(SubcomposeChild::new).collect()
    }

    fn measure(&mut self, child: SubcomposeChild, constraints: Constraints) -> SubcomposePlaceable {
        if self.error.borrow().is_some() {
            return SubcomposePlaceable::value(0.0, 0.0, child.node_id());
        }

        let telemetry_start = subcompose_telemetry_enabled().then(Instant::now);
        if !self.ensure_pending_commands_applied() {
            return SubcomposePlaceable::value(0.0, 0.0, child.node_id());
        }

        let placeable = (self.measurer)(child.node_id(), constraints);
        if let Some(start) = telemetry_start {
            log::warn!(
                "[subcompose-telemetry] child={} measure_ms={:.2} size=({:.2},{:.2})",
                child.node_id(),
                start.elapsed().as_secs_f64() * 1000.0,
                placeable.width(),
                placeable.height()
            );
        }
        placeable
    }

    fn node_has_no_parent(&self, node_id: NodeId) -> bool {
        self.composer.node_has_no_parent(node_id)
    }
}

impl SubcomposeMeasureScopeImpl<'_> {
    /// Returns the number of active slots in the subcompose state.
    ///
    /// Used by lazy layouts to report statistics about slot usage.
    pub fn active_slots_count(&self) -> usize {
        self.state.active_slots_count()
    }

    /// Returns the number of reusable slots in the pool.
    ///
    /// Used by lazy layouts to report statistics about cached slots.
    pub fn reusable_slots_count(&self) -> usize {
        self.state.reusable_slots_count()
    }

    /// Whether `slot_id` still has a composition: active or in the reuse pool.
    pub(crate) fn slot_is_retained(&self, slot_id: SlotId) -> bool {
        self.state.slot_is_retained(slot_id)
    }

    pub(crate) fn slot_is_active(&self, slot_id: SlotId) -> bool {
        self.state.slot_is_active(slot_id)
    }

    /// Registers the content type for a slot.
    ///
    /// Call this before `subcompose()` to enable content-type-aware slot reuse.
    /// If the policy supports content types (like `ContentTypeReusePolicy`),
    /// slots with matching content types can reuse each other's nodes.
    pub fn register_content_type(&mut self, slot_id: SlotId, content_type: u64) {
        self.state.register_content_type(slot_id, content_type);
    }

    /// Updates the content type for a slot, handling Some→None transitions.
    ///
    /// If `content_type` is `Some(type)`, registers the type for the slot.
    /// If `content_type` is `None`, removes any previously registered type.
    /// This ensures stale types don't drive incorrect reuse after transitions.
    pub fn update_content_type(&mut self, slot_id: SlotId, content_type: Option<u64>) {
        self.state.update_content_type(slot_id, content_type);
    }

    pub(crate) fn set_reusable_pool_limits(&mut self, per_type: usize, untyped: usize) {
        self.state.set_reusable_pool_limits(per_type, untyped);
    }

    pub(crate) fn focused_slot(&self) -> Option<SlotId> {
        let mut node_id = crate::active_focus_target()?;
        while node_id != self.root_id {
            if let Some(slot) = self.state.active_slot_for_node(node_id) {
                return Some(slot);
            }
            node_id = self.composer.node_parent(node_id).ok()??;
        }
        None
    }

    pub(crate) fn recycle_active_slots_where(&mut self, predicate: impl FnMut(SlotId) -> bool) {
        let disposed = self.state.recycle_active_slots_where(predicate);
        if let Err(error) = self.composer.dispose_subcomposed_nodes(disposed) {
            self.record_error(error);
        }
    }

    /// Returns whether the last subcomposed slot was reused.
    ///
    /// Returns `Some(true)` if the slot already existed (was reused from pool or
    /// was recomposed), `Some(false)` if it was newly created, or `None` if no
    /// slot has been subcomposed yet this pass.
    ///
    /// This is useful for tracking composition statistics in lazy layouts.
    pub fn was_last_slot_reused(&self) -> Option<bool> {
        self.state.was_last_slot_reused()
    }

    pub(crate) fn measure_retained(
        &mut self,
        child: SubcomposeChild,
        constraints: Constraints,
    ) -> (SubcomposePlaceable, Option<Rc<MeasuredNode>>) {
        let placeable = self.measure(child, constraints);
        let retained = (self.retained_measure_lookup)(child.node_id());
        (placeable, retained)
    }

    pub(crate) fn children_need_relayout(&mut self, children: &[SubcomposeChild]) -> bool {
        if !self.ensure_pending_commands_applied() {
            return true;
        }

        self.composer
            .nodes_need_relayout(children.iter().map(SubcomposeChild::node_id))
    }
}

fn compose_subcompose_slot_content(holder: cranpose_core::CallbackHolder) {
    cranpose_core::with_current_composer(|composer| {
        let holder_for_recompose = holder.clone();
        composer.set_recompose_callback(move |_composer| {
            compose_subcompose_slot_content(holder_for_recompose.clone());
        });
    });

    let invoke = holder.clone_rc();
    invoke();
}

pub(crate) type MeasurePolicy =
    dyn for<'scope> Fn(&mut SubcomposeMeasureScopeImpl<'scope>, Constraints) -> MeasureResult;

// Measures a subcompose node from the slots its last pass kept, composing
// nothing: `None` where the node needs a composition, which its
// `MeasurePolicy` runs.
pub(crate) type RetainedMeasurePolicy =
    dyn for<'scope> Fn(&mut RetainedMeasureScope<'scope>, Constraints) -> Option<MeasureResult>;

/// Node responsible for orchestrating measure-time subcomposition.
pub struct SubcomposeLayoutNode {
    inner: Rc<RefCell<SubcomposeLayoutNodeInner>>,
    parent: Cell<Option<NodeId>>,
    id: Cell<Option<NodeId>>,
    needs_semantics: Cell<bool>,
    needs_redraw: Cell<bool>,
    needs_pointer_pass: Cell<bool>,
    needs_focus_sync: Cell<bool>,
    parts: Rc<LayoutParts>,
    modifier_slices_snapshot: crate::modifier::SlicesSnapshot,
    modifier_slices_dirty: Cell<bool>,
}

impl SubcomposeLayoutNode {
    /// Creates a node with `modifier` whose children `measure_policy` subcomposes and measures.
    pub fn new(modifier: Modifier, measure_policy: Rc<MeasurePolicy>) -> Self {
        let inner = Rc::new(RefCell::new(SubcomposeLayoutNodeInner::new(measure_policy)));
        let node = Self {
            inner,
            parent: Cell::new(None),
            id: Cell::new(None),
            needs_semantics: Cell::new(true),
            needs_redraw: Cell::new(true),
            needs_pointer_pass: Cell::new(false),
            needs_focus_sync: Cell::new(false),
            parts: Rc::new(LayoutParts::empty()),
            modifier_slices_snapshot: crate::modifier::SlicesSnapshot::default(),
            modifier_slices_dirty: Cell::new(true),
        };
        let (invalidations, _) = node.inner.borrow_mut().set_modifier_collect(modifier);
        node.dispatch_modifier_invalidations(&invalidations, NodeCapabilities::empty());
        node.note_host_to_the_composition_that_made_it();
        node
    }

    fn note_host_to_the_composition_that_made_it(&self) {
        let host = Rc::clone(&self.inner.borrow().slots);
        cranpose_core::note_nested_slots_host(&host);
    }

    /// Creates a SubcomposeLayoutNode with ContentTypeReusePolicy.
    ///
    /// Use this for lazy lists to enable content-type-aware slot reuse.
    /// Slots with matching content types can reuse each other's nodes,
    /// improving efficiency when scrolling through items with different types.
    pub fn with_content_type_policy(modifier: Modifier, measure_policy: Rc<MeasurePolicy>) -> Self {
        let mut inner_data = SubcomposeLayoutNodeInner::new(measure_policy);
        inner_data
            .state
            .set_policy(Box::new(cranpose_core::ContentTypeReusePolicy));
        let inner = Rc::new(RefCell::new(inner_data));
        let node = Self {
            inner,
            parent: Cell::new(None),
            id: Cell::new(None),
            needs_semantics: Cell::new(true),
            needs_redraw: Cell::new(true),
            needs_pointer_pass: Cell::new(false),
            needs_focus_sync: Cell::new(false),
            parts: Rc::new(LayoutParts::empty()),
            modifier_slices_snapshot: crate::modifier::SlicesSnapshot::default(),
            modifier_slices_dirty: Cell::new(true),
        };
        let (invalidations, _) = node.inner.borrow_mut().set_modifier_collect(modifier);
        node.dispatch_modifier_invalidations(&invalidations, NodeCapabilities::empty());
        node.note_host_to_the_composition_that_made_it();
        node
    }

    /// Returns a cloneable handle that shares this node's state.
    pub fn handle(&self) -> SubcomposeLayoutNodeHandle {
        SubcomposeLayoutNodeHandle {
            inner: Rc::clone(&self.inner),
        }
    }

    #[doc(hidden)]
    pub fn debug_scope_ids_by_slot(&self) -> Vec<(u64, Vec<usize>)> {
        self.inner.borrow().state.debug_scope_ids_by_slot()
    }

    #[doc(hidden)]
    pub fn debug_slot_table_for_slot(
        &self,
        slot_id: SlotId,
    ) -> Option<Vec<cranpose_core::SlotDebugEntry>> {
        self.inner.borrow().state.debug_slot_table_for_slot(slot_id)
    }

    #[doc(hidden)]
    pub fn debug_slot_table_groups_for_slot(
        &self,
        slot_id: SlotId,
    ) -> Option<Vec<cranpose_core::subcompose::DebugSlotGroup>> {
        self.inner
            .borrow()
            .state
            .debug_slot_table_groups_for_slot(slot_id)
    }

    /// Replaces the measure policy and invalidates the subcomposition. Does nothing if `policy` is
    /// the same `Rc` as the current one.
    pub fn set_measure_policy(&mut self, policy: Rc<MeasurePolicy>) {
        let mut inner = self.inner.borrow_mut();
        if Rc::ptr_eq(&inner.measure_policy, &policy) {
            return;
        }
        inner.set_measure_policy(policy);
        drop(inner);
        self.invalidate_subcomposition();
    }

    // Gives the node a policy that measures it from the slots of its last
    // pass, which a pass tries before the measure policy. A new measure
    // policy drops it.
    pub(crate) fn set_retained_measure_policy(&mut self, policy: Rc<RetainedMeasurePolicy>) {
        self.inner.borrow_mut().retained_measure_policy = Some(policy);
    }

    /// Records the source composition context for measure-time subcomposition.
    /// A context under a changed static composition local makes every slot
    /// compose again, running every body it holds, as Compose forces a
    /// `SubcomposeLayout`'s children.
    pub fn set_captured_context(&mut self, context: CapturedCompositionContext) {
        let locals_changed = context.locals_changed();
        self.inner.borrow_mut().captured_context = Some(context);
        if locals_changed {
            self.inner.borrow().state.invalidate_locals();
            self.request_measure_recompose();
        }
    }

    /// Records the grid the composition provided, re-measuring if it moved.
    ///
    /// Mirrors [`LayoutNode::set_density`](crate::widgets::nodes::LayoutNode::set_density):
    /// `SubcomposeLayout` captures this at the same composition site that
    /// captures the subcomposition context, so the two cannot disagree.
    pub fn set_density(&mut self, density: crate::density::Density) {
        let mut inner = self.inner.borrow_mut();
        if inner.density != density {
            inner.density = density;
            drop(inner);
            self.modifier_slices_dirty.set(true);
            self.mark_needs_measure();
        }
    }

    /// Updates relative modifier placement for this node's composition scope.
    pub fn set_layout_direction(&mut self, direction: crate::LayoutDirection) {
        let mut inner = self.inner.borrow_mut();
        if inner.modifier_chain.set_layout_direction(direction) {
            drop(inner);
            self.modifier_slices_dirty.set(true);
            self.mark_needs_measure();
        }
    }

    /// The grid the composition provided, which the chain's lengths land on.
    pub(crate) fn density(&self) -> crate::density::Density {
        self.inner.borrow().density
    }

    /// Replaces the modifier chain and invalidates the layout, draw, pointer input and semantics
    /// work that the changed modifier nodes affect.
    pub fn set_modifier(&mut self, modifier: Modifier) {
        let prev_caps = self.modifier_capabilities();
        let (invalidations, modifier_changed) = {
            let mut inner = self.inner.borrow_mut();
            inner.set_modifier_collect(modifier)
        };
        self.dispatch_modifier_invalidations(&invalidations, prev_caps);
        self.modifier_slices_dirty.set(true);
        crate::modal_nodes::reach_changed(self.id.get());
        if modifier_changed {
            self.request_semantics_update();
        }
    }

    fn update_modifier_slices_cache(&self) {
        let inner = self.inner.borrow();
        // No coordinators: the draws sit inside the padding before them.
        self.modifier_slices_snapshot.collect(
            inner.modifier_chain.chain(),
            None,
            inner.density.density(),
        );
        self.modifier_slices_dirty.set(false);
    }

    pub(crate) fn mark_modifier_slices_dirty(&self) {
        self.modifier_slices_dirty.set(true);
    }

    /// Turns debug logging of the modifier chain on or off.
    pub fn set_debug_modifiers(&mut self, enabled: bool) {
        self.inner.borrow_mut().set_debug_modifiers(enabled);
    }

    /// Returns the modifier that was last set on this node.
    pub fn modifier(&self) -> Modifier {
        self.handle().modifier()
    }

    /// Returns the padding, layout properties and offset that the modifier chain resolved to.
    pub fn resolved_modifiers(&self) -> ResolvedModifiers {
        self.inner.borrow().modifier_chain.resolved_modifiers()
    }

    /// What the chain tells the parent's measure policy about this node.
    pub(crate) fn parent_data(&self) -> cranpose_ui_layout::ParentData {
        self.inner.borrow().modifier_chain.parent_data()
    }

    /// Returns a clone of the current layout state.
    pub fn layout_state(&self) -> LayoutState {
        *self.parts.layout_state().borrow()
    }

    pub(crate) fn cache(&self) -> &NodeCache {
        self.parts.cache()
    }

    pub(crate) fn layout_parts(&self) -> &Rc<LayoutParts> {
        &self.parts
    }

    // Updates the position of this node, which `placer` placed. Called
    // during placement. `LayoutState::place` self-reports actual moves to
    // the scene phase.
    pub(crate) fn place(&self, at: ChildPlacement, placer: Option<NodeId>, context: &AppContext) {
        self.parts
            .layout_state()
            .borrow_mut()
            .place_child(at, placer, context);
    }

    /// Updates the measured size of this node. Called during measurement.
    /// [`LayoutState::set_size`] self-reports actual changes to the scene
    /// phase.
    pub fn set_measured_size(&self, size: Size, context: &AppContext) {
        self.parts
            .layout_state()
            .borrow_mut()
            .set_size(size, context);
    }

    /// Clears the is_placed flag. Called at the start of a layout pass.
    pub fn clear_placed(&self, context: &AppContext) {
        self.parts.layout_state().borrow_mut().clear_placed(context);
    }

    /// Semantics reported by this node's live modifier chain.
    pub fn semantics_configuration(&self) -> Option<SemanticsConfiguration> {
        crate::modifier::collect_semantics_from_chain(self.inner.borrow().modifier_chain.chain())
    }

    /// Whether this node's modifiers make it modal or hidden.
    pub fn semantics_reach(&self) -> cranpose_foundation::SemanticsReach {
        crate::modifier::semantics_reach_of_chain(self.inner.borrow().modifier_chain.chain())
    }

    /// Runs `read` with the node's modifier chain.
    pub(crate) fn with_modifier_chain<R>(&self, read: impl FnOnce(&ModifierChainHandle) -> R) -> R {
        read(&self.inner.borrow().modifier_chain)
    }

    /// Returns the modifier slices snapshot for rendering.
    pub fn modifier_slices_snapshot(&self) -> Rc<ModifierNodeSlices> {
        if self.modifier_slices_dirty.get() {
            self.update_modifier_slices_cache();
        }
        self.modifier_slices_snapshot.get()
    }

    /// Borrows the subcomposition state that tracks the slots composed for this node.
    pub fn state(&self) -> Ref<'_, SubcomposeState> {
        Ref::map(self.inner.borrow(), |inner| &inner.state)
    }

    /// Mutably borrows the subcomposition state that tracks the slots composed for this node.
    pub fn state_mut(&self) -> RefMut<'_, SubcomposeState> {
        RefMut::map(self.inner.borrow_mut(), |inner| &mut inner.state)
    }

    /// Invalidates the recompose scopes of all slots and schedules a measure, so the measure policy
    /// subcomposes again.
    pub fn invalidate_subcomposition(&self) {
        self.inner.borrow().state.invalidate_scopes();
        self.mark_needs_measure();
        if let Some(id) = self.id.get() {
            cranpose_core::bubble_measure_dirty_in_composer(id);
        }
    }

    /// Schedules a measure for this node and its ancestors without invalidating the recompose
    /// scopes of its slots.
    pub fn request_measure_recompose(&self) {
        self.mark_needs_measure();
        if let Some(id) = self.id.get() {
            cranpose_core::bubble_measure_dirty_in_composer(id);
        }
    }

    /// Calls `f` with the children this node placed in its last layout, in
    /// placement order, without copying them.
    /// Changes through a node handle during `f` become visible to the next
    /// read; this read keeps its original children.
    pub fn with_active_children<R>(&self, f: impl FnOnce(&[NodeId]) -> R) -> R {
        let children = Rc::clone(&self.inner.borrow().last_placements);
        f(&children)
    }

    /// Mark this node as needing measure. Also marks it as needing layout.
    pub fn mark_needs_measure(&self) {
        self.parts.cache().mark_needs_measure();
    }

    /// Mark this node as needing layout (but not necessarily measure).
    pub fn mark_needs_layout_flag(&self) {
        self.parts.cache().mark_needs_layout();
    }

    /// Mark this node as needing redraw without forcing measure/layout.
    pub fn mark_needs_redraw(&self) {
        self.needs_redraw.set(true);
        if let Some(id) = self.id.get() {
            crate::schedule_draw_repass(id);
        }
        crate::request_render_invalidation();
    }

    /// Check if this node needs measure.
    pub fn needs_measure(&self) -> bool {
        self.parts.cache().dirt().measure
    }

    pub(crate) fn clear_needs_measure(&self) {
        self.parts.cache().clear_needs_measure();
    }

    /// Clears the node's layout flag and its descendants': a layout pass
    /// visited them.
    pub(crate) fn clear_needs_layout(&self) {
        self.parts.cache().clear_layout_dirt();
    }

    /// Mark this node as needing semantics recomputation.
    pub fn mark_needs_semantics(&self) {
        self.needs_semantics.set(true);
        crate::modal_nodes::reach_changed(self.id.get());
    }

    /// The id this node was inserted under, once it is.
    pub(crate) fn id(&self) -> Option<NodeId> {
        self.id.get()
    }

    pub(crate) fn clear_needs_semantics(&self) {
        self.needs_semantics.set(false);
    }

    #[cfg(test)]
    pub(crate) fn clear_needs_semantics_for_tests(&self) {
        self.clear_needs_semantics();
    }

    /// Returns true when this node requested a redraw since the last render pass.
    pub fn needs_redraw(&self) -> bool {
        self.needs_redraw.get()
    }

    /// Clears the pending redraw flag once the node has been drawn.
    pub fn clear_needs_redraw(&self) {
        self.needs_redraw.set(false);
    }

    /// Marks this node as needing a fresh pointer-input pass.
    pub fn mark_needs_pointer_pass(&self) {
        self.needs_pointer_pass.set(true);
    }

    /// Returns true when pointer-input state needs to be recomputed.
    pub fn needs_pointer_pass(&self) -> bool {
        self.needs_pointer_pass.get()
    }

    /// Clears the pointer-input dirty flag after hosts service it.
    pub fn clear_needs_pointer_pass(&self) {
        self.needs_pointer_pass.set(false);
    }

    /// Marks this node as needing a focus synchronization.
    pub fn mark_needs_focus_sync(&self) {
        self.needs_focus_sync.set(true);
    }

    /// Returns true when focus state needs to be synchronized.
    pub fn needs_focus_sync(&self) -> bool {
        self.needs_focus_sync.get()
    }

    /// Clears the focus dirty flag after the focus manager processes it.
    pub fn clear_needs_focus_sync(&self) {
        self.needs_focus_sync.set(false);
    }

    fn request_semantics_update(&self) {
        let already_dirty = self.needs_semantics.replace(true);
        if already_dirty {
            return;
        }

        if let Some(id) = self.id.get() {
            cranpose_core::queue_semantics_invalidation(id);
        }
    }

    /// Returns the modifier capabilities for this node.
    pub fn modifier_capabilities(&self) -> NodeCapabilities {
        self.inner.borrow().modifier_capabilities
    }

    /// Returns whether the modifier chain contains layout modifier nodes.
    pub fn has_layout_modifier_nodes(&self) -> bool {
        self.modifier_capabilities()
            .contains(NodeCapabilities::LAYOUT)
    }

    /// Returns whether the modifier chain contains draw modifier nodes.
    pub fn has_draw_modifier_nodes(&self) -> bool {
        self.modifier_capabilities()
            .contains(NodeCapabilities::DRAW)
    }

    /// Returns whether the modifier chain contains pointer input modifier nodes.
    pub fn has_pointer_input_modifier_nodes(&self) -> bool {
        self.modifier_capabilities()
            .contains(NodeCapabilities::POINTER_INPUT)
    }

    /// Returns whether the modifier chain contains semantics modifier nodes.
    pub fn has_semantics_modifier_nodes(&self) -> bool {
        self.modifier_capabilities()
            .contains(NodeCapabilities::SEMANTICS)
    }

    /// Returns whether the modifier chain contains focus modifier nodes.
    pub fn has_focus_modifier_nodes(&self) -> bool {
        self.modifier_capabilities()
            .contains(NodeCapabilities::FOCUS)
    }

    fn dispatch_modifier_invalidations(
        &self,
        invalidations: &[ModifierInvalidation],
        prev_caps: NodeCapabilities,
    ) {
        let curr_caps = self.modifier_capabilities();
        for invalidation in invalidations {
            self.modifier_slices_dirty.set(true);
            let invalidation_caps = invalidation.capabilities();
            let has_capability = |capability| {
                curr_caps.contains(capability)
                    || prev_caps.contains(capability)
                    || invalidation_caps.contains(capability)
            };
            match invalidation.kind() {
                InvalidationKind::Layout => {
                    if has_capability(NodeCapabilities::LAYOUT) {
                        self.mark_needs_measure();
                    }
                }
                InvalidationKind::Draw => {
                    if has_capability(NodeCapabilities::DRAW) {
                        self.mark_needs_redraw();
                    }
                }
                InvalidationKind::PointerInput => {
                    if has_capability(NodeCapabilities::POINTER_INPUT) {
                        self.mark_needs_pointer_pass();
                        crate::request_pointer_invalidation();
                        if let Some(id) = self.id.get() {
                            crate::schedule_pointer_repass(id);
                        }
                    }
                }
                InvalidationKind::Semantics => {
                    self.request_semantics_update();
                }
                InvalidationKind::Focus => {
                    if has_capability(NodeCapabilities::FOCUS) {
                        self.mark_needs_focus_sync();
                        crate::request_focus_invalidation();
                        if let Some(id) = self.id.get() {
                            crate::schedule_focus_invalidation(id);
                        }
                    }
                }
            }
        }
    }
}

impl cranpose_core::Node for SubcomposeLayoutNode {
    fn mount(&mut self) {
        let mut inner = self.inner.borrow_mut();
        let node_id = inner.node_id;
        inner.modifier_chain.remount(node_id);
        crate::modal_nodes::reach_changed(self.id.get());
    }

    fn unmount(&mut self) {
        let mut inner = self.inner.borrow_mut();
        inner.modifier_chain.chain_mut().detach_nodes();
        if let Some(node_id) = inner.node_id
            && let Some(context) = crate::render_state::current_app_context()
        {
            context.measure_reads.forget(node_id);
        }
    }

    fn insert_child(&mut self, child: NodeId) -> bool {
        let mut inner = self.inner.borrow_mut();
        if inner.children.contains(&child) {
            return false;
        }
        inner.children.push(child);
        true
    }

    fn remove_child(&mut self, child: NodeId) -> bool {
        let mut inner = self.inner.borrow_mut();
        let before = inner.children.len();
        inner.children.retain(|&id| id != child);
        inner.children.len() < before
    }

    fn move_child(&mut self, from: usize, to: usize) {
        let mut inner = self.inner.borrow_mut();
        if from == to || from >= inner.children.len() {
            return;
        }
        let child = inner.children.remove(from);
        let target = to.min(inner.children.len());
        inner.children.insert(target, child);
    }

    fn update_children(&mut self, children: &[NodeId]) {
        let mut inner = self.inner.borrow_mut();
        inner.children.clear();
        inner.children.extend_from_slice(children);
    }

    /// The node adds a slot host when a slot is first composed and drops it
    /// when the slot is disposed; a measure pass, which composes only the
    /// slots it needs, does not list the rest.
    fn keeps_own_children(&self) -> bool {
        true
    }

    fn collect_children_into(&self, out: &mut SmallVec<[NodeId; 8]>) {
        out.clear();
        self.with_active_children(|children| out.extend_from_slice(children));
    }

    fn collect_owned_children_into(&self, out: &mut SmallVec<[NodeId; 8]>) {
        out.clear();
        out.extend_from_slice(&self.inner.borrow().children);
    }

    fn owned_child_index(&self, child: NodeId) -> Option<usize> {
        self.inner
            .borrow()
            .children
            .iter()
            .position(|&id| id == child)
    }

    fn set_node_id(&mut self, id: NodeId) {
        // A redraw asked for before the node had an id went to no draw
        // repass.
        if self.needs_redraw.get() {
            crate::render_state::note_retained_redraw(id);
        }
        self.id.set(Some(id));
        self.parts.layout_state().borrow_mut().set_node_id(id);
        {
            let mut inner = self.inner.borrow_mut();
            let previous = inner.node_id.replace(id);
            inner.modifier_chain.move_to_node_later(previous, Some(id));
        }
        // The slices carry the node's id; they are collected again when next read.
        self.modifier_slices_dirty.set(true);
    }

    fn on_attached_to_parent(&mut self, parent: NodeId) {
        self.parent.set(Some(parent));
    }

    fn on_removed_from_parent(&mut self) {
        self.parent.set(None);
        self.inner.borrow().state.bump_content_generation();
    }

    fn parent(&self) -> Option<NodeId> {
        self.parent.get()
    }

    fn mark_needs_layout(&self) {
        self.parts.cache().mark_needs_layout();
    }

    fn needs_layout(&self) -> bool {
        self.parts.cache().dirt().layout
    }

    fn mark_needs_measure(&self) {
        Self::mark_needs_measure(self);
    }

    fn needs_measure(&self) -> bool {
        Self::needs_measure(self)
    }

    fn mark_descendant_needs_layout(&self, measure: bool) {
        self.parts.cache().mark_descendant_needs_layout(measure);
    }

    fn descendant_needs_layout(&self) -> bool {
        self.parts.cache().dirt().descendant.layout
    }

    fn descendant_needs_measure(&self) -> bool {
        self.parts.cache().dirt().descendant.measure
    }

    fn mark_needs_semantics(&self) {
        self.needs_semantics.set(true);
        crate::modal_nodes::reach_changed(self.id.get());
    }

    /// One flag serves both: the tree merges a subcompose node on every
    /// update, and a descendant's change leaves its reach as it was.
    fn mark_descendant_needs_semantics(&self) {
        self.needs_semantics.set(true);
    }

    fn needs_semantics(&self) -> bool {
        self.needs_semantics.get()
    }

    fn set_parent_for_bubbling(&mut self, parent: NodeId) {
        if self.parent.get().is_none() {
            self.parent.set(Some(parent));
        }
    }
}

#[derive(Clone)]
pub struct SubcomposeLayoutNodeHandle {
    inner: Rc<RefCell<SubcomposeLayoutNodeInner>>,
}

impl SubcomposeLayoutNodeHandle {
    pub(crate) fn note_slot_host(&self, slot_host: &Rc<SlotsHost>) {
        let Ok(inner) = self.inner.try_borrow() else {
            return;
        };
        if Rc::ptr_eq(&inner.slots, slot_host) {
            return;
        }
        inner.slots.note_nested_host(slot_host);
    }

    pub(crate) fn measured_children_scratch(&self) -> Rc<MeasuredChildren> {
        let scratch = {
            let inner = self.inner.borrow();
            Rc::clone(&inner.measured_children_scratch)
        };
        scratch.borrow_mut().clear();
        scratch
    }

    pub fn modifier(&self) -> Modifier {
        self.inner.borrow().modifier.clone()
    }

    pub fn layout_properties(&self) -> crate::modifier::LayoutProperties {
        self.resolved_modifiers().layout_properties()
    }

    pub fn resolved_modifiers(&self) -> ResolvedModifiers {
        self.inner.borrow().modifier_chain.resolved_modifiers()
    }

    pub fn total_offset(&self) -> Point {
        self.resolved_modifiers().offset()
    }

    pub fn modifier_capabilities(&self) -> NodeCapabilities {
        self.inner.borrow().modifier_capabilities
    }

    pub fn has_layout_modifier_nodes(&self) -> bool {
        self.modifier_capabilities()
            .contains(NodeCapabilities::LAYOUT)
    }

    pub fn has_draw_modifier_nodes(&self) -> bool {
        self.modifier_capabilities()
            .contains(NodeCapabilities::DRAW)
    }

    pub fn has_pointer_input_modifier_nodes(&self) -> bool {
        self.modifier_capabilities()
            .contains(NodeCapabilities::POINTER_INPUT)
    }

    pub fn has_semantics_modifier_nodes(&self) -> bool {
        self.modifier_capabilities()
            .contains(NodeCapabilities::SEMANTICS)
    }

    pub fn has_focus_modifier_nodes(&self) -> bool {
        self.modifier_capabilities()
            .contains(NodeCapabilities::FOCUS)
    }

    pub fn set_debug_modifiers(&self, enabled: bool) {
        self.inner.borrow_mut().set_debug_modifiers(enabled);
    }

    // Measures the node with its retained measure policy, from the slots of
    // its last pass: `None` where it has no such policy or the policy needs
    // a composition.
    pub(crate) fn measure_retained(
        &self,
        applier: &dyn ApplierHost,
        node_id: NodeId,
        constraints: Constraints,
    ) -> Option<MeasureResult> {
        let (policy, state, mut scratch, density, owner_epoch) = {
            let mut inner = self.inner.borrow_mut();
            let policy = Rc::clone(inner.retained_measure_policy.as_ref()?);
            let owner_epoch = inner.captured_context.as_ref().map_or(
                0,
                CapturedCompositionContext::owner_chain_deactivation_epoch,
            );
            (
                policy,
                std::mem::take(&mut inner.state),
                std::mem::take(&mut inner.measure_scratch),
                inner.density,
                owner_epoch,
            )
        };
        let result = policy(
            &mut RetainedMeasureScope::new(
                &state,
                applier,
                node_id,
                (density, owner_epoch),
                &mut scratch,
            ),
            constraints,
        );
        let mut inner = self.inner.borrow_mut();
        inner.state = state;
        inner.measure_scratch = scratch;
        if let Some(result) = &result {
            inner.replace_placed_children(
                result.placements.iter().map(|placement| placement.node_id),
            );
            crate::thread_state::cells(|cells| {
                cells
                    .retained_measures
                    .set(cells.retained_measures.get() + 1);
            });
        }
        result
    }

    pub(crate) fn measure_with_callbacks(
        &self,
        applier: &Rc<dyn ApplierHost>,
        runtime: &RuntimeHandle,
        node_id: NodeId,
        constraints: Constraints,
        callbacks: MeasureCallbacks<'_>,
    ) -> Result<MeasureResult, NodeError> {
        let MeasureCallbacks {
            measurer,
            retained_measure_lookup,
            error,
        } = callbacks;
        let (policy, mut state, slots_host, scratch, captured_context, density) = {
            let mut inner = self.inner.borrow_mut();
            let policy = Rc::clone(&inner.measure_policy);
            let state = std::mem::take(&mut inner.state);
            let slots_host = Rc::clone(&inner.slots);
            let scratch = std::mem::take(&mut inner.measure_scratch);
            let captured_context = inner.captured_context.clone();
            let density = inner.density;
            (
                policy,
                state,
                slots_host,
                scratch,
                captured_context,
                density,
            )
        };
        state.begin_pass();

        let constraints_copy = constraints;
        let fallback_context;
        let context = if let Some(context) = captured_context.as_ref() {
            context
        } else {
            fallback_context = CapturedCompositionContext::default();
            &fallback_context
        };
        let ((result, scratch), _) = Composer::subcompose_measure_slot(
            applier,
            runtime,
            &slots_host,
            node_id,
            context,
            |inner_composer| {
                let mut scope = SubcomposeMeasureScopeImpl::new(SubcomposeMeasureScopeInit {
                    composer: inner_composer.clone(),
                    density,
                    state: &mut state,
                    constraints: constraints_copy,
                    measurer,
                    retained_measure_lookup,
                    error,
                    parent_handle: self.clone(),
                    root_id: node_id,
                    scratch,
                });
                let result = (policy)(&mut scope, constraints_copy);
                (result, scope.into_scratch())
            },
        )?;

        let disposed = state.finish_pass();
        let disposal = Composer::dispose_measure_subcomposed_nodes(applier, disposed);

        {
            let mut inner = self.inner.borrow_mut();
            inner.state = state;
            inner.measure_scratch = scratch;

            inner.replace_placed_children(
                result.placements.iter().map(|placement| placement.node_id),
            );
        }

        disposal?;
        Ok(result)
    }

    pub(crate) fn recycle_placement_scratch(&self, mut placements: Vec<Placement>) {
        placements.clear();
        let mut inner = self.inner.borrow_mut();
        if placements.capacity() > inner.measure_scratch.placements.capacity() {
            inner.measure_scratch.placements = placements;
        }
    }

    /// The lazy items' roots the last pass placed, in the order of its
    /// placements, or none: see
    /// [`PlacedRootsScope::layout_with_placed_roots`].
    /// [`Self::recycle_placed_roots`] gives the storage back.
    pub(crate) fn take_placed_roots(&self) -> Vec<Rc<LazyItemRoots>> {
        std::mem::take(&mut self.inner.borrow_mut().measure_scratch.placed_roots)
    }

    pub(crate) fn recycle_placed_roots(&self, mut placed_roots: Vec<Rc<LazyItemRoots>>) {
        placed_roots.clear();
        let mut inner = self.inner.borrow_mut();
        if placed_roots.capacity() > inner.measure_scratch.placed_roots.capacity() {
            inner.measure_scratch.placed_roots = placed_roots;
        }
    }

    pub fn set_active_children<I>(&self, children: I)
    where
        I: IntoIterator<Item = NodeId>,
    {
        self.inner.borrow_mut().replace_placed_children(children);
    }
}

struct SubcomposeLayoutNodeInner {
    modifier: Modifier,
    modifier_chain: ModifierChainHandle,
    modifier_capabilities: NodeCapabilities,
    state: SubcomposeState,
    measure_policy: Rc<MeasurePolicy>,
    retained_measure_policy: Option<Rc<RetainedMeasurePolicy>>,
    children: Vec<NodeId>,
    slots: Rc<SlotsHost>,
    debug_modifiers: bool,
    node_id: Option<NodeId>,
    last_placements: Rc<Vec<NodeId>>,
    measure_scratch: MeasureScratch,
    measured_children_scratch: Rc<RefCell<HashMap<NodeId, Rc<MeasuredNode>>>>,
    captured_context: Option<CapturedCompositionContext>,
    density: crate::density::Density,
}

impl SubcomposeLayoutNodeInner {
    /// Writes the children this node placed, self-reporting an actual change
    /// to the scene phase the way [`LayoutState::place`] reports a move.
    ///
    /// These children *are* the node's render-graph children, and a
    /// subcomposition changes them without the applier seeing an insert or a
    /// remove: a lazy row that leaves the content keeps its nodes parked in
    /// the reusable pool, still attached and still carrying the position it
    /// was last placed at. Nothing else in the frame then says the child set
    /// shrank, so a scoped scene update would keep the departed row's layer
    /// and paint it under the row that took its place.
    fn replace_placed_children<I>(&mut self, children: I)
    where
        I: IntoIterator<Item = NodeId>,
    {
        let mut children = children.into_iter();
        let mut kept = 0usize;
        let mut first_change = None;
        for child in children.by_ref() {
            if self.last_placements.get(kept) != Some(&child) {
                first_change = Some(child);
                break;
            }
            kept += 1;
        }
        let changed = if let Some(child) = first_change {
            // From the first child that differs on, the list is written anew.
            let placements = Rc::make_mut(&mut self.last_placements);
            placements.truncate(kept);
            placements.push(child);
            placements.extend(children);
            true
        } else if self.last_placements.len() > kept {
            Rc::make_mut(&mut self.last_placements).truncate(kept);
            true
        } else {
            false
        };
        if changed && let Some(id) = self.node_id {
            crate::render_state::record_geometry_scene_node(id);
        }
    }

    fn new(measure_policy: Rc<MeasurePolicy>) -> Self {
        Self {
            modifier: Modifier::empty(),
            modifier_chain: ModifierChainHandle::detached(),
            modifier_capabilities: NodeCapabilities::default(),
            state: SubcomposeState::default(),
            measure_policy,
            retained_measure_policy: None,
            children: Vec::new(),
            slots: Rc::new(SlotsHost::new(SlotTable::default())),
            debug_modifiers: false,
            node_id: None,
            last_placements: Rc::new(Vec::new()),
            measure_scratch: MeasureScratch::default(),
            measured_children_scratch: Rc::new(RefCell::new(HashMap::default())),
            captured_context: None,
            density: crate::density::Density::default(),
        }
    }

    fn set_measure_policy(&mut self, policy: Rc<MeasurePolicy>) {
        self.measure_policy = policy;
        self.retained_measure_policy = None;
        if let Err(err) = self.slots.reset() {
            log::error!(
                "failed to reset root measurement slots after measure policy update: {err}"
            );
        }
    }

    fn set_modifier_collect(&mut self, modifier: Modifier) -> (ModifierInvalidations, bool) {
        let modifier_changed = !self.modifier.structural_eq(&modifier);
        self.modifier = modifier;
        self.modifier_chain.set_debug_logging(self.debug_modifiers);
        let invalidations = self
            .modifier_chain
            .update_on_node(self.node_id, &self.modifier);
        self.modifier_capabilities = self.modifier_chain.capabilities();

        (invalidations, modifier_changed)
    }

    fn set_debug_modifiers(&mut self, enabled: bool) {
        self.debug_modifiers = enabled;
        self.modifier_chain.set_debug_logging(enabled);
    }
}

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