Retain frame and extent dependencies independently

Keep the original measurement placement separate from the assigned slot.
Validate frame and extent lengths before reusing an answer or drawing, and
represent hint-only records as having no measured answer.

Retain primitive and mask coordinates with their frame/extent reference.
Forwarded children follow a reused wrapper's placement without rerunning
valid draw bodies. Keep the single Widget::draw API.

Restore the eight failing suite cases from the region/placement prototype,
with regressions for mixed coordinate references, a changed inherited
extent, the sizing-stack fraction, and an undrawn share becoming visible.

This remains experimental: nested container updates do substantially more
work than e44dea3 despite restoring the leaf and wrapper reuse guarantees.
Do not merge it as a performance improvement.

core/src/orientation/axis.rs

@@ -7,6 +7,17 @@ pub enum Axis {
     Y,
 }
 
+impl Axis {
+    /// A per-axis pair with `aligned` on this axis and `ortho` on the other,
+    /// which is what `from_axis` does for a vector.
+    pub fn pair<T>(self, aligned: T, ortho: T) -> [T; 2] {
+        match self {
+            Self::X => [aligned, ortho],
+            Self::Y => [ortho, aligned],
+        }
+    }
+}
+
 impl std::ops::Not for Axis {
     type Output = Self;
 

core/src/render/mod.rs

@@ -106,7 +106,8 @@ impl UiRenderNode {
             self.active.push(i);
             for change in draws.apply_free() {
                 if let Some(inst) = ui_render.active.get_mut(&change.id) {
-                    for h in &mut inst.primitives {
+                    for primitive in &mut inst.primitives {
+                        let h = &mut primitive.handle;
                         if h.layer == i && h.kind == change.kind && h.inst_idx == change.old {
                             h.inst_idx = change.new;
                             break;

core/src/ui/active.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Holds, LayerId, LayoutLen, MaskIdx, MoveIdx, PrimitiveHandle, RegionAlign, Size, TextureHandle,
+    DrawRegion, LayerId, LayoutHolds, LayoutLen, MaskIdx, MoveIdx, RegionAlign, RetainedPrimitive,
-    UiRegion, UiVec2, WidgetId,
+    Size, TextureHandle, UiRegion, UiVec2, WidgetId,
 };
 
 /// What is kept of a widget its parent has asked about. `drawn` says whether
@@ -9,12 +9,12 @@ use crate::{
 #[derive(Debug)]
 pub struct ActiveData {
     pub id: WidgetId,
-    /// The box its drawing is in, in `parent_move`'s coordinates.
+    /// The box its parent gave it, in `parent_move`'s coordinates: what it
+    /// was asked about, and what a fraction under it is a fraction of. A
+    /// local redraw asks here.
     pub region: UiRegion,
-    /// The box its parent gave it, in the same coordinates: what it was
+    /// Where its drawing sits inside that box, in the box's own coordinates.
-    /// asked about, before its own answer placed its drawing inside it.
+    pub placement: UiRegion,
-    /// `region` is that placement, and a local redraw asks here.
-    pub given: UiRegion,
     /// The same box as lengths of its parent's box, which is the one route
     /// to a box in pixels: a draw threads these down a level at a time, and
     /// [`crate::UiRenderState::redraw`] takes the same steps back up.
@@ -25,13 +25,14 @@ pub struct ActiveData {
     /// asked again -- and a chain of fractions has no frame in it, which is
     /// why a region node between two widgets cannot break it.
     pub offer_len: UiVec2,
-    /// What it answered there: the size and what that held for.
+    pub offer_placement: [Option<crate::UiSpan>; 2],
-    pub answer: (Size, [Holds; 2]),
+    /// The measured answer and its dependencies. A hint-only dependency or
+    /// a widget first encountered during placement has no measurement yet.
+    pub answer: Option<(Size, LayoutHolds)>,
     /// What the widget said it used of its box, the last time it drew.
     pub size: Size,
-    /// The pixel lengths of `region`, per axis, that its drawing and `size`
+    /// The frame, extent and explicit placement reads that this drawing holds for.
-    /// hold for.
+    pub holds: LayoutHolds,
-    pub holds: [Holds; 2],
     pub drawn: bool,
     pub parent: Option<WidgetId>,
     /// How far down the tree it was drawn, the root being 1. Carried down a
@@ -39,7 +40,9 @@ pub struct ActiveData {
     /// widget a frame visits and cannot drift while one is being drawn.
     pub depth: usize,
     pub textures: Vec<TextureHandle>,
-    pub primitives: Vec<PrimitiveHandle>,
+    pub primitives: Vec<RetainedPrimitive>,
+    pub mask_region: Option<DrawRegion>,
+    pub inherited_children: Vec<WidgetId>,
     pub children: Vec<WidgetId>,
     /// The children whose size this widget read while drawing.
     pub size_deps: Vec<WidgetId>,
@@ -70,8 +73,18 @@ pub struct ActiveData {
 }
 
 impl ActiveData {
-    /// Whether its drawing and size hold for a box of these pixel lengths.
+    /// Whether what it answered still stands for a box of these pixel
-    pub fn holds_at(&self, px: crate::PxVec2) -> bool {
+    /// lengths -- the box it was asked in, where `holds` is about the box its
-        self.holds[0].contains(px.x) && self.holds[1].contains(px.y)
+    /// answer then chose.
+    pub fn answers_at(&self, px: crate::PxVec2) -> bool {
+        self.answer.is_some_and(|(_, holds)| {
+            holds.contains(
+                px,
+                UiRegion {
+                    x: self.offer_placement[0].unwrap_or(crate::UiSpan::FULL),
+                    y: self.offer_placement[1].unwrap_or(crate::UiSpan::FULL),
+                },
+            )
+        })
     }
 }

core/src/ui/draw_region.rs

@@ -0,0 +1,36 @@
+use crate::{PrimitiveHandle, UiRegion};
+
+/// Retains which box geometry follows when only the extent changes.
+#[derive(Clone, Copy, Debug)]
+pub enum DrawRegion {
+    Frame(UiRegion),
+    Extent(UiRegion),
+}
+
+impl DrawRegion {
+    pub(crate) fn resolve(self, frame: UiRegion, extent: UiRegion) -> UiRegion {
+        match self {
+            Self::Frame(local) => local.within(&frame),
+            Self::Extent(local) => local.within(&extent).within(&frame),
+        }
+    }
+
+    pub(crate) fn map(self, f: impl FnOnce(UiRegion) -> UiRegion) -> Self {
+        match self {
+            Self::Frame(local) => Self::Frame(f(local)),
+            Self::Extent(local) => Self::Extent(f(local)),
+        }
+    }
+}
+
+impl From<UiRegion> for DrawRegion {
+    fn from(region: UiRegion) -> Self {
+        Self::Frame(region)
+    }
+}
+
+#[derive(Debug)]
+pub struct RetainedPrimitive {
+    pub handle: PrimitiveHandle,
+    pub region: DrawRegion,
+}

core/src/ui/layout_holds.rs

@@ -0,0 +1,33 @@
+use crate::{Axis, Holds, PxVec2, UiRegion};
+
+/// Dependencies of one evaluation, before the frame and extent are composed.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct LayoutHolds {
+    pub frame: [Holds; 2],
+    pub extent: [Holds; 2],
+    pub placement: Option<UiRegion>,
+}
+
+impl LayoutHolds {
+    pub const ANY: Self = Self {
+        frame: [Holds::ANY; 2],
+        extent: [Holds::ANY; 2],
+        placement: None,
+    };
+
+    pub fn contains(self, px: PxVec2, placement: UiRegion) -> bool {
+        self.placement.is_none_or(|old| old == placement)
+            && [Axis::X, Axis::Y].into_iter().all(|axis| {
+                self.frame[axis as usize].contains(px.axis(axis))
+                    && self.extent[axis as usize]
+                        .contains(placement.axis(axis).len().to_px(px.axis(axis)))
+            })
+    }
+
+    pub fn in_frame(self, placement: UiRegion) -> [Holds; 2] {
+        [Axis::X, Axis::Y].map(|axis| {
+            self.frame[axis as usize]
+                .and(self.extent[axis as usize].through(placement.axis(axis).len()))
+        })
+    }
+}

core/src/ui/mod.rs

@@ -10,12 +10,16 @@ use crate::{
 pub const CHAIN_LIMIT: u32 = 64;
 
 mod active;
+mod draw_region;
 mod holds;
+mod layout_holds;
 mod painter;
 mod render_state;
 
 pub use active::*;
+pub use draw_region::*;
 pub use holds::*;
+pub use layout_holds::*;
 pub use painter::{Painter, PrimitiveLike};
 pub use render_state::*;
 

core/src/ui/painter.rs

@@ -1,12 +1,12 @@
 #[cfg(feature = "layout-diagnostics")]
 use crate::layout_diagnostics::{self as diag, Counter};
 use crate::{
-    Axis, Holds, LayoutLen, Len, Px, PxVec2, RegionAlign, RenderedText, Size, StrongWidget,
+    Axis, DrawRegion, Holds, LayoutLen, Len, Px, PxVec2, RegionAlign, RenderedText,
-    TextAttrs, TextBuffer, TextData, TextureHandle, UiRegion, UiRenderState, UiRsc, UiVec2, Weight,
+    RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextData, TextureHandle,
-    WidgetId, Widgets,
+    UiRegion, UiRenderState, UiRsc, UiSpan, UiVec2, Weight, WidgetId, Widgets,
     render::{
-        GlyphPrimitive, Mask, MaskIdx, MoveIdx, Primitive, PrimitiveHandle, PrimitiveInst,
+        GlyphPrimitive, Mask, MaskIdx, MoveIdx, Primitive, PrimitiveInst, PrimitiveKind,
-        PrimitiveKind, TexturePrimitive,
+        TexturePrimitive,
     },
     ui::render_state::DrawInfo,
 };
@@ -17,8 +17,20 @@ pub struct Painter<'a> {
     pub(super) state: &'a mut UiRenderState,
     pub(super) rsc: &'a mut dyn UiRsc,
 
-    /// This widget's box, in the coordinates of `move_idx`.
+    /// The box its parent gave it, in the coordinates of `move_idx`: what a
+    /// fraction of this widget's area is a fraction of, and what every region
+    /// it writes composes within. The same box on the ask that measures and
+    /// the ask that places, which is what keeps a fraction under it from
+    /// being resolved twice.
     pub(super) region: UiRegion,
+    /// Where this widget's drawing sits inside that box, in the box's own
+    /// coordinates: `FULL` while its answer is not yet known, and the box
+    /// its answer or its parent chose once one of them has.
+    pub(super) placement: UiRegion,
+    /// Whether this draw read its placement, which makes the drawing one
+    /// that holds for that placement alone -- the way reading a length in
+    /// pixels makes it hold for that length.
+    pub(super) reads_placement: bool,
     /// That box in pixels, which its children's are a length of: threaded
     /// down from the box this widget was given rather than composed back up
     /// the chain, so every length in layout is one multiply from its
@@ -26,7 +38,11 @@ pub struct Painter<'a> {
     pub(super) px: PxVec2,
     pub(super) mask: MaskIdx,
     pub(super) textures: Vec<TextureHandle>,
-    pub(super) primitives: Vec<PrimitiveHandle>,
+    pub(super) primitives: Vec<RetainedPrimitive>,
+    pub(super) mask_region: Option<DrawRegion>,
+    pub(super) inherited_children: Vec<WidgetId>,
+    pub(super) extent_own: [Holds; 2],
+    pub(super) extent_under: [Holds; 2],
     pub(super) children: Vec<WidgetId>,
     /// The children asked about so far, so the first box each was asked in
     /// is the one recorded as its offer.
@@ -57,13 +73,13 @@ pub struct Painter<'a> {
 }
 
 impl<'a> Painter<'a> {
-    fn primitive_at<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+    fn primitive_at<P: Primitive>(&mut self, primitive: P, region: DrawRegion) {
         let kind = self.rsc.ui_mut().primitives.kind::<P>();
         self.write(kind, primitive, region);
     }
 
     /// Takes the kind, for a caller writing many of one primitive.
-    fn write<P: Primitive>(&mut self, kind: PrimitiveKind<P>, primitive: P, region: UiRegion) {
+    fn write<P: Primitive>(&mut self, kind: PrimitiveKind<P>, primitive: P, region: DrawRegion) {
         #[cfg(feature = "layout-diagnostics")]
         diag::bump(Counter::PrimitiveWrites);
         let h = self.state.layers.write(
@@ -72,15 +88,15 @@ impl<'a> Painter<'a> {
                 kind,
                 id: self.id,
                 primitive,
-                region,
+                region: region.resolve(self.region, self.placement),
                 mask_idx: self.mask,
                 move_idx: self.move_idx,
             },
         );
-        self.push_primitive(h);
+        self.push_primitive(RetainedPrimitive { handle: h, region });
     }
 
-    fn push_primitive(&mut self, h: PrimitiveHandle) {
+    fn push_primitive(&mut self, h: RetainedPrimitive) {
         if self.mask != MaskIdx::NONE {
             // TODO: I have no clue if this works at all :joy:
             self.rsc.ui_mut().masks.push_ref(self.mask);
@@ -88,28 +104,42 @@ impl<'a> Painter<'a> {
         self.primitives.push(h);
     }
 
-    /// Writes a primitive to be rendered
+    /// Writes a primitive over the whole of this widget's own box.
     pub fn primitive(&mut self, primitive: impl PrimitiveLike) {
+        let at = DrawRegion::Extent(UiRegion::FULL);
         let primitive = primitive.into_primitive(self);
-        self.primitive_at(primitive, self.region)
+        self.primitive_at(primitive, at)
     }
 
-    pub fn primitive_within(&mut self, primitive: impl PrimitiveLike, region: UiRegion) {
+    /// Writes in the frame by default. `DrawRegion::Extent` keeps the local
+    /// geometry attached to this widget's box without reading its placement.
+    pub fn primitive_within(
+        &mut self,
+        primitive: impl PrimitiveLike,
+        region: impl Into<DrawRegion>,
+    ) {
         let primitive = primitive.into_primitive(self);
-        self.primitive_at(primitive, region.within(&self.region));
+        self.primitive_at(primitive, region.into());
     }
 
-    pub fn set_mask(&mut self, region: UiRegion) {
+    /// Sets a mask in the selected frame or extent coordinates.
+    pub fn set_mask(&mut self, region: impl Into<DrawRegion>) {
+        let region = region.into();
+        self.mask_region = Some(region);
         assert!(self.mask == MaskIdx::NONE);
         self.mask = self.rsc.ui_mut().masks.push(Mask {
-            region,
+            region: region.resolve(self.region, self.placement),
             move_idx: self.move_idx,
         });
     }
 
-    /// Draws a widget within this widget's region.
+    /// Draws a widget in the whole of this widget's own box: it gets the
+    /// same region -- the same area for its fractions to be of -- and is put
+    /// where this widget was put. What a container that is only a wrapper
+    /// around one child wants, since its box is the child's.
     pub fn widget<'s, W: ?Sized>(&'s mut self, id: &'s StrongWidget<W>) -> DrawResult<'s, 'a, W> {
-        self.widget_within(id, UiRegion::FULL)
+        let own = self.placement;
+        self.widget_at_inner(id, UiRegion::FULL, [Some(own.x), Some(own.y)], true)
     }
 
     /// What a widget's rules declare its lengths to be, which whoever draws
@@ -125,55 +155,63 @@ impl<'a> Painter<'a> {
     /// this frame; what it answered is still something this widget asked.
     pub fn undraw<W: ?Sized>(&mut self, id: &StrongWidget<W>) {
         self.children.retain(|child| *child != id.id());
+        self.inherited_children.retain(|child| *child != id.id());
         self.state.undraw_rec(id.id(), self.rsc);
     }
 
     /// Draws a widget somewhere within this one. `region` is in this widget's
-    /// own coordinates, and the child's declared lengths are still to be
+    /// own region, and is the child's own region: what its declared lengths
-    /// taken from it. Where the child's drawing sits inside what it is given
+    /// and its report are fractions of. Where its drawing sits inside that is
-    /// is the child's alignment, applied where the child is drawn, so a
+    /// its own answer placed by its alignment.
-    /// container positions a child either by handing it a box of exactly its
-    /// length or by leaving it room and letting its alignment decide.
     pub fn widget_within<'s, W: ?Sized>(
         &'s mut self,
         id: &'s StrongWidget<W>,
         region: UiRegion,
     ) -> DrawResult<'s, 'a, W> {
-        self.widget_at(id, region, region.size(), [false; 2])
+        self.widget_at(id, region, [None; 2])
     }
 
-    /// Draws a widget in `region`, saying what the answer means.
+    /// Draws a widget in `region`, saying where in it the drawing goes.
     ///
-    /// `reports_of` is what a fraction the child reports is a fraction of, as
+    /// `region` is the child's own area: what a fraction it declares or
-    /// lengths of this widget's own box. It is the box the child was given
+    /// reports is a fraction of, and the coordinates the regions it writes
-    /// wherever that box is the child's whole area -- a pad's inset, a stack
+    /// compose within. It is the same box on the ask that measures and the
-    /// child, a scroll's content -- and a span passes its own extent along
+    /// ask that places, which is what stops a fraction under it being
-    /// the row instead: it offers each child the room left from its cursor,
+    /// resolved twice.
-    /// because a text has to wrap at the width actually there, while
-    /// `rel(0.5)` still means half the span wherever the child sits in it.
     ///
-    /// A `decided` axis is one where this box was chosen from the widget's
+    /// `placement` is what of that region the child's drawing takes, per
-    /// own answer. On those the answer is not placed inside the box again: it
+    /// axis, wherever this widget is choosing. `None` leaves the axis to the
-    /// already is the box, and a fraction taken of it a second time would
+    /// child's own answer and alignment, which is what
-    /// shrink it twice. A container uses that where it hands back exactly
+    /// [`Self::widget_within`] passes. A span passes the whole row as the
-    /// what a child asked for -- a span placing a child at the length it
+    /// region, so `rel(0.5)` is half the row wherever the child sits in it,
-    /// reported, a scroll giving its content the content's own length.
+    /// and places the child by passing the slot along its axis.
     pub fn widget_at<'s, W: ?Sized>(
         &'s mut self,
         id: &'s StrongWidget<W>,
         region: UiRegion,
-        reports_of: UiVec2,
+        placement: [Option<UiSpan>; 2],
-        decided: [bool; 2],
     ) -> DrawResult<'s, 'a, W> {
+        self.widget_at_inner(id, region, placement, false)
+    }
+
+    fn widget_at_inner<'s, W: ?Sized>(
+        &'s mut self,
+        id: &'s StrongWidget<W>,
+        region: UiRegion,
+        placement: [Option<UiSpan>; 2],
+        inherited: bool,
+    ) -> DrawResult<'s, 'a, W> {
+        if inherited {
+            if !self.inherited_children.contains(&id.id()) {
+                self.inherited_children.push(id.id());
+            }
+        } else {
+            self.inherited_children.retain(|child| *child != id.id());
+        }
         let region_node = self.rsc.widgets().is_region_node(id.id());
         let declared = self.declared_lens(id);
         let align = self.rsc.widgets().alignment(id.id());
-        // Composing `FULL` through a box is not quite the identity in f32,
+        let (local, placement) = ask_box(region, declared, align, placement);
-        // so a child with nothing declared keeps the box it would have had.
-        let local = match declared.iter().any(Option::is_some) {
-            true => declared_box(region, declared, align),
-            false => region,
-        };
         let within = match local == UiRegion::FULL {
             true => self.region,
             false => local.within(&self.region),
@@ -197,11 +235,16 @@ impl<'a> Painter<'a> {
                 .get(&id.id())
                 .map_or(given_len, |a| a.offer_len),
         };
+        let offer_placement = if first_ask {
+            placement
+        } else {
+            self.state
+                .active
+                .get(&id.id())
+                .map_or(placement, |a| a.offer_placement)
+        };
         let px = given_len.to_px(self.px);
         let offered_px = offer_len.to_px(self.offered_px);
-        // Whether this ask is the child's offer question, which is a question
-        // about lengths: the same lengths somewhere else is the same question.
-        let answers_offer = self.at_offer && px == offered_px;
         // The answer and what it holds for, both about the box asked in. The
         // child's record may say something else once its drawing has been
         // placed: a drawing made again in its placed box holds for that box.
@@ -217,25 +260,36 @@ impl<'a> Painter<'a> {
                 mask: self.mask,
                 given_len,
                 offer_len,
+                offer_placement,
                 px,
                 offered_px,
-                decided,
+                placement,
             },
             None,
             self.rsc,
         );
-        if answers_offer {
-            self.state.active.get_mut(&id.id()).unwrap().answer = (size, holds);
-        }
         // Whatever the child's answer holds for keeps this one to the boxes
         // that give the child a length inside it.
-        for (axis, under) in AXES.into_iter().zip(self.under.iter_mut()) {
+        for axis in AXES {
-            *under = under.and(holds[axis as usize].through(local.axis(axis).len()));
+            let n = axis as usize;
+            let frame = holds.frame[n].through(local.axis(axis).len());
+            self.under[n] = self.under[n].and(frame);
+            if inherited && declared[n].is_none() {
+                self.extent_under[n] = self.extent_under[n].and(holds.extent[n]);
+                self.reads_placement |= holds.placement.is_some();
+            } else {
+                let extent = placement[n].unwrap_or(UiSpan::FULL).len();
+                self.under[n] = self.under[n].and(
+                    holds.extent[n]
+                        .through(extent)
+                        .through(local.axis(axis).len()),
+                );
+            }
         }
         DrawResult {
             child: id,
             painter: self,
-            size: in_parent_frame(size, reports_of, declared),
+            size: in_parent_frame(size, local.size(), declared),
         }
     }
 
@@ -267,42 +321,50 @@ impl<'a> Painter<'a> {
         }
     }
 
-    /// A child's length in the box it is about to be offered, if it can be
+    /// A child's length in the region it is about to be offered, if it can
-    /// had without drawing it: from its hint, or from a drawing it already
+    /// be had without drawing it: from its hint, or from a drawing it already
-    /// has that holds for that box. `reports_of` is what a fraction in the
+    /// has that holds for that box.
-    /// answer is a fraction of, as it is for [`Self::widget_at`].
     pub fn known_len<W: ?Sized>(
         &mut self,
         child: &StrongWidget<W>,
         axis: Axis,
         region: UiRegion,
-        reports_of: UiVec2,
+        placement: [Option<UiSpan>; 2],
     ) -> Option<LayoutLen> {
         let declared = self.declared_lens(child);
         let align = self.rsc.widgets().alignment(child.id());
-        let local = declared_box(region, declared, align);
+        let (local, placement) = ask_box(region, declared, align, placement);
-        let first_ask = self.offer(child.id());
+        let first_ask = self.at_offer && !self.offered.contains(&child.id());
-        if first_ask && let Some(active) = self.state.active.get_mut(&child.id()) {
+
-            active.offer_len = local.size();
-        }
         if let Some(hint) = self.size_hint(child, axis) {
             return Some(hint);
         }
         let px = local.size().to_px(self.px);
-        let (size, holds) =
+        let (size, holds) = self.state.retained_size(
-            self.state
+            child.id(),
-                .retained_size(child.id(), px, self.move_idx, self.rsc.widgets())?;
+            px,
+            placement,
+            self.move_idx,
+            self.rsc.widgets(),
+        )?;
         #[cfg(feature = "layout-diagnostics")]
         diag::bump(Counter::RetainedSizeHits);
         self.depend_on(child);
         if first_ask {
+            self.offered.push(child.id());
             let active = self.state.active.get_mut(&child.id()).unwrap();
-            active.answer = (size, holds);
+            active.offer_len = local.size();
+            active.offer_placement = placement;
         }
+        let placement = UiRegion {
+            x: placement[0].unwrap_or(UiSpan::FULL),
+            y: placement[1].unwrap_or(UiSpan::FULL),
+        };
+        let holds = holds.in_frame(placement);
         for (axis, under) in AXES.into_iter().zip(self.under.iter_mut()) {
             *under = under.and(holds[axis as usize].through(local.axis(axis).len()));
         }
-        Some(in_parent_frame(size, reports_of, declared).axis(axis))
+        Some(in_parent_frame(size, local.size(), declared).axis(axis))
     }
 
     /// Whether this is the first box a child is asked about in during a draw
@@ -334,20 +396,24 @@ impl<'a> Painter<'a> {
         ui.text.render(buffer, attrs, width)
     }
 
+    /// Writes glyphs in the selected frame or extent coordinates.
     // TODO: merge the text methods into the primitive ones.
-    pub fn glyphs(&mut self, text: &RenderedText, origin: UiRegion) {
+    pub fn glyphs(&mut self, text: &RenderedText, origin: impl Into<DrawRegion>) {
+        let origin = origin.into();
         let kind = self.rsc.ui_mut().primitives.kind::<GlyphPrimitive>();
         for glyph in text.glyphs.iter() {
-            let mut region = origin;
+            let region = origin.map(|mut region| {
-            region.x.end = region.x.start;
+                region.x.end = region.x.start;
-            region.y.end = region.y.start;
+                region.y.end = region.y.start;
-            let mut region = region.offset(UiVec2::from_px(glyph.offset));
+                let mut region = region.offset(UiVec2::from_px(glyph.offset));
-            let size = PxVec2::new(
+                let size = PxVec2::new(
-                Px::from_int(glyph.entry.width as i32),
+                    Px::from_int(glyph.entry.width as i32),
-                Px::from_int(glyph.entry.height as i32),
+                    Px::from_int(glyph.entry.height as i32),
-            );
+                );
-            region.x.end = region.x.start.offset(size.x);
+                region.x.end = region.x.start.offset(size.x);
-            region.y.end = region.y.start.offset(size.y);
+                region.y.end = region.y.start.offset(size.y);
+                region
+            });
             self.write(
                 kind,
                 GlyphPrimitive {
@@ -362,12 +428,26 @@ impl<'a> Painter<'a> {
         }
     }
 
-    /// This widget's box, in the coordinates its own primitives are written
+    /// The box this widget's parent gave it, in the coordinates its own
-    /// in -- so a region composed `within` it may be drawn directly.
+    /// primitives are written in -- so a region composed `within` it may be
+    /// drawn directly. Its own box is [`Self::placement`] of this one.
     pub fn region(&self) -> UiRegion {
         self.region
     }
 
+    /// Where this widget's drawing goes inside the box it was given, in that
+    /// box's coordinates: what its own answer took of it, or what its parent
+    /// chose for it. `FULL` on the ask that measures, since nothing has been
+    /// placed yet.
+    ///
+    /// Reading it is what says the drawing depends on it, so a widget that
+    /// positions its own content reads it and is drawn again once its box is
+    /// known, and one that fills whatever it is given never is.
+    pub fn placement(&mut self) -> UiRegion {
+        self.reads_placement = true;
+        self.placement
+    }
+
     /// Where this widget sits in a box longer than the length it takes. A
     /// widget that positions its own content reads it to place that content
     /// the way the box around it would have placed the widget.
@@ -401,20 +481,44 @@ impl<'a> Painter<'a> {
         placed_box(UiRegion::FULL, lens, RegionAlign::NEAR)
     }
 
-    /// This widget's box in pixels. Reading it makes the drawing one that
+    /// This widget's own box in pixels. Reading it makes the drawing one
-    /// holds for this box only, until `holds` says how far it goes.
+    /// that holds for this box only, until `holds` says how far it goes.
     pub fn px_size(&mut self) -> PxVec2 {
-        for (own, len) in self.own.iter_mut().zip([self.px.x, self.px.y]) {
+        PxVec2::new(self.px_len(Axis::X), self.px_len(Axis::Y))
-            if *own == Holds::ANY {
-                *own = Holds::at(len);
-            }
-        }
-        self.px
     }
 
-    /// One axis of this widget's box in pixels. Prefer this to
+    /// One axis of this widget's own box in pixels. Prefer this to
     /// [`Self::px_size`] when the other axis cannot affect the drawing.
     pub fn px_len(&mut self, axis: Axis) -> Px {
+        let part = self.placement.axis(axis).len();
+        let len = part.to_px(self.px.axis(axis));
+        let own = &mut self.extent_own[axis as usize];
+        if *own == Holds::ANY {
+            *own = Holds::at(len);
+        }
+        len
+    }
+
+    /// The lengths of this widget's own box on `axis` that what it is drawing
+    /// holds for -- the same primitives, in the same fractions and offsets
+    /// of the box, and the same reported size. A widget that read its length
+    /// in pixels holds for that one alone until it says otherwise.
+    pub fn holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
+        let part = self.placement.axis(axis).len();
+        let holds = holds.into();
+        debug_assert!(
+            holds.contains(part.to_px(self.px.axis(axis))),
+            "'{}' ({:?}) says its drawing holds for lengths that leave out its own box",
+            self.label(),
+            self.id
+        );
+        self.extent_own[axis as usize] = holds;
+    }
+
+    /// One axis of the box this widget's parent gave it, in pixels -- what a
+    /// fraction of its area resolves against, and so what a container divides
+    /// among its children. Its own box is a part of this one.
+    pub fn region_px_len(&mut self, axis: Axis) -> Px {
         let len = self.px.axis(axis);
         let own = &mut self.own[axis as usize];
         if *own == Holds::ANY {
@@ -423,15 +527,14 @@ impl<'a> Painter<'a> {
         len
     }
 
-    /// The lengths of this widget's box on `axis` that what it is drawing
+    /// [`Self::holds`] stated about the region rather than about this
-    /// holds for -- the same primitives, in the same fractions and offsets
+    /// widget's own box, for a container whose drawing turns on the box it
-    /// of the box, and the same reported size. A widget that read its
+    /// was given rather than on the part of it it took.
-    /// length in pixels holds for that one alone until it says otherwise.
+    pub fn region_holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
-    pub fn holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
         let holds = holds.into();
         debug_assert!(
             holds.contains(self.px.axis(axis)),
-            "'{}' ({:?}) says its drawing holds for lengths that leave out its own box",
+            "'{}' ({:?}) says its drawing holds for lengths that leave out its region",
             self.label(),
             self.id
         );
@@ -521,19 +624,16 @@ impl PrimitiveLike for &TextureHandle {
     }
 }
 
-/// A child's answer as lengths of the parent's own box. A widget reports a
+/// A child's answer as lengths of the parent's own region. A widget reports
-/// fraction, and `reports_of` is the length that fraction is of: the box the
+/// a fraction of its own region, and `of` is that region as a length of this
-/// child was given wherever that is the child's whole area, and the parent's
+/// one. Pixels come through untouched, being that many pixels wherever they
-/// own extent wherever the box is a positional remainder, as a span's is
+/// end up. A declared axis is already the parent's: it resolved the rule in
-/// after an earlier child. Pixels come through untouched either way, being
+/// its own region, and the rule is what the report says.
-/// that many pixels wherever they end up. A declared axis is already the
+fn in_parent_frame(size: Size, of: UiVec2, declared: [Option<LayoutLen>; 2]) -> Size {
-/// parent's: it resolved the rule in its own box, and the rule is what the
-/// report says.
-fn in_parent_frame(size: Size, reports_of: UiVec2, declared: [Option<LayoutLen>; 2]) -> Size {
     let mut size = size;
     for (axis, declared) in AXES.into_iter().zip(declared) {
         if declared.is_none() {
-            *size.axis_mut(axis) = size.axis(axis).within_len(reports_of.axis(axis));
+            *size.axis_mut(axis) = size.axis(axis).within_len(of.axis(axis));
         }
     }
     size
@@ -562,9 +662,9 @@ pub(crate) fn declared_lens(widgets: &Widgets, id: WidgetId) -> [Option<LayoutLe
 /// Whether what a widget reported along an axis is the whole of the box it
 /// is in rather than a part to be placed inside it. A share fills, because a
 /// share is a length only to whoever divides one, and whoever did is the one
-/// that handed down this box. A declared axis does too: `declared_box`
+/// that handed down this box. A declared axis does too: the rule already gave
-/// already placed it, in the parent's box, and the rule's length is what the
+/// the region its length, and the rule's length is what the widget reports
-/// widget reports there. And an axis the parent decided from the answer is
+/// there. And an axis the parent decided from the answer is
 /// the answer already.
 pub(crate) fn fills(reported: LayoutLen, declared: Option<LayoutLen>, decided: bool) -> bool {
     reported.leftover != Weight::ZERO || declared.is_some() || decided
@@ -612,21 +712,35 @@ pub(crate) fn placed_box(region: UiRegion, lens: UiVec2, align: RegionAlign) ->
     placed
 }
 
-/// Takes a widget's declared lengths in the box `region` is given in, since a
+/// A child's own region and where in it its drawing goes, from the box it is
-/// fraction of a length means a fraction of that one, and puts what is left
+/// offered, the lengths its rules declare, and what its parent chose.
-/// over on the side its alignment says. A caller that already reserved the
+///
-/// space hands back the same length, so this is the identity for it.
+/// A rule gives the region its length outright -- that is what makes a rule
-pub(crate) fn declared_box(
+/// win, and it is why a widget under one never learns of it -- and the region
+/// then sits where its parent placed it, or where its alignment says if its
+/// parent left the axis open. With no rule the region is the whole of what
+/// was offered, since that is the area a fraction under it is a fraction of,
+/// and what the parent chose is where in it the drawing goes. So the two
+/// coordinate spaces are the same one wherever a placement survives.
+pub(crate) fn ask_box(
     mut region: UiRegion,
     declared: [Option<LayoutLen>; 2],
     align: RegionAlign,
-) -> UiRegion {
+    placement: [Option<UiSpan>; 2],
-    for (axis, len) in AXES.into_iter().zip(declared) {
+) -> (UiRegion, [Option<UiSpan>; 2]) {
-        let Some(len) = len else { continue };
+    let mut placed = [None; 2];
+    for (axis, (len, chosen)) in AXES.into_iter().zip(declared.into_iter().zip(placement)) {
+        let Some(len) = len else {
+            placed[axis as usize] = chosen;
+            continue;
+        };
         let span = region.axis_mut(axis);
         let len = Len::from_parts(len.rel, len.px);
-        span.start += (span.len() - len).scale(align.axis(axis).rel());
+        span.start = match chosen {
+            Some(chosen) => chosen.start,
+            None => span.start + (span.len() - len).scale(align.axis(axis).rel()),
+        };
         span.end = span.start + len;
     }
-    region
+    (region, placed)
 }

core/src/ui/render_state.rs

@@ -1,10 +1,10 @@
 #[cfg(feature = "layout-diagnostics")]
 use crate::layout_diagnostics::{self as diag, Counter, ReuseOutcome, TimerKind};
-use crate::ui::painter::{declared_box, declared_lens, placed_box, placed_lens};
+use crate::ui::painter::{ask_box, declared_lens, placed_box, placed_lens};
 use crate::{
-    ActiveData, Axis, DrawLayers, Holds, IdLike, LayoutLen, Len, MaskIdx, MoveIdx, Moves, Painter,
+    ActiveData, Axis, DrawLayers, Holds, IdLike, LayoutHolds, LayoutLen, Len, MaskIdx, MoveIdx,
-    PixelRegion, Px, PxVec2, Rel, Size, StrongWidget, UiRegion, UiRsc, UiSpan, UiVec2, Weight,
+    Moves, Painter, PixelRegion, Px, PxVec2, Rel, Size, StrongWidget, UiRegion, UiRsc, UiSpan,
-    WidgetId, Widgets,
+    UiVec2, Weight, WidgetId, Widgets,
     util::{HashMap, Vec2},
 };
 
@@ -26,14 +26,32 @@ pub(super) struct DrawInfo {
     /// carries them unchanged while its own region is the placement inside.
     pub given_len: UiVec2,
     pub offer_len: UiVec2,
+    pub offer_placement: [Option<UiSpan>; 2],
     /// This ask's box in pixels, and the offer's: one multiply from the
     /// parent's own, which is where every pixel length in layout comes from.
     pub px: PxVec2,
     pub offered_px: PxVec2,
-    /// The axes along which the parent chose this box from the widget's own
+    /// What of that region the parent chose to put the drawing in, per axis.
-    /// answer, so the answer is not placed inside it again. See
+    /// `None` leaves the axis to the widget's own answer and its alignment.
-    /// [`Painter::widget_at`].
+    /// See [`Painter::widget_at`].
-    pub decided: [bool; 2],
+    pub placement: [Option<UiSpan>; 2],
+}
+
+impl DrawInfo {
+    /// The axes the parent chose the placement on, which are the axes the
+    /// answer is not placed inside its region again.
+    fn decided(&self) -> [bool; 2] {
+        self.placement.map(|span| span.is_some())
+    }
+
+    /// The placement to draw in before the answer is known: what the parent
+    /// chose, and the whole region on any axis it left open.
+    fn offered_placement(&self) -> UiRegion {
+        UiRegion {
+            x: self.placement[0].unwrap_or(UiSpan::FULL),
+            y: self.placement[1].unwrap_or(UiSpan::FULL),
+        }
+    }
 }
 
 pub struct UiRenderState {
@@ -43,7 +61,9 @@ pub struct UiRenderState {
 
     old_root: Option<WidgetId>,
     /// Whether the output has changed since the last update. A frame is
-    /// owed for that whether or not anything has to be drawn again.
+    /// owed for that whether or not anything has to be drawn again: every
+    /// fraction becomes pixels against the output, in the shader's uniform
+    /// as well as here.
     resized: bool,
     /// A widget's move slot, which outlives any one `ActiveData`: a redraw
     /// replaces that while its children go on pointing at the slot.
@@ -83,13 +103,28 @@ impl UiRenderState {
     /// size is applied where a fraction becomes pixels -- here in `to_px`,
     /// and in the shader by its uniform. A resize therefore rewrites no
     /// retained entry at all.
-    pub fn resize(&mut self, size: impl Into<Vec2>) {
+    ///
+    /// The root is the only widget a resize marks, and only where the new
+    /// output falls outside what its answer holds for: that range is the
+    /// intersection of everything under it, so admitting the new output says
+    /// the whole tree still stands. Where it does not, the ordinary walk
+    /// draws the root, and each widget's own range decides how far down the
+    /// new length reaches.
+    pub fn resize(&mut self, size: impl Into<Vec2>, widgets: &mut Widgets) {
         let size = PxVec2::from_f32(size.into());
         if size == self.output_size {
             return;
         }
         self.output_size = size;
         self.resized = true;
+        let Some(root) = self.old_root else { return };
+        let stands = self
+            .active
+            .get(&root)
+            .is_some_and(|active| active.answers_at(active.given_len.to_px(size)));
+        if !stands {
+            widgets.needs_redraw.insert(root);
+        }
     }
 
     /// The root is asked about in the output: the window is where a fraction
@@ -108,9 +143,10 @@ impl UiRenderState {
             mask: MaskIdx::NONE,
             given_len: region.size(),
             offer_len: UiVec2::FULL_SIZE,
+            offer_placement: [None; 2],
             px,
             offered_px: px,
-            decided: [false; 2],
+            placement: [None; 2],
         }
     }
 
@@ -143,17 +179,6 @@ impl UiRenderState {
         if self.root_changed(root) {
             self.redraw_all(root, rsc);
             self.old_root = root.map(|r| r.id());
-        } else if let Some(root) = root
-            && self.resized
-        {
-            // The output is the root's box, so a resize is that box changing
-            // length, found the way every other box change is found. Before
-            // anything dirty settles, so that whatever a new output draws
-            // again is drawn once, in the box it will have.
-            let region = Self::root_region(root.id(), rsc.widgets());
-            let info = self.root_info(region);
-            let answer = self.draw_inner(root.id(), region, info, None, rsc);
-            self.active.get_mut(&root.id()).unwrap().answer = answer;
         }
         self.resized = false;
         if rsc.widgets().has_updates() {
@@ -175,11 +200,13 @@ impl UiRenderState {
     }
 
     fn root_region(id: WidgetId, widgets: &Widgets) -> UiRegion {
-        declared_box(
+        ask_box(
             UiRegion::FULL,
             declared_lens(widgets, id),
             widgets.alignment(id),
+            [None; 2],
         )
+        .0
     }
 
     pub(super) fn draw_inner(
@@ -189,83 +216,108 @@ impl UiRenderState {
         info: DrawInfo,
         mut old: Option<ActiveData>,
         rsc: &mut dyn UiRsc,
-    ) -> (Size, [Holds; 2]) {
+    ) -> (Size, LayoutHolds) {
         #[cfg(feature = "layout-diagnostics")]
         {
             diag::bump(Counter::DrawRequests);
             diag::draw_request(id, info.parent, region, info.px, info.region_node);
         }
         let align = rsc.widgets().alignment(id);
-        // Nothing this widget has is an answer while something it measured
+        // Nothing this widget measured can be dirty while it draws: layout is
-        // is dirty: settling that changes what it would report, and a widget
+        // one bottom-up walk, so anything deeper has settled or deferred to
-        // settled inside its parent's draw tells nobody -- the comparison
+        // its own parent, and a deferred one leaves that parent marked.
-        // that marks a reader is in `redraw`, which is not what asked here.
+        let stale = rsc.widgets().needs_redraw.contains(&id);
-        // Both retained routes are an answer, so the question is asked once
-        // rather than by each of them.
-        let stale =
-            rsc.widgets().needs_redraw.contains(&id) || self.dirty_size_under(id, rsc.widgets());
         let replace_answer = self.answer_invalid.remove(&id) || (self.replace_answers && stale);
         let retained = match replace_answer || stale {
             true => None,
             false => self
                 .retained_answer(id, info)
-                .or_else(|| self.try_reuse(id, region, info, rsc)),
+                .or_else(|| self.try_reuse(id, region, info.offered_placement(), info, rsc)),
         };
         let answer = retained.unwrap_or_else(|| {
             if old.is_none() {
                 old = self.remove(id, false, rsc);
             }
-            self.draw_at(id, region, info, old.take(), rsc)
+            self.draw_at(id, region, info.offered_placement(), info, old.take(), rsc)
         });
 
         let declared = declared_lens(rsc.widgets(), id);
-        // The second, final ask is in a box chosen from the answer on both
+        // Where the drawing goes, in the region's own coordinates: what the
-        // axes, which is also what makes it terminate.
+        // parent chose, and on any axis it left open, what the answer took of
-        let lens = placed_lens(answer.0, declared, info.decided);
+        // the region placed by the widget's alignment. The region itself does
-        let placed = placed_box(region, lens, align);
+        // not change, so nothing under it resolves a fraction a second time.
-        let placed_info = DrawInfo {
+        let lens = placed_lens(answer.0, declared, info.decided());
-            px: lens.to_px(info.px),
+        let own = placed_box(UiRegion::FULL, lens, align);
-            decided: [true; 2],
+        let placement = UiRegion {
-            ..info
+            x: info.placement[0].unwrap_or(own.x),
+            y: info.placement[1].unwrap_or(own.y),
         };
-        self.place(id, placed, placed_info, rsc);
+        self.place(id, region, placement, info, rsc);
 
-        // The answer is only reusable while both parts of the operation are:
+        // On axes chosen by the parent, measurement and drawing share an
-        // what the widget reported in the box it was asked in, and what it
+        // extent. Otherwise the answer fixes the final extent as a function
-        // drew in the box its report selected. Express the latter's contract
+        // of the frame, so pull that drawing's validity back through it.
-        // back in terms of the box asked in before handing it to the parent.
         let drawing_holds = self.active[&id].holds;
         let mut settled = answer;
         for axis in AXES {
-            settled.1[axis as usize] =
+            let n = axis as usize;
-                settled.1[axis as usize].and(drawing_holds[axis as usize].through(lens.axis(axis)));
+            settled.1.frame[n] = settled.1.frame[n].and(drawing_holds.frame[n]);
+            if info.placement[n].is_some() {
+                settled.1.extent[n] = settled.1.extent[n].and(drawing_holds.extent[n]);
+            } else {
+                settled.1.frame[n] = settled.1.frame[n]
+                    .and(drawing_holds.extent[n].through(placement.axis(axis).len()));
+            }
+        }
+        if drawing_holds.placement.is_some() && info.placement.iter().any(Option::is_some) {
+            settled.1.placement = Some(info.offered_placement());
         }
 
         let active = self.active.get_mut(&id).unwrap();
         // Whoever asked owns how the box was reached: the box it stated, and
         // what of that box the answer then took. A local redraw asks the
         // same question again from these.
-        active.given = region;
+        active.region = region;
         active.given_len = info.given_len;
         active.offer_len = info.offer_len;
-        active.answer = settled;
+        if info.placement == info.offer_placement && info.px == info.offered_px {
-        active.decided = info.decided;
+            active.answer = Some(settled);
+            active.offer_placement = info.offer_placement;
+        }
+        active.decided = info.decided();
         active.own_align = align;
-        active.depth = info.depth;
+        // A subtree can be reused whole under a different parent -- same box,
+        // same layer, same region node -- and nothing in the drawing says it
+        // changed hands. Two things read who its parent is: a deferral, which
+        // marks whoever has it to draw, and the old parent's list of children,
+        // which its next draw undraws whatever is missing from.
+        let old_parent = std::mem::replace(&mut active.parent, info.parent);
+        if old_parent != info.parent
+            && let Some(old_parent) = old_parent
+            && let Some(old_parent) = self.active.get_mut(&old_parent)
+        {
+            old_parent.children.retain(|child| *child != id);
+            old_parent.inherited_children.retain(|child| *child != id);
+        }
         settled
     }
 
-    /// Draws a widget in the final box its answer chose, reusing the drawing
+    /// Recompose retained geometry when the evaluation still holds at this extent.
-    /// already there where its retained contract holds for that box. The
+    fn place(
-    /// symbolic box can be unchanged while the box it sits in changed pixel
+        &mut self,
-    /// length, so what reuse checks is the box in pixels.
+        id: WidgetId,
-    fn place(&mut self, id: WidgetId, placed: UiRegion, info: DrawInfo, rsc: &mut dyn UiRsc) {
+        region: UiRegion,
-        if self.try_reuse(id, placed, info, rsc).is_none() {
+        placement: UiRegion,
-            #[cfg(feature = "layout-diagnostics")]
+        info: DrawInfo,
-            diag::bump(Counter::PlaceRedraws);
+        rsc: &mut dyn UiRsc,
-            let old = self.remove(id, false, rsc);
+    ) {
-            self.draw_at(id, placed, info, old, rsc);
+        if self.try_reuse(id, region, placement, info, rsc).is_some() {
+            return;
         }
+        #[cfg(feature = "layout-diagnostics")]
+        diag::bump(Counter::PlaceRedraws);
+        let old = self.remove(id, false, rsc);
+        self.draw_at(id, region, placement, info, old, rsc);
     }
 
     /// Calls a widget's `draw` and keeps what it drew in `region`.
@@ -273,10 +325,11 @@ impl UiRenderState {
         &mut self,
         id: WidgetId,
         region: UiRegion,
+        placement: UiRegion,
         info: DrawInfo,
         old: Option<ActiveData>,
         rsc: &mut dyn UiRsc,
-    ) -> (Size, [Holds; 2]) {
+    ) -> (Size, LayoutHolds) {
         let (move_idx, local, retired_move) = match info.region_node {
             // Its box becomes its movable region, so it draws in that
             // region's coordinates and its box is one entry to rewrite.
@@ -290,20 +343,25 @@ impl UiRenderState {
             false => (info.parent_move, region, self.slots.remove(&id)),
         };
         let (old_children, old_answer) = match old {
-            Some(old) => (old.children, Some(old.answer)),
+            Some(old) => (old.children, old.answer),
             None => (Vec::new(), None),
         };
         rsc.widgets_mut().needs_redraw.remove(&id);
-        // A box of the offered lengths asks the offer's question wherever it
+        // Only evaluation at the original offer establishes the children's
-        // sits, since what a drawing depends on is its lengths -- and
+        // offers. A placing evaluation must not overwrite that question.
-        // equality is the comparison, these being counts of a step rather
-        // than floats to be compared for nearness.
         let px = info.px;
-        let at_offer = px == info.offered_px;
+        let at_offer = px == info.offered_px
+            && placement
+                == UiRegion {
+                    x: info.offer_placement[0].unwrap_or(UiSpan::FULL),
+                    y: info.offer_placement[1].unwrap_or(UiSpan::FULL),
+                };
 
         let mut painter = Painter {
             state: self,
             region: local,
+            placement,
+            reads_placement: false,
             px,
             mask: info.mask,
             layer: info.layer,
@@ -311,6 +369,8 @@ impl UiRenderState {
             id,
             textures: Vec::new(),
             primitives: Vec::new(),
+            mask_region: None,
+            inherited_children: Vec::new(),
             children: Vec::new(),
             offered: Vec::new(),
             offered_px: info.offered_px,
@@ -318,6 +378,8 @@ impl UiRenderState {
             size_deps: Vec::new(),
             own: [Holds::ANY; 2],
             under: [Holds::ANY; 2],
+            extent_own: [Holds::ANY; 2],
+            extent_under: [Holds::ANY; 2],
             depth: info.depth,
             move_idx,
             rsc,
@@ -338,10 +400,16 @@ impl UiRenderState {
             state: _,
             rsc: _,
             region: _,
+            placement: _,
+            reads_placement,
             px: _,
             mask,
             textures,
             primitives,
+            mask_region,
+            inherited_children,
+            extent_own,
+            extent_under,
             children,
             offered: _,
             offered_px: _,
@@ -379,9 +447,16 @@ impl UiRenderState {
             "'{}' ({id:?}) clips to {px:?} and reports {size}",
             rsc.widgets().label(id),
         );
-        let holds = [own[0].and(under[0]), own[1].and(under[1])];
+        let holds = LayoutHolds {
+            frame: [own[0].and(under[0]), own[1].and(under[1])],
+            extent: [
+                extent_own[0].and(extent_under[0]),
+                extent_own[1].and(extent_under[1]),
+            ],
+            placement: reads_placement.then_some(placement),
+        };
         debug_assert!(
-            holds[0].contains(px.x) && holds[1].contains(px.y),
+            holds.contains(px, placement),
             "'{}' ({id:?}) drew in {px:?}, outside the ranges it reported: {holds:?}",
             rsc.widgets().label(id),
         );
@@ -410,9 +485,10 @@ impl UiRenderState {
                         mask,
                         given_len: UiVec2::FULL_SIZE,
                         offer_len: UiVec2::FULL_SIZE,
+                        offer_placement: [None; 2],
                         px,
                         offered_px: px,
-                        decided: [false; 2],
+                        placement: [None; 2],
                     },
                     rsc,
                 );
@@ -423,14 +499,12 @@ impl UiRenderState {
         let active = ActiveData {
             id,
             region,
-            // The box a placing ask draws in is a part of the one its parent
+            placement,
-            // gave, which `draw_inner` writes back over these once the
-            // placement is done.
-            given: region,
             given_len: info.given_len,
             offer_len: info.offer_len,
+            offer_placement: info.offer_placement,
             // Whoever asked writes the answer, if this was the asking.
-            answer: old_answer.unwrap_or((size, holds)),
+            answer: old_answer,
             size,
             holds,
             drawn: true,
@@ -438,10 +512,12 @@ impl UiRenderState {
             depth: info.depth,
             textures,
             primitives,
+            mask_region,
+            inherited_children,
             children,
             size_deps,
             declared: declared_lens(rsc.widgets(), id),
-            decided: info.decided,
+            decided: info.decided(),
             own_align: rsc.widgets().alignment(id),
             move_idx,
             parent_move: info.parent_move,
@@ -481,18 +557,24 @@ impl UiRenderState {
         &self,
         id: WidgetId,
         px: PxVec2,
+        placement: [Option<UiSpan>; 2],
         parent_move: MoveIdx,
         widgets: &Widgets,
-    ) -> Option<(Size, [Holds; 2])> {
+    ) -> Option<(Size, LayoutHolds)> {
-        if widgets.needs_redraw.contains(&id) || self.dirty_size_under(id, widgets) {
+        if widgets.needs_redraw.contains(&id) {
             return None;
         }
         let active = self.active.get(&id)?;
-        let (size, holds) = active.answer;
+        let (size, holds) = active.answer?;
         let valid = active.drawn
             && active.parent_move == parent_move
-            && holds[0].contains(px.x)
+            && holds.contains(
-            && holds[1].contains(px.y);
+                px,
+                UiRegion {
+                    x: placement[0].unwrap_or(UiSpan::FULL),
+                    y: placement[1].unwrap_or(UiSpan::FULL),
+                },
+            );
         valid.then_some((size, holds))
     }
 
@@ -500,7 +582,7 @@ impl UiRenderState {
     /// drawing ended up. Alignment is exactly that case: the first box is the
     /// question and the smaller placed box holds the drawing. Whether the
     /// answer is stale at all is its caller's question, asked once there.
-    fn retained_answer(&self, id: WidgetId, info: DrawInfo) -> Option<(Size, [Holds; 2])> {
+    fn retained_answer(&self, id: WidgetId, info: DrawInfo) -> Option<(Size, LayoutHolds)> {
         let active = self.active.get(&id)?;
         let has_region_node = active.move_idx != active.parent_move;
         if !active.drawn
@@ -509,22 +591,11 @@ impl UiRenderState {
         {
             return None;
         }
-        let (size, holds) = active.answer;
+        let answer = active.answer?;
-        (holds[0].contains(info.px.x) && holds[1].contains(info.px.y)).then_some((size, holds))
+        answer
-    }
+            .1
-
+            .contains(info.px, info.offered_placement())
-    /// Whether anything whose size this widget's own size was read from is
+            .then_some(answer)
-    /// dirty, which makes what it would answer not yet known. It also keeps
-    /// a reader that asks first from laying out twice, which is all it was
-    /// here for while a changed size was thought to reach its reader in any
-    /// order; it does not, where the change settles inside the reader's own
-    /// draw.
-    fn dirty_size_under(&self, id: WidgetId, widgets: &Widgets) -> bool {
-        self.active.get(&id).is_some_and(|active| {
-            active.size_deps.iter().any(|child| {
-                widgets.needs_redraw.contains(child) || self.dirty_size_under(*child, widgets)
-            })
-        })
     }
 
     /// The pixel lengths of the box a widget was given and of the box it was
@@ -542,11 +613,7 @@ impl UiRenderState {
         // Nothing above the root: the window is where a fraction becomes
         // pixels, which is also the whole of the box the root is given.
         let (parent_px, parent_offer) = match active.parent.and_then(|p| self.active.get(&p)) {
-            Some(parent) => {
+            Some(parent) => self.asked_px(parent.id),
-                let (given, offer) = self.asked_px(parent.id);
-                let lens = placed_lens(parent.answer.0, parent.declared, parent.decided);
-                (lens.to_px(given), offer)
-            }
             None => (self.output_size, self.output_size),
         };
         let px = active.given_len.to_px(parent_px);
@@ -568,9 +635,10 @@ impl UiRenderState {
         &mut self,
         id: WidgetId,
         region: UiRegion,
+        placement: UiRegion,
         info: DrawInfo,
         rsc: &mut dyn UiRsc,
-    ) -> Option<(Size, [Holds; 2])> {
+    ) -> Option<(Size, LayoutHolds)> {
         #[cfg(feature = "layout-diagnostics")]
         diag::bump(Counter::ReuseAttempts);
         if rsc.widgets().needs_redraw.contains(&id) {
@@ -619,7 +687,7 @@ impl UiRenderState {
         // In pixels, because `region` is a fraction of the box its parent
         // drew in and that box may be what changed -- an unchanged fraction
         // of a box half the size is half the widget.
-        if !active.holds_at(info.px) {
+        if !active.holds.contains(info.px, placement) {
             #[cfg(feature = "layout-diagnostics")]
             {
                 diag::bump(Counter::ReuseOutside);
@@ -627,6 +695,7 @@ impl UiRenderState {
             }
             return None;
         }
+        let extent_moved = active.placement != placement;
         let moved = active.region != region;
         let (answer, old_region, slot) =
             ((active.size, active.holds), active.region, active.move_idx);
@@ -638,12 +707,14 @@ impl UiRenderState {
                 self.remap_subtree(id, &remap, info.parent_move, rsc);
             }
         }
+        if extent_moved {
+            self.reposition(id, region, placement, info, rsc);
+        }
+        self.redepth(id, info.depth);
         let active = self.active.get_mut(&id).unwrap();
         active.region = region;
-        active.given = region;
         active.given_len = info.given_len;
         active.offer_len = info.offer_len;
-        active.depth = info.depth;
         #[cfg(feature = "layout-diagnostics")]
         {
             match (moved, has_region_node) {
@@ -667,6 +738,88 @@ impl UiRenderState {
         Some(answer)
     }
 
+    fn reposition(
+        &mut self,
+        id: WidgetId,
+        region: UiRegion,
+        placement: UiRegion,
+        info: DrawInfo,
+        rsc: &mut dyn UiRsc,
+    ) {
+        let active = self.active.get_mut(&id).unwrap();
+        active.region = region;
+        active.placement = placement;
+        let local = if info.region_node {
+            UiRegion::FULL
+        } else {
+            region
+        };
+        for primitive in &active.primitives {
+            let handle = &primitive.handle;
+            *self.layers[handle.layer].region_mut(handle) =
+                primitive.region.resolve(local, placement);
+        }
+        if let Some(mask_region) = active.mask_region {
+            rsc.ui_mut().masks.get_mut(active.mask).region = mask_region.resolve(local, placement);
+        }
+        let parent_move = active.move_idx;
+        let mask = active.mask;
+        let children = active.inherited_children.len();
+        for index in 0..children {
+            let child = self.active[&id].inherited_children[index];
+            let active = &self.active[&child];
+            let (child_local, chosen) = ask_box(
+                UiRegion::FULL,
+                active.declared,
+                active.own_align,
+                [Some(placement.x), Some(placement.y)],
+            );
+            let child_placement = UiRegion {
+                x: chosen[0].unwrap_or(UiSpan::FULL),
+                y: chosen[1].unwrap_or(UiSpan::FULL),
+            };
+            let child_info = DrawInfo {
+                layer: active.layer,
+                parent: Some(id),
+                depth: info.depth + 1,
+                parent_move,
+                region_node: active.move_idx != active.parent_move,
+                mask,
+                given_len: child_local.size(),
+                offer_len: active.offer_len,
+                offer_placement: active.offer_placement,
+                px: child_local.size().to_px(info.px),
+                offered_px: active.offer_len.to_px(info.offered_px),
+                placement: chosen,
+            };
+            self.place(
+                child,
+                child_local.within(&local),
+                child_placement,
+                child_info,
+                rsc,
+            );
+        }
+    }
+
+    /// A reused subtree keeps its shape, so every widget in it moves by the
+    /// same amount -- and where the top of it did not move, none of it did,
+    /// which is what makes this free in the ordinary case.
+    fn redepth(&mut self, id: WidgetId, depth: usize) {
+        let Some(active) = self.active.get_mut(&id) else {
+            return;
+        };
+        if active.depth == depth {
+            return;
+        }
+        active.depth = depth;
+        let children = active.children.len();
+        for index in 0..children {
+            let child = self.active[&id].children[index];
+            self.redepth(child, depth + 1);
+        }
+    }
+
     /// Re-expresses an ordinary retained subtree in a new parent region.
     /// An independently movable descendant needs only its own region changed;
     /// its contents stay in that region's coordinate space.
@@ -678,18 +831,18 @@ impl UiRenderState {
         rsc: &mut dyn UiRsc,
     ) {
         let active = self.active.get_mut(&id).unwrap();
-        active.given = remap.apply(active.given);
         if active.move_idx != parent_move {
             let region = remap.apply(active.region);
             active.region = region;
             self.moves.set(active.move_idx, region);
             return;
         }
-        for handle in &active.primitives {
-            let region = self.layers[handle.layer].region_mut(handle);
-            *region = remap.apply(*region);
-        }
         active.region = remap.apply(active.region);
+        for primitive in &active.primitives {
+            let handle = &primitive.handle;
+            *self.layers[handle.layer].region_mut(handle) =
+                primitive.region.resolve(active.region, active.placement);
+        }
         let own_mask = (active.mask != active.parent_mask).then_some(active.mask);
         let children = active.children.len();
         // A mask the widget set itself moves with it; one it inherited
@@ -697,7 +850,10 @@ impl UiRenderState {
         if let Some(idx) = own_mask {
             let mask = rsc.ui_mut().masks.get_mut(idx);
             debug_assert_eq!(mask.move_idx, parent_move);
-            mask.region = remap.apply(mask.region);
+            mask.region = active
+                .mask_region
+                .unwrap()
+                .resolve(active.region, active.placement);
         }
         for index in 0..children {
             let child = self.active[&id].children[index];
@@ -720,8 +876,8 @@ impl UiRenderState {
     fn remove(&mut self, id: WidgetId, undraw: bool, rsc: &mut dyn UiRsc) -> Option<ActiveData> {
         let mut active = self.active.remove(&id);
         if let Some(active) = &mut active {
-            for h in &active.primitives {
+            for primitive in &active.primitives {
-                let mask = self.layers.free(h);
+                let mask = self.layers.free(&primitive.handle);
                 if mask != MaskIdx::NONE {
                     rsc.ui_mut().masks.remove(mask);
                 }
@@ -776,17 +932,20 @@ impl UiRenderState {
             ActiveData {
                 id,
                 region: UiRegion::FULL,
-                given: UiRegion::FULL,
+                placement: UiRegion::FULL,
                 given_len: UiVec2::FULL_SIZE,
                 offer_len: UiVec2::FULL_SIZE,
-                answer: (size, [Holds::ANY; 2]),
+                offer_placement: [None; 2],
+                answer: None,
                 size,
-                holds: [Holds::ANY; 2],
+                holds: LayoutHolds::ANY,
                 drawn: false,
                 parent: info.parent,
                 depth: info.depth,
                 textures: Vec::new(),
                 primitives: Vec::new(),
+                mask_region: None,
+                inherited_children: Vec::new(),
                 children: Vec::new(),
                 size_deps: Vec::new(),
                 move_idx: info.parent_move,
@@ -935,8 +1094,9 @@ impl UiRenderState {
     pub fn window_region(&self, id: &impl IdLike) -> Option<PixelRegion> {
         let active = self.active.get(&id.id())?;
         active.drawn.then(|| {
+            let placed = active.placement.within(&active.region);
             self.moves
-                .resolve(active.parent_move, active.region)
+                .resolve(active.parent_move, placed)
                 .to_px(self.output_size)
         })
     }
@@ -957,7 +1117,7 @@ impl UiRenderState {
         let declared_changed = declared_lens(rsc.widgets(), id) != active.declared;
         let alignment_changed = rsc.widgets().alignment(id) != active.own_align;
         if let Some(parent) = active.parent
-            && (declared_changed || alignment_changed || !active.drawn)
+            && (declared_changed || alignment_changed || !active.drawn || active.answer.is_none())
         {
             if declared_changed {
                 self.replace_answers = true;
@@ -1013,19 +1173,30 @@ impl UiRenderState {
             mask: active.parent_mask,
             given_len: active.given_len,
             offer_len: active.offer_len,
+            offer_placement: active.offer_placement,
             px: given_px,
             offered_px,
-            decided: active.decided,
+            // The same question its parent asked: the axes its parent chose
+            // the placement on, put back where they were.
+            placement: AXES
+                .map(|axis| active.decided[axis as usize].then(|| *active.placement.axis(axis))),
         };
-        let (given, was_answer) = (active.given, active.answer);
+        let (given, was_answer) = (active.region, active.answer);
         #[cfg(feature = "layout-diagnostics")]
         diag::bump(Counter::LocalRedraws);
 
         let old = self.remove(id, false, rsc);
-        // `draw_inner` places the answer inside that box itself, which is the
+        // Refresh the original measurement before restoring the assigned slot.
-        // ask that leaves the widget where its parent put it.
+        // Its lengths may differ even though the fraction reference is unchanged.
-        let answer = self.draw_inner(id, given, info, old, rsc);
+        let offered = DrawInfo {
-        if answer != was_answer {
+            placement: info.offer_placement,
+            ..info
+        };
+        let answer = self.draw_inner(id, given, offered, old, rsc);
+        if info.placement != offered.placement {
+            self.draw_inner(id, given, info, None, rsc);
+        }
+        if Some(answer) != was_answer {
             // Its parent chose its box knowing the old answer, so it lays out
             // again and chooses the box the new one asks for.
             #[cfg(feature = "layout-diagnostics")]

src/default/mod.rs

@@ -251,7 +251,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
                 ui_state.renderer.draw();
             }
             WindowEvent::Resized(size) => {
-                render.resize((size.width, size.height));
+                render.resize((size.width, size.height), rsc.widgets_mut());
                 ui_state.renderer.resize(size)
             }
             WindowEvent::KeyboardInput { event, .. } => {

src/harness.rs

@@ -144,9 +144,9 @@ impl Harness {
         // bound that comes with `SyncSender` is far past anything a test
         // leaves unread.
         let (send, updates) = sync_channel(1024);
-        let rsc = DefaultRsc::init(Arc::new(Queue(send)));
+        let mut rsc = DefaultRsc::init(Arc::new(Queue(send)));
         let mut render = UiRenderState::new();
-        render.resize(size);
+        render.resize(size, rsc.widgets_mut());
         Self {
             rsc,
             render,
@@ -161,7 +161,7 @@ impl Harness {
     }
 
     pub fn resize(&mut self, size: impl Into<Vec2>) {
-        self.render.resize(size);
+        self.render.resize(size, self.rsc.widgets_mut());
     }
 
     /// Changes a length rule after the fact, the way `.width()` sets one.

src/widget/mask.rs

@@ -6,7 +6,7 @@ pub struct Masked {
 
 impl Widget for Masked {
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter.set_mask(painter.region());
+        painter.set_mask(DrawRegion::Extent(UiRegion::FULL));
         painter.widget(&self.inner);
         // What it occupies is its box, on both axes, for the reason `Scroll`
         // reports the same: it clips what is inside to that box, so it can

src/widget/position/pad.rs

@@ -13,9 +13,8 @@ impl Widget for Pad {
         // it; where the box is bigger -- a share of a row, a rule over this
         // widget -- the slack is the inner's to sit in, and forcing the near
         // edge pinned it to a corner it had not asked for.
-        let inner = painter
+        let inside = self.padding.region_of(painter.placement());
-            .widget_within(&self.inner, self.padding.region())
+        let inner = painter.widget_within(&self.inner, inside).size();
-            .size();
         Size {
             x: LayoutLen {
                 px: inner.x.px + self.padding.left + self.padding.right,
@@ -53,14 +52,18 @@ impl Padding {
             bottom: amt,
         }
     }
-    pub fn region(&self) -> UiRegion {
+    /// `region` less this padding on each side.
-        let mut region = UiRegion::FULL;
+    pub fn region_of(&self, mut region: UiRegion) -> UiRegion {
         region.x.start.px += self.left;
         region.y.start.px += self.top;
         region.x.end.px -= self.right;
         region.y.end.px -= self.bottom;
         region
     }
+
+    pub fn region(&self) -> UiRegion {
+        self.region_of(UiRegion::FULL)
+    }
     pub fn x(amt: impl UiNum) -> Self {
         let amt = Px::from_num(amt);
         Self {

src/widget/position/scroll.rs

@@ -15,10 +15,12 @@ impl Widget for Scroll {
         // Draw in the whole container only when its scrolling-axis length is
         // not already known, then draw it at the scrolled offset.
         let whole = UiRegion::FULL;
-        let answer_len = match painter.known_len(&self.inner, self.axis, whole, whole.size()) {
+        let own = painter.placement();
-            Some(len) => len,
+        let answer_len =
-            None => painter.widget(&self.inner).size().axis(self.axis),
+            match painter.known_len(&self.inner, self.axis, whole, [Some(own.x), Some(own.y)]) {
-        };
+                Some(len) => len,
+                None => painter.widget(&self.inner).size().axis(self.axis),
+            };
         let content = answer_len.apply_leftover();
         self.container_len = container_len;
         self.content_len = content.to_px(container_len);
@@ -64,7 +66,11 @@ impl Widget for Scroll {
             region = region.offset(offset);
             region.axis_mut(self.axis).end = region.axis(self.axis).start.offset(self.content_len);
         }
-        painter.widget_at(&self.inner, region, region.size(), [true; 2]);
+        // The viewport is the inner's region, so a fraction it declares or
+        // reports is a fraction of what is on screen rather than of the
+        // content box its own answer decided. Where it is put is the content
+        // box, scrolled.
+        painter.widget_at(&self.inner, whole, [Some(region.x), Some(region.y)]);
         // What it occupies is its box, on both axes: it clips its content to
         // that box, so it can neither take less of one nor honestly ask for
         // more. The content's length is what it scrolls through, not what it

src/widget/position/span.rs

@@ -10,25 +10,36 @@ pub struct Span {
 impl Widget for Span {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let axis = self.dir.axis;
+        // The row: this span's own box, as a span of the region it was given.
+        // Its children are laid out along it, and what they declare or report
+        // is a fraction of the region -- the area this span was told it has,
+        // which it passes on unchanged.
+        let own = painter.placement();
+        let row = *own.axis(axis);
+        // Across itself the span's own box is the child's region: a span is
+        // what contains its children there, and nothing divides that axis.
+        // Along it the whole region is, so a fraction means the same thing
+        // for every child however much of the row is left when it is asked.
+        let region = UiRegion::from_axis(axis, UiSpan::FULL, *own.axis(!axis));
+        let along = |from: Len, to: Len| match self.dir.sign {
+            Sign::Pos => UiSpan::new(row.start + from, row.start + to),
+            Sign::Neg => UiSpan::new(row.end - to, row.end - from),
+        };
+        let far = row.len();
         // A length for every child before their final boxes are chosen: from
         // a hint where one exists, and from drawing otherwise.
         let mut cursor = Len::rel_min();
         let mut lens = Vec::with_capacity(self.children.len());
         for child in &self.children {
-            let mut span = UiSpan::new(cursor, Len::rel_max());
+            // The whole region is the child's, so `rel(0.5)` is half the area
-            if self.dir.sign == Sign::Neg {
+            // this span was given whatever else is in it and wherever this
-                span.flip();
+            // child sits among them. What it is placed in is the room left
-            }
+            // from the cursor, because a text has to wrap at the width
-            let region = UiRegion::from_axis(axis, span, UiSpan::FULL);
+            // actually there.
-            // Offered the room left from the cursor, because a text has to
+            let room = axis.pair(Some(along(cursor, far)), None);
-            // wrap at the width actually there, but reporting a fraction of
+            let len = match painter.known_len(child, axis, region, room) {
-            // the whole row: `rel(0.5)` is half the span whatever else is in
-            // it and wherever this child sits among them.
-            let len = match painter.known_len(child, axis, region, UiVec2::FULL_SIZE) {
                 Some(len) => len,
-                None => painter
+                None => painter.widget_at(child, region, room).len(axis),
-                    .widget_at(child, region, UiVec2::FULL_SIZE, [false; 2])
-                    .len(axis),
             };
             cursor.px += len.px + self.gap;
             cursor.rel += len.rel;
@@ -46,43 +57,26 @@ impl Widget for Span {
             |sum, len| sum + *len,
         );
 
+        // What is left for the shares to divide: the row less everything
+        // fixed, as a length of the region rather than a number of pixels.
+        let room = far - Len::from_parts(total.rel, total.px);
         // Whether anything is left over is a question in pixels: `rel(0.5)`
-        // beside 300 px is full at 600 and overfull at 400. The room to
+        // beside 300 px is full at 600 and overfull at 400. Asked of `room`
-        // divide is `len * fixed - total.px`, and the length where it runs
+        // itself, and answered back through the same expression, so the
-        // out is exactly the box a parent sizing itself from this answer
+        // boundary is the drawing's own and not a second way of finding it:
-        // hands back -- which is why this used to need a margin either side
+        // the three cases a rounded division needed -- the fixed parts
-        // of the boundary, and why it does not now: that box and this sum are
+        // growing slower than the box, faster, or exactly with it -- are the
-        // whole counts of the same step, and both routes to it land on the
+        // sign of `room.rel`, which `through` already reads. What the
-        // same count. What the generated oracle checks is the consequence,
+        // generated oracle checks is the consequence, since which children
-        // since which children exist at all turns on this.
+        // exist at all turns on this.
-        let fixed = Rel::ONE - total.rel;
         let mut shares = false;
         if total.leftover > Weight::ZERO {
-            let current = painter.px_len(axis);
+            shares = room.to_px(painter.region_px_len(axis)) > Px::ZERO;
-            let holds = if fixed > Rel::ZERO {
+            let holds = match shares {
-                // The box length the fixed parts alone fill.
+                true => Holds::from(Px::STEP..=Px::MAX),
-                let full = total.px.div(fixed);
+                false => Holds::from(Px::MIN..=Px::ZERO),
-                shares = current > full;
-                match shares {
-                    true => Holds::from(full.next_up()..=Px::MAX),
-                    false => Holds::from(Px::MIN..=full),
-                }
-            } else if fixed < Rel::ZERO {
-                // The relative parts grow faster than the box does, so here
-                // a shorter box is the one that leaves room.
-                let full = total.px.div(fixed);
-                shares = current < full;
-                match shares {
-                    true => Holds::from(Px::MIN..=full.next_down()),
-                    false => Holds::from(full..=Px::MAX),
-                }
-            } else {
-                // The relative parts take exactly the box, whatever it is, so
-                // the only room is what negative pixels leave.
-                shares = total.px < Px::ZERO;
-                Holds::ANY
             };
-            painter.holds(axis, holds);
+            painter.region_holds(axis, holds.through(room));
         }
 
         // Across itself a span is as long as its longest child -- unless a
@@ -99,7 +93,6 @@ impl Widget for Span {
         // row.
         let mut fixed = Len::rel_min();
         let mut taken = Weight::ZERO;
-        let room = Len::rel_max() - Len::from_parts(total.rel, total.px);
         let mut start = Len::rel_min();
         let mut ortho = LayoutLen::ZERO;
         for (child, len) in self.children.iter().zip(&lens) {
@@ -112,28 +105,19 @@ impl Widget for Span {
                 fixed.px += self.gap;
                 continue;
             }
-            let mut span = UiSpan::FULL;
+            let from = start;
-            span.start = start;
             if len.leftover > Weight::ZERO && shares {
                 taken += len.leftover;
             }
             fixed.px += len.px;
             fixed.rel += len.rel;
             start = shared(fixed, taken, total.leftover, room);
-            span.end = start;
+            // Along the row the span says where the child goes; across it the
-            let mut region = UiRegion::from_axis(axis, span, UiSpan::FULL);
+            // child sits where its own alignment says. Its region is the
-            if self.dir.sign == Sign::Neg {
+            // whole of what this span was given either way, which is what its
-                region.flip(axis);
+            // fractions are of.
-            }
+            let placed =
-            // Along the row this box is the child's own answer, so the answer
+                painter.widget_at(child, region, axis.pair(Some(along(from, start)), None));
-            // is not placed in it again; across it the child sits where its
-            // alignment says.
-            let placed = painter.widget_at(
-                child,
-                region,
-                UiVec2::FULL_SIZE,
-                [axis == Axis::X, axis == Axis::Y],
-            );
             if shrinks {
                 let used = placed.len(!axis);
                 // Choosing between a fixed and a relative length from the

src/widget/position/stack.rs

@@ -13,31 +13,37 @@ impl Widget for Stack {
             StackSize::Default => None,
             StackSize::Child(i) => Some(i),
         };
-        // Whichever child sizes the stack decides the box every child gets.
+        // This stack's own box, which is `FULL` until its answer is known.
-        // The stack reports that size, so a child given a longer box would
+        let placement = painter.placement();
-        // draw outside what the stack says it occupies.
+        // Whichever child sizes the stack keeps the stack's whole region as
+        // its own -- the stack is the length that child asked for, so taking
+        // the fraction of the stack's box again would take it twice -- and is
+        // put where the stack itself is put.
         let size = match sizing.and_then(|i| self.children.get(i).map(|c| (i, c))) {
             // On the layer that child ends up on, so the ask below is a reuse
             // rather than a second drawing of it somewhere else: a retained
             // drawing belongs to the layer it was made on.
             Some((i, child)) => {
                 painter.child_layer_at(i);
-                painter.widget(child).size()
+                painter
+                    .widget_at(
+                        child,
+                        UiRegion::FULL,
+                        [Some(placement.x), Some(placement.y)],
+                    )
+                    .size()
             }
             None => Size::LEFTOVER,
         };
-        let region = painter.box_of(size);
         for (i, child) in self.children.iter().enumerate() {
+            if sizing == Some(i) {
+                continue;
+            }
             painter.child_layer_at(i);
-            // The sizing child placed its own content in the box its answer
+            // Every other child has the stack's own box for its region, since
-            // decided, and this box was derived from that answer, so applying
+            // the stack is what contains it, and where it sits in one bigger
-            // its alignment again here would place it twice. Every other
+            // than itself is its own business.
-            // child is handed a box that owes nothing to its own answer, and
+            painter.widget_within(child, placement);
-            // where it sits in one bigger than itself is its own business.
-            match sizing == Some(i) {
-                true => painter.widget_at(child, region, region.size(), [true; 2]),
-                false => painter.widget_within(child, region),
-            };
         }
         size
     }

src/widget/text/mod.rs

@@ -89,8 +89,7 @@ impl TextView {
         // hair under that line, and the break made in it is not the break a
         // cold layout makes there.
         let size = Size::from_px(PxVec2::ceil_from_f32(tex.size));
-        let within = region.within(&painter.region());
+        painter.glyphs(tex, DrawRegion::Extent(region));
-        painter.glyphs(tex, within);
         (region, size)
     }
 

tests/cases/layout.rs

@@ -20,11 +20,12 @@ fn a_span_gives_each_child_the_width_it_asked_for() {
     assert_corners!(h, right, (100, 0), (400, 200));
 }
 
-/// A span offers each child the room left after the one before, because a
+/// A span places each child in the room left after the one before, because a
-/// text has to wrap at the width actually there, but reads what the child
+/// text has to wrap at the width actually there, but the child's region is
-/// reports as a fraction of the whole row. So two children asking for half
+/// the whole row. So two children asking for half each take the whole row
-/// each take the whole row between them, however much of it was left when
+/// between them, however much of it was left when each was asked, and a third
-/// each was asked, and a third overflows.
+/// overflows -- and a span passes its own region on unchanged, so a child of
+/// a nested span asking for half asks for half of the same row.
 #[test]
 fn a_span_reads_a_child_report_as_a_fraction_of_the_row() {
     let mut h = Harness::new((400, 100));
@@ -34,10 +35,10 @@ fn a_span_reads_a_child_report_as_a_fraction_of_the_row() {
     let tail = rect(Color::BLUE).width(100).add(&mut h.rsc);
     h.set_root((half, nested, tail).span(Dir::RIGHT).width(rel(1.0)));
 
-    // The nested span is placed at the length it reported and drawn there
+    // The nested span is placed at the length it reported, and its own child
-    // once more; half of that final box is what its own child takes.
+    // asks for half of the row rather than half of that placement.
     assert_corners!(h, nested, (200, 0), (400, 100));
-    assert_corners!(h, inner, (200, 0), (300, 100));
+    assert_corners!(h, inner, (200, 0), (400, 100));
     assert_corners!(h, tail, (400, 0), (500, 100));
 }
 
@@ -698,3 +699,20 @@ fn equal_shares_differ_by_at_most_two_steps_and_fill_the_row() {
         }
     }
 }
+
+#[test]
+fn a_stack_sized_by_a_child_does_not_take_that_childs_fraction_twice() {
+    let mut h = Harness::new((400, 200));
+    let half = rect(Color::RED).width(rel(0.5)).add(&mut h.rsc);
+    let behind = rect(Color::BLUE).add(&mut h.rsc);
+    let stack = Stack {
+        children: vec![behind.add_strong(&mut h.rsc), half.add_strong(&mut h.rsc)],
+        size: StackSize::Child(1),
+    }
+    .add(&mut h.rsc);
+    h.set_root((stack,).span(Dir::RIGHT).width(rel(1.0)));
+
+    assert_corners!(h, stack, (0, 0), (200, 200));
+    assert_corners!(h, half, (0, 0), (200, 200));
+    assert_corners!(h, behind, (0, 0), (200, 200));
+}

tests/cases/retained.rs

@@ -156,16 +156,9 @@ fn a_span_child_that_declares_its_length_is_drawn_once() {
     h.set_root((hinted, asked).span(Dir::RIGHT));
 
     assert_eq!(told_draws.get(), 1);
-    // Reading its box makes its drawing hold for the measuring box alone,
+    // Only the available length changes: positioning the final slot does
-    // and it reports less than that box: so it is drawn again in the box its
+    // not invalidate a numeric size read.
-    // answer places it in, and once more in the final box the span chooses.
+    assert_eq!(asked_draws.get(), 2);
-    // A widget that says what it holds for, as text does, skips the middle
-    // one.
-    assert_eq!(
-        asked_draws.get(),
-        3,
-        "drawn to be measured, in its placed box, then in its final box"
-    );
 }
 
 #[test]
@@ -628,3 +621,190 @@ fn a_masked_widget_redrawn_on_its_own_sets_its_mask_again() {
     h.frame();
     assert_corners!(h, inner, (100, 0), (400, 200));
 }
+
+/// The two spans a subtree changes hands between, and the branch that is not
+/// in the tree yet -- kept alive by the test until it is.
+struct Handover {
+    leaf: WidgetId,
+    first: WeakWidget<Span>,
+    second: WeakWidget<Span>,
+    root: WeakWidget<Span>,
+    spare: StrongWidget,
+}
+
+/// A subtree that changes hands while its box does not move, so nothing about
+/// reusing its drawing says it changed parents. `deeper` puts a span between
+/// the root and `second`, so it changes depth by changing hands as well.
+fn plant_handover(h: &mut Harness, moved: bool, deeper: bool, width: f32) -> Handover {
+    let leaf = rect(Color::RED).add(&mut h.rsc);
+    let sized = leaf.width(width).add(&mut h.rsc);
+    let holder = (sized,).span(Dir::RIGHT).add(&mut h.rsc);
+    let first = Span {
+        children: match moved {
+            true => Vec::new(),
+            false => vec![holder.add_strong(&mut h.rsc)],
+        },
+        dir: Dir::RIGHT,
+        gap: Px::ZERO,
+    }
+    .add(&mut h.rsc);
+    let second = Span {
+        children: match moved {
+            true => vec![holder.add_strong(&mut h.rsc)],
+            false => Vec::new(),
+        },
+        dir: Dir::RIGHT,
+        gap: Px::ZERO,
+    }
+    .add(&mut h.rsc);
+    let branch = match deeper {
+        true => (second,).span(Dir::RIGHT).add_strong(&mut h.rsc),
+        false => second.add_strong(&mut h.rsc),
+    };
+    let (in_tree, spare) = match moved {
+        true => (branch, first.add_strong(&mut h.rsc)),
+        false => (first.add_strong(&mut h.rsc), branch),
+    };
+    let root = Span {
+        children: vec![in_tree],
+        dir: Dir::RIGHT,
+        gap: Px::ZERO,
+    }
+    .add(&mut h.rsc);
+    h.state.root = Some(root.add_strong(&mut h.rsc));
+    Handover {
+        leaf: sized.id(),
+        first,
+        second,
+        root,
+        spare,
+    }
+}
+
+/// Moves the subtree and swaps the branch it sits in for the one it left.
+fn hand_over(h: &mut Harness, tree: Handover) -> WidgetId {
+    let holder = h.rsc[tree.first].children.remove(0);
+    h.rsc[tree.second].children.push(holder);
+    h.rsc[tree.root].children.clear();
+    h.rsc[tree.root].children.push(tree.spare);
+    h.frame();
+    tree.leaf
+}
+
+#[test]
+fn a_subtree_that_changed_parents_is_not_undrawn_by_the_one_it_left() {
+    let mut warm = Harness::new((400, 200));
+    let tree = plant_handover(&mut warm, false, false, 40.0);
+    warm.frame();
+    let leaf = hand_over(&mut warm, tree);
+
+    let mut cold = Harness::new((400, 200));
+    let grown = plant_handover(&mut cold, true, false, 40.0);
+    cold.frame();
+
+    assert_eq!(
+        warm.region(&leaf),
+        cold.region(&grown.leaf),
+        "the span it left still listed it and undrew it"
+    );
+}
+
+#[test]
+fn a_subtree_that_changed_parents_settles_at_the_depth_it_moved_to() {
+    let mut warm = Harness::new((400, 200));
+    let tree = plant_handover(&mut warm, false, true, 40.0);
+    warm.frame();
+    let leaf = hand_over(&mut warm, tree);
+    // After it has changed hands, so what has to reach the new parent is a
+    // change made under the subtree it now holds.
+    warm.set_len(leaf, Axis::X, LayoutLen::px(90.0));
+    warm.frame();
+
+    let mut cold = Harness::new((400, 200));
+    let grown = plant_handover(&mut cold, true, true, 90.0);
+    cold.frame();
+
+    assert_eq!(
+        warm.region(&leaf),
+        cold.region(&grown.leaf),
+        "the span it moved to is the one the change has to reach"
+    );
+}
+
+fn primitive_bounds(h: &Harness, id: WidgetId) -> Vec<PixelRegion> {
+    h.render.active[&id]
+        .primitives
+        .iter()
+        .map(|primitive| {
+            let handle = &primitive.handle;
+            let instance = &h.render.layers[handle.layer].primitives()[handle.kind as usize]
+                .as_ref()
+                .unwrap()
+                .instances()[handle.inst_idx];
+            h.render
+                .moves
+                .resolve(instance.move_idx, instance.region)
+                .to_px(h.render.output_size())
+        })
+        .collect()
+}
+
+#[test]
+fn frame_geometry_and_extent_geometry_keep_their_references() {
+    struct Both(Rc<Cell<usize>>);
+    impl Widget for Both {
+        fn draw(&mut self, painter: &mut Painter) -> Size {
+            self.0.set(self.0.get() + 1);
+            painter.primitive_within(RectPrimitive::color(Color::RED), UiRegion::FULL);
+            painter.primitive(RectPrimitive::color(Color::BLUE));
+            Size::LEFTOVER
+        }
+    }
+    for node in [false, true] {
+        let mut h = Harness::new((400, 200));
+        let first = rect(Color::GREEN).width(100).add(&mut h.rsc);
+        let draws = Rc::new(Cell::new(0));
+        let both = Both(draws.clone()).add(&mut h.rsc);
+        h.rsc.widgets_mut().set_region_node(both, node);
+        h.set_root((first, both).span(Dir::RIGHT));
+        let count = draws.get();
+        h.set_len(first, Axis::X, 200);
+        h.frame();
+        assert_eq!(draws.get(), count);
+        let bounds = primitive_bounds(&h, both.id());
+        assert_eq!(bounds[0].top_left.x, Px::ZERO);
+        assert_eq!(bounds[0].bot_right.x, Px::from_int(400));
+        assert_eq!(bounds[1].top_left.x, Px::from_int(200));
+        assert_eq!(bounds[1].bot_right.x, Px::from_int(400));
+    }
+}
+
+#[test]
+fn changing_an_inherited_extent_keeps_the_original_measurement_offer() {
+    fn build(h: &mut Harness, width: i32, text: &str) -> (WeakWidget<Text>, WeakWidget<Rect>) {
+        let first = rect(Color::RED).width(width).add(&mut h.rsc);
+        let words = wtext(text).size(20).wrap(true).add(&mut h.rsc);
+        let through = Stretchy {
+            inner: words.add_strong(&mut h.rsc),
+            draws: Rc::new(Cell::new(0)),
+        }
+        .add(&mut h.rsc);
+        h.set_root((first, through).span(Dir::RIGHT));
+        (words, first)
+    }
+    let short = "one two";
+    let long = "one two three four five six seven eight nine ten eleven twelve";
+    let mut warm = Harness::new((400, 200));
+    let (words, first) = build(&mut warm, 50, short);
+    warm.set_len(first, Axis::X, 200);
+    warm.frame();
+    *warm.rsc[words].content = long.to_string();
+    warm.frame();
+    let mut cold = Harness::new((400, 200));
+    let (other, _) = build(&mut cold, 200, long);
+    assert_eq!(warm.region(&words), cold.region(&other));
+    assert_eq!(
+        primitive_bounds(&warm, words.id()),
+        primitive_bounds(&cold, other.id())
+    );
+}

tests/cases/unsettled.rs

@@ -614,3 +614,61 @@ fn a_text_is_given_back_a_box_the_line_it_measured_fits_in() {
 
     assert_eq!(warm.region(&text), cold.region(&cold_text));
 }
+
+#[test]
+fn adding_text_to_a_reverse_row_keeps_its_shared_height() {
+    fn build(
+        h: &mut Harness,
+        changed: bool,
+    ) -> (WeakWidget<Span>, WeakWidget<Text>, Vec<StrongWidget>) {
+        let wrap = wtext("Wrapping shapes one source into as many lines as the box leaves room for, so a paragraph's height is an answer and not a setting.").size(16).wrap(true).add_strong(&mut h.rsc);
+        let one = || {
+            wtext("one line, overflowing whatever it is given")
+                .size(16)
+                .wrap(false)
+        };
+        let plain = one().add_strong(&mut h.rsc);
+        let shared = one()
+            .width(LayoutLen::LEFTOVER)
+            .height(LayoutLen::LEFTOVER)
+            .add(&mut h.rsc);
+        let mut extra: Vec<StrongWidget> = vec![
+            rect(Color::RED).add_strong(&mut h.rsc),
+            one().add_strong(&mut h.rsc),
+            one().add_strong(&mut h.rsc),
+        ];
+        let children: Vec<StrongWidget> = if changed {
+            let mut children: Vec<StrongWidget> = vec![plain, shared.add_strong(&mut h.rsc)];
+            children.append(&mut extra);
+            children
+        } else {
+            vec![wrap, plain, shared.add_strong(&mut h.rsc)]
+        };
+        let row = Span {
+            children,
+            dir: Dir::LEFT,
+            gap: Px::ZERO,
+        }
+        .height(LayoutLen::rel(1.0))
+        .add(&mut h.rsc);
+        let fill: StrongWidget = rect(Color::BLUE).add_strong(&mut h.rsc);
+        let children: Vec<StrongWidget> = vec![fill, row.add_strong(&mut h.rsc)];
+        let root = Span {
+            children,
+            dir: Dir::RIGHT,
+            gap: Px::from_int(4),
+        }
+        .height(LayoutLen::rel(1.0))
+        .add(&mut h.rsc);
+        h.set_root(root);
+        (row, shared, extra)
+    }
+    let mut warm = Harness::new((900, 1200));
+    let (row, shared, extra) = build(&mut warm, false);
+    warm.rsc[row].children.remove(0);
+    warm.rsc[row].children.extend(extra);
+    warm.frame();
+    let mut cold = Harness::new((900, 1200));
+    let (_, other, _) = build(&mut cold, true);
+    assert_eq!(warm.region(&shared), cold.region(&other));
+}