Record which widget is drawing a subtree that changed hands

A subtree can be reused whole under a different parent -- same box, same
layer, same region node, clean -- and nothing in the drawing says it
moved. Two things read who its parent is, and both were wrong after one
of these.

The old parent still listed it as a child, and a parent's next draw
undraws whatever is missing from that list: two spans under one root,
with the root swapping which of them it holds, drew the subtree under
the new span and then erased it when the old one drew. The move is
recorded on both sides where `draw_inner` already writes what the ask
decided, rather than guarded at each reader.

Its depth was also the one it had under the old parent, which is what
the settling walk orders by, so a change made under it afterwards
settled at the wrong point in the frame. `try_reuse` re-walks the
subtree's depths, and only where the top of it moved, which is what
makes that free in the ordinary case.

Two tests: one shape where the subtree's box does not move and the span
it left erases it, one where it changes depth and the change made under
it has to reach the span it moved to. Each fails without one half.

core/src/fixed.rs

@@ -109,6 +109,18 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
         })
     }
 
+    /// The first step at or above `v`, where [`Self::from_f32`] takes the
+    /// nearest one and is below it half the time. For a bound that has to
+    /// admit the value it came from: a measurement rounded down is a bound
+    /// that leaves out the thing it was measured from.
+    pub const fn ceil_from_f32(v: f32) -> Self {
+        let nearest = Self::from_f32(v);
+        match nearest.to_f32() < v {
+            true => nearest.next_up(),
+            false => nearest,
+        }
+    }
+
     /// From a number as it is written in source -- `16`, `1.5` -- which is
     /// the other place a value enters the grid.
     pub fn from_num(v: impl UiNum) -> Self {
@@ -372,6 +384,12 @@ impl<const SHIFT: u32> FixedVec2<SHIFT> {
         Self::new(Fixed::from_f32(v.x), Fixed::from_f32(v.y))
     }
 
+    /// The first step at or above each part, for a measurement reported as a
+    /// box: what it occupies is not less than what was measured.
+    pub fn ceil_from_f32(v: Vec2) -> Self {
+        Self::new(Fixed::ceil_from_f32(v.x), Fixed::ceil_from_f32(v.y))
+    }
+
     pub fn to_f32(self) -> Vec2 {
         Vec2::new(self.x.to_f32(), self.y.to_f32())
     }
@@ -488,6 +506,25 @@ mod tests {
         assert_eq!(Px::from_int(100) / Rel::from_f32(0.5), Px::from_int(200));
     }
 
+    /// The bound a greedy line break needs: the width it was measured at is
+    /// not on the grid, and the narrowest box the break still holds for is
+    /// the step at or above it, never the one below.
+    #[test]
+    fn a_ceiling_never_lands_below_the_number_it_came_from() {
+        let step = 1.0 / (1 << PX_SHIFT) as f32;
+        for n in 0..64 {
+            let v = 189.0 + n as f32 * step / 3.0;
+            let up = Px::ceil_from_f32(v);
+            assert!(up.to_f32() >= v, "{up:?} is below {v}");
+            assert!(
+                up.to_f32() - v < step,
+                "{up:?} is more than a step above {v}"
+            );
+        }
+        // An exact step is its own ceiling.
+        assert_eq!(Px::ceil_from_f32(189.5), Px::from_f32(189.5));
+    }
+
     #[test]
     fn a_number_from_outside_is_clamped_to_the_grid() {
         assert_eq!(Px::from_f32(1e12), Px::MAX);

core/src/primitive/text.rs

@@ -107,13 +107,6 @@ impl Default for TextAttrs {
     }
 }
 
-/// How far below the longest line a width may fall and still be answered by
-/// the break in hand. A parent that offers a child the length it reported
-/// composes that length back through the box chain, so the two differ in the
-/// last bits -- and at exactly the longest line, that decides whether a line
-/// fits. Sub-pixel, so no break it admits is one a reader could see.
-const BREAK_EPSILON_PX: f32 = 0.05;
-
 /// Keeps text and its corresponding layout from getting out of sync.
 pub struct TextBuffer {
     text: String,
@@ -200,15 +193,19 @@ impl TextBuffer {
         // A greedy break at one width is the same break at every width down
         // to the longest line it produced: each line still fits, and none can
         // take a word that would not fit in the wider box. So the layout in
-        // hand already answers, and re-breaking would only be a chance to
-        // disagree with itself -- which is what happens when a parent offers
-        // a child the length that child just reported, and the two land
-        // either side of a float.
+        // hand already answers, and re-breaking would only be work.
+        //
+        // At the longest line exactly, with no margin below it. A narrower
+        // width really does break differently, so answering one from the
+        // break in hand is how a warm tree keeps lines a cold tree would
+        // never produce. The margin was here because a text reports the
+        // width it used and a parent hands that back; the report is the step
+        // at or above its longest line now, so what comes back fits.
         if let Some(key) = &self.layout_key
             && key.attrs == *attrs
             && let (Some(broke_at), Some(want)) = (key.max_width, width)
             && want <= broke_at
-            && want + BREAK_EPSILON_PX >= self.layout.width()
+            && want >= self.layout.width()
         {
             #[cfg(feature = "layout-diagnostics")]
             diag::bump(Counter::TextShapeHits);

core/src/ui/active.rs

@@ -74,4 +74,12 @@ impl ActiveData {
     pub fn holds_at(&self, px: crate::PxVec2) -> bool {
         self.holds[0].contains(px.x) && self.holds[1].contains(px.y)
     }
+
+    /// Whether what it answered still stands for a box of these pixel
+    /// lengths -- the box it was asked in, where `holds` is about the box its
+    /// answer then chose.
+    pub fn answers_at(&self, px: crate::PxVec2) -> bool {
+        let (_, holds) = self.answer;
+        holds[0].contains(px.x) && holds[1].contains(px.y)
+    }
 }

core/src/ui/painter.rs

@@ -139,29 +139,30 @@ impl<'a> Painter<'a> {
         id: &'s StrongWidget<W>,
         region: UiRegion,
     ) -> DrawResult<'s, 'a, W> {
-        self.widget_at(id, region, [false; 2])
+        self.widget_at(id, region, region.size(), [false; 2])
     }
 
-    /// Draws a widget in a box this widget chose from the widget's own
-    /// answer along the `decided` axes. On those the answer is not placed
-    /// inside the box again: it already is the box, and a fraction the
-    /// widget reported of its offer, taken of this box a second time, would
-    /// shrink it twice. A container uses this where it hands back exactly
+    /// Draws a widget in `region`, saying what the answer means.
+    ///
+    /// `reports_of` is what a fraction the child reports is a fraction of, as
+    /// lengths of this widget's own box. It is the box the child was given
+    /// wherever that box is the child's whole area -- a pad's inset, a stack
+    /// child, a scroll's content -- and a span passes its own extent along
+    /// the row instead: it offers each child the room left from its cursor,
+    /// 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
+    /// own answer. On those the answer is not placed inside the box again: it
+    /// already is the box, and a fraction taken of it a second time would
+    /// shrink it twice. A container uses that where it hands back exactly
     /// what a child asked for -- a span placing a child at the length it
     /// reported, a scroll giving its content the content's own length.
-    pub fn widget_decided<'s, W: ?Sized>(
-        &'s mut self,
-        id: &'s StrongWidget<W>,
-        region: UiRegion,
-        decided: [bool; 2],
-    ) -> DrawResult<'s, 'a, W> {
-        self.widget_at(id, region, decided)
-    }
-
-    fn widget_at<'s, W: ?Sized>(
+    pub fn widget_at<'s, W: ?Sized>(
         &'s mut self,
         id: &'s StrongWidget<W>,
         region: UiRegion,
+        reports_of: UiVec2,
         decided: [bool; 2],
     ) -> DrawResult<'s, 'a, W> {
         let region_node = self.rsc.widgets().is_region_node(id.id());
@@ -234,7 +235,7 @@ impl<'a> Painter<'a> {
         DrawResult {
             child: id,
             painter: self,
-            size: in_parent_frame(size, local, declared),
+            size: in_parent_frame(size, reports_of, declared),
         }
     }
 
@@ -268,12 +269,14 @@ impl<'a> Painter<'a> {
 
     /// A child's length in the box it is about to be offered, if it can be
     /// had without drawing it: from its hint, or from a drawing it already
-    /// has that holds for that box.
+    /// has that holds for that box. `reports_of` is what a fraction in the
+    /// 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,
     ) -> Option<LayoutLen> {
         let declared = self.declared_lens(child);
         let align = self.rsc.widgets().alignment(child.id());
@@ -299,7 +302,7 @@ impl<'a> Painter<'a> {
         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, local, declared).axis(axis))
+        Some(in_parent_frame(size, reports_of, declared).axis(axis))
     }
 
     /// Whether this is the first box a child is asked about in during a draw
@@ -518,18 +521,19 @@ impl PrimitiveLike for &TextureHandle {
     }
 }
 
-/// A child's answer as lengths of the box it was asked from. A widget reports
-/// a fraction of the box it was given, and the widget that gave it wants the
-/// same length as a fraction of its own: one composition apart wherever the
-/// offer was not the whole of the parent's extent, as a span's is after a
-/// relative child. A declared axis is already the parent's: it resolved the
-/// rule in its own box, and the rule is what the report says.
-fn in_parent_frame(size: Size, local: UiRegion, declared: [Option<LayoutLen>; 2]) -> Size {
+/// A child's answer as lengths of the parent's own box. A widget reports a
+/// fraction, and `reports_of` is the length that fraction is of: the box the
+/// child was given wherever that is the child's whole area, and the parent's
+/// own extent wherever the box is a positional remainder, as a span's is
+/// after an earlier child. Pixels come through untouched either way, being
+/// that many pixels wherever they end up. A declared axis is already the
+/// 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() {
-            let len = local.axis(axis).len();
-            *size.axis_mut(axis) = size.axis(axis).within_len(len);
+            *size.axis_mut(axis) = size.axis(axis).within_len(reports_of.axis(axis));
         }
     }
     size

core/src/ui/render_state.rs

@@ -32,7 +32,7 @@ pub(super) struct DrawInfo {
     pub offered_px: PxVec2,
     /// The axes along which the parent chose this box from the widget's own
     /// answer, so the answer is not placed inside it again. See
-    /// [`Painter::widget_decided`].
+    /// [`Painter::widget_at`].
     pub decided: [bool; 2],
 }
 
@@ -43,7 +43,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.
@@ -55,6 +57,9 @@ pub struct UiRenderState {
     /// Whether this frame contains a declared-length change, so any dirty
     /// dependent replaces its answer too.
     replace_answers: bool,
+    /// Widgets waiting for an ancestor to draw them, so the walk down the
+    /// depths does not pick one up again at its own depth.
+    deferred: crate::util::HashSet<WidgetId>,
     pub moves: Moves,
 }
 
@@ -68,6 +73,7 @@ impl UiRenderState {
             slots: Default::default(),
             answer_invalid: Default::default(),
             replace_answers: false,
+            deferred: Default::default(),
             moves: Default::default(),
             resized: false,
         }
@@ -79,13 +85,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
@@ -139,17 +160,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() {
@@ -192,14 +202,15 @@ impl UiRenderState {
             diag::draw_request(id, info.parent, region, info.px, info.region_node);
         }
         let align = rsc.widgets().alignment(id);
-        let replace_answer = self.answer_invalid.remove(&id)
-            || (self.replace_answers
-                && (rsc.widgets().needs_redraw.contains(&id)
-                    || self.dirty_size_under(id, rsc.widgets())));
-        let retained = match replace_answer {
+        // Nothing this widget measured can be dirty while it draws: layout is
+        // one bottom-up walk, so anything deeper has settled or deferred to
+        // its own parent, and a deferred one leaves that parent marked.
+        let stale = rsc.widgets().needs_redraw.contains(&id);
+        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, rsc.widgets())
+                .retained_answer(id, info)
                 .or_else(|| self.try_reuse(id, region, info, rsc)),
         };
         let answer = retained.unwrap_or_else(|| {
@@ -242,7 +253,18 @@ impl UiRenderState {
         active.answer = settled;
         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);
+        }
         settled
     }
 
@@ -475,7 +497,7 @@ impl UiRenderState {
         parent_move: MoveIdx,
         widgets: &Widgets,
     ) -> Option<(Size, [Holds; 2])> {
-        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)?;
@@ -489,16 +511,9 @@ impl UiRenderState {
 
     /// The answer to an ask can be retained independently of where its
     /// drawing ended up. Alignment is exactly that case: the first box is the
-    /// question and the smaller placed box holds the drawing.
-    fn retained_answer(
-        &self,
-        id: WidgetId,
-        info: DrawInfo,
-        widgets: &Widgets,
-    ) -> Option<(Size, [Holds; 2])> {
-        if widgets.needs_redraw.contains(&id) || self.dirty_size_under(id, widgets) {
-            return None;
-        }
+    /// 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])> {
         let active = self.active.get(&id)?;
         let has_region_node = active.move_idx != active.parent_move;
         if !active.drawn
@@ -507,20 +522,7 @@ impl UiRenderState {
         {
             return None;
         }
-        let (size, holds) = active.answer;
-        (holds[0].contains(info.px.x) && holds[1].contains(info.px.y)).then_some((size, holds))
-    }
-
-    /// Whether anything whose size this widget's own size was read from is
-    /// dirty. Not needed for the answer to come right -- a changed size
-    /// reaches its reader in any order -- but a reader that asks first
-    /// lays out once rather than twice.
-    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)
-            })
-        })
+        active.answers_at(info.px).then_some(active.answer)
     }
 
     /// The pixel lengths of the box a widget was given and of the box it was
@@ -634,12 +636,12 @@ impl UiRenderState {
                 self.remap_subtree(id, &remap, info.parent_move, 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) {
@@ -663,6 +665,24 @@ impl UiRenderState {
         Some(answer)
     }
 
+    /// 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.
@@ -827,19 +847,34 @@ impl UiRenderState {
     pub fn redraw_updates(&mut self, rsc: &mut dyn UiRsc) {
         #[cfg(feature = "layout-diagnostics")]
         let _layout = diag::timer(TimerKind::IncrementalLayout);
-        // Deepest first: a reader whose children have all settled asks each
-        // once, where any other order has it lay out again for whatever
-        // settles under it afterwards. Equal-depth widgets are independent,
-        // so their order does not matter.
-        while let Some(id) = {
-            let dirty = rsc.widgets().needs_redraw.iter().copied();
-            dirty.max_by_key(|&id| self.depth(id))
-        } {
+        // Deepest first, and strictly: a widget that cannot settle where it
+        // is defers to its parent rather than drawing the parent from
+        // inside itself. It marks the parent, stays marked, and waits here
+        // until the walk reaches its parent's depth.
+        //
+        // What that buys is that nothing shallower is ever drawn while
+        // anything deeper is still dirty. A parent drawing can therefore
+        // trust every answer it reads without descending to check whether
+        // something below is about to change it -- which is the whole class
+        // of defect where a widget settles inside its parent's draw, clears
+        // its mark there, and tells nobody its answer moved.
+        loop {
+            let next = rsc
+                .widgets()
+                .needs_redraw
+                .iter()
+                .copied()
+                .filter(|id| !self.deferred.contains(id))
+                .max_by_key(|&id| self.depth(id));
+            let Some(id) = next else { break };
             #[cfg(feature = "layout-diagnostics")]
             diag::bump(Counter::QueuePops);
-            self.redraw(id, rsc);
+            if !self.redraw(id, rsc) {
+                self.deferred.insert(id);
             }
         }
+        self.deferred.clear();
+    }
 
     fn depth(&self, id: WidgetId) -> usize {
         #[cfg(feature = "layout-diagnostics")]
@@ -923,11 +958,13 @@ impl UiRenderState {
     }
 
     /// Settles a dirty widget: asks it again where its parent asked, and
-    /// tells the parent if the answer changed.
-    pub fn redraw(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) {
+    /// tells the parent if the answer changed. `false` where the question is
+    /// its parent's rather than its own, which leaves it marked for the
+    /// parent to draw when the walk reaches that depth.
+    pub fn redraw(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) -> bool {
         rsc.widgets_mut().needs_redraw.remove(&id);
         let Some(active) = self.active.get(&id) else {
-            return;
+            return true;
         };
         // Its parent resolved its declared lengths into its box and decided
         // whether to draw it at all, so a change to either is the parent's
@@ -947,14 +984,15 @@ impl UiRenderState {
                     at = self.active[&next].parent;
                 }
             }
+            // Both stay marked: the parent because it has this to draw, and
+            // this because the parent must draw it rather than keep what it
+            // has. The mark comes off in `draw_at`, where the parent draws.
             rsc.widgets_mut().needs_redraw.insert(id);
-            self.redraw(parent, rsc);
-            // Whatever the parent did not draw again is nothing it holds now.
-            rsc.widgets_mut().needs_redraw.remove(&id);
-            return;
+            rsc.widgets_mut().needs_redraw.insert(parent);
+            return false;
         }
         if !active.drawn {
-            return;
+            return true;
         }
         // Nothing above the root resolved its rules or its alignment, so its
         // box is its own to work out again against the output. Every other
@@ -969,7 +1007,7 @@ impl UiRenderState {
             diag::bump(Counter::LocalRedraws);
             let old = self.remove(id, false, rsc);
             self.draw_inner(id, region, info, old, rsc);
-            return;
+            return true;
         };
         let (given_px, offered_px) = self.asked_px(id);
         // Asked again in the box its parent gave it, which is the question
@@ -979,9 +1017,8 @@ impl UiRenderState {
         // on is its lengths, so the same lengths elsewhere is one question.
         if given_px != offered_px {
             rsc.widgets_mut().needs_redraw.insert(id);
-            self.redraw(parent, rsc);
-            rsc.widgets_mut().needs_redraw.remove(&id);
-            return;
+            rsc.widgets_mut().needs_redraw.insert(parent);
+            return false;
         }
         let info = DrawInfo {
             layer: active.layer,
@@ -1014,6 +1051,7 @@ impl UiRenderState {
             }
             rsc.widgets_mut().needs_redraw.insert(parent);
         }
+        true
     }
 }
 

examples/text.rs

@@ -28,10 +28,14 @@ impl DefaultAppState for State {
             .pad(16)
             .background(panel());
 
+        // Each one takes the whole width, because `text_align` puts the
+        // glyphs somewhere in the box the text is given and a text that
+        // reports the width of its own glyphs is given exactly that.
+        let label = |text: &str, align| wtext(text).size(24).text_align(align).width(rel(1.0));
         let aligned = (
-            wtext("left").size(24).text_align(Align::LEFT),
-            wtext("centred").size(24).text_align(Align::CENTER),
-            wtext("right").size(24).text_align(Align::RIGHT),
+            label("left", Align::LEFT),
+            label("centred", Align::H_CENTER),
+            label("right", Align::RIGHT),
         )
             .span(Dir::DOWN)
             .gap(8)

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/position/scroll.rs

@@ -14,7 +14,8 @@ impl Widget for Scroll {
         let container_len = painter.px_len(self.axis);
         // Draw in the whole container only when its scrolling-axis length is
         // not already known, then draw it at the scrolled offset.
-        let answer_len = match painter.known_len(&self.inner, self.axis, UiRegion::FULL) {
+        let whole = UiRegion::FULL;
+        let answer_len = match painter.known_len(&self.inner, self.axis, whole, whole.size()) {
             Some(len) => len,
             None => painter.widget(&self.inner).size().axis(self.axis),
         };
@@ -63,7 +64,7 @@ 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_decided(&self.inner, region, [true; 2]);
+        painter.widget_at(&self.inner, region, region.size(), [true; 2]);
         // 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

@@ -20,9 +20,15 @@ impl Widget for Span {
                 span.flip();
             }
             let region = UiRegion::from_axis(axis, span, UiSpan::FULL);
-            let len = match painter.known_len(child, axis, region) {
+            // Offered the room left from the cursor, because a text has to
+            // wrap at the width actually there, but reporting a fraction of
+            // 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.widget_within(child, region).len(axis),
+                None => painter
+                    .widget_at(child, region, UiVec2::FULL_SIZE, [false; 2])
+                    .len(axis),
             };
             cursor.px += len.px + self.gap;
             cursor.rel += len.rel;
@@ -40,43 +46,26 @@ impl Widget for Span {
             |sum, len| sum + *len,
         );
 
+        // What is left for the shares to divide: the box less everything
+        // fixed, as a length of the box rather than a number of pixels.
+        let room = Len::rel_max() - 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
-        // divide is `len * fixed - total.px`, and the length where it runs
-        // out is exactly the box a parent sizing itself from this answer
-        // hands back -- which is why this used to need a margin either side
-        // of the boundary, and why it does not now: that box and this sum are
-        // whole counts of the same step, and both routes to it land on the
-        // same count. What the generated oracle checks is the consequence,
-        // since which children exist at all turns on this.
-        let fixed = Rel::ONE - total.rel;
+        // beside 300 px is full at 600 and overfull at 400. Asked of `room`
+        // itself, and answered back through the same expression, so the
+        // boundary is the drawing's own and not a second way of finding it:
+        // the three cases a rounded division needed -- the fixed parts
+        // growing slower than the box, faster, or exactly with it -- are the
+        // sign of `room.rel`, which `through` already reads. What the
+        // generated oracle checks is the consequence, since which children
+        // exist at all turns on this.
         let mut shares = false;
         if total.leftover > Weight::ZERO {
-            let current = painter.px_len(axis);
-            let holds = if fixed > Rel::ZERO {
-                // The box length the fixed parts alone fill.
-                let full = total.px.div(fixed);
-                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
+            shares = room.to_px(painter.px_len(axis)) > Px::ZERO;
+            let holds = match shares {
+                true => Holds::from(Px::STEP..=Px::MAX),
+                false => Holds::from(Px::MIN..=Px::ZERO),
             };
-            painter.holds(axis, holds);
+            painter.holds(axis, holds.through(room));
         }
 
         // Across itself a span is as long as its longest child -- unless a
@@ -93,7 +82,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) {
@@ -122,7 +110,12 @@ impl Widget for Span {
             // Along the row this box is the child's own answer, so the answer
             // is not placed in it again; across it the child sits where its
             // alignment says.
-            let placed = painter.widget_decided(child, region, [axis == Axis::X, axis == Axis::Y]);
+            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

@@ -35,7 +35,7 @@ impl Widget for Stack {
             // child is handed a box that owes nothing to its own answer, and
             // where it sits in one bigger than itself is its own business.
             match sizing == Some(i) {
-                true => painter.widget_decided(child, region, [true; 2]),
+                true => painter.widget_at(child, region, region.size(), [true; 2]),
                 false => painter.widget_within(child, region),
             };
         }

src/widget/text/mod.rs

@@ -55,8 +55,13 @@ impl TextView {
         // line up to the one it was made at: each line still fits, and none
         // could take a word that did not fit in the wider box. A line too
         // long to fit at all says nothing about narrower boxes.
+        //
+        // The step at or above that longest line rather than the nearest
+        // one, since the shaper measures in floats: the nearest step is
+        // under the line half the time, and a range starting there admits a
+        // box the line does not fit in, where the break is not this one.
         if let Some(width) = width {
-            painter.holds(Axis::X, Px::from_f32(text.size.x).min(width)..=width);
+            painter.holds(Axis::X, Px::ceil_from_f32(text.size.x).min(width)..=width);
         }
         text
     }
@@ -78,7 +83,12 @@ impl TextView {
 
         let tex = self.render(painter);
         let region = tex.size.align(align);
-        let size = Size::px(tex.size);
+        // The step at or above what the shaper measured, so a parent that
+        // hands back the length this reports hands back a box the longest
+        // line fits in. Rounded to the nearest step it is half the time a
+        // 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, within);
         (region, size)

tests/cases/layout.rs

@@ -20,13 +20,13 @@ fn a_span_gives_each_child_the_width_it_asked_for() {
     assert_corners!(h, right, (100, 0), (400, 200));
 }
 
-/// A drawn child reports a fraction of the box it was given, and a span
-/// offers each child what is left after the one before. So a nested span
-/// that takes half of the half it was offered has taken a quarter of the row,
-/// and what follows starts three quarters along -- not at the end, which is
-/// where adding its report straight into the cursor put it.
+/// A span offers each child the room left after the one before, because a
+/// text has to wrap at the width actually there, but reads what the child
+/// reports as a fraction of the whole row. So two children asking for half
+/// each take the whole row between them, however much of it was left when
+/// each was asked, and a third overflows.
 #[test]
-fn a_span_reads_a_child_report_as_a_fraction_of_what_it_offered() {
+fn a_span_reads_a_child_report_as_a_fraction_of_the_row() {
     let mut h = Harness::new((400, 100));
     let half = rect(Color::RED).width(rel(0.5)).add(&mut h.rsc);
     let inner = rect(Color::GREEN).width(rel(0.5)).add(&mut h.rsc);
@@ -35,11 +35,51 @@ fn a_span_reads_a_child_report_as_a_fraction_of_what_it_offered() {
     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
-    // once more; half of that final box is what its child takes, packed at
-    // the nested span's own start.
-    assert_corners!(h, nested, (200, 0), (300, 100));
-    assert_corners!(h, inner, (200, 0), (250, 100));
-    assert_corners!(h, tail, (300, 0), (400, 100));
+    // once more; half of that final box is what its own child takes.
+    assert_corners!(h, nested, (200, 0), (400, 100));
+    assert_corners!(h, inner, (200, 0), (300, 100));
+    assert_corners!(h, tail, (400, 0), (500, 100));
+}
+
+/// The same fraction either way round: after a 100 px child in a 400 px row,
+/// `rel(0.5)` is 100 to 300 whether the child's own rule says so or the child
+/// drew half of what it was offered and reported that. Half the row, not half
+/// of the 300 px left of it.
+#[test]
+fn a_reported_fraction_is_of_the_row_like_a_declared_one() {
+    let mut declaring = Harness::new((400, 100));
+    let head = rect(Color::RED).width(100).add(&mut declaring.rsc);
+    let declared = rect(Color::GREEN).width(rel(0.5)).add(&mut declaring.rsc);
+    declaring.set_root((head, declared).span(Dir::RIGHT).width(rel(1.0)));
+    assert_corners!(declaring, declared, (100, 0), (300, 100));
+
+    let mut reporting = Harness::new((400, 100));
+    let head = rect(Color::RED).width(100).add(&mut reporting.rsc);
+    let inner = rect(Color::GREEN).width(rel(0.5)).add(&mut reporting.rsc);
+    let reported = (inner,).span(Dir::RIGHT).add(&mut reporting.rsc);
+    reporting.set_root((head, reported).span(Dir::RIGHT).width(rel(1.0)));
+    assert_corners!(reporting, reported, (100, 0), (300, 100));
+}
+
+/// What the fraction a child reports is of and what box it is offered are
+/// two different lengths, and only the first is the whole row: a text still
+/// wraps at the room actually left after its neighbour, so the same
+/// paragraph is taller where less of the row is left for it.
+#[test]
+fn a_text_in_a_span_wraps_at_the_room_left_rather_than_the_whole_row() {
+    let paragraph = "Wrapping shapes one source into as many lines as the box \
+                     leaves room for, so a paragraph's height is an answer.";
+    let height_after = |head_width: i32| {
+        let mut h = Harness::new((400, 400));
+        let head = rect(Color::RED).width(head_width).add(&mut h.rsc);
+        let text = wtext(paragraph).size(16).wrap(true).add(&mut h.rsc);
+        h.set_root((head, text).span(Dir::RIGHT).width(rel(1.0)));
+        let region = h.region(&text).unwrap();
+        (region.bot_right.y - region.top_left.y).to_f32()
+    };
+
+    let (crowded, whole_row) = (height_after(300), height_after(0));
+    assert!(crowded > whole_row, "{crowded} against {whole_row}");
 }
 
 /// The same reading through a pad: its inset is the whole box less the

tests/cases/retained.rs

@@ -628,3 +628,112 @@ 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"
+    );
+}

tests/cases/unsettled.rs

@@ -7,7 +7,8 @@
 //! neither: one box length, composed two ways, landing either side of the
 //! boundary that decided whether a child was drawn at all, and two boxes
 //! reached through a region node's own entry rather than through the offer
-//! that node was given.
+//! that node was given. The last is a wrapping text handed back the width
+//! it measured, rounded to a step below the line it measured there.
 
 use iris::harness::Harness;
 use iris::prelude::*;
@@ -554,3 +555,62 @@ fn a_widget_under_a_region_node_is_asked_in_the_box_that_node_was_offered() {
     }
     assert!(wrong.is_empty(), "{}", wrong.join("\n"));
 }
+
+const PARAGRAPH: &str = "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.";
+
+/// Eight widgets, shrunk from a 118-widget tree (seed 1121, depth 4,
+/// `shuffle-swap-for-three`). The stack takes its size from the span above,
+/// the span takes its width from the longest line of the texts in it, and
+/// the text below the span is then wrapped at that width -- so a width the
+/// shaper measured comes back to it as the box to break in.
+fn plant_a_measured_width(h: &mut Harness, swapped: bool) -> (WeakWidget<Span>, WidgetId) {
+    let first: StrongWidget = rect(Color::YELLOW).add_strong(&mut h.rsc);
+    let mut inner = Span::empty(Dir::UP);
+    inner.children = match swapped {
+        true => swapped_in(h),
+        false => vec![first],
+    };
+    let inner = inner.height(142).add(&mut h.rsc);
+    let text = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
+    let stack = Stack {
+        children: vec![inner.add_strong(&mut h.rsc), text.add_strong(&mut h.rsc)],
+        size: StackSize::Child(0),
+    }
+    .add(&mut h.rsc);
+    h.set_root((stack,).span(Dir::DOWN).width(195));
+    (inner, text.id())
+}
+
+/// What the span holds once its children have been swapped, which is what
+/// the warm tree is changed to and what the cold one is grown with.
+fn swapped_in(h: &mut Harness) -> Vec<StrongWidget> {
+    let paragraph = |h: &mut Harness| -> StrongWidget {
+        wtext(PARAGRAPH).size(16).wrap(true).add_strong(&mut h.rsc)
+    };
+    vec![
+        paragraph(h),
+        rect(Color::YELLOW).add_strong(&mut h.rsc),
+        paragraph(h),
+    ]
+}
+
+/// A text handed back the width it measured breaks there the way it broke
+/// when it measured it. The width the shaper answers is not on the grid, and
+/// a report rounded to the nearest step is under the longest line half the
+/// time: a warm tree then keeps a break made in a wider box while a cold one
+/// makes a narrower break in the same box, and the paragraph gains a line.
+#[test]
+fn a_text_is_given_back_a_box_the_line_it_measured_fits_in() {
+    let mut warm = Harness::new((900, 1200));
+    let (inner, text) = plant_a_measured_width(&mut warm, false);
+    warm.frame();
+    warm.rsc[inner].children = swapped_in(&mut warm);
+    warm.frame();
+
+    let mut cold = Harness::new((900, 1200));
+    let (_, cold_text) = plant_a_measured_width(&mut cold, true);
+    cold.frame();
+
+    assert_eq!(warm.region(&text), cold.region(&cold_text));
+}