Hold what a widget answers with a rule, and its box with a widget

Bryan's call, given the measurements in `76aaf06`: `SizeRule::{Min, Max,
Clamp}` holds the length a widget answers and never touches the box it draws
in, and `MaxSize` is the box version.

The split is the difference between a rule and a widget here. A box is
whoever asked's to decide, and the retained machinery hands a widget one by
paths that never ask it anything -- a parent re-placing a child, a subtree
repositioned after its parent's box moved. A rule that read the box was
therefore decided again by whichever path arrived last, which is what the
oracle was refusing. A widget has no such trouble: it is drawn again whenever
its own box changes, so `MaxSize` asks `longer_than` where the answer can be
kept, and `region_len` pins the box lengths its drawing holds for.

What that costs is nothing the app wanted: `a_capped_scroll_takes_its_
viewport_from_the_cap` puts 400 px of content under `.max_height(100)` and
gets a 100 px viewport with 300 to scroll, which is what `MaxSize` gave on the
app's pin, and `.max_width`/`.max_height` are that widget rather than a rule.
A cap narrows the offer and not a declared length, so a child that declares
500 px still draws 500 and the cap holds what `MaxSize` itself answers; a
child that asked for a share takes the box the cap allows and the share passes
up, since whoever divides one is `MaxSize`'s parent.

`.min_width`/`.min_height` stay a rule: answering at least so much is a claim
about the length, and a row honours it without anyone narrowing anything.

Bounds in the generated trees are pixels for now, with the reason written
where the next tree is grown: a fraction in a bound is resolved against the
rel base the widget was asked with, and `place_at` hands a parent a retained
answer without checking that it still holds for the rel base this place
gives. Seeds 4 and 196 at depth 5 are where that showed. The hole is older
than bounds -- an `Exact` rule that is a fraction can reach it too -- and
closing it is a check at the re-place site rather than anything about bounds.
A fraction through `MaxSize` is fine and tested, since the widget compares
against its own box.

Format, clippy with and without layout-diagnostics, and the suite (142 + 19 +
13 + 4) are clean. All three seed scans pass: 400 at depth 5 (62s), 1,000 at
depth 6 (162s), 2,000 at depth 4 (299s). The cold dump is 34,986 boxes and
moves wholesale against `2dba90b`, which is the generator growing rules it
did not grow before rather than a layout change; it is the new baseline.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Cargo.toml

@@ -25,6 +25,12 @@ tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread", "time"]
 [workspace]
 members = ["core", "macro", "rig-input"]
 
+# Full debug info was the bulk of what the linker wrote here and almost none of
+# what anything read. `dev` keeps line tables and scopes, which is what stepping
+# through an example wants; the tests keep the line tables alone, which is what
+# a backtrace reads. Measured when the tests became one target: relinking them
+# went from 9.8 s to 7.7 s with these, and target/ from 45 GB to 13 GB with the
+# two changes together.
 [profile.dev]
 debug = 1
 

TODO

@@ -14,3 +14,27 @@ WidgetRef<W> or smth instead of Id
 vecs for each widget type?
 
 POTENTIAL BUG: closures that store IDs will not decrement the id!!! need to not increment id if moved into closure somehow??? wait no, need to decrement ID every time an event fn is added...... only if the id is used in it..??
+
+transforms on a move entry (scale + rotation)
+    an entry is a translation today; composing through one scales the rel
+    part and passes px through untouched, so fixed-size content and glyphs
+    do not follow a shortened entry
+    want a real transform per entry, resolved in resolve_move the way the
+    translation already is, so a whole subtree transforms with one buffer
+    write and no redraw
+    wanted for compose-style stretch at the end of a scroll area, and for
+    rotation generally
+
+a prepare stage on Event, so Data has no placeholder field
+    run_sensors builds one CursorData per widget and has to put something in
+    `sense` before anything knows which sense matched, so it writes
+    CursorSense::Hovering and says in place that it means nothing;
+    should_run then clones the whole thing to overwrite that one field
+    the state is representable only because the type lets the caller say it:
+    what the caller supplies and what matching adds are two different things
+    wearing one struct
+    the awkward part is doing it without the generics getting annoying --
+    Data<'a> is already a GAT with a default, and splitting it in two adds
+    another associated type to every Event impl for the sake of one field
+    (Bryan, 2026-09-20; low priority, he wants a good answer rather than a
+    quick one)

core/src/fixed.rs

@@ -10,23 +10,30 @@ use std::{
 /// chain, and the same box summed from what its children asked for -- and has
 /// to decide whether the two are the same place. In floats they land a few
 /// bits apart, which is a defect wherever the answer changes what is drawn
-/// rather than where. Here adding and subtracting are exact and only a
-/// multiply or a conversion rounds, back onto the same steps, so two routes
-/// that come within half a step land on one number and everything downstream
-/// compares for equality instead of for nearness.
+/// rather than where. Here adding and subtracting are exact, a multiply
+/// drops to the step below, and a conversion between grids takes the nearest
+/// one, so two routes to one place land on one number and everything
+/// downstream compares for equality instead of for nearness.
 ///
 /// `SHIFT` is the number of fractional bits, which is what makes the steps
 /// divide a whole number: a power of two also converts to `f32` without
 /// rounding while the value fits in its mantissa.
+///
+/// Arithmetic wraps at the ends of the range, the way the `i32` underneath
+/// does. Saturating instead was measured at a twelfth of layout's
+/// instructions -- five per add against one -- to keep the ordering of
+/// coordinates two million pixels out, where nothing draws anyway. A value
+/// off the end is a defect either way; wrapping makes it an obvious one.
+/// Only [`Self::from_f32`] clamps, since a float has further to come from.
 #[repr(transparent)]
 #[derive(
     Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, bytemuck::Pod, bytemuck::Zeroable,
 )]
 pub struct Fixed<const SHIFT: u32>(i32);
 
-/// A length or a coordinate in pixels, to a sixty-fourth. Finer than anything
-/// a display can show, and exact in `f32` up to 262,144 px, which is what lets
-/// the same number reach the GPU.
+/// A length or a coordinate in pixels, in steps of `1/1024`. Finer than
+/// anything a display can show, and exact in `f32` up to 16,384 px, which is
+/// what lets the same number reach the GPU.
 pub type Px = Fixed<PX_SHIFT>;
 
 /// How many bits of a pixel a [`Px`] keeps. One place, because [`PxVec2`]
@@ -56,8 +63,8 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
     /// The gap between neighbouring values, which is also how far apart two
     /// numbers can be and still mean the same place.
     pub const STEP: Self = Self(1);
-    /// Also what stands in for an unbounded end, since arithmetic saturates
-    /// here rather than wrapping past it.
+    /// Also what stands in for an unbounded end: compared against, never
+    /// added to, since arithmetic wraps past it.
     pub const MIN: Self = Self(i32::MIN);
     pub const MAX: Self = Self(i32::MAX);
 
@@ -77,12 +84,13 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
     }
 
     pub const fn from_int(v: i32) -> Self {
-        Self(v.saturating_mul(Self::one().0))
+        Self(v.wrapping_mul(Self::one().0))
     }
 
-    /// Rounds to the nearest step, and saturates rather than wrapping. A NaN
-    /// has no nearest step and becomes zero, which is a caller's mistake
-    /// rather than a value worth carrying.
+    /// Rounds to the nearest step, and clamps to the ends of the grid rather
+    /// than wrapping: this is where a number from outside arrives, and a float
+    /// has the range to be anywhere. A NaN has no nearest step and becomes
+    /// zero, which is a caller's mistake rather than a value worth carrying.
     ///
     /// Half-away is written out rather than called through `f32::round`,
     /// which is not `const`: a layout constant has to stay a constant.
@@ -101,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 {
@@ -111,36 +131,36 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
         self.0 as f32 / Self::one().0 as f32
     }
 
-    /// The same value on another grid, rounded where the new one is coarser.
-    pub const fn to_scale<const TO: u32>(self) -> Fixed<TO> {
-        Fixed(match TO >= SHIFT {
-            true => narrow((self.0 as i64) << (TO - SHIFT)),
-            false => narrow(shift_round(self.0 as i64, SHIFT - TO)),
-        })
-    }
-
     pub const fn add(self, rhs: Self) -> Self {
-        Self(self.0.saturating_add(rhs.0))
+        Self(self.0.wrapping_add(rhs.0))
     }
 
     pub const fn sub(self, rhs: Self) -> Self {
-        Self(self.0.saturating_sub(rhs.0))
+        Self(self.0.wrapping_sub(rhs.0))
     }
 
     pub const fn neg(self) -> Self {
-        Self(self.0.saturating_neg())
+        Self(self.0.wrapping_neg())
     }
 
     /// Scaled by a number on any grid, which is how a length takes a fraction
     /// of itself and keeps being a length: the product is measured in the
     /// receiver's steps.
+    ///
+    /// Dropped to the step below rather than taken to the nearest one
+    /// (Bryan, 2026-09-16), which costs a share a thousandth of a pixel of
+    /// its row -- less than an even number of pixels draws. Toward negative
+    /// infinity on both sides of zero, since that is a shift and nothing
+    /// else: a value and its negation therefore land different distances
+    /// from where they came, so a flipped span can sit a step from its
+    /// mirror image.
     pub const fn mul<const BY: u32>(self, by: Fixed<BY>) -> Self {
-        Self(narrow(shift_round(self.0 as i64 * by.0 as i64, BY)))
+        Self(((self.0 as i64 * by.0 as i64) >> BY) as i32)
     }
 
     /// Repeated a whole number of times, which no grid rounds.
     pub const fn mul_int(self, by: i32) -> Self {
-        Self(narrow(self.0 as i64 * by as i64))
+        Self(self.0.wrapping_mul(by))
     }
 
     /// Divided into a whole number of parts, rounded to the nearest step.
@@ -149,12 +169,13 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
         if by == 0 {
             return Self::ZERO;
         }
-        Self(narrow(div_round(self.0 as i64, by as i64)))
+        Self(div_round(self.0 as i64, by as i64) as i32)
     }
 
     /// Divided by a number on any grid. A zero divisor is a caller bug -- a
-    /// box of no length has no fraction of itself -- and saturates so that a
-    /// release build lays out something absurd rather than dying.
+    /// box of no length has no fraction of itself -- and answers with the end
+    /// of the range so that a release build lays out something absurd rather
+    /// than dying.
     pub const fn div<const BY: u32>(self, by: Fixed<BY>) -> Self {
         debug_assert!(by.0 != 0, "dividing by a length of zero");
         if by.0 == 0 {
@@ -163,7 +184,7 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
                 false => Self::MAX,
             };
         }
-        Self(narrow(div_round((self.0 as i64) << BY, by.0 as i64)))
+        Self(div_round((self.0 as i64) << BY, by.0 as i64) as i32)
     }
 
     /// `num / den` on *this* grid rather than on theirs, for weights coarser
@@ -173,7 +194,7 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
         if den.0 == 0 {
             return Self::ZERO;
         }
-        Self(narrow(div_round((num.0 as i64) << SHIFT, den.0 as i64)))
+        Self(div_round((num.0 as i64) << SHIFT, den.0 as i64) as i32)
     }
 
     /// `from` and `to` a fraction of the way apart, the fraction being the
@@ -197,7 +218,7 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
     }
 
     pub const fn abs(self) -> Self {
-        Self(self.0.saturating_abs())
+        Self(self.0.wrapping_abs())
     }
 
     pub const fn clamp(self, lo: Self, hi: Self) -> Self {
@@ -209,21 +230,11 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
     /// boundary. The step is the whole gap, so there is nothing to exclude
     /// between this and the boundary itself.
     pub const fn next_up(self) -> Self {
-        Self(self.0.saturating_add(1))
+        Self(self.0.wrapping_add(1))
     }
 
     pub const fn next_down(self) -> Self {
-        Self(self.0.saturating_sub(1))
-    }
-}
-
-/// Back to a single step, rounding halves away from zero so that a value and
-/// its negation round to the same distance.
-const fn shift_round(v: i64, bits: u32) -> i64 {
-    let half = (1i64 << bits) >> 1;
-    match v < 0 {
-        true => -((-v + half) >> bits),
-        false => (v + half) >> bits,
+        Self(self.0.wrapping_sub(1))
     }
 }
 
@@ -250,6 +261,8 @@ pub(crate) const fn div_toward(num: i64, den: i64, up: bool) -> i64 {
     }
 }
 
+/// Clamped to the ends, unlike a [`Fixed`]'s own arithmetic: a range of box
+/// lengths that runs past `i32` really is unbounded.
 pub(crate) const fn narrow(v: i64) -> i32 {
     if v > i32::MAX as i64 {
         return i32::MAX;
@@ -353,6 +366,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())
     }
@@ -444,38 +463,54 @@ mod tests {
         assert_eq!(Px::from_int(100) * Rel::ZERO, Px::ZERO);
     }
 
+    /// Toward negative infinity on both sides of zero, which is what makes
+    /// it a shift rather than a shift and a sign branch -- and what makes a
+    /// value and its negation land different distances from where they came,
+    /// so a flipped span can sit a step from its mirror image.
     #[test]
-    fn halves_round_away_from_zero_either_side() {
+    fn a_multiply_drops_to_the_step_below_on_both_sides_of_zero() {
         // A step and a half of one, which has no step of its own.
         let step_and_a_half = Rel::from_f32(1.5).div_int(Px::ONE.raw());
-        assert_eq!(Px::ONE * step_and_a_half, Px::from_raw(2));
+        assert_eq!(Px::ONE * step_and_a_half, Px::from_raw(1));
         assert_eq!(Px::ONE.neg() * step_and_a_half, Px::from_raw(-2));
     }
 
+    /// A division rounds to the nearest step, so it cannot put back the
+    /// steps a truncating multiply dropped: a round trip comes back short,
+    /// never long, and by the few steps the two operations gave up.
     #[test]
-    fn dividing_by_a_fraction_undoes_multiplying_by_it() {
+    fn dividing_by_a_fraction_cannot_undo_a_truncating_multiply() {
         let third = Rel::ONE / Rel::from_int(3);
         let len = Px::from_int(300);
-        assert_eq!(len * third / third, len);
+        let back = len * third / third;
+        assert!(back <= len, "{back:?} is longer than {len:?}");
+        assert!(len - back <= Px::from_raw(3), "{back:?} against {len:?}");
         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 arithmetic_saturates_rather_than_wrapping() {
-        assert_eq!(Px::MAX + Px::ONE, Px::MAX);
-        assert_eq!(Px::MIN - Px::ONE, Px::MIN);
-        assert_eq!(Px::from_f32(1e12), Px::MAX);
-        assert_eq!(Px::from_f32(-1e12), Px::MIN);
-        assert_eq!(Px::from_int(i32::MAX), Px::MAX);
+    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_coarser_grid_rounds_and_a_finer_one_does_not() {
-        // A third, which neither grid holds exactly.
-        let third = Rel::ONE / Rel::from_int(3);
-        assert_eq!(third.to_scale::<6>(), Fixed::<6>::from_raw(21));
-        let coarse = Fixed::<6>::from_raw(21);
-        assert_eq!(coarse.to_scale::<24>().to_scale::<6>(), coarse);
+    fn a_number_from_outside_is_clamped_to_the_grid() {
+        assert_eq!(Px::from_f32(1e12), Px::MAX);
+        assert_eq!(Px::from_f32(-1e12), Px::MIN);
     }
 
     #[test]

core/src/layout_diagnostics.rs

@@ -15,7 +15,7 @@
 //! reuse, size, placement, and text events for one suspicious widget. The
 //! selection is a set and survives [`take`] until cleared.
 
-use crate::{Axis, LayoutLen, PxVec2, Size, UiRegion, WidgetId};
+use crate::{Axis, LayoutHolds, LayoutLen, PxVec2, Size, UiRegion, UiVec2, WidgetId};
 use std::{
     cell::RefCell,
     collections::{HashMap, HashSet},
@@ -23,98 +23,71 @@ use std::{
     time::Instant,
 };
 
-#[derive(Clone, Copy)]
-pub(crate) enum Counter {
-    Updates,
-    DrawRequests,
-    WidgetDraws,
-    RegionNodeDraws,
-    SizeReads,
-    HintHits,
-    HintMisses,
-    RetainedSizeHits,
-    ReuseAttempts,
-    ReuseExact,
-    ReuseMoved,
-    ReuseDirty,
-    ReuseWrongParent,
-    ReuseRemapped,
-    ReuseOutside,
-    ReuseWrongLayer,
-    ReuseWrongNode,
-    PlaceRedraws,
-    QueuePops,
-    DepthReads,
-    LocalRedraws,
-    SizeChanges,
-    ReaderEdges,
-    PrimitiveWrites,
-    TextRenders,
-    TextShapeHits,
-    TextShapes,
-    TextBreaks,
-    GlyphPlacements,
+/// Declares a counter or timer kind beside the name its report prints. Two
+/// lists in the same order was one list too many: a variant inserted without
+/// its label moving with it renames every total after it, and nothing says
+/// so.
+macro_rules! labelled {
+    ($(#[$meta:meta])* $vis:vis enum $Name:ident { $($variant:ident = $label:literal,)* }) => {
+        $(#[$meta])*
+        #[derive(Clone, Copy)]
+        $vis enum $Name { $($variant,)* }
+
+        impl $Name {
+            const COUNT: usize = [$($label,)*].len();
+            const NAMES: [&'static str; Self::COUNT] = [$($label,)*];
+        }
+    };
 }
 
-impl Counter {
-    const COUNT: usize = Self::GlyphPlacements as usize + 1;
-
-    const NAMES: [&'static str; Self::COUNT] = [
-        "updates",
-        "draw requests",
-        "widget draws",
-        "region-node draws",
-        "draw-result size reads",
-        "hint hits",
-        "hint misses",
-        "retained size hits",
-        "reuse attempts",
-        "reuse exact",
-        "reuse moved",
-        "reuse: dirty",
-        "reuse: wrong parent",
-        "reuse remapped",
-        "reuse: outside what it holds for",
-        "reuse: another layer",
-        "reuse: region-node choice changed",
-        "placed by redrawing",
-        "redraw queue pops",
-        "depth reads",
-        "local redraws",
-        "size changes",
-        "reader edges",
-        "primitive writes",
-        "text renders",
-        "text shape hits",
-        "text shapes",
-        "text line breaks",
-        "glyph placements",
-    ];
+labelled! {
+    pub(crate) enum Counter {
+        Updates = "updates",
+        DrawRequests = "draw requests",
+        WidgetDraws = "widget draws",
+        RegionNodeDraws = "region-node draws",
+        SizeReads = "draw-result size reads",
+        HintHits = "hint hits",
+        HintMisses = "hint misses",
+        ReuseAttempts = "reuse attempts",
+        ReuseExact = "reuse exact",
+        ReuseMoved = "reuse moved",
+        ReuseDirty = "reuse: dirty",
+        ReuseUndrawn = "reuse: nothing drawn to keep",
+        ReuseWrongParent = "reuse: wrong parent",
+        ReuseRemapped = "reuse remapped",
+        ReuseOutside = "reuse: outside what it holds for",
+        ReuseWrongLayer = "reuse: another layer",
+        ReuseWrongNode = "reuse: region-node choice changed",
+        ReuseWrongMask = "reuse: a different inherited mask",
+        QueuePops = "redraw queue pops",
+        DepthReads = "depth reads",
+        LocalRedraws = "local redraws",
+        SizeChanges = "size changes",
+        ReaderEdges = "reader edges",
+        PrimitiveWrites = "primitive writes",
+        TextRenders = "text renders",
+        TextShapeHits = "text shape hits",
+        TextShapes = "text shapes",
+        TextBreaks = "text line breaks",
+        GlyphPlacements = "glyph placements",
+        OutsidePinnedLen = "reuse outside: the length it was pinned to",
+        OutsideWindow = "reuse outside: this window",
+        OutsideRelBase = "reuse outside: a rel base",
+        OutsideRegion = "reuse outside: a region length",
+    }
 }
 
-#[derive(Clone, Copy)]
-pub(crate) enum TimerKind {
-    Update,
-    FullLayout,
-    IncrementalLayout,
-    TextRender,
-    TextShape,
-    TextBreak,
-    GlyphPlacement,
-}
-
-impl TimerKind {
-    const COUNT: usize = Self::GlyphPlacement as usize + 1;
-
-    const NAMES: [&'static str; Self::COUNT] = [
-        "update total",
-        "full layout",
-        "incremental layout",
-        "text render",
-        "text shape",
-        "text line break",
-        "glyph placement",
-    ];
+labelled! {
+    pub(crate) enum TimerKind {
+        Update = "update total",
+        FullLayout = "full layout",
+        IncrementalLayout = "incremental layout",
+        TextRender = "text render",
+        TextShape = "text shape",
+        TextBreak = "text line break",
+        GlyphPlacement = "glyph placement",
+    }
 }
 
 #[derive(Clone)]
@@ -249,6 +222,8 @@ pub enum ReuseOutcome {
     Dirty,
     WrongParent,
     WrongLayer,
+    WrongMask,
+    WrongNode,
     Remapped,
     Outside,
     Undrawn,
@@ -262,7 +237,7 @@ pub enum TraceEvent {
         id: WidgetId,
         parent: Option<WidgetId>,
         region: UiRegion,
-        pixel_size: PxVec2,
+        region_px: PxVec2,
         region_node: bool,
     },
     Reuse {
@@ -358,7 +333,7 @@ pub(crate) fn draw_request(
     id: WidgetId,
     parent: Option<WidgetId>,
     region: UiRegion,
-    pixel_size: PxVec2,
+    region_px: PxVec2,
     region_node: bool,
 ) {
     trace(
@@ -367,7 +342,7 @@ pub(crate) fn draw_request(
             id,
             parent,
             region,
-            pixel_size,
+            region_px,
             region_node,
         },
     );
@@ -377,6 +352,41 @@ pub(crate) fn reuse(id: WidgetId, outcome: ReuseOutcome) {
     trace(id, TraceEvent::Reuse { id, outcome });
 }
 
+/// A drawing that cannot be reused because the box on offer is outside what
+/// it holds for, and which of the four contracts said so. They overlap: a
+/// drawing can be outside two of them at once, and counting each is what
+/// says where a rel base redrawing more than it should is coming from.
+pub(crate) fn outside(
+    id: WidgetId,
+    holds: LayoutHolds,
+    region: UiRegion,
+    rel_base: UiVec2,
+    window: PxVec2,
+) {
+    for axis in Axis::BOTH {
+        let holds = holds[axis];
+        let len = region[axis].len();
+        let window = window[axis];
+        if holds.region_len.is_some_and(|pinned| pinned != len) {
+            bump(Counter::OutsidePinnedLen);
+        }
+        if !holds.window.contains(window) {
+            bump(Counter::OutsideWindow);
+        }
+        if holds
+            .rel_base
+            .is_some_and(|pinned| pinned != rel_base[axis])
+        {
+            bump(Counter::OutsideRelBase);
+        }
+        if !holds.region.contains(len.to_px(window)) {
+            bump(Counter::OutsideRegion);
+        }
+    }
+    bump(Counter::ReuseOutside);
+    reuse(id, ReuseOutcome::Outside);
+}
+
 pub(crate) fn size_reported(id: WidgetId, size: Size) {
     trace(id, TraceEvent::SizeReported { id, size });
 }

core/src/lib.rs

@@ -9,6 +9,7 @@
 #![feature(unsize)]
 #![feature(coerce_unsized)]
 #![feature(option_into_flat_iter)]
+#![feature(const_index)]
 
 #[cfg(feature = "layout-diagnostics")]
 pub mod layout_diagnostics;

core/src/orientation/align.rs

@@ -1,8 +1,9 @@
+use crate::util::impl_axis_index;
 use crate::{Px, Rel};
 
 use super::*;
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Align {
     pub x: Option<AxisAlign>,
     pub y: Option<AxisAlign>,
@@ -83,29 +84,6 @@ pub struct RegionAlign {
     pub y: AxisAlign,
 }
 
-impl RegionAlign {
-    /// Both axes at the near edge. What a container passes as an override for
-    /// a child it is going to position itself.
-    pub const NEAR: Self = Self {
-        x: AxisAlign::NEG,
-        y: AxisAlign::NEG,
-    };
-
-    pub fn axis(&self, axis: Axis) -> AxisAlign {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-
-    pub fn axis_mut(&mut self, axis: Axis) -> &mut AxisAlign {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-}
-
 impl RegionAlign {
     pub const TOP_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::NEG);
     pub const TOP_CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::NEG);
@@ -173,13 +151,15 @@ impl Vec2 {
 }
 
 impl Len {
+    /// This length placed in the box it is measured in: the alignment names a
+    /// point along that box, and the two ends are that point less the part of
+    /// the length falling before it and plus the part falling after.
     pub const fn align(&self, align: AxisAlign) -> UiSpan {
         let rel = align.rel();
-        let rest = Rel::ONE.sub(rel);
         let at = Len::from_parts(rel, Px::ZERO);
         UiSpan {
-            start: Len::from_parts(at.rel.sub(self.rel.mul(rel)), at.px.sub(self.px.mul(rel))),
-            end: Len::from_parts(at.rel.add(self.rel.mul(rest)), at.px.add(self.px.mul(rest))),
+            start: at - self.scale(rel),
+            end: at + self.scale(Rel::ONE.sub(rel)),
         }
     }
 }
@@ -232,3 +212,6 @@ impl RegionAlign {
         UiVec2::from(self)
     }
 }
+
+impl_axis_index!(RegionAlign => AxisAlign);
+impl_axis_index!(Align => Option<AxisAlign>);

core/src/orientation/axis.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::util::impl_axis_index;
 use crate::{Fixed, FixedVec2};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -7,6 +8,11 @@ pub enum Axis {
     Y,
 }
 
+impl Axis {
+    /// Both of them, for the layout code that asks the same question of each.
+    pub const BOTH: [Self; 2] = [Self::X, Self::Y];
+}
+
 impl std::ops::Not for Axis {
     type Output = Self;
 
@@ -42,20 +48,6 @@ pub enum Sign {
 }
 
 impl<const SHIFT: u32> FixedVec2<SHIFT> {
-    pub const fn axis(&self, axis: Axis) -> Fixed<SHIFT> {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-
-    pub const fn axis_mut(&mut self, axis: Axis) -> &mut Fixed<SHIFT> {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-
     pub const fn from_axis(axis: Axis, aligned: Fixed<SHIFT>, ortho: Fixed<SHIFT>) -> Self {
         match axis {
             Axis::X => Self::new(aligned, ortho),
@@ -65,20 +57,6 @@ impl<const SHIFT: u32> FixedVec2<SHIFT> {
 }
 
 impl Vec2 {
-    pub fn axis(&self, axis: Axis) -> f32 {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-
-    pub fn axis_mut(&mut self, axis: Axis) -> &mut f32 {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-
     pub const fn from_axis(axis: Axis, aligned: f32, ortho: f32) -> Self {
         Self {
             x: match axis {
@@ -93,47 +71,5 @@ impl Vec2 {
     }
 }
 
-pub const trait AxisT {
-    fn get() -> Axis;
-}
-
-pub struct XAxis;
-const impl AxisT for XAxis {
-    fn get() -> Axis {
-        Axis::X
-    }
-}
-
-pub struct YAxis;
-const impl AxisT for YAxis {
-    fn get() -> Axis {
-        Axis::Y
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default)]
-pub struct BothAxis<T> {
-    pub x: T,
-    pub y: T,
-}
-
-impl<T> BothAxis<T> {
-    pub const fn axis<A: const AxisT>(&mut self) -> &mut T {
-        match A::get() {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-    pub fn take_axis<A: const AxisT>(self) -> T {
-        match A::get() {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-    pub fn axis_dyn(&mut self, axis: Axis) -> &mut T {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-}
+impl_axis_index!({const SHIFT: u32} FixedVec2<SHIFT> => Fixed<SHIFT>);
+impl_axis_index!(Vec2 => f32);

core/src/orientation/len.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::util::impl_axis_index;
 use crate::{Px, PxVec2, Rel, UiNum, Weight, util::impl_op};
 
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
@@ -22,6 +23,14 @@ pub struct LayoutLen {
     pub leftover: Weight,
 }
 
+/// A bare number is pixels, which is the one length that needs no box to be
+/// read in.
+impl<N: UiNum> From<N> for Len {
+    fn from(value: N) -> Self {
+        Len::px(value.to_f32())
+    }
+}
+
 impl<N: UiNum> From<N> for LayoutLen {
     fn from(value: N) -> Self {
         LayoutLen::px(value.to_f32())
@@ -118,13 +127,6 @@ impl Size {
             },
         }
     }
-
-    pub fn axis(&self, axis: Axis) -> LayoutLen {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
 }
 
 impl LayoutLen {
@@ -151,6 +153,46 @@ impl LayoutLen {
         Len::from_parts(self.rel.add(share), self.px)
     }
 
+    /// Only pixels: the same number of them whatever box it lands in, and
+    /// whatever anyone else in the row asks for. A length that is any part
+    /// of a box or of what is left over is not one.
+    pub fn is_px(&self) -> bool {
+        self.rel == Rel::ZERO && self.leftover == Weight::ZERO
+    }
+
+    /// Nothing but a claim on what is left over, so there is no length here
+    /// at all where nothing is.
+    pub fn is_only_leftover(&self) -> bool {
+        self.leftover > Weight::ZERO && self.without_leftover() == Len::ZERO
+    }
+
+    /// This as a length of a box, where it is one. `leftover` is not: a
+    /// share of what is left over is a length only to whoever divides one,
+    /// so it passes up in the reported size instead and is resolved there.
+    pub fn declared(&self) -> Option<Len> {
+        (self.leftover == Weight::ZERO).then(|| self.without_leftover())
+    }
+
+    /// What this takes whatever is left over: the reading of a length for
+    /// anyone not dividing a box between siblings, where a share is a claim
+    /// on someone else's room rather than a length of its own.
+    /// [`Self::apply_leftover`] is the opposite reading of the same value.
+    pub const fn without_leftover(&self) -> Len {
+        Len::from_parts(self.rel, self.px)
+    }
+
+    /// This length, given as a part of a box `len` long, as a part of the
+    /// box `len` is itself a part of. The share is untouched: it is a claim
+    /// on whoever divides the room, not a fraction of anything.
+    pub const fn within_len(self, len: Len) -> Self {
+        let part = self.without_leftover().within_len(len);
+        Self {
+            px: part.px,
+            rel: part.rel,
+            leftover: self.leftover,
+        }
+    }
+
     pub fn px(px: impl UiNum) -> Self {
         Self {
             px: Px::from_num(px),
@@ -217,3 +259,5 @@ impl std::fmt::Display for LayoutLen {
         Ok(())
     }
 }
+
+impl_axis_index!(Size => LayoutLen);

core/src/orientation/pos.rs

@@ -1,3 +1,4 @@
+use crate::util::impl_axis_index;
 use std::{fmt::Display, marker::Destruct};
 
 use super::*;
@@ -61,20 +62,6 @@ impl UiVec2 {
         }
     }
 
-    pub fn axis_mut(&mut self, axis: Axis) -> &mut Len {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-
-    pub fn axis(&self, axis: Axis) -> Len {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-
     /// Resolved against a box of `size`, which is where a fraction stops
     /// being one and becomes a place.
     pub fn to_px(&self, size: PxVec2) -> PxVec2 {
@@ -176,14 +163,6 @@ impl Len {
         Self::from_parts(Rel::ZERO, Px::from_f32(px))
     }
 
-    pub const fn rel_min() -> Self {
-        Self::ZERO
-    }
-
-    pub const fn rel_max() -> Self {
-        Self::FULL
-    }
-
     pub const fn max(&self, other: Self) -> Self {
         Self {
             rel: self.rel.max(other.rel),
@@ -219,17 +198,13 @@ impl Len {
         }
     }
 
-    pub fn within_len(&self, len: Len) -> Self {
+    pub const fn within_len(&self, len: Len) -> Self {
         self.within(&UiSpan {
             start: Len::ZERO,
             end: len,
         })
     }
 
-    pub fn select_len(&self, len: Len) -> Self {
-        len.within_len(*self)
-    }
-
     pub const fn flip(&mut self) {
         self.rel = Rel::ONE.sub(self.rel);
         self.px = self.px.neg();
@@ -282,6 +257,11 @@ impl UiSpan {
         self.end += offset;
     }
 
+    /// Composing a box through the one it sits in, and the hottest line in
+    /// layout. It used to skip the multiplies where a span was the whole of
+    /// its parent or the parent the whole of its own; both come out of the
+    /// multiply unchanged anyway, and the body those comparisons cost was
+    /// what kept the inliner from taking this at all.
     pub const fn within(&self, parent: &Self) -> Self {
         Self {
             start: self.start.within(parent),
@@ -289,6 +269,15 @@ impl UiSpan {
         }
     }
 
+    /// A box `len` long inside this one, on the side `align` says. Both must
+    /// be lengths of the same rel base: it subtracts one from the other
+    /// rather than composing it in, which is what keeps a fraction the same
+    /// fraction however long this box turns out to be.
+    pub const fn place(self, len: Len, align: AxisAlign) -> Self {
+        let start = self.start + (self.len() - len).scale(align.rel());
+        Self::new(start, start + len)
+    }
+
     pub const fn len(&self) -> Len {
         self.end - self.start
     }
@@ -323,20 +312,6 @@ impl UiRegion {
             y: self.y.within(&parent.y),
         }
     }
-    pub const fn axis(&self, axis: Axis) -> &UiSpan {
-        match axis {
-            Axis::X => &self.x,
-            Axis::Y => &self.y,
-        }
-    }
-
-    pub const fn axis_mut(&mut self, axis: Axis) -> &mut UiSpan {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-
     pub const fn flip(&mut self, axis: Axis) {
         match axis {
             Axis::X => self.x.flip(),
@@ -437,3 +412,6 @@ impl Display for PixelRegion {
         write!(f, "{} -> {}", self.top_left, self.bot_right)
     }
 }
+
+impl_axis_index!(UiVec2 => Len);
+impl_axis_index!(UiRegion => UiSpan);

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,
@@ -140,10 +133,6 @@ impl TextBuffer {
         }
     }
 
-    pub fn new_empty() -> Self {
-        Self::new("")
-    }
-
     pub fn text(&self) -> &str {
         &self.text
     }
@@ -183,6 +172,23 @@ impl TextBuffer {
         self.layout_key.as_ref()?.max_width
     }
 
+    /// Widths covered by the current line breaks, including a wider shaping
+    /// retained when a later draw requested a narrower box.
+    pub fn width_holds(&self) -> crate::Holds {
+        let Some(width) = self.wrap_width() else {
+            return crate::Holds::ANY;
+        };
+        let width = Px::from_f32(width);
+        let soft_wrapped = self.layout.lines().any(|line| {
+            matches!(
+                line.break_reason(),
+                parley::layout::BreakReason::Regular | parley::layout::BreakReason::Emergency
+            )
+        });
+        let upper = if soft_wrapped { width } else { Px::MAX };
+        crate::Holds::from(Px::ceil_from_f32(self.layout.width()).min(width)..=upper)
+    }
+
     pub fn size(&self) -> Vec2 {
         Vec2::new(self.layout.width(), self.layout.height())
     }
@@ -200,15 +206,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/render/atlas.rs

@@ -167,10 +167,6 @@ impl GlyphAtlas {
     pub fn page_count(&self) -> u32 {
         self.pages.len() as u32
     }
-
-    pub fn glyph_count(&self) -> usize {
-        self.entries.len()
-    }
 }
 
 impl Page {

core/src/render/mod.rs

@@ -23,13 +23,22 @@ pub use primitive::*;
 const PRELUDE: &str = include_str!("./shader/prelude.wgsl");
 
 fn module_source(wgsl: &str) -> String {
-    // The steps come from the same constants the CPU counts in, rather than
-    // a second copy of them written into the shader: a grid the two disagree
-    // about puts every coordinate somewhere else.
+    // Every number both sides count in, written once here rather than a
+    // second time in the shader: a grid the two disagree about puts every
+    // coordinate somewhere else, and a sentinel they disagree about makes one
+    // of them walk a chain from a slot the other says is not there.
     format!(
-        "const PX_STEP: f32 = 1.0 / {}.0;\nconst REL_STEP: f32 = 1.0 / {}.0;\n{PRELUDE}\n{wgsl}",
+        "const PX_STEP: f32 = 1.0 / {}.0;\n\
+         const REL_STEP: f32 = 1.0 / {}.0;\n\
+         const MASK_NONE: u32 = {}u;\n\
+         const MOVE_NONE: u32 = {}u;\n\
+         const CHAIN_LIMIT: u32 = {}u;\n\
+         {PRELUDE}\n{wgsl}",
         1u32 << crate::PX_SHIFT,
         1u32 << crate::REL_SHIFT,
+        MaskIdx::NONE.idx(),
+        MoveIdx::NONE.idx(),
+        crate::CHAIN_LIMIT,
     )
 }
 
@@ -106,7 +115,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/render/shader/prelude.wgsl

@@ -26,15 +26,21 @@ struct MoveOffset {
     parent: u32,
 }
 
-// `PX_STEP` and `REL_STEP` are prepended from `iris_core`'s own constants:
-// what it stores is a whole count of each, both powers of two, so decoding
-// is exact and the number here is the number the CPU decided.
+// `PX_STEP`, `REL_STEP`, `MASK_NONE`, `MOVE_NONE` and `CHAIN_LIMIT` are
+// prepended from `iris_core`'s own constants, so none of them is written
+// twice. What the CPU stores is a whole count of each step, and both steps
+// are powers of two, so decoding is exact and the number here is the number
+// the CPU decided.
 
 // Every coordinate the CPU decided is a whole count of `PX_STEP`, so one that
 // composes to within half a step of a pixel boundary is on that boundary and
 // belongs to the pixel above it. Flooring the product instead drops a pixel
 // wherever a fraction divides a window exactly: a fifth of 1920 comes out of
 // `REL_STEP` as 383.99998, and five tabs each lose their last column.
+//
+// Taken over the whole coordinate, fraction and pixels summed, since a floor
+// does not distribute over a sum: floored apart, a half of one and a half of
+// the other lose the pixel the two together make.
 fn snap_floor(v: vec2<f32>) -> vec2<f32> {
     return floor(v + PX_STEP * 0.5);
 }
@@ -66,12 +72,6 @@ struct Region {
     y: UiSpan,
 }
 
-const MOVE_NONE: u32 = 4294967295u;
-// Keep in step with `iris_core::CHAIN_LIMIT`. It bounds a malformed cycle
-// rather than any real tree, and the CPU walk uses the same number so both
-// resolve a deep one the same way.
-const CHAIN_LIMIT: u32 = 64u;
-
 // The same expression `Len::within` uses, in floats rather than on the
 // CPU's grid: a move is resolved here so that scrolling a subtree writes one
 // entry instead of walking it. What has to hold is that this agrees with
@@ -147,8 +147,8 @@ fn vs_main(
     let bot_right_rel = vec2(r.x.end.rel, r.y.end.rel);
     let bot_right_px = vec2(r.x.end.px, r.y.end.px);
 
-    let top_left = snap_floor(top_left_rel * window.dim) + snap_floor(top_left_px);
-    let bot_right = snap_floor(bot_right_rel * window.dim) + snap_floor(bot_right_px);
+    let top_left = snap_floor(top_left_rel * window.dim + top_left_px);
+    let bot_right = snap_floor(bot_right_rel * window.dim + bot_right_px);
     let size = bot_right - top_left;
 
     let uv = vec2<f32>(
@@ -167,7 +167,7 @@ fn vs_main(
 }
 
 fn masked(in: VertexOutput, color: vec4<f32>) -> vec4<f32> {
-    if in.mask_idx == 4294967295u {
+    if in.mask_idx == MASK_NONE {
         return color;
     }
     let mask = masks[in.mask_idx];
@@ -179,8 +179,8 @@ fn masked(in: VertexOutput, color: vec4<f32>) -> vec4<f32> {
     let br = vec2(m.x.end.rel, m.y.end.rel);
     let br_px = vec2(m.x.end.px, m.y.end.px);
 
-    let top_left = snap_floor(tl * window.dim) + snap_floor(tl_px);
-    let bot_right = snap_floor(br * window.dim) + snap_floor(br_px);
+    let top_left = snap_floor(tl * window.dim + tl_px);
+    let bot_right = snap_floor(br * window.dim + br_px);
     let pos = in.clip_position.xy;
     if pos.x < top_left.x || pos.x > bot_right.x || pos.y < top_left.y || pos.y > bot_right.y {
         return color * 0.0;

core/src/ui/active.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Holds, LayerId, LayoutLen, MaskIdx, MoveIdx, PrimitiveHandle, RegionAlign, Size, TextureHandle,
-    UiRegion, WidgetId,
+    Bounds, Declared, LayerId, LayoutHolds, MaskIdx, MoveIdx, PlaceDesc, RegionAlign,
+    RetainedPrimitive, Size, TextureHandle, UiRegion, UiVec2, WidgetId,
 };
 
 /// What is kept of a widget its parent has asked about. `drawn` says whether
@@ -9,20 +9,35 @@ use crate::{
 #[derive(Debug)]
 pub struct ActiveData {
     pub id: WidgetId,
-    /// The box its drawing is in, in `parent_move`'s coordinates.
+    /// Where its drawing goes, in its region node's coordinates.
+    pub placement: UiRegion,
+    /// What a fraction declared or reported under this widget is a fraction
+    /// of, as a length of the window.
+    pub rel_base: UiVec2,
+    /// Where its drawing was put, and where it was asked. The two differ
+    /// where a container asks in one place and puts the answer in another --
+    /// a row measures from its cursor and puts the child in its slot. Each
+    /// carries the rel base that ask stated, so asking again from either is
+    /// the same question it was.
+    pub placed: PlaceDesc,
+    pub asked: PlaceDesc,
+    /// The box it was asked in, in the parent's region-node coordinates: the
+    /// box its drawing was made in and the one its contract is about. Its
+    /// drawing is placed elsewhere by re-expression, never by asking again.
     pub region: UiRegion,
-    /// The box its parent first asked about it in, as a part of the box the
-    /// parent was itself asked in. Any later box it was given was decided
-    /// knowing its answer, so this is where a question about it is asked
-    /// again -- and it is kept relative so that it follows the parent's.
-    pub offer: UiRegion,
-    /// What it answered there: the size and what that held for.
-    pub answer: (Size, [Holds; 2]),
-    /// What the widget said it used of its box, the last time it drew.
+    /// The measured answer and its dependencies. A hint-only dependency or
+    /// a widget first encountered during placement has no measurement yet.
+    pub answer: Option<Answer>,
+    /// Asked more than once in its parent's last draw -- measured in one box
+    /// and then asked in the one the parent decided. The parent's layout
+    /// rests on the first answer and its drawing on the last, so only the
+    /// parent can ask either again.
+    pub re_asked: bool,
+    /// What the widget reported, in window-unit lengths.
     pub size: Size,
-    /// The pixel lengths of `region`, per axis, that its drawing and `size`
-    /// hold for.
-    pub holds: [Holds; 2],
+    /// The window and region reads that this drawing holds for, and the
+    /// rel base and region it pinned.
+    pub holds: LayoutHolds,
     pub drawn: bool,
     pub parent: Option<WidgetId>,
     /// How far down the tree it was drawn, the root being 1. Carried down a
@@ -30,35 +45,59 @@ 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>,
+    /// Its primitives, each keeping the box it was written in -- in this
+    /// widget's placement coordinates, which is what a move recomposes from.
+    pub primitives: Vec<RetainedPrimitive>,
+    /// An owned mask holds one reference independently of its primitives.
+    pub mask_region: Option<UiRegion>,
     pub children: Vec<WidgetId>,
-    /// The children whose size this widget read while drawing.
-    pub size_deps: Vec<WidgetId>,
     /// The movable region its primitives are positioned through: its own when
     /// opted in, otherwise the nearest ancestor's.
     pub move_idx: MoveIdx,
-    /// The declared lengths whoever drew this widget resolved into its box.
+    /// The declared lengths whoever drew this widget resolved into its rel base.
     /// A change to one moves a box this widget cannot fix by drawing again,
     /// and comparing them is what says so.
-    pub declared: [Option<LayoutLen>; 2],
-    /// The alignment its parent asked it with. A local redraw repeats that
-    /// question, including an override chosen by a container.
-    pub align: RegionAlign,
-    /// Whether that alignment was the parent's override rather than the
-    /// widget's own property.
-    pub align_override: bool,
-    /// Its own alignment when it was last drawn. A change to the property is
-    /// found against this even when its parent overrode the alignment.
+    pub declared: Declared,
+    /// Its bounds, resolved the same way. The answer is held to these where
+    /// the box was not, so a change to one changes what it answers even
+    /// where its declared lengths stand.
+    pub bounds: Bounds,
+    /// Its alignment when it was last drawn, which a change to the property
+    /// is found against.
     pub own_align: RegionAlign,
-    /// The movable region whose coordinates `region` uses.
+    /// The movable region whose coordinates its placement is in when this
+    /// widget does not own a region node.
     pub parent_move: MoveIdx,
+    /// The mask its drawing is clipped to: one it set itself, or the one it
+    /// inherited from whoever drew it.
     pub mask: MaskIdx,
+    /// That inherited one. The two differ exactly where the widget set a
+    /// mask of its own, which is the one it owns and the one a move rewrites
+    /// -- and the one a redraw of it must not be handed back, since setting
+    /// a mask asserts there is none.
+    pub parent_mask: MaskIdx,
     pub layer: LayerId,
 }
 
 impl ActiveData {
-    /// Whether its drawing and size hold for a box of these pixel lengths.
-    pub fn holds_at(&self, px: crate::PxVec2) -> bool {
-        self.holds[0].contains(px.x) && self.holds[1].contains(px.y)
+    /// What it answered when its parent asked, where it has been asked at
+    /// all. Not `size`, which is what its last drawing reported: a drawing
+    /// re-expressed in the box that answer chose is not a second answer.
+    pub fn measured(&self) -> Option<Size> {
+        self.answer.map(|answer| answer.size)
+    }
+
+    /// Whether it owns a region node rather than sharing the one it was drawn
+    /// under, which is what its two move indices being different says.
+    pub fn is_region_node(&self) -> bool {
+        self.move_idx != self.parent_move
     }
 }
+
+/// What a widget answered when it was asked: the size it reported, and the
+/// boxes and windows that answer holds for.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Answer {
+    pub size: Size,
+    pub holds: LayoutHolds,
+}

core/src/ui/holds.rs

@@ -1,4 +1,4 @@
-use crate::{Len, Px, REL_SHIFT, fixed::div_toward, fixed::narrow};
+use crate::{Bound, Len, Outside, Px, REL_SHIFT, fixed::div_toward, fixed::narrow};
 use std::ops::RangeInclusive;
 
 /// The lengths of a box, in pixels, that one drawing of a widget holds for:
@@ -10,15 +10,73 @@ use std::ops::RangeInclusive;
 ///
 /// The ends are lengths on the grid rather than floats with a tolerance
 /// around them: a box offered back at the length a widget reported comes back
-/// as the same number, so a range means what it says. What widening there is
-/// belongs to [`Self::through`], which has a rounding to undo, and is derived
-/// from that rounding rather than chosen.
+/// as the same number, so a range means what it says. The one place a range
+/// is wider than the length it came from is [`Self::through`], and what it is
+/// wider by is the floor that inverting a fraction undoes.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Holds {
     pub lo: Px,
     pub hi: Px,
 }
 
+impl Len {
+    /// Whether this is longer than `than` in a window this wide, and the
+    /// windows that answer holds for.
+    ///
+    /// Which is longer is a question in pixels -- `rel(0.5)` is longer than
+    /// 300 px at a box of 600 and shorter at 400 -- and it is asked of the
+    /// difference and answered back through that same difference, so the
+    /// boundary is the comparison's own rather than a second way of finding
+    /// it.
+    pub fn longer_than(&self, than: Len, window: Px) -> (bool, Holds) {
+        let over = *self - than;
+        let longer = over.to_px(window) > Px::ZERO;
+        let side = match longer {
+            true => Px::STEP..=Px::MAX,
+            false => Px::MIN..=Px::ZERO,
+        };
+        (longer, Holds::from(side).through(over))
+    }
+}
+
+impl Bound {
+    /// Which end of this bound `len` falls outside, and the windows that
+    /// answer holds for. Nothing where it is inside, which is the answer
+    /// wherever there is no bound at all.
+    ///
+    /// `len` and this bound are lengths of the same thing, whichever that
+    /// is: a box in window lengths wants the bound resolved, and a length a
+    /// widget declares of its rel base wants it as the rule wrote it. Both
+    /// comparisons are in pixels, so each is a question about this window,
+    /// and the box is decided again on the other side of a crossing.
+    pub fn outside(&self, len: Len, window: Px) -> (Option<Outside>, Holds) {
+        let mut outside = None;
+        let mut holds = Holds::ANY;
+        let mut held = len;
+        if let Some(min) = self.min {
+            let (shorter, kept) = min.longer_than(held, window);
+            holds = holds.and(kept);
+            if shorter {
+                outside = Some(Outside::Shorter);
+                held = min;
+            }
+        }
+        if let Some(max) = self.max {
+            let (longer, kept) = held.longer_than(max, window);
+            holds = holds.and(kept);
+            if longer {
+                debug_assert!(
+                    outside.is_none(),
+                    "a floor of {:?} over a cap of {max:?} bounds nothing",
+                    self.min,
+                );
+                outside = Some(Outside::Longer);
+            }
+        }
+        (outside, holds)
+    }
+}
+
 impl Holds {
     pub const ANY: Self = Self {
         lo: Px::MIN,
@@ -33,7 +91,13 @@ impl Holds {
         len.raw() >= self.lo.raw() && len.raw() <= self.hi.raw()
     }
 
-    pub const fn and(self, other: Self) -> Self {
+    /// Every length `other` holds for is one this holds for, so a drawing
+    /// made under this range is still good wherever `other` is.
+    pub const fn covers(&self, other: Self) -> bool {
+        self.lo.raw() <= other.lo.raw() && self.hi.raw() >= other.hi.raw()
+    }
+
+    pub const fn and(&self, other: Self) -> Self {
         Self {
             lo: self.lo.max(other.lo),
             hi: self.hi.min(other.hi),
@@ -41,32 +105,32 @@ impl Holds {
     }
 
     /// What a box has to be for a part of it, `len` of the box long, to stay
-    /// in this range. A part with no relative extent is a fixed length: it
-    /// was drawn at that length and any box keeps it there.
+    /// in this range: the exact preimage of `px + floor(rel * box)`, which is
+    /// the one way a box in pixels is reached. A part with no relative extent
+    /// is a fixed length -- it was drawn at that length and any box keeps it
+    /// there.
     ///
-    /// The way in is `px + rel * box` taken to the nearest step, so a part
-    /// of exactly `lo` came from anything within half a step of it and the
-    /// answer is an interval even where this range is one length. Inverting
-    /// the length alone instead gives a point that need not even contain the
-    /// box the part was drawn in, which is a range excluding the drawing it
-    /// was made for.
-    pub const fn through(self, len: Len) -> Self {
+    /// The answer is an interval even where this range is a single length,
+    /// because the multiply on the way in drops to the step below and many
+    /// boxes therefore give one length. That is a floor rather than an
+    /// allowance: inverting it is two divisions and nothing else, and the
+    /// whole of a box maps back to itself.
+    pub const fn through(&self, len: Len) -> Self {
+        if self.lo.raw() == Px::MIN.raw() && self.hi.raw() == Px::MAX.raw() {
+            return Self::ANY;
+        }
         let rel = len.rel.raw() as i64;
         if rel == 0 {
             return Self::ANY;
         }
-        // Three half steps either side -- one for the rounding on the way
-        // in, two for the difference between a length composed down the
-        // chain and the same length measured against the window -- and half
-        // of what a `Rel` counts in, to divide by the fraction. Exact until
-        // the division takes it back to the grid.
         let px = len.px.raw() as i64;
-        let half_rel = REL_SHIFT - 1;
-        let lo = ((self.lo.raw() as i64 - px) * 2 - 3) << half_rel;
-        let hi = ((self.hi.raw() as i64 - px) * 2 + 3) << half_rel;
-        // Dividing by a negative turns the ends around, so which end each
-        // bound comes from is decided before dividing rather than by taking
-        // the min and max of four divisions.
+        // `floor(rel * box) >= lo - px` is `rel * box >= (lo - px) << REL`, and
+        // `floor(rel * box) <= hi - px` is `rel * box < (hi - px + 1) << REL`.
+        let lo = (self.lo.raw() as i64 - px) << REL_SHIFT;
+        let hi = (((self.hi.raw() as i64 - px) + 1) << REL_SHIFT) - 1;
+        // Dividing by a negative fraction turns the ends around, so which
+        // bound each comes from is decided before dividing rather than by
+        // taking the min and max of four divisions.
         match rel > 0 {
             true => Self::raws(div_toward(lo, rel, true), div_toward(hi, rel, false)),
             false => Self::raws(div_toward(hi, rel, true), div_toward(lo, rel, false)),
@@ -95,6 +159,16 @@ mod tests {
     use super::*;
     use crate::Rel;
 
+    #[test]
+    fn an_unrestricted_range_stays_unrestricted_through_any_length() {
+        for rel in [-2.0, -0.5, 0.0, 0.5, 1.0, 2.0] {
+            for px in [-8, 0, 8] {
+                let len = Len::from_parts(Rel::from_f32(rel), Px::from_int(px));
+                assert_eq!(Holds::ANY.through(len), Holds::ANY);
+            }
+        }
+    }
+
     #[test]
     fn through_reverses_a_range_for_a_negative_fraction() {
         // `10 - box / 2` is between 20 and 40 for boxes from -60 to -20.
@@ -116,6 +190,48 @@ mod tests {
         }
     }
 
+    /// A widget handed the whole of its parent's box, with or without pixels
+    /// taken off it, has no fraction to invert: multiplying by one is exact
+    /// and taking the pixels off again is too, so the box maps back to
+    /// itself. Allowing for anything here compounded a step a level down a
+    /// chain of widgets each taking the whole of its parent.
+    #[test]
+    fn the_whole_of_a_box_maps_back_to_itself() {
+        let at = Px::from_int(956);
+        assert_eq!(Holds::at(at).through(Len::FULL), Holds::at(at));
+        let less_eight = Len::from_parts(Rel::ONE, Px::from_int(-8));
+        assert_eq!(
+            Holds::at(at).through(less_eight),
+            Holds::at(at + Px::from_int(8))
+        );
+    }
+
+    /// The range is the exact preimage at both ends, so a box one step
+    /// outside it really does give a length outside this range. What a wider
+    /// range costs is a drawing reused where it does not hold.
+    #[test]
+    fn a_box_one_step_outside_the_range_is_outside_it() {
+        let part = Len::from_parts(Rel::from_f32(1.0 / 3.0), Px::from_int(-146));
+        let at = Px::from_int(300);
+        let holds = Holds::at(at).through(part);
+        for inside in [holds.lo, holds.hi] {
+            assert_eq!(part.to_px(inside), at, "{inside:?} left out of {holds:?}");
+        }
+        for outside in [holds.lo.next_down(), holds.hi.next_up()] {
+            assert_ne!(part.to_px(outside), at, "{outside:?} admitted by {holds:?}");
+        }
+    }
+
+    /// A truncating multiply only ever drops, so the step it needs allowing
+    /// for on the way in belongs at the top of the range and not the bottom.
+    #[test]
+    fn a_fraction_widens_further_up_than_down() {
+        let half = Len::from_parts(Rel::from_f32(0.5), Px::ZERO);
+        let holds = Holds::at(Px::from_int(100)).through(half);
+        let box_len = Px::from_int(200);
+        assert!(holds.hi - box_len > box_len - holds.lo, "{holds:?}");
+    }
+
     #[test]
     fn a_boundary_the_next_step_along_does_not_admit_it() {
         let boundary = Px::from_int(10);

core/src/ui/layout_holds.rs

@@ -0,0 +1,108 @@
+use crate::util::impl_axis_index;
+use crate::{Axis, Holds, Len, Px, PxVec2, UiRegion, UiVec2};
+
+/// What one evaluation of a widget depends on along one axis: the window
+/// lengths its reads hold for, the pixel lengths of its own box, and the
+/// symbolic lengths of that box and of its rel base where either one is what
+/// it was expressed in.
+///
+/// The symbolic lengths are pins rather than ranges: a container places its
+/// children as lengths of its rel base measured from where its own box starts,
+/// so what it draws turns on that box's length and on nothing about where it
+/// is. A box pin reaches the parent only where the box it pinned is the
+/// parent's own; anywhere else the parent chose that length itself, and a
+/// widget pinned this way is checked when it is re-placed.
+///
+/// A rel base pin says the answer or the drawing is a fraction of the rel base,
+/// which is a different length wherever the rel base is a different one -- at
+/// the same window size, so no range of window pixels can say it. A length
+/// of the rel base that is only pixels is not one: it is that many pixels
+/// whatever the rel base turns out to be.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct AxisHolds {
+    pub window: Holds,
+    pub rel_base: Option<Len>,
+    pub region: Holds,
+    pub region_len: Option<Len>,
+}
+
+impl AxisHolds {
+    pub const ANY: Self = Self {
+        window: Holds::ANY,
+        rel_base: None,
+        region: Holds::ANY,
+        region_len: None,
+    };
+
+    pub fn and(&self, other: Self) -> Self {
+        // Two pins of the same length disagreeing would mean one drawing was
+        // a fraction of two different lengths at once.
+        debug_assert!(
+            self.region_len.is_none()
+                || other.region_len.is_none()
+                || self.region_len == other.region_len
+        );
+        debug_assert!(
+            self.rel_base.is_none() || other.rel_base.is_none() || self.rel_base == other.rel_base
+        );
+        Self {
+            window: self.window.and(other.window),
+            rel_base: self.rel_base.or(other.rel_base),
+            region: self.region.and(other.region),
+            region_len: self.region_len.or(other.region_len),
+        }
+    }
+
+    pub fn covers(&self, other: Self) -> bool {
+        self.window.covers(other.window)
+            && self.region.covers(other.region)
+            && self
+                .region_len
+                .is_none_or(|len| other.region_len == Some(len))
+            && self.rel_base.is_none_or(|len| other.rel_base == Some(len))
+    }
+
+    /// Whether a widget in a box `len` long, with that rel base, in that
+    /// window, is one this drawing holds for.
+    pub fn contains(&self, window: Px, rel_base: Len, len: Len) -> bool {
+        self.window.contains(window)
+            && self.rel_base.is_none_or(|pinned| pinned == rel_base)
+            && self.region.contains(len.to_px(window))
+            && self.region_len.is_none_or(|pinned| pinned == len)
+    }
+}
+
+/// [`AxisHolds`] on both axes. Every question asked of it is asked of one
+/// axis at a time, since a widget that read one length holds for any length
+/// of the other.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct LayoutHolds {
+    pub x: AxisHolds,
+    pub y: AxisHolds,
+}
+
+impl LayoutHolds {
+    pub const ANY: Self = Self {
+        x: AxisHolds::ANY,
+        y: AxisHolds::ANY,
+    };
+
+    pub fn and(&self, other: Self) -> Self {
+        Self {
+            x: self.x.and(other.x),
+            y: self.y.and(other.y),
+        }
+    }
+
+    pub fn covers(&self, other: Self) -> bool {
+        self.x.covers(other.x) && self.y.covers(other.y)
+    }
+
+    pub fn contains(&self, window: PxVec2, rel_base: UiVec2, region: UiRegion) -> bool {
+        Axis::BOTH
+            .into_iter()
+            .all(|axis| self[axis].contains(window[axis], rel_base[axis], region[axis].len()))
+    }
+}
+
+impl_axis_index!(LayoutHolds => AxisHolds);

core/src/ui/mod.rs

@@ -11,12 +11,16 @@ pub const CHAIN_LIMIT: u32 = 64;
 
 mod active;
 mod holds;
+mod layout_holds;
 mod painter;
+mod place;
 mod render_state;
 
 pub use active::*;
 pub use holds::*;
+pub use layout_holds::*;
 pub use painter::{Painter, PrimitiveLike};
+pub use place::{PlaceDesc, PlaceDescAxis, RetainedPrimitive};
 pub use render_state::*;
 
 #[derive(Default)]
@@ -68,17 +72,24 @@ impl Moves {
         }
     }
 
-    /// Composes a region held in `idx`'s coordinates down the chain, which is
-    /// the same walk the vertex shader does.
+    /// The same walk the vertex shader does, in the same `Len` the shader is
+    /// handed, for asking where a drawing will actually land -- hit testing,
+    /// and nothing layout decides on. Layout threads its lengths down the
+    /// draw instead, so no box it compares is composed back up this chain.
     pub fn resolve(&self, idx: MoveIdx, local: UiRegion) -> UiRegion {
         let mut region = local;
+        self.walk(idx, |entry| region = region.within(entry));
+        region
+    }
+
+    fn walk(&self, idx: MoveIdx, mut step: impl FnMut(&UiRegion)) {
         let mut at = idx;
         for _ in 0..CHAIN_LIMIT {
             if at == MoveIdx::NONE {
-                return region;
+                return;
             }
-            let entry = self.arena[at.idx()];
-            region = region.within(&entry.region);
+            let entry = &self.arena[at.idx()];
+            step(&entry.region);
             at = entry.parent;
         }
         debug_assert!(
@@ -86,7 +97,6 @@ impl Moves {
             "a move chain longer than {CHAIN_LIMIT} resolves to the wrong place, \
              and the shader stops at the same depth"
         );
-        region
     }
 
     /// How many slots a region in `idx` is composed through, which is what

core/src/ui/place.rs

@@ -0,0 +1,214 @@
+use crate::util::impl_axis_index;
+use crate::{Axis, AxisAlign, Len, PrimitiveHandle, RegionAlign, UiRegion, UiSpan, UiVec2};
+
+/// How a child's region along one axis comes from the region of the widget
+/// asking, and what its fractions are of.
+///
+/// The three ways of saying a region are the three the geometry already has:
+/// a span composed into the caller's box, a span shifted to where that box
+/// starts, and a length placed in it by alignment. Which one is meant cannot
+/// be read off the numbers, since two of them take the same span and apply
+/// it differently, so it is said here.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct PlaceDescAxis {
+    pub span: PlaceSpan,
+    pub fills: bool,
+    pub rel_base: RelBase,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum PlaceSpan {
+    Within(UiSpan),
+    Shifted(UiSpan),
+    Sized(Len),
+}
+
+/// What a child's fractions are of. [`PlaceSpan::Sized`] is a length the
+/// caller named, which is always its own base, so nothing here constructs one
+/// beside anything but [`Self::Len`].
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RelBase {
+    /// The caller's own, unchanged.
+    Inherit,
+    /// The caller's own, narrowed the way the region is.
+    WithRegion,
+    /// This length of the window.
+    Len(Len),
+}
+
+impl PlaceDescAxis {
+    /// The whole of the caller's box.
+    pub const WHOLE: Self = UiSpan::FULL.within_desc();
+
+    /// This region is the child's placement: its answer is not placed inside
+    /// it again. A container uses it where it hands back exactly what the
+    /// child asked for -- a row placing a child at the length it reported.
+    pub const fn fills(mut self) -> Self {
+        self.fills = true;
+        self
+    }
+
+    /// This along `axis`, and the whole of the caller's box across it: what
+    /// a container dividing one axis says, since nothing divides the other.
+    /// [`PlaceDesc::from_axis`] says the across one where it is not the
+    /// whole.
+    pub const fn on_axis(self, axis: Axis) -> PlaceDesc {
+        PlaceDesc::from_axis(axis, self, Self::WHOLE)
+    }
+
+    /// What the child's fractions are of, as a length of the window: a
+    /// resolved share, or a box a sibling's answer decided.
+    pub const fn rel_base(mut self, len: Len) -> Self {
+        self.rel_base = RelBase::Len(len);
+        self
+    }
+
+    /// Where it lands in the coordinates `own` is in.
+    pub fn of(self, own: UiSpan, align: AxisAlign) -> UiSpan {
+        match self.span {
+            PlaceSpan::Within(span) => span.within(&own),
+            PlaceSpan::Shifted(mut span) => {
+                span.shift(own.start);
+                span
+            }
+            PlaceSpan::Sized(len) => own.place(len, align),
+        }
+    }
+}
+
+/// Where a child is asked, on both axes. A [`UiRegion`] converts into the
+/// common case: that box of the caller's own, the answer placed inside it.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct PlaceDesc {
+    pub x: PlaceDescAxis,
+    pub y: PlaceDescAxis,
+}
+
+impl PlaceDesc {
+    /// The whole of the caller's box, on both axes.
+    pub const WHOLE: Self = Self::splat(PlaceDescAxis::WHOLE);
+
+    pub const fn new(x: PlaceDescAxis, y: PlaceDescAxis) -> Self {
+        Self { x, y }
+    }
+
+    /// The same on both axes.
+    pub const fn splat(place: PlaceDescAxis) -> Self {
+        Self { x: place, y: place }
+    }
+
+    /// A description per axis, where the two differ and neither is the
+    /// axis a container divides.
+    pub fn from_axes(f: impl Fn(Axis) -> PlaceDescAxis) -> Self {
+        Self::new(f(Axis::X), f(Axis::Y))
+    }
+
+    /// `aligned` on `axis` and `ortho` on the other, which is how a
+    /// container that divides one axis says what it is doing.
+    pub const fn from_axis(axis: Axis, aligned: PlaceDescAxis, ortho: PlaceDescAxis) -> Self {
+        match axis {
+            Axis::X => Self::new(aligned, ortho),
+            Axis::Y => Self::new(ortho, aligned),
+        }
+    }
+
+    /// Both regions are the child's placement. See [`PlaceDescAxis::fills`].
+    pub const fn fills(self) -> Self {
+        Self::new(self.x.fills(), self.y.fills())
+    }
+
+    /// The child's rel base on one axis. See [`PlaceDescAxis::rel_base`].
+    pub const fn rel_base(mut self, axis: Axis, len: Len) -> Self {
+        self[axis] = self[axis].rel_base(len);
+        self
+    }
+
+    /// What a child's fractions on one axis are of, as a length of the
+    /// window: a length this place names, or the rel base of the widget
+    /// giving it, which is `parent_rel_base`.
+    pub(super) fn base(&self, axis: Axis, parent_rel_base: UiVec2) -> Len {
+        match self[axis].rel_base {
+            RelBase::Len(len) => len,
+            RelBase::Inherit | RelBase::WithRegion => parent_rel_base[axis],
+        }
+    }
+
+    /// The box each axis names, in the coordinates `own` is in.
+    pub fn of(self, own: UiRegion, align: RegionAlign) -> UiRegion {
+        UiRegion::new(self.x.of(own.x, align.x), self.y.of(own.y, align.y))
+    }
+}
+
+impl UiSpan {
+    /// This span composed into the caller's own box, so it moves and scales
+    /// with it: [`UiSpan::within`], which is what a container that insets
+    /// one speaks. Taking eleven pixels off the end needs no length, where
+    /// saying the same thing in window lengths would make the container read
+    /// its own box -- and a box chosen from its own answer then feeds back
+    /// into the answer.
+    ///
+    /// The child's rel base is narrowed the same way, so padding takes its
+    /// pixels off both and `rel(1)` under it fills the caller rather than
+    /// overflowing it.
+    pub const fn within_desc(self) -> PlaceDescAxis {
+        PlaceDescAxis {
+            span: PlaceSpan::Within(self),
+            fills: false,
+            rel_base: RelBase::WithRegion,
+        }
+    }
+
+    /// This span shifted to where the caller's own box starts: window
+    /// lengths along a cursor, which is what a container dividing room among
+    /// its children speaks. A child's report is a window length, so the
+    /// cursor that sums those reports is one too, and a moved box re-places
+    /// every child by re-adding its start, exactly.
+    ///
+    /// The child's rel base passes through: how far along the cursor a child
+    /// sits says nothing about what a fraction under it is of. The same span
+    /// says [`Self::within_desc`] as a part of that box instead, and which is
+    /// meant cannot be read off the numbers.
+    pub const fn shifted_desc(self) -> PlaceDescAxis {
+        PlaceDescAxis {
+            span: PlaceSpan::Shifted(self),
+            fills: false,
+            rel_base: RelBase::Inherit,
+        }
+    }
+}
+
+impl Len {
+    /// A box this long, placed in the caller's own by the child's alignment:
+    /// the rule that places an answer, with the length given from above
+    /// rather than reported. What a stack's sizing child decides for the
+    /// rest. It is the child's rel base too.
+    pub const fn as_desc(self) -> PlaceDescAxis {
+        PlaceDescAxis {
+            span: PlaceSpan::Sized(self),
+            fills: false,
+            rel_base: RelBase::Len(self),
+        }
+    }
+}
+
+impl From<UiRegion> for PlaceDesc {
+    fn from(region: UiRegion) -> Self {
+        Self::new(region.x.within_desc(), region.y.within_desc())
+    }
+}
+
+impl From<PlaceDescAxis> for PlaceDesc {
+    fn from(place: PlaceDescAxis) -> Self {
+        Self::splat(place)
+    }
+}
+
+/// A primitive as it was written: its box in the widget's own box's
+/// coordinates, which is what a move of that box re-composes from.
+#[derive(Debug)]
+pub struct RetainedPrimitive {
+    pub handle: PrimitiveHandle,
+    pub region: UiRegion,
+}
+
+impl_axis_index!(PlaceDesc => PlaceDescAxis);

core/src/util/arena.rs

@@ -35,7 +35,7 @@ impl<T, I: IdNum> Arena<T, I> {
         self.data[i]
     }
 
-    pub(crate) fn get_mut(&mut self, id: Id<I>) -> &mut T {
+    pub fn get_mut(&mut self, id: Id<I>) -> &mut T {
         &mut self.data[id.idx()]
     }
 }

core/src/util/math.rs

@@ -93,3 +93,31 @@ macro_rules! impl_op {
 }
 
 pub(crate) use impl_op;
+
+/// `Index<Axis>` for a pair, which is how every pair here is read by axis.
+/// The generics clause is given in braces where the type has one.
+macro_rules! impl_axis_index {
+    ($({$($gen:tt)*})? $T:ty => $Out:ty) => {
+        const impl $(<$($gen)*>)? std::ops::Index<crate::Axis> for $T {
+            type Output = $Out;
+
+            fn index(&self, axis: crate::Axis) -> &$Out {
+                match axis {
+                    crate::Axis::X => &self.x,
+                    crate::Axis::Y => &self.y,
+                }
+            }
+        }
+
+        const impl $(<$($gen)*>)? std::ops::IndexMut<crate::Axis> for $T {
+            fn index_mut(&mut self, axis: crate::Axis) -> &mut $Out {
+                match axis {
+                    crate::Axis::X => &mut self.x,
+                    crate::Axis::Y => &mut self.y,
+                }
+            }
+        }
+    };
+}
+
+pub(crate) use impl_axis_index;

core/src/util/slot.rs

@@ -1,4 +1,4 @@
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct SlotId {
     idx: u32,
     genr: u32,

core/src/widget/size_rule.rs

@@ -1,4 +1,5 @@
-use crate::{Axis, LayoutLen, Weight};
+use crate::util::impl_axis_index;
+use crate::{Axis, LayoutLen, Len, Rel};
 
 /// What a widget's length on one axis is, as a rule its parent applies where
 /// it draws it rather than an answer the widget gives about itself.
@@ -8,6 +9,10 @@ use crate::{Axis, LayoutLen, Weight};
 /// with no rule. That is what lets a span divide its space around a length
 /// nobody has drawn yet, and it is why a rule lives beside the widget rather
 /// than inside it -- the widget under the rule never has to know about it.
+///
+/// A rule gives a length or bounds one, never both: a share that is also
+/// capped wants two widgets, one taking the share and one capping what is
+/// inside it.
 #[derive(Debug, Clone, Copy, PartialEq, Default)]
 pub enum SizeRule {
     /// Whatever the widget reports from drawing.
@@ -15,20 +20,78 @@ pub enum SizeRule {
     Free,
     /// This length, whatever the widget reports.
     Exact(LayoutLen),
+    /// At least this long, and otherwise whatever the box gives it.
+    Min(Len),
+    /// At most this long.
+    Max(Len),
+    /// Between the two.
+    Clamp { min: Len, max: Len },
 }
 
 impl SizeRule {
-    /// The length this rule gives without the widget being drawn, if it can
-    /// give one. `leftover` is never among them: a share is a length only to
-    /// whoever divides one, so it passes up in the reported size instead and
-    /// is resolved there.
-    pub fn declared(&self) -> Option<LayoutLen> {
-        match self {
-            Self::Exact(len) if len.leftover == Weight::ZERO => Some(*len),
-            _ => None,
+    /// What this rule allows the length to be where it does not give one
+    /// outright.
+    pub fn bound(&self) -> Bound {
+        match *self {
+            Self::Free | Self::Exact(_) => Bound::ANY,
+            Self::Min(min) => Bound {
+                min: Some(min),
+                max: None,
+            },
+            Self::Max(max) => Bound {
+                min: None,
+                max: Some(max),
+            },
+            Self::Clamp { min, max } => Bound {
+                min: Some(min),
+                max: Some(max),
+            },
         }
     }
 
+    /// Whether what this rule says is a fraction of the rel base, so that
+    /// the same rule against a different one is a different length.
+    pub fn has_fraction(&self) -> bool {
+        let bound = self.bound();
+        self.exact().is_some_and(|len| len.rel != Rel::ZERO)
+            || [bound.min, bound.max]
+                .iter()
+                .flatten()
+                .any(|len| len.rel != Rel::ZERO)
+    }
+
+    /// This rule with a floor under it, which is the whole of it where there
+    /// was no rule.
+    pub fn at_least(&self, min: Len) -> Self {
+        match *self {
+            Self::Free | Self::Min(_) => Self::Min(min),
+            Self::Max(max) | Self::Clamp { max, .. } => Self::Clamp { min, max },
+            Self::Exact(len) => {
+                debug_assert!(false, "{len:?} is a length, so bounding it says nothing");
+                Self::Min(min)
+            }
+        }
+    }
+
+    /// This rule with a cap over it, which is the whole of it where there was
+    /// no rule.
+    pub fn at_most(&self, max: Len) -> Self {
+        match *self {
+            Self::Free | Self::Max(_) => Self::Max(max),
+            Self::Min(min) | Self::Clamp { min, .. } => Self::Clamp { min, max },
+            Self::Exact(len) => {
+                debug_assert!(false, "{len:?} is a length, so bounding it says nothing");
+                Self::Max(max)
+            }
+        }
+    }
+
+    /// The length this rule gives without the widget being drawn, if it can
+    /// give one.
+    pub fn declared(&self) -> Option<Len> {
+        self.exact().and_then(|len| len.declared())
+    }
+
     /// The length this rule gives outright, whatever the widget reports --
     /// which makes the widget's answer on that axis moot. A share counts: it
     /// is a length the widget's parent still has to divide, so it is exact
@@ -36,20 +99,84 @@ impl SizeRule {
     /// that give a box directly.
     pub fn exact(&self) -> Option<LayoutLen> {
         match self {
-            Self::Free => None,
             Self::Exact(len) => Some(*len),
-        }
-    }
-
-    /// The length a widget reporting `reported` ends up with.
-    pub fn apply(&self, reported: LayoutLen) -> LayoutLen {
-        match self {
-            Self::Free => reported,
-            Self::Exact(len) => *len,
+            Self::Free | Self::Min(_) | Self::Max(_) | Self::Clamp { .. } => None,
         }
     }
 }
 
+/// What a rule allows a length to be where it does not give one outright: a
+/// floor, a cap, or both. Each is a length of the rel base the widget is
+/// asked with, which is the base a declared length is a fraction of too, and
+/// a bound that binds is a declaration -- the box comes to what it says.
+///
+/// A bound is a [`Len`] and never a share. Which of a fixed and a relative
+/// child is longer, asked at the length the cap is itself deciding, admits
+/// several self-sizing fixed points, so a cap containing `leftover` has no
+/// one answer: see `docs/LAYOUT.md` under the failed hypotheses.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Bound {
+    pub min: Option<Len>,
+    pub max: Option<Len>,
+}
+
+/// Which end of a bound a length fell outside.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Outside {
+    Shorter,
+    Longer,
+}
+
+impl Bound {
+    /// Every length.
+    pub const ANY: Self = Self {
+        min: None,
+        max: None,
+    };
+
+    /// The end [`Outside`] names, which is the length a widget outside it
+    /// gets instead of its own.
+    pub fn at(&self, outside: Outside) -> Len {
+        let end = match outside {
+            Outside::Shorter => self.min,
+            Outside::Longer => self.max,
+        };
+        end.expect("an end nothing is outside of")
+    }
+
+    /// This bound as lengths of the window, from lengths of a rel base that
+    /// long.
+    pub fn within_len(&self, len: Len) -> Self {
+        Self {
+            min: self.min.map(|min| min.within_len(len)),
+            max: self.max.map(|max| max.within_len(len)),
+        }
+    }
+}
+
+/// One bound per axis, as [`SizeRules`] is one rule per axis.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Bounds {
+    pub x: Bound,
+    pub y: Bound,
+}
+
+impl Bounds {
+    pub const ANY: Self = Self {
+        x: Bound::ANY,
+        y: Bound::ANY,
+    };
+
+    pub fn from_axes(f: impl Fn(Axis) -> Bound) -> Self {
+        Self {
+            x: f(Axis::X),
+            y: f(Axis::Y),
+        }
+    }
+}
+
+impl_axis_index!(Bounds => Bound);
+
 impl From<LayoutLen> for SizeRule {
     fn from(len: LayoutLen) -> Self {
         Self::Exact(len)
@@ -70,18 +197,29 @@ pub struct SizeRules {
     pub y: SizeRule,
 }
 
-impl SizeRules {
-    pub fn axis(&self, axis: Axis) -> SizeRule {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
+impl_axis_index!(SizeRules => SizeRule);
 
-    pub fn axis_mut(&mut self, axis: Axis) -> &mut SizeRule {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
+/// What a widget's box is on each axis where something says so outright,
+/// before it is drawn: a rule beside it, or a hint it gives about itself.
+/// Whoever draws the widget resolves these against its rel base.
+///
+/// A [`Len`] rather than a [`LayoutLen`], because a share can never be one
+/// -- see [`LayoutLen::declared`].
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Declared {
+    pub x: Option<Len>,
+    pub y: Option<Len>,
+}
+
+impl Declared {
+    pub const NONE: Self = Self { x: None, y: None };
+
+    pub fn from_axes(f: impl Fn(Axis) -> Option<Len>) -> Self {
+        Self {
+            x: f(Axis::X),
+            y: f(Axis::Y),
         }
     }
 }
+
+impl_axis_index!(Declared => Option<Len>);

core/src/widget/widgets.rs

@@ -1,8 +1,8 @@
 use std::sync::mpsc::{Receiver, Sender, channel};
 
 use crate::{
-    Axis, AxisAlign, IdLike, RegionAlign, SizeRule, SizeRules, StrongWidget, WeakWidget, Widget,
-    WidgetData, WidgetId,
+    Axis, AxisAlign, IdLike, Len, RegionAlign, SizeRule, SizeRules, StrongWidget, WeakWidget,
+    Widget, WidgetData, WidgetId,
     util::{DynBorrower, HashSet, SlotVec, forget_mut, to_mut},
 };
 
@@ -30,6 +30,14 @@ impl Widgets {
         !self.needs_redraw.is_empty()
     }
 
+    /// Marks this widget for the next frame to draw again, with nothing about
+    /// it changed. Taking a widget mutably marks it too, which is the ordinary
+    /// content-change signal; this is for a change the borrow cannot express,
+    /// and for asking for the same tree over again.
+    pub fn mark_for_redraw(&mut self, id: impl IdLike) {
+        self.needs_redraw.insert(id.id());
+    }
+
     pub fn get_dyn(&self, id: WidgetId) -> Option<&dyn Widget> {
         Some(self.vec.get(id)?.widget.as_ref())
     }
@@ -41,14 +49,14 @@ impl Widgets {
 
     /// get_dyn but dynamic borrow checking of widgets
     /// lets you do recursive (tree) operations, like the painter does
-    pub(crate) fn get_dyn_dynamic<'a>(&self, id: WidgetId) -> WidgetWrapper<'a> {
+    pub(crate) fn get_dyn_dynamic<'a>(&self, id: WidgetId) -> DynBorrower<'a, dyn Widget> {
         // SAFETY: must guarantee no other mutable references to this widget exist
         // done through the borrow variable
         let data = unsafe { forget_mut(to_mut(self.vec.get(id).unwrap())) };
         if data.borrowed {
             panic!("tried to mutably borrow the same widget twice");
         }
-        WidgetWrapper::new(data.widget.as_mut(), &mut data.borrowed)
+        DynBorrower::new(data.widget.as_mut(), &mut data.borrowed)
     }
 
     pub fn get<I: IdLike>(&self, id: &I) -> Option<&I::Widget>
@@ -130,13 +138,29 @@ impl Widgets {
     pub fn set_size_rule(&mut self, id: impl IdLike, axis: Axis, rule: SizeRule) {
         let id = id.id();
         let data = self.data_mut(id).unwrap();
-        if *data.size.axis_mut(axis) == rule {
+        if data.size[axis] == rule {
             return;
         }
-        *data.size.axis_mut(axis) = rule;
+        data.size[axis] = rule;
         self.needs_redraw.insert(id);
     }
 
+    /// Puts a floor under this widget's length on one axis, keeping a cap it
+    /// already had. See [`SizeRule::at_least`].
+    pub fn set_min_len(&mut self, id: impl IdLike, axis: Axis, min: Len) {
+        let id = id.id();
+        let rule = self.size_rules(id)[axis].at_least(min);
+        self.set_size_rule(id, axis, rule);
+    }
+
+    /// Puts a cap over it, keeping a floor it already had. See
+    /// [`SizeRule::at_most`].
+    pub fn set_max_len(&mut self, id: impl IdLike, axis: Axis, max: Len) {
+        let id = id.id();
+        let rule = self.size_rules(id)[axis].at_most(max);
+        self.set_size_rule(id, axis, rule);
+    }
+
     /// Where this widget sits in a box longer than the length it takes.
     pub fn alignment(&self, id: impl IdLike) -> RegionAlign {
         self.data(id).unwrap().align
@@ -147,14 +171,14 @@ impl Widgets {
     pub fn set_alignment(&mut self, id: impl IdLike, axis: Axis, align: AxisAlign) {
         let id = id.id();
         let data = self.data_mut(id).unwrap();
-        if *data.align.axis_mut(axis) == align {
+        if data.align[axis] == align {
             return;
         }
-        *data.align.axis_mut(axis) = align;
+        data.align[axis] = align;
         self.needs_redraw.insert(id);
     }
 
-    /// Both axes at once, for a caller holding a pair.
+    /// Both axes at once.
     pub fn set_size_rules(
         &mut self,
         id: impl IdLike,
@@ -188,8 +212,6 @@ impl Default for Widgets {
     }
 }
 
-pub type WidgetWrapper<'a> = DynBorrower<'a, dyn Widget>;
-
 impl<I: IdLike> std::ops::Index<I> for Widgets
 where
     I::Widget: Sized + Widget,

examples/tabs/main.rs

@@ -20,10 +20,14 @@ impl DefaultAppState for Client {
         let pad_test = (
             rrect.color(Color::BLUE),
             (
+                // The square is one widget and the two shares of the row it
+                // sits centred in are another: a length is a property of a
+                // widget, so `.width` here would overwrite the `.sized`.
                 rrect
                     .color(Color::RED)
                     .sized((100, 100))
                     .center()
+                    .wrapper()
                     .width(leftover(2)),
                 (
                     rrect.color(Color::ORANGE),
@@ -143,7 +147,7 @@ impl DefaultAppState for Client {
             .span(Dir::DOWN)
             .add(rsc);
 
-        let main = WidgetPtr::new().add(rsc);
+        let main = Wrapper::new().add(rsc);
 
         let vals = Rc::new(RefCell::new((0, Vec::new())));
         let mut switch_button = |color, to: WeakWidget, label| {

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)

macro/src/lib.rs

@@ -18,6 +18,7 @@ struct Input {
 }
 
 struct InputFn {
+    attrs: Vec<Attribute>,
     sig: Signature,
     body: Block,
 }
@@ -32,9 +33,10 @@ impl Parse for Input {
         input.parse::<Token![;]>()?;
         let mut fns = Vec::new();
         while !input.is_empty() {
+            let attrs = input.call(Attribute::parse_outer)?;
             let sig = input.parse()?;
             let body = input.parse()?;
-            fns.push(InputFn { sig, body })
+            fns.push(InputFn { attrs, sig, body })
         }
         if !input.is_empty() {
             input.error("function expected");
@@ -59,10 +61,15 @@ pub fn widget_trait(input: TokenStream) -> TokenStream {
         fns,
     } = parse_macro_input!(input as Input);
 
-    let sigs: Vec<_> = fns.iter().map(|f| f.sig.clone()).collect();
+    // What a method says about itself belongs on the trait, where a reader
+    // looks it up; the implementation is the same text and says it again.
+    let sigs: Vec<_> = fns
+        .iter()
+        .map(|InputFn { attrs, sig, .. }| quote! { #(#attrs)* #sig })
+        .collect();
     let impls: Vec<_> = fns
         .iter()
-        .map(|InputFn { sig, body }| quote! { #sig #body })
+        .map(|InputFn { attrs, sig, body }| quote! { #(#attrs)* #sig #body })
         .collect();
 
     let Some(GenericParam::Type(state)) = generics.params.first() else {

scripts/run-headless.sh

@@ -106,11 +106,16 @@ export WAYLAND_DISPLAY
 
 echo "run-headless: $WAYLAND_DISPLAY (sway $(swaymsg -t get_version --raw | sed -n 's/.*"human_readable":"\([^"]*\)".*/\1/p'))" >&2
 
-swaymsg output HEADLESS-1 mode "$mode" >/dev/null
-# The extent `replay-touch` positions against, so a script's coordinates
-# are the output's own pixels.
-out_w=${mode%x*}
-out_h=${mode#*x}; out_h=${out_h%@*}
+# The extent `replay-touch` positions against, so a script's coordinates are
+# the output's own pixels. Set beside every mode change, since a gesture
+# scaled against a mode the output no longer has lands somewhere else and
+# still looks like a run that worked.
+set_mode() {
+    swaymsg output HEADLESS-1 mode "$1" >/dev/null
+    out_w=${1%x*}
+    out_h=${1#*x}; out_h=${out_h%@*}
+}
+set_mode "$mode"
 
 # Built before the app starts, so a compile error is not reported as a
 # window that failed to move.
@@ -149,7 +154,7 @@ while [ $i -lt "$((seconds * 2))" ]; do
 done
 
 if [ -n "$resize" ] && kill -0 "$pid" 2>/dev/null; then
-    swaymsg output HEADLESS-1 mode "$resize" >/dev/null
+    set_mode "$resize"
     echo "run-headless: resized to $resize" >&2
     sleep 2
 fi

src/default/attr.rs

@@ -15,9 +15,10 @@ where
             let region = ctx.data.render.window_region(&id).unwrap();
             let id_pos = region.top_left;
             let container_pos = ctx.data.render.window_region(&container).unwrap().top_left;
-            // The pointer arrives from the platform in floats; everything
-            // it is compared against is on the grid.
-            let pos = (PxVec2::from_f32(ctx.data.pos) + container_pos - id_pos).to_f32();
+            // The two regions are on the grid and the pointer is not, so the
+            // step between them is taken there and the pointer keeps the
+            // precision the platform gave it.
+            let pos = ctx.data.pos + (container_pos - id_pos).to_f32();
             let size = region.size().to_f32();
             select(
                 rsc,

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/default/render.rs

@@ -22,12 +22,12 @@ impl UiRenderer {
     }
 
     pub fn draw(&mut self) {
-        let output = match self.surface.get_current_texture() {
-            CurrentSurfaceTexture::Success(texture) => texture,
-            CurrentSurfaceTexture::Suboptimal(texture) => {
-                self.surface.configure(&self.device, &self.config);
-                texture
-            }
+        let (output, suboptimal) = match self.surface.get_current_texture() {
+            CurrentSurfaceTexture::Success(texture) => (texture, false),
+            // Used for this frame, and the swapchain rebuilt after it has
+            // been presented: configuring the surface while a texture it
+            // handed out is still alive panics.
+            CurrentSurfaceTexture::Suboptimal(texture) => (texture, true),
             CurrentSurfaceTexture::Outdated | CurrentSurfaceTexture::Lost => {
                 self.surface.configure(&self.device, &self.config);
                 return;
@@ -60,6 +60,9 @@ impl UiRenderer {
         self.queue.submit(std::iter::once(encoder.finish()));
         self.window.pre_present_notify();
         self.queue.present(output);
+        if suboptimal {
+            self.surface.configure(&self.device, &self.config);
+        }
     }
 
     pub fn resize(&mut self, size: &PhysicalSize<u32>) {

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/image.rs

@@ -12,7 +12,16 @@ impl Widget for Image {
     }
 
     fn size_hint(&self, axis: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::px(self.handle.size().axis(axis)))
+        Some(LayoutLen::px(self.handle.size()[axis]))
+    }
+}
+
+impl Image {
+    /// One texture already uploaded, for a caller holding its handle: [`image()`]
+    /// uploads what it is given, and several widgets showing one picture want
+    /// one upload and one slot between them.
+    pub fn new(handle: TextureHandle) -> Self {
+        Self { handle }
     }
 }
 

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(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
@@ -15,4 +15,8 @@ impl Widget for Masked {
         // draw, and the framework would place the drawing it clipped away.
         Size::LEFTOVER
     }
+
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::LEFTOVER)
+    }
 }

src/widget/mod.rs

@@ -1,15 +1,15 @@
 mod image;
 mod mask;
 mod position;
-mod ptr;
 mod rect;
 mod text;
 mod trait_fns;
+mod wrapper;
 
 pub use image::*;
 pub use mask::*;
 pub use position::*;
-pub use ptr::*;
 pub use rect::*;
 pub use text::*;
 pub use trait_fns::*;
+pub use wrapper::*;

src/widget/position/max_size.rs

@@ -0,0 +1,60 @@
+use crate::prelude::*;
+
+/// Asks its child in the shorter of a cap and the box this widget was given,
+/// and answers what the child used, held to the same cap.
+///
+/// A cap on the box is a widget rather than a [`SizeRule`] because a box is
+/// whoever asked's to decide: a rule that read the box it was given would be
+/// decided again by every path that hands a widget one, including the ones
+/// that re-place a drawing without asking it anything, and the decision would
+/// then depend on which path arrived last. A widget is drawn again whenever
+/// its own box changes, so the comparison is made where the answer can be
+/// kept -- `longer_than` narrows the windows this drawing holds for, and
+/// `holds` says the box lengths.
+///
+/// The box is what a text wraps at and what a scroll takes its viewport from,
+/// which is why capping the answer alone is not the same thing.
+pub struct MaxSize {
+    pub inner: StrongWidget,
+    pub x: Option<Len>,
+    pub y: Option<Len>,
+}
+
+impl MaxSize {
+    fn max(&self, axis: Axis) -> Option<Len> {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+}
+
+impl Widget for MaxSize {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        let align = painter.alignment();
+        let mut region = UiRegion::FULL;
+        for axis in Axis::BOTH {
+            let Some(max) = self.max(axis) else {
+                continue;
+            };
+            let own = painter.region_len(axis);
+            if painter.longer_than(own, max, axis) {
+                region[axis] = max.align(align[axis]);
+            }
+        }
+        let mut size = painter.widget_at(&self.inner, region).size();
+        for axis in Axis::BOTH {
+            // The child may draw past the box it was given -- a text too tall
+            // for it -- and the cap is a promise about the length as well. A
+            // share passes through: it is a length only to whoever divides
+            // one, and that is this widget's parent rather than this widget,
+            // which has already given the share the box the cap allows.
+            if let Some(max) = self.max(axis)
+                && painter.longer_than(size[axis].without_leftover(), max, axis)
+            {
+                size[axis] = max.into();
+            }
+        }
+        size
+    }
+}

src/widget/position/mod.rs

@@ -1,4 +1,5 @@
 mod layer;
+mod max_size;
 mod offset;
 mod pad;
 mod scroll;
@@ -6,6 +7,7 @@ mod span;
 mod stack;
 
 pub use layer::*;
+pub use max_size::*;
 pub use offset::*;
 pub use pad::*;
 pub use scroll::*;

src/widget/position/offset.rs

@@ -7,7 +7,8 @@ pub struct Offset {
 
 impl Widget for Offset {
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        let region = UiRegion::FULL.offset(self.amt);
-        painter.widget_within(&self.inner, region).size()
+        painter
+            .widget_at(&self.inner, UiRegion::FULL.offset(self.amt))
+            .size()
     }
 }

src/widget/position/pad.rs

@@ -7,9 +7,19 @@ pub struct Pad {
 
 impl Widget for Pad {
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        let inner = painter
-            .widget_aligned(&self.inner, self.padding.region(), RegionAlign::NEAR)
-            .size();
+        // The inner's own alignment, not the near edge. This reports the
+        // inner's size plus the padding, so where the box is that answer the
+        // inset box is exactly the inner and alignment has no room to move
+        // 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.
+        //
+        // Padding is an inset of both: it comes off the rel base, so `rel(1)`
+        // under it fills this widget rather than overflowing it by the
+        // padding, and it comes off the box, so what is drawn sits inside.
+        // The two stay distinct -- the box can be narrower still, where a row
+        // asked this widget in the room left, and a text wraps at that.
+        let inner = painter.widget_at(&self.inner, self.padding.region()).size();
         Size {
             x: LayoutLen {
                 px: inner.x.px + self.padding.left + self.padding.right,
@@ -47,14 +57,18 @@ impl Padding {
             bottom: amt,
         }
     }
-    pub fn region(&self) -> UiRegion {
-        let mut region = UiRegion::FULL;
+    /// `region` less this padding on each side.
+    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

@@ -12,64 +12,68 @@ pub struct Scroll {
 impl Widget for Scroll {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         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) {
-            Some(len) => len,
-            None => painter.widget(&self.inner).size().axis(self.axis),
-        };
-        let content = answer_len.apply_leftover();
+        // Asked in the whole viewport, then put at the scrolled offset.
+        let answer_len = painter
+            .widget_at(&self.inner, PlaceDesc::WHOLE.fills())
+            .len(self.axis);
+        let answer_px = painter.to_px(answer_len.without_leftover(), self.axis);
         self.container_len = container_len;
-        self.content_len = content.to_px(container_len);
+        self.content_len = answer_px.max(container_len);
 
         if self.snap_end {
             self.amt = self.content_len - self.container_len;
         }
         self.update_amt();
-        let align = painter.alignment().axis(self.axis);
-        // Content of a fixed length that fits sits at the start of any box it
-        // fits in -- but only anchored there. Anywhere else it is a part of
-        // the room left over, so it moves with every length the box takes and
-        // the drawing holds for that length alone. One scrolled part way sits
-        // where it is until the box shrinks past what is left of it. Kept to
-        // the end, it moves with every length.
-        let fixed_len = content.rel == Rel::ZERO;
-        if fixed_len && self.content_len <= self.container_len && align == AxisAlign::NEG {
-            painter.holds(self.axis, self.content_len..=Px::MAX);
-        } else if fixed_len && !self.snap_end {
+        // Reading the box in pixels above holds this drawing to that one
+        // length, so these two say where it holds more widely.
+        //
+        // Content of a fixed length that fits is handed the whole box below,
+        // and nothing here reads the box again, so every longer box gives the
+        // same drawing: it holds from the length the content needs upwards,
+        // and shrinking past that is what changes it. Where it sits in a box
+        // longer than itself is not this widget's to say -- placing its
+        // answer in the whole box is its own alignment, and that placement is
+        // a fraction of the box, so it holds at every length too.
+        //
+        // One scrolled part way sits where it is until the box shrinks past
+        // what is left of it. Kept to the end, it moves with every length.
+        let answer_is_px = answer_len.is_px();
+        if answer_is_px && self.content_len <= self.container_len {
+            painter.holds(self.axis, answer_px..=Px::MAX);
+        } else if answer_is_px && !self.snap_end {
             let left = self.content_len - self.amt;
             painter.holds(self.axis, Px::MIN..=left);
         }
 
-        // Content shorter than the viewport has room to sit in, and where it
-        // sits is this widget's own alignment -- the same property that would
-        // have placed the whole scroll in a box longer than it.
-        let slack = (self.container_len - self.content_len).max(Px::ZERO);
-        let anchor = slack.mul(align.rel());
-        let mut region = UiRegion::FULL;
-        // Content that fills the viewport and has not been scrolled is the
-        // viewport, and is handed back as it came. Writing the same box as
-        // its own length in pixels is the same box in another form, and the
-        // two do not round alike: a part centred in `rel 1` lands a step from
-        // one centred in `px 900`, since halving a difference is not halving
-        // each part of it.
-        let moved = anchor != Px::ZERO || self.amt != Px::ZERO;
-        if moved || self.content_len != self.container_len {
-            let offset = UiVec2::from_axis(
-                self.axis,
-                Len::from_parts(Rel::ZERO, anchor - self.amt),
-                Len::ZERO,
-            );
-            region = region.offset(offset);
-            region.axis_mut(self.axis).end = region.axis(self.axis).start.offset(self.content_len);
-        }
-        painter.widget_aligned(&self.inner, region, RegionAlign::NEAR);
+        // Content that fills the viewport is the viewport, and is handed back
+        // as it came -- it has nothing to scroll through, so the clamp above
+        // has already put `amt` at zero. Writing the same box as its own
+        // length in pixels is the same box in another form, and the two do
+        // not round alike: a part centred in `rel 1` lands a step from one
+        // centred in `px 900`, since halving a difference is not halving each
+        // part of it.
+        let content = match self.content_len > self.container_len {
+            true => {
+                let start = Len::from_parts(Rel::ZERO, -self.amt);
+                UiSpan::new(start, start.offset(self.content_len)).shifted_desc()
+            }
+            false => PlaceDescAxis::WHOLE,
+        };
+        // The viewport is the inner's rel base, 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 goes is the content
+        // box, scrolled: its drawing moved there, not made again there.
+        painter.place_at(&self.inner, content.on_axis(self.axis).fills());
         // 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
         // is.
         Size::LEFTOVER
     }
+
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::LEFTOVER)
+    }
 }
 
 impl Scroll {

src/widget/position/span.rs

@@ -10,22 +10,32 @@ pub struct Span {
 impl Widget for Span {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let axis = self.dir.axis;
-        // 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();
+        // The row this span lays its children out along, as a length of the
+        // rel base they are laid out against. Where it starts is nothing's
+        // business -- a slot is a length from there -- so what this reads is
+        // the length alone.
+        let row = painter.region_len(axis);
+        // A length for every child before their final slots are chosen: from
+        // a hint where one says, and from drawing otherwise. The rel base passes
+        // through unchanged, so `rel(0.5)` is half the area this span was
+        // given whatever else is in it and wherever this child sits among
+        // them; what a drawn child is asked in is the room left from the
+        // cursor, because a text has to wrap at the width actually there.
+        let mut cursor = Len::ZERO;
         let mut lens = Vec::with_capacity(self.children.len());
         for child in &self.children {
-            let mut span = UiSpan::new(cursor, Len::rel_max());
-            if self.dir.sign == Sign::Neg {
-                span.flip();
-            }
-            let region = UiRegion::from_axis(axis, span, UiSpan::FULL);
-            let len = match painter.known_len(child, axis, region) {
+            let len = match painter.size_hint(child, axis) {
                 Some(len) => len,
-                None => painter.widget_within(child, region).len(axis),
+                None => {
+                    // Across itself the child sits where its own alignment
+                    // says, in the whole of the row: a span is what contains
+                    // its children there, and nothing divides that axis.
+                    let room = self.slot(row, cursor, row).shifted_desc().on_axis(axis);
+                    painter.widget_at(child, room).len(axis)
+                }
             };
-            cursor.px += len.px + self.gap;
-            cursor.rel += len.rel;
+            cursor += len.without_leftover();
+            cursor.px += self.gap;
             lens.push(len);
         }
 
@@ -40,44 +50,17 @@ impl Widget for Span {
             |sum, len| sum + *len,
         );
 
-        // 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;
-        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
-            };
-            painter.holds(axis, holds);
-        }
+        // What is left for the shares to divide: the row less everything
+        // fixed, as a length of the rel base rather than a number of pixels.
+        let all_fixed = total.without_leftover();
+        let room = row - all_fixed;
+        // 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 the range `longer_than` keeps already
+        // reads. What the generated oracle checks is the consequence, since
+        // which children exist at all turns on this.
+        let any_leftover = total.leftover > Weight::ZERO;
+        let has_room = any_leftover && painter.longer_than(row, all_fixed, axis);
 
         // Across itself a span is as long as its longest child -- unless a
         // rule beside it gives that length outright, and then reading them
@@ -87,53 +70,59 @@ impl Widget for Span {
         let shrinks = !painter.has_exact_size(!axis);
         // What the fixed parts and the gaps before here take, which is a sum
         // of lengths and exact, and how much of the leftover weight is
-        // spoken for. A position is one from the other rather than a step
-        // from the last child: the share of the room is rounded, and taking
-        // each from the one before it would carry every rounding along the
-        // row.
-        let mut fixed = Len::rel_min();
+        // spoken for. Both ends of a slot are read from those two rather
+        // than stepped from the last child: the share of the room is
+        // rounded, and taking each end from the one before it would carry
+        // every rounding along the row.
+        let mut fixed = Len::ZERO;
         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) {
+        // Nothing divides the room where no child asked for any of it, and a
+        // ratio of a whole of nothing has no answer.
+        let reached = |fixed: Len, taken: Weight| match any_leftover {
+            false => fixed,
+            true => fixed + room.scale(Rel::ratio(taken, total.leftover)),
+        };
+        for (child, &len) in self.children.iter().zip(&lens) {
             // A child asking for nothing but a part of what is left over,
             // when nothing is, is not drawn at all. One that also asked for
             // pixels or a fraction keeps those and overflows.
-            if len.leftover > Weight::ZERO && len.px == Px::ZERO && len.rel == Rel::ZERO && !shares
-            {
+            if len.is_only_leftover() && !has_room {
                 painter.undraw(child);
                 fixed.px += self.gap;
                 continue;
             }
-            let mut span = UiSpan::FULL;
-            span.start = start;
-            if len.leftover > Weight::ZERO && shares {
+            let from = reached(fixed, taken);
+            if len.leftover > Weight::ZERO && has_room {
                 taken += len.leftover;
             }
-            fixed.px += len.px;
-            fixed.rel += len.rel;
-            start = shared(fixed, taken, total.leftover, room);
-            span.end = start;
-            let mut region = UiRegion::from_axis(axis, span, UiSpan::FULL);
-            if self.dir.sign == Sign::Neg {
-                region.flip(axis);
+            fixed += len.without_leftover();
+            let to = reached(fixed, taken);
+            // Along the row the span says where the child goes, and that slot
+            // is the child's box outright rather than something to place an
+            // answer inside again. A share is decided here and nowhere
+            // else: its slot narrows its rel base, and the child is asked in
+            // it, since a text wraps at the width it is actually given. A
+            // fixed child's slot is its own answer, so a drawing made in the
+            // room is put there as it is, and one not made yet is made here.
+            let slot = self.slot(row, from, to);
+            let mut place = slot.shifted_desc().fills().on_axis(axis);
+            if len.leftover > Weight::ZERO && has_room {
+                place = place.rel_base(axis, slot.len());
             }
-            let placed = painter.widget_within(child, region);
+            let used = painter.place_at(child, place).len(!axis);
             if shrinks {
-                let used = placed.len(!axis);
                 // Choosing between a fixed and a relative length from the
                 // span's own eventual width admits multiple fixed points.
-                // A scalable child therefore makes Children scalable too;
+                // A scalable child therefore makes the span scalable too;
                 // only fixed children are compared with one another.
-                if used.rel != Rel::ZERO || used.leftover != Weight::ZERO {
+                if !used.is_px() {
                     ortho = LayoutLen::LEFTOVER;
                 } else if ortho.leftover == Weight::ZERO {
                     ortho.px = ortho.px.max(used.px);
                 }
             }
             fixed.px += self.gap;
-            start = shared(fixed, taken, total.leftover, room);
         }
 
         // Carried whole rather than collapsed to one share: a span that sizes
@@ -143,26 +132,26 @@ impl Widget for Span {
         // get a quarter each, which collapsing to `leftover(1)` per level does
         // not give. Resolution happens at the nearest ancestor with a length,
         // and the root always has one.
-        let along = total;
         let ortho = match shrinks {
             true => ortho,
             false => LayoutLen::rel(1.0),
         };
-        Size::from_axis(axis, along, ortho)
+        Size::from_axis(axis, total, ortho)
     }
 }
 
-/// Where a row has reached: everything fixed before this point, which is a
-/// sum and exact, plus the share of the room the weights so far are worth,
-/// which is one rounding wherever it is asked for.
-fn shared(fixed: Len, taken: Weight, weight: Weight, room: Len) -> Len {
-    if taken == Weight::ZERO {
-        return fixed;
-    }
-    fixed + room.scale(Rel::ratio(taken, weight))
-}
-
 impl Span {
+    /// The stretch of the row between two distances from where this span
+    /// starts laying children out, as a span of its own box. A negative
+    /// direction lays out from the far end, so the same two distances mirror
+    /// in a row `row` long.
+    fn slot(&self, row: Len, from: Len, to: Len) -> UiSpan {
+        match self.dir.sign {
+            Sign::Pos => from.to(to),
+            Sign::Neg => (row - to).to(row - from),
+        }
+    }
+
     pub fn empty(dir: Dir) -> Self {
         Self {
             children: Vec::new(),

src/widget/position/stack.rs

@@ -13,26 +13,49 @@ impl Widget for Stack {
             StackSize::Default => None,
             StackSize::Child(i) => Some(i),
         };
-        // Whichever child sizes the stack decides the box every child gets.
-        // The stack reports that size, so a child given a longer box would
-        // draw outside what the stack says it occupies.
+        // Whichever child sizes the stack is given the stack's whole box --
+        // the stack is the length that child asked for, so placing that
+        // answer inside the box it decided would apply it twice.
         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, PlaceDesc::WHOLE.fills()).size()
             }
             None => Size::LEFTOVER,
         };
-        let region = painter.box_of(size);
+        // Every other child gets the box the sizing child decided: the
+        // stack is that length, so that is the box they are asked in, and a
+        // fraction under them is a fraction of it. A share leaves the axis
+        // to whoever gave the stack its box. Where a child sits in a box
+        // bigger than itself is its own business.
+        let place = PlaceDesc::from_axes(|axis| {
+            let len = size[axis];
+            match len.leftover == Weight::ZERO {
+                true => len.without_leftover().as_desc().fills(),
+                false => PlaceDescAxis::WHOLE,
+            }
+        });
         for (i, child) in self.children.iter().enumerate() {
+            if sizing == Some(i) {
+                continue;
+            }
             painter.child_layer_at(i);
-            painter.widget_aligned(child, region, RegionAlign::NEAR);
+            painter.widget_at(child, place);
         }
         size
     }
+
+    /// Without a sizing child a stack is whatever box it is given, which it
+    /// can say without drawing anything.
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        match self.size {
+            StackSize::Default => Some(LayoutLen::LEFTOVER),
+            StackSize::Child(_) => None,
+        }
+    }
 }
 
 #[derive(Default, Debug)]

src/widget/text/edit.rs

@@ -321,12 +321,10 @@ impl<'a> TextEditCtx<'a> {
         let old = (self.text.view.buf.text().to_string(), self.text.selection);
         let mut undo = false;
         let res = self.apply_event_inner(event, modifiers, &mut undo);
-        if undo {
-            if let Some((old, selection)) = self.text.history.pop() {
-                self.set(&old);
-                self.text.selection = selection;
-                self.clamp_selection_to_layout();
-            }
+        if undo && let Some((old, selection)) = self.text.history.pop() {
+            self.set(&old);
+            self.text.selection = selection;
+            self.clamp_selection_to_layout();
         } else if self.text.view.buf.text() != old.0 {
             self.text.history.push(old);
         }

src/widget/text/mod.rs

@@ -50,15 +50,11 @@ impl TextView {
         let width = self.attrs.wrap.then(|| painter.px_len(Axis::X));
         // The shaper measures in floats, which is where a glyph advance comes
         // from; what it answers goes back on the grid.
-        let text = painter.render_text(&mut self.buf, &self.attrs, width.map(Px::to_f32));
-        // A greedy break is the same break at every width from its longest
-        // 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.
-        if let Some(width) = width {
-            painter.holds(Axis::X, Px::from_f32(text.size.x).min(width)..=width);
+        painter.render_text(&mut self.buf, &self.attrs, width.map(Px::to_f32));
+        if width.is_some() {
+            painter.holds(Axis::X, self.buf.width_holds());
         }
-        text
+        self.buf.rendered().expect("render_text placed the glyphs")
     }
 
     pub fn tex(&self) -> Option<&RenderedText> {
@@ -78,9 +74,13 @@ impl TextView {
 
         let tex = self.render(painter);
         let region = tex.size.align(align);
-        let size = Size::px(tex.size);
-        let within = region.within(&painter.region());
-        painter.glyphs(tex, within);
+        // 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));
+        painter.glyphs(tex, region);
         (region, size)
     }
 

src/widget/trait_fns.rs

@@ -19,8 +19,8 @@ widget_trait! {
         move |state| {
             let id = self.add(state);
             let widgets = &mut state.ui_mut().widgets;
-            for (axis, align) in [(Axis::X, align.x), (Axis::Y, align.y)] {
-                if let Some(align) = align {
+            for axis in Axis::BOTH {
+                if let Some(align) = align[axis] {
                     widgets.set_alignment(id, axis, align);
                 }
             }
@@ -71,6 +71,50 @@ widget_trait! {
         }
     }
 
+    /// Answers at least this wide, whatever it drew: a rule beside the
+    /// widget, so what a row gives it is at least this even where the widget
+    /// itself wanted less. The box it draws in is untouched -- for that, see
+    /// [`MaxSize`].
+    fn min_width(self, len: impl Into<Len>) -> impl WidgetIdFn<Rsc, WL::Widget> {
+        let len = len.into();
+        move |state| {
+            let id = self.add(state);
+            state.ui_mut().widgets.set_min_len(id, Axis::X, len);
+            id
+        }
+    }
+
+    fn min_height(self, len: impl Into<Len>) -> impl WidgetIdFn<Rsc, WL::Widget> {
+        let len = len.into();
+        move |state| {
+            let id = self.add(state);
+            state.ui_mut().widgets.set_min_len(id, Axis::Y, len);
+            id
+        }
+    }
+
+    /// Puts this in a [`MaxSize`]: it is asked in the shorter of the cap and
+    /// the box that widget was given, and is as long as it used, held to the
+    /// cap. A widget rather than a rule because the box is whoever asked's to
+    /// decide -- see [`MaxSize`].
+    fn max_width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
+        let len = len.into();
+        move |state| MaxSize {
+            inner: self.add_strong(state),
+            x: Some(len),
+            y: None,
+        }
+    }
+
+    fn max_height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
+        let len = len.into();
+        move |state| MaxSize {
+            inner: self.add_strong(state),
+            x: None,
+            y: Some(len),
+        }
+    }
+
     fn height(self, len: impl Into<LayoutLen>) -> impl WidgetIdFn<Rsc, WL::Widget> {
         let len = len.into();
         move |state| {
@@ -134,9 +178,13 @@ widget_trait! {
         |state| self.add(state)
     }
 
-    fn set_ptr(self, ptr: WeakWidget<WidgetPtr>, state: &mut Rsc) {
-        let id = self.add_strong(state);
-        state.ui_mut().widgets[ptr].inner = Some(id);
+    // Named for the type it makes rather than as `wrapped`, which would read
+    // as the text setting. `widget_trait!` takes no attributes, so what it is
+    // for is on `Wrapper` itself.
+    fn wrapper(self) -> impl WidgetFn<Rsc, Wrapper> {
+        |state| Wrapper {
+            inner: Some(self.add_strong(state)),
+        }
     }
 }
 

src/widget/wrapper.rs

@@ -1,11 +1,20 @@
 use crate::prelude::*;
 use std::marker::Unsize;
 
-pub struct WidgetPtr {
+/// One widget in a box of its own, doing as little as possible on the way:
+/// it draws its child in the whole of its box and reports back what the child
+/// said. It exists because a length and an alignment are properties of one
+/// widget, so a widget cannot both be 100 wide and take two shares of a row
+/// -- the two lengths need two widgets, and this is the smaller one.
+///
+/// Its child is optional so it can also be the swappable slot a tab bar
+/// needs, which is what it was written for.
+#[derive(Default)]
+pub struct Wrapper {
     pub inner: Option<StrongWidget>,
 }
 
-impl Widget for WidgetPtr {
+impl Widget for Wrapper {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         match &self.inner {
             Some(id) => painter.widget(id).size(),
@@ -14,15 +23,11 @@ impl Widget for WidgetPtr {
     }
 }
 
-impl WidgetPtr {
+impl Wrapper {
     pub fn new() -> Self {
         Self::default()
     }
-    pub fn empty() -> Self {
-        Self {
-            inner: Default::default(),
-        }
-    }
+
     pub fn set<W: ?Sized + Unsize<dyn Widget>>(&mut self, to: StrongWidget<W>) {
         self.inner = Some(to)
     }
@@ -34,9 +39,3 @@ impl WidgetPtr {
         self.inner.replace(to)
     }
 }
-
-impl Default for WidgetPtr {
-    fn default() -> Self {
-        Self::empty()
-    }
-}

tests/cases/determinism.rs

@@ -21,16 +21,18 @@ struct BranchesOnMeasurement {
 
 impl Widget for BranchesOnMeasurement {
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        let mut top = UiRegion::FULL;
-        top.y.end = top.y.start.offset(Px::from_int(40));
-        let measured = painter.widget_within(&self.probe, top).len(Axis::X);
-        let px = measured.apply_leftover().to_px(painter.px_len(Axis::X));
+        let cut = Len::from_parts(Rel::ZERO, Px::from_int(40));
+        let top = UiSpan::new(Len::ZERO, cut).shifted_desc();
+        let measured = painter
+            .widget_at(&self.probe, top.on_axis(Axis::Y))
+            .len(Axis::X);
+        let px = painter.to_px(measured.apply_leftover(), Axis::X);
 
-        let mut below = UiRegion::FULL;
-        below.y.start = below.y.start.offset(Px::from_int(40));
+        let below = UiSpan::new(cut, painter.region_len(Axis::Y)).shifted_desc();
+        let place = below.on_axis(Axis::Y);
         match px > Px::from_f32(self.threshold) {
-            true => painter.widget_within(&self.wide, below),
-            false => painter.widget_within(&self.narrow, below),
+            true => painter.widget_at(&self.wide, place),
+            false => painter.widget_at(&self.narrow, place),
         };
         Size::LEFTOVER
     }
@@ -67,8 +69,8 @@ fn a_branch_taken_on_a_measurement_holds_across_repaints() {
         assert_ne!(first, (false, false), "threshold {threshold}: neither drew");
 
         for frame in 0..4 {
-            h.rsc.widgets_mut().get_dyn_mut(wide);
-            h.rsc.widgets_mut().get_dyn_mut(narrow);
+            h.rsc.widgets_mut().mark_for_redraw(wide);
+            h.rsc.widgets_mut().mark_for_redraw(narrow);
             h.frame();
             assert_eq!(
                 taken(&h, wide, narrow),
@@ -86,7 +88,7 @@ fn a_branch_taken_on_a_measurement_is_the_one_a_cold_start_takes() {
         let (wide, narrow) = plant(&mut warm, threshold);
         warm.resize((640, 480));
         warm.frame();
-        warm.rsc.widgets_mut().get_dyn_mut(wide);
+        warm.rsc.widgets_mut().mark_for_redraw(wide);
         warm.frame();
 
         let mut cold = Harness::new((640, 480));

tests/cases/idempotence.rs

@@ -18,7 +18,7 @@ fn a_wrapping_text_in_a_span_settles_on_one_width() {
         let r = h.region(&t.id()).unwrap();
         widths.push(r.bot_right.x - r.top_left.x);
         // Redrawing it changes nothing about the state, so nothing may move.
-        h.rsc.widgets_mut().get_dyn_mut(t.id());
+        h.rsc.widgets_mut().mark_for_redraw(t.id());
         h.frame();
     }
     println!("widths over six frames: {widths:?}");

tests/cases/layout.rs

@@ -1,5 +1,7 @@
 //! Where a frame puts things, with no window to put them in.
 
+use std::{cell::Cell, rc::Rc};
+
 use iris::harness::{Harness, assert_corners};
 use iris::prelude::*;
 
@@ -20,6 +22,160 @@ fn a_span_gives_each_child_the_width_it_asked_for() {
     assert_corners!(h, right, (100, 0), (400, 200));
 }
 
+/// 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 the child's region is
+/// 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 -- 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));
+    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);
+    let nested = (inner,).span(Dir::RIGHT).add(&mut h.rsc);
+    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 its own child
+    // 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), (400, 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}");
+}
+
+/// Padding is an inset: it narrows the frame a fraction resolves against and
+/// adds itself back to the padded widget's reported length.
+#[test]
+fn a_pad_puts_its_padding_around_a_fraction_of_the_whole_box() {
+    let mut h = Harness::new((400, 100));
+    let inner = rect(Color::GREEN).width(rel(0.5)).add(&mut h.rsc);
+    let padded = (inner,).span(Dir::RIGHT).pad(10).add(&mut h.rsc);
+    let tail = rect(Color::BLUE).width(100).add(&mut h.rsc);
+    // Ruled to the window: a root reporting a fraction of it is otherwise
+    // placed inside it by its own alignment, which is not what is under test.
+    h.set_root((padded, tail).span(Dir::RIGHT).width(rel(1.0)));
+
+    assert_corners!(h, inner, (10, 10), (200, 90));
+    assert_corners!(h, padded, (0, 0), (210, 100));
+    assert_corners!(h, tail, (210, 0), (310, 100));
+}
+
+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.";
+
+/// The worked example of what padding insets: in a 900 px row after a 24 px
+/// icon, a `rel(1.0)` inside `pad(16)` is 900 - 32 and overflows the row by
+/// the icon's width, while a wrapping text beside it is asked in the room
+/// left, 900 - 24 - 32, and wraps there.
+#[test]
+fn padding_keeps_the_rel_base_distinct_from_the_room_left_in_a_row() {
+    let mut h = Harness::new((900, 200));
+    let icon = rect(Color::RED).width(24).add(&mut h.rsc);
+    let fill = rect(Color::GREEN).width(rel(1.0)).add(&mut h.rsc);
+    let padded = fill.pad(16).add(&mut h.rsc);
+    h.set_root((icon, padded).span(Dir::RIGHT).width(rel(1.0)));
+    let fill_width = h.region(&fill).unwrap().size().x;
+    assert_eq!(fill_width, Px::from_int(868));
+
+    let mut h = Harness::new((900, 200));
+    let icon = rect(Color::RED).width(24).add(&mut h.rsc);
+    let text = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
+    let padded = text.pad(16).add(&mut h.rsc);
+    h.set_root((icon, padded).span(Dir::RIGHT).width(rel(1.0)));
+    let active = &h.render.active[&text.id()];
+    let window = h.render.output_size().x;
+    let asked = active.region.x.len().to_px(window);
+    assert_eq!(active.rel_base.x.to_px(window), Px::from_int(868));
+    assert_eq!(asked, Px::from_int(844));
+}
+
+/// The other way round: a share inside padding. A slot is a length of the
+/// row, which is already the padded width, so what the span decided reaches
+/// the child as it stands -- taking the padding off a second time would make
+/// `rel(1.0)` in the slot shorter than the slot.
+#[test]
+fn a_share_inside_padding_fills_the_slot_it_was_given() {
+    let mut h = Harness::new((900, 200));
+    let fill = rect(Color::GREEN).width(rel(1.0)).add(&mut h.rsc);
+    let first = Span {
+        children: vec![fill.add_strong(&mut h.rsc)],
+        dir: Dir::RIGHT,
+        gap: Px::ZERO,
+    }
+    .width(leftover(1))
+    .add(&mut h.rsc);
+    let second = rect(Color::BLUE).width(leftover(1)).add(&mut h.rsc);
+    let row = (first, second).span(Dir::RIGHT).add(&mut h.rsc);
+    h.set_root(row.pad(16));
+
+    assert_eq!(h.region(&first).unwrap().size().x, Px::from_int(434));
+    assert_eq!(h.region(&fill).unwrap().size().x, Px::from_int(434));
+}
+
+/// The same padding in a share instead: the slot is 450, so both the
+/// fraction and the wrap are the slot less the padding, and the two agree.
+#[test]
+fn padding_narrows_both_rel_base_and_box_inside_a_share() {
+    let mut h = Harness::new((900, 200));
+    let fill = rect(Color::GREEN).width(rel(1.0)).add(&mut h.rsc);
+    let padded = fill.pad(16).width(leftover(1)).add(&mut h.rsc);
+    let other = rect(Color::BLUE).width(leftover(1)).add(&mut h.rsc);
+    h.set_root((padded, other).span(Dir::RIGHT).width(rel(1.0)));
+    assert_eq!(h.region(&fill).unwrap().size().x, Px::from_int(418));
+
+    let mut h = Harness::new((900, 200));
+    let text = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
+    let padded = text.pad(16).width(leftover(1)).add(&mut h.rsc);
+    let other = rect(Color::BLUE).width(leftover(1)).add(&mut h.rsc);
+    h.set_root((padded, other).span(Dir::RIGHT).width(rel(1.0)));
+    let active = &h.render.active[&text.id()];
+    let window = h.render.output_size().x;
+    assert_eq!(active.rel_base.x.to_px(window), Px::from_int(418));
+    assert_eq!(active.region.x.len().to_px(window), Px::from_int(418));
+}
+
 #[test]
 fn a_span_ruled_across_itself_does_not_measure_its_children_there() {
     let mut h = Harness::new((400, 200));
@@ -65,6 +221,134 @@ fn an_empty_widget_takes_a_share_of_a_span() {
     assert_corners!(h, right, (300, 0), (400, 200));
 }
 
+/// A widget with a natural pixel size, like an image, which records the box
+/// it was asked in so a test can see which length decided it.
+struct NaturalSize {
+    len: f32,
+    asked: Rc<Cell<f32>>,
+}
+
+impl Widget for NaturalSize {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        self.asked.set(painter.px_len(Axis::X).to_f32());
+        Size::px(Vec2::new(self.len, self.len))
+    }
+
+    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
+        Some(LayoutLen::px(self.len))
+    }
+}
+
+/// A rule wins over what the widget says about itself, and a share is a rule:
+/// it is a length only to whoever divides one, and nobody here does, so the
+/// widget is asked in the whole box rather than in the size it asked for.
+#[test]
+fn a_share_rule_beats_the_widgets_own_pixel_size() {
+    let mut h = Harness::new((400, 200));
+    let asked = Rc::new(Cell::new(0.0));
+    let natural = NaturalSize {
+        len: 50.0,
+        asked: asked.clone(),
+    }
+    .add(&mut h.rsc);
+    h.set_root(natural.wrapper());
+    assert_eq!(asked.get(), 50.0, "its hint gives it its own size");
+
+    h.set_len(natural, Axis::X, LayoutLen::LEFTOVER);
+    h.frame();
+
+    assert_eq!(asked.get(), 400.0, "the share is all of the box");
+}
+
+/// Every box a widget is given comes of one ask, and the window is one of
+/// them: the root is asked in it exactly as a child is asked in its parent's
+/// box, so a rule of its own reads the same way at either place.
+#[derive(Clone, Copy, Debug)]
+enum Asked {
+    Root,
+    Wrapped,
+    InASpan,
+}
+
+impl Asked {
+    const ALL: [Self; 3] = [Self::Root, Self::Wrapped, Self::InASpan];
+
+    /// The width the probe is given under this parent, in a 400 px window.
+    fn width(&self, rule: LayoutLen) -> Px {
+        let mut h = Harness::new((400, 200));
+        let probe = rect(Color::RED).add(&mut h.rsc);
+        h.set_len(probe, Axis::X, rule);
+        match self {
+            Self::Root => h.set_root(probe),
+            Self::Wrapped => h.set_root(probe.wrapper()),
+            Self::InASpan => h.set_root((probe,).span(Dir::RIGHT)),
+        }
+        h.region(&probe).unwrap().size().x
+    }
+}
+
+/// A share with pixels or a fraction beside it is the longer of the two: it
+/// fills what they leave of the box and overflows the box where they are
+/// longer than it. A parent that divides nothing gives the same length as a
+/// span with one child, because in both there is nobody else to divide with --
+/// and so does the window, which divides nothing either.
+#[test]
+fn a_share_is_a_minimum_wherever_nothing_divides_it() {
+    for (rule, want) in [
+        (LayoutLen::LEFTOVER, 400),
+        (LayoutLen::px(50.0) + LayoutLen::LEFTOVER, 400),
+        (LayoutLen::px(500.0) + LayoutLen::LEFTOVER, 500),
+        (LayoutLen::rel(0.5) + LayoutLen::LEFTOVER, 400),
+        (LayoutLen::rel(2.0) + LayoutLen::LEFTOVER, 800),
+        (LayoutLen::px(500.0), 500),
+    ] {
+        let want = Px::from_int(want);
+        for asked in Asked::ALL {
+            assert_eq!(asked.width(rule), want, "{rule:?} asked {asked:?}");
+        }
+    }
+}
+
+/// Which of the two is longer is a question in pixels, so the box is decided
+/// again wherever the answer can change: a window that crosses the length the
+/// pixels ask for, and the rule itself crossing it while the window holds
+/// still. The first is a range the drawing holds for; the second cannot be
+/// seen in what the widget declares, since a share declares nothing either
+/// way, so it reaches the parent as a length only the parent can resolve.
+#[test]
+fn a_share_past_the_box_is_decided_again_on_either_side_of_the_crossing() {
+    // At the root as well as under a parent: the comparison is the same one,
+    // and nothing above the root will make it again on its behalf, so the
+    // range it holds for is the root's own.
+    for wrapped in [false, true] {
+        let mut h = Harness::new((400, 200));
+        let probe = rect(Color::RED).add(&mut h.rsc);
+        h.set_len(probe, Axis::X, LayoutLen::px(500.0) + LayoutLen::LEFTOVER);
+        match wrapped {
+            true => h.set_root(probe.wrapper()),
+            false => h.set_root(probe),
+        }
+        let width = |h: &Harness| h.region(&probe).unwrap().size().x;
+        assert_eq!(width(&h), Px::from_int(500), "wrapped: {wrapped}");
+
+        h.resize((900, 200));
+        h.frame();
+        assert_eq!(width(&h), Px::from_int(900), "wrapped: {wrapped}");
+
+        h.resize((400, 200));
+        h.frame();
+        assert_eq!(width(&h), Px::from_int(500), "wrapped: {wrapped}");
+
+        h.set_len(probe, Axis::X, LayoutLen::px(50.0) + LayoutLen::LEFTOVER);
+        h.frame();
+        assert_eq!(width(&h), Px::from_int(400), "wrapped: {wrapped}");
+
+        h.set_len(probe, Axis::X, LayoutLen::px(500.0) + LayoutLen::LEFTOVER);
+        h.frame();
+        assert_eq!(width(&h), Px::from_int(500), "wrapped: {wrapped}");
+    }
+}
+
 #[test]
 fn a_child_drawn_twice_moves_once() {
     let mut h = Harness::new((400, 200));
@@ -225,21 +509,21 @@ fn only_a_region_node_lengthens_the_chain_and_it_can_be_removed() {
     h.set_root((bar, buried).span(Dir::RIGHT));
 
     let move_idx = h.render.active[&leaf.id()].parent_move;
-    assert_eq!(h.render.moves.depth(move_idx), 1, "only the root region");
+    assert_eq!(h.render.moves.depth(move_idx), 0, "the window is no entry");
 
     h.rsc.widgets_mut().set_region_node(buried, true);
     h.frame();
     let move_idx = h.render.active[&leaf.id()].parent_move;
     assert_eq!(
         h.render.moves.depth(move_idx),
-        2,
-        "the opted-in widget's region and the root region"
+        1,
+        "the opted-in widget's region alone"
     );
 
     h.rsc.widgets_mut().set_region_node(buried, false);
     h.frame();
     let move_idx = h.render.active[&leaf.id()].parent_move;
-    assert_eq!(h.render.moves.depth(move_idx), 1);
+    assert_eq!(h.render.moves.depth(move_idx), 0);
 }
 
 /// A span that sizes from its children passes their `leftover` weight up
@@ -266,6 +550,11 @@ fn nested_spans_divide_the_space_once_however_deep_the_nesting_is() {
 
 /// The same space, unevenly nested: weights carried up mean a share is a
 /// share of the whole, not of whatever branch a widget happens to sit in.
+///
+/// Each edge lands on the even division or one step below it, since a share
+/// is a fraction of the room and a truncating multiply gives up what that
+/// fraction does not divide. What stays exact is that each share starts
+/// where the last one ended and the row ends at its own edge.
 #[test]
 fn an_uneven_nesting_still_gives_every_share_the_same_length() {
     let mut h = Harness::new((400, 200));
@@ -279,10 +568,24 @@ fn an_uneven_nesting_still_gives_every_share_the_same_length() {
     let three = (b, c, d).span(Dir::RIGHT).add(&mut h.rsc);
     h.set_root((one, three).span(Dir::RIGHT));
 
+    let mut start = Px::ZERO;
     for (i, id) in [a, b, c, d].into_iter().enumerate() {
-        let x = i as f32 * 100.0;
-        assert_corners!(h, id, (x, 0), (x + 100.0, 200));
+        let got = h.region(&id).expect("widget drew nothing");
+        let even = Px::from_int((i as i32 + 1) * 100);
+        assert_eq!(got.top_left, PxVec2::new(start, Px::ZERO), "share {i}");
+        assert_eq!(got.bot_right.y, Px::from_int(200), "share {i}");
+        assert!(
+            got.bot_right.x == even || got.bot_right.x == even.next_down(),
+            "share {i} ends at {:?}, not {even:?}",
+            got.bot_right.x
+        );
+        start = got.bot_right.x;
     }
+    assert_eq!(
+        start,
+        Px::from_int(400),
+        "the row stopped short of its edge"
+    );
 }
 
 /// However many ways a row is divided, the shares add up to the row: each
@@ -322,17 +625,16 @@ fn a_row_of_equal_shares_fills_it_exactly() {
     }
 }
 
-/// Where the shader puts an edge: the two parts of a scalar are floored
-/// apart, so a fraction and a pixel offset snap independently, and each is
-/// taken to the boundary it composes to within half a step of. Kept in step
-/// with `snap_floor` in `prelude.wgsl`.
+/// Where the shader puts an edge: the fraction resolved against the window
+/// plus the pixel offset, taken to the boundary it composes to within half
+/// a step of. Kept in step with `snap_floor` in `prelude.wgsl`.
 fn drawn_edges(h: &Harness, id: WidgetId, axis: Axis) -> (f32, f32) {
     let active = &h.render.active[&id];
-    let region = h.render.moves.resolve(active.parent_move, active.region);
-    let dim = h.size().axis(axis);
+    let region = h.render.moves.resolve(active.move_idx, active.placement);
+    let dim = h.size()[axis];
     let snap = |v: f32| (v + Px::STEP.to_f32() * 0.5).floor();
-    let edge = |s: Len| snap(s.rel.to_f32() * dim) + snap(s.px.to_f32());
-    let span = region.axis(axis);
+    let edge = |s: Len| snap(s.rel.to_f32() * dim + s.px.to_f32());
+    let span = region[axis];
     (edge(span.start), edge(span.end))
 }
 
@@ -454,7 +756,7 @@ fn only_a_pure_leftover_child_disappears_when_nothing_is_left() {
     let mut h = Harness::new((100, 20));
     let fixed = rect(Color::RED).width(100).add(&mut h.rsc);
     let mixed = rect(Color::BLUE)
-        .width(LayoutLen::px(20) + LayoutLen::LEFTOVER)
+        .width(LayoutLen::px(20.0) + LayoutLen::LEFTOVER)
         .add(&mut h.rsc);
     h.set_root((fixed, mixed).span(Dir::RIGHT));
 
@@ -480,3 +782,337 @@ fn leftover_children_disappear_at_the_exact_fixed_content_boundary() {
     assert!(h.region(&a).is_none());
     assert!(h.region(&b).is_none());
 }
+
+/// **A stack child smaller than the stack sits where its own alignment
+/// says.** `Stack` gives every child the box its sizing child defines and
+/// used to force the near edge on all of them; that override is owed only to
+/// the sizing child, which has already placed its own content in the box the
+/// stack derived from its answer. Every other child is handed a box that owes
+/// nothing to it, so where it sits in one bigger than itself is its own
+/// business -- and with the override it could not be aligned at all, which is
+/// what moved the `tabs` example's counters to the wrong corner.
+#[test]
+fn a_stack_child_smaller_than_the_stack_keeps_its_own_alignment() {
+    let mut h = Harness::new((400, 200));
+    let big = rect(Color::BLUE).add(&mut h.rsc);
+    let small = rect(Color::RED).sized((50, 50)).add(&mut h.rsc);
+    h.rsc
+        .widgets_mut()
+        .set_alignment(small.id(), Axis::X, AxisAlign::POS);
+    let (a, b) = (big.add_strong(&mut h.rsc), small.add_strong(&mut h.rsc));
+    let children: Vec<StrongWidget> = vec![a, b];
+    h.set_root(Stack {
+        children,
+        size: StackSize::Default,
+    });
+
+    assert_corners!(h, big, (0, 0), (400, 200));
+    // The far edge on X because it asked for it, the middle on Y because
+    // that is the default.
+    assert_corners!(h, small, (350, 75), (400, 125));
+}
+/// Five children of one span, buried under three containers that are each a
+/// fraction of their parent so no length reaches the window without being
+/// composed and rounded on the way. Returns each child's drawn width and
+/// each gap between them, in pixels.
+fn row_under_fractions(kid: Option<LayoutLen>, gap: f32, box_w: f32) -> (Vec<Px>, Vec<Px>) {
+    let mut h = Harness::new((box_w, 400.0));
+    let mut ids = Vec::new();
+    let mut kids: Vec<StrongWidget> = Vec::new();
+    for _ in 0..5 {
+        let r = rect(Color::RED).add(&mut h.rsc);
+        if let Some(len) = kid {
+            h.rsc
+                .widgets_mut()
+                .set_size_rule(r.id(), Axis::X, SizeRule::Exact(len));
+        }
+        ids.push(r.id());
+        kids.push(r.add_strong(&mut h.rsc));
+    }
+    let span = Span {
+        children: kids,
+        dir: Dir::RIGHT,
+        gap: Px::from_f32(gap),
+    }
+    .add(&mut h.rsc);
+    let a = (span.width(rel(0.9)),).span(Dir::RIGHT).add(&mut h.rsc);
+    let b = (a.width(rel(0.8)),).span(Dir::RIGHT).add(&mut h.rsc);
+    h.set_root((b.width(rel(0.7)),).span(Dir::RIGHT));
+    let boxes: Vec<_> = ids
+        .iter()
+        .map(|id| h.region(id).expect("a child drew nothing"))
+        .collect();
+    (
+        boxes.iter().map(|b| b.bot_right.x - b.top_left.x).collect(),
+        boxes
+            .windows(2)
+            .map(|p| p[1].top_left.x - p[0].bot_right.x)
+            .collect(),
+    )
+}
+
+/// **A length given in pixels is that many pixels, wherever it ends up.** A
+/// gap and a declared width compose additively -- `Len::within` adds a part's
+/// own pixels rather than scaling them, and both ends of a gap carry the same
+/// fraction, so the multiply that rounds is the same on each -- which is why
+/// nesting the row inside fractions of fractions cannot move them. Swept over
+/// 2,100 box widths when this was written and exact at every one; five here,
+/// including widths that divide badly by five.
+#[test]
+fn a_length_in_pixels_is_that_many_pixels_however_it_is_nested() {
+    for box_w in [300.0, 1000.0, 1001.0, 1003.0, 1920.0] {
+        let want = Px::from_int(7);
+        let (_, gaps) = row_under_fractions(None, 7.0, box_w);
+        assert!(
+            gaps.iter().all(|g| *g == want),
+            "box {box_w}: gaps between leftover children are {gaps:?}"
+        );
+        let (widths, gaps) = row_under_fractions(Some(LayoutLen::px(100.0)), 7.0, box_w);
+        assert!(
+            gaps.iter().all(|g| *g == want),
+            "box {box_w}: gaps between fixed children are {gaps:?}"
+        );
+        assert!(
+            widths.iter().all(|w| *w == Px::from_int(100)),
+            "box {box_w}: declared widths came out {widths:?}"
+        );
+    }
+}
+
+/// **Children asking for the same share of a row are not the same length**,
+/// and this pins by how much rather than claiming they are equal. A position
+/// is the quantity that gets rounded, so the row fills exactly and no two
+/// children leave a seam; what that costs is a step or two between lengths
+/// that were asked for identically. Exact composition would shrink the
+/// spread, not remove it: five equal lengths cannot fill a row whose step
+/// count is not a multiple of five.
+#[test]
+fn equal_shares_differ_by_at_most_two_steps_and_fill_the_row() {
+    for kid in [None, Some(LayoutLen::rel(0.2))] {
+        for box_w in [300.0, 1000.0, 1001.0, 1003.0, 1920.0] {
+            let (widths, gaps) = row_under_fractions(kid, 0.0, box_w);
+            let spread = *widths.iter().max().unwrap() - *widths.iter().min().unwrap();
+            assert!(
+                spread <= Px::from_raw(2),
+                "box {box_w}, {kid:?}: widths {widths:?} spread {spread:?}"
+            );
+            assert!(
+                gaps.iter().all(|g| *g == Px::ZERO),
+                "box {box_w}, {kid:?}: children left seams {gaps:?}"
+            );
+        }
+    }
+}
+
+#[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));
+}
+
+#[test]
+fn a_fixed_child_is_centered_in_its_wrappers_share() {
+    let mut h = Harness::new((600, 300));
+    let leaf = rect(Color::RED).sized((100, 100)).center().add(&mut h.rsc);
+    let wrapper = leaf
+        .wrapper()
+        .width(leftover(2))
+        .height(rel(1.0))
+        .add(&mut h.rsc);
+    let other = rect(Color::BLUE).width(200).add(&mut h.rsc);
+    h.set_root((other, wrapper).span(Dir::RIGHT));
+
+    assert_corners!(h, wrapper, (200, 0), (600, 300));
+    assert_corners!(h, leaf, (350, 100), (450, 200));
+
+    h.resize((900, 400));
+    h.frame();
+    assert_corners!(h, wrapper, (200, 0), (900, 400));
+    assert_corners!(h, leaf, (500, 150), (600, 250));
+}
+
+/// The root's frame is the window and its rule is a fraction of that, which
+/// is one resolution and not two: nothing above it narrowed anything.
+#[test]
+fn a_root_with_a_fraction_rule_is_that_fraction_of_the_window() {
+    let mut h = Harness::new((900, 200));
+    let root = rect(Color::RED).width(rel(0.5)).add(&mut h.rsc);
+    h.set_root(root);
+    assert_eq!(h.region(&root).unwrap().size().x, Px::from_int(450));
+}
+
+#[test]
+fn a_collapsed_share_keeps_the_gaps_before_the_next_slot() {
+    for dir in [Dir::RIGHT, Dir::LEFT, Dir::DOWN, Dir::UP] {
+        for collapsed in [1, 2] {
+            let mut h = Harness::new((400, 400));
+            let head = rect(Color::RED).add(&mut h.rsc);
+            h.set_len(head, dir.axis, 200);
+            let tail = rect(Color::BLUE).add(&mut h.rsc);
+            let tail_len = 200 - 10 * (collapsed + 1);
+            h.set_len(tail, dir.axis, tail_len);
+            let mut children: Vec<StrongWidget> = vec![head.add_strong(&mut h.rsc)];
+            let mut shares = Vec::new();
+            for _ in 0..collapsed {
+                let share = rect(Color::GREEN).add(&mut h.rsc);
+                shares.push(share);
+                children.push(share.add_strong(&mut h.rsc));
+            }
+            children.push(tail.add_strong(&mut h.rsc));
+            h.set_root(Span {
+                children,
+                dir,
+                gap: Px::from_int(10),
+            });
+            for share in shares {
+                assert!(h.region(&share).is_none());
+            }
+            let region = h.region(&tail).unwrap();
+            let (from, to) = match dir.sign {
+                Sign::Pos => (400 - tail_len, 400),
+                Sign::Neg => (0, tail_len),
+            };
+            assert_eq!(region.top_left[dir.axis], Px::from_int(from));
+            assert_eq!(region.bot_right[dir.axis], Px::from_int(to));
+        }
+    }
+}
+
+/// The root is asked the way any child is, so what it says about itself is
+/// read there too: a root that opted into a region node gets one, where the
+/// path it used to have ignored the flag.
+#[test]
+fn a_region_node_root_is_a_region_node() {
+    let mut h = Harness::new((400, 200));
+    let probe = rect(Color::RED).add(&mut h.rsc);
+    let root = (probe,).span(Dir::RIGHT).region_node().add(&mut h.rsc);
+    h.set_root(root);
+    assert_eq!(h.region(&probe).unwrap().size().x, Px::from_int(400));
+
+    h.resize((900, 200));
+    h.frame();
+    assert_eq!(h.region(&probe).unwrap().size().x, Px::from_int(900));
+}
+
+/// A bound is a rule about what a widget answers: it holds the length that
+/// reaches whoever asked and leaves the box alone. Here the content is 400
+/// wide in a 250 window, so a cap cuts what the row reports and a floor
+/// raises it, while the rects inside stay where the 250 box put them.
+#[test]
+fn a_bound_holds_what_a_widget_answers() {
+    let row = |rule: SizeRule| {
+        let mut h = Harness::new((250, 200));
+        let left = rect(Color::RED).width(200).add(&mut h.rsc);
+        let right = rect(Color::BLUE).width(200).add(&mut h.rsc);
+        let row = (left, right).span(Dir::RIGHT).add(&mut h.rsc);
+        h.rsc.widgets_mut().set_size_rule(row, Axis::X, rule);
+        h.set_root(row);
+        (
+            h.region(&row).unwrap().size().x,
+            h.region(&left).unwrap().size().x,
+        )
+    };
+    let (capped, left) = row(SizeRule::Max(Len::px(300.0)));
+    assert_eq!(capped, Px::from_int(300), "the cap, not the 400 drawn");
+    assert_eq!(left, Px::from_int(200), "the box the children were given");
+
+    let (floored, _) = row(SizeRule::Min(Len::px(600.0)));
+    assert_eq!(floored, Px::from_int(600), "the floor, not the 400 drawn");
+
+    let (free, _) = row(SizeRule::Free);
+    assert_eq!(free, Px::from_int(400), "what it drew");
+}
+
+/// A cap on the box is `MaxSize`, which asks its child in the shorter of the
+/// cap and its own box. That is the box a text wraps at and a scroll takes
+/// its viewport from, so it cannot be had by holding the answer.
+#[test]
+fn a_cap_widget_asks_its_child_in_the_shorter_box() {
+    let mut h = Harness::new((400, 200));
+    // A fraction of its box, so it says what box it was asked in.
+    let fills = rect(Color::RED).width(rel(1.0)).add(&mut h.rsc);
+    let capped = fills.max_width(300).add(&mut h.rsc);
+    h.set_root(capped);
+
+    assert_eq!(h.region(&fills).unwrap().size().x, Px::from_int(300));
+    assert_eq!(
+        h.region(&capped).unwrap().size().x,
+        Px::from_int(300),
+        "as long as its child used"
+    );
+
+    // A child that asked for a share takes the box the cap allows, and the
+    // share itself passes up: whoever divides one is this widget's parent.
+    let mut h = Harness::new((400, 200));
+    let share = rect(Color::RED).add(&mut h.rsc);
+    let capped = share.max_width(300).add(&mut h.rsc);
+    h.set_root(capped);
+
+    assert_eq!(h.region(&share).unwrap().size().x, Px::from_int(300));
+    assert_eq!(h.region(&capped).unwrap().size().x, Px::from_int(400));
+}
+
+/// Which of the cap and the box is shorter is a question in pixels, so it is
+/// asked again wherever the answer can change -- and the widget asking it is
+/// drawn again whenever its own box is, which is what keeps the two in step.
+#[test]
+fn a_cap_widget_is_decided_again_on_either_side_of_the_crossing() {
+    let mut h = Harness::new((400, 200));
+    let probe = rect(Color::RED).add(&mut h.rsc);
+    h.set_root(probe.max_width(300));
+    let width = |h: &Harness| h.region(&probe).unwrap().size().x;
+    assert_eq!(width(&h), Px::from_int(300));
+
+    h.resize((250, 200));
+    h.frame();
+    assert_eq!(
+        width(&h),
+        Px::from_int(250),
+        "its box, which is under the cap"
+    );
+
+    h.resize((400, 200));
+    h.frame();
+    assert_eq!(width(&h), Px::from_int(300));
+}
+
+/// A fraction in a cap is a fraction of the box the widget capping it was
+/// given, which is the box a declared length of its own would be a fraction
+/// of -- not of the window, and not of what the cap itself decided.
+#[test]
+fn a_cap_is_a_fraction_of_the_box_it_was_given() {
+    let mut h = Harness::new((400, 200));
+    let probe = rect(Color::RED).add(&mut h.rsc);
+    h.set_root(probe.max_width(Len::rel(0.5)).pad(Padding::uniform(50)));
+
+    // Half of the 300 left by the padding, not half of the window.
+    assert_eq!(h.region(&probe).unwrap().size().x, Px::from_int(150));
+}
+
+/// A cap is a promise about the length as well as the box: a widget whose
+/// content is longer than the box it was given reports what it drew, and the
+/// cap holds that down even though it never decided the box.
+#[test]
+fn a_cap_holds_an_answer_that_overflowed_its_box() {
+    let mut h = Harness::new((250, 200));
+    let left = rect(Color::RED).width(200).add(&mut h.rsc);
+    let right = rect(Color::BLUE).width(200).add(&mut h.rsc);
+    let row = (left, right).span(Dir::RIGHT).add(&mut h.rsc);
+    h.rsc.widgets_mut().set_max_len(row, Axis::X, 300.into());
+    h.set_root(row);
+
+    // The box is the 250 window, which the cap of 300 leaves alone, and the
+    // row draws 400 of it. Its answer is the cap, and the window centres it.
+    assert_corners!(h, row, (-25, 0), (275, 200));
+}

tests/cases/plan.rs

@@ -0,0 +1,156 @@
+//! The tree a seed describes, as a value rather than as widgets.
+//!
+//! Two things have to hold for a plan to be worth having. Editing a plan has
+//! to mean what growing with those edits means, or a scenario reads one thing
+//! and the oracle another. And reducing a plan has to end, or a shrinker
+//! searching for the smallest counterexample never returns.
+
+use iris::harness::Harness;
+use iris::prelude::*;
+use iris::random::{Edits, Kind, Plan, Rng, SpanEdit, grow, plan};
+use std::collections::HashMap;
+
+fn some_edits(seed: u64, of: &Plan) -> Edits {
+    let mut rng = Rng::new(seed);
+    let (mut sized, mut aligned, mut nodes, mut spans) = (0, 0, 0, 0);
+    let mut of = of.clone();
+    of.walk_mut(&mut |p| {
+        if matches!(p.kind, Kind::Span { .. }) {
+            spans += 1;
+        }
+        sized += p.size.is_some() as usize;
+        aligned += p.align.is_some() as usize;
+        nodes += p.region_node.is_some() as usize;
+    });
+    let pick =
+        |n: usize, rng: &mut Rng| -> Vec<usize> { (0..n).filter(|_| rng.chance()).collect() };
+    Edits {
+        sizes: pick(sized, &mut rng)
+            .into_iter()
+            .map(|i| {
+                (
+                    i,
+                    SizeRules {
+                        x: SizeRule::Exact(LayoutLen::LEFTOVER),
+                        y: SizeRule::Free,
+                    },
+                )
+            })
+            .collect(),
+        aligns: pick(aligned, &mut rng)
+            .into_iter()
+            .map(|i| {
+                (
+                    i,
+                    Align {
+                        x: Some(AxisAlign::POS),
+                        y: None,
+                    },
+                )
+            })
+            .collect(),
+        nodes: pick(nodes, &mut rng)
+            .into_iter()
+            .map(|i| (i, true))
+            .collect(),
+        spans: pick(spans, &mut rng)
+            .into_iter()
+            .map(|i| {
+                (
+                    i,
+                    SpanEdit {
+                        detach: vec![0],
+                        attach: 2,
+                    },
+                )
+            })
+            .collect::<HashMap<_, _>>(),
+        fixed_branches: false,
+    }
+}
+
+/// The two routes to an edited tree are one tree. `plan` resolves edits out
+/// of the random stream as it draws; `edited` puts them on a tree that
+/// already exists, which is the only route a shrunk plan has, since no seed
+/// grows one. A scenario written against either has to read the same.
+#[test]
+fn editing_a_plan_is_growing_one_with_those_edits() {
+    for seed in 1..=60 {
+        let bare = plan(seed, 5, &Edits::default());
+        let edits = some_edits(seed, &bare);
+        assert_eq!(
+            bare.edited(&edits),
+            plan(seed, 5, &edits),
+            "seed {seed}: edited and grown-with-edits disagree"
+        );
+    }
+}
+
+/// No simplification is larger, which is the half of "the shrinker stops" a
+/// widget count can see. Most are not smaller either -- a dropped alignment
+/// and a simpler leaf both keep the count -- so what rules out circling is
+/// that those are one-way too: a `Some` becomes a `None`, and a kind steps
+/// down a ladder with no way back up.
+#[test]
+fn no_simplification_of_a_plan_is_larger_than_it() {
+    for seed in 1..=60 {
+        let tree = plan(seed, 4, &Edits::default());
+        let mut queue = vec![tree];
+        let mut seen = 0;
+        while let Some(node) = queue.pop() {
+            seen += 1;
+            if seen > 400 {
+                break;
+            }
+            for small in node.smaller() {
+                assert!(
+                    small.size() <= node.size(),
+                    "seed {seed}: a simplification grew from {} to {}",
+                    node.size(),
+                    small.size()
+                );
+                if small.size() < node.size() {
+                    queue.push(small);
+                }
+            }
+        }
+    }
+}
+
+/// Reducing until nothing reduces ends, and ends at something small enough to
+/// read rather than at the tree it started from.
+#[test]
+fn reducing_a_plan_all_the_way_ends() {
+    for seed in 1..=30 {
+        let mut node = plan(seed, 5, &Edits::default());
+        let grown = node.size();
+        let mut steps = 0;
+        while let Some(next) = node.smaller().into_iter().next() {
+            node = next;
+            steps += 1;
+            assert!(steps < 10_000, "seed {seed}: reducing did not end");
+        }
+        assert!(
+            node.size() < grown.max(2),
+            "seed {seed}: reduced {grown} widgets to {}",
+            node.size()
+        );
+    }
+}
+
+/// Every image in a tree is the same picture, and a handle is a reference to
+/// the texture rather than a copy of it, so one upload and one slot serve all
+/// of them however many a tree grows -- and the trees are grown in hundreds.
+#[test]
+fn a_tree_of_images_uploads_one_texture() {
+    let mut images = 0;
+    let mut tree = plan(1, 4, &Edits::default());
+    tree.walk_mut(&mut |p| images += (p.kind == Kind::Image) as usize);
+    assert!(images > 1, "a tree of {images} images tests nothing");
+
+    let mut h = Harness::new((900, 1200));
+    let (root, _) = grow(&mut h.rsc, 1, 4, &Edits::default());
+    h.state.root = Some(root);
+    h.frame();
+    assert_eq!(h.rsc.ui().textures.count(), 1);
+}

tests/cases/scroll.rs

@@ -60,6 +60,69 @@ fn a_wheel_scrolls_the_content_and_stops_at_its_end() {
     assert_corners!(h, top, (0, 0), (400, 200));
 }
 
+#[test]
+fn fixed_content_and_a_share_fill_one_viewport() {
+    let mut h = Harness::new((900, 100));
+    let content = rect(Color::RED)
+        .width(LayoutLen {
+            px: Px::from_int(600),
+            rel: Rel::ZERO,
+            leftover: Weight::ONE,
+        })
+        .add(&mut h.rsc);
+    let scroll = Scroll::new(content.add_strong(&mut h.rsc), Axis::X);
+    h.set_root(scroll);
+
+    assert_corners!(h, content, (0, 0), (900, 100));
+}
+
+#[test]
+fn fixed_content_wider_than_the_viewport_still_scrolls() {
+    let mut h = Harness::new((900, 100));
+    let content = rect(Color::RED).width(1200).add(&mut h.rsc);
+    let scroll = Scroll::new(content.add_strong(&mut h.rsc), Axis::X);
+    h.set_root(scroll);
+
+    assert_corners!(h, content, (-300, 0), (900, 100));
+}
+
+#[test]
+fn a_lone_share_fills_without_scrolling() {
+    let mut h = Harness::new((900, 100));
+    let content = rect(Color::RED).width(LayoutLen::LEFTOVER).add(&mut h.rsc);
+    let scroll = Scroll::new(content.add_strong(&mut h.rsc), Axis::X);
+    h.set_root(scroll);
+
+    assert_corners!(h, content, (0, 0), (900, 100));
+}
+
+#[test]
+fn wrapping_content_beside_a_fixed_length_is_stable_warm_and_cold() {
+    fn plant(h: &mut Harness) -> (WidgetId, WidgetId) {
+        let fixed = rect(Color::RED).width(600).add(&mut h.rsc);
+        let text = 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)
+            .width(LayoutLen::LEFTOVER)
+            .add(&mut h.rsc);
+        let content = (fixed, text).span(Dir::RIGHT).add(&mut h.rsc);
+        let scroll = Scroll::new(content.add_strong(&mut h.rsc), Axis::X);
+        h.set_root(scroll);
+        (text.id(), content.id())
+    }
+
+    let mut warm = Harness::new((900, 300));
+    let (text, content) = plant(&mut warm);
+    warm.rsc.widgets_mut().mark_for_redraw(text);
+    warm.frame();
+
+    let mut cold = Harness::new((900, 300));
+    let (cold_text, cold_content) = plant(&mut cold);
+
+    assert_eq!(warm.region(&text), cold.region(&cold_text));
+    assert_eq!(warm.region(&content), cold.region(&cold_content));
+}
+
 /// A widget that clips to its box may not report more than the box: its
 /// parent would place the part it cut off, and the framework would put a
 /// drawing longer than its box somewhere. `Masked` is the second of these
@@ -71,7 +134,7 @@ fn a_clipping_widget_reporting_more_than_its_box_is_caught() {
 
     impl Widget for Clipper {
         fn draw(&mut self, painter: &mut Painter) -> Size {
-            painter.set_mask(painter.region());
+            painter.set_mask(UiRegion::FULL);
             painter.widget(&self.0).size()
         }
     }
@@ -79,6 +142,45 @@ fn a_clipping_widget_reporting_more_than_its_box_is_caught() {
     let mut h = Harness::new((100, 100));
     let tall = rect(Color::RED).height(400).add_strong(&mut h.rsc);
     let clipper = Clipper(tall).add(&mut h.rsc);
+    // `set_root` lays the tree out, so this is where it is caught.
     h.set_root(clipper);
+}
+
+/// Content that fits sits in the viewport, not in a box of the window's
+/// length anchored at the viewport's start. `Part::From` takes window
+/// lengths, so a `rel(1.0)` span in one is the window, and only a scroll
+/// filling the window would land right.
+#[test]
+fn content_that_fits_is_placed_in_the_viewport_and_not_in_the_window() {
+    let mut h = Harness::new((400, 400));
+    let head = rect(Color::RED).height(100).add(&mut h.rsc);
+    let inner = rect(Color::BLUE).height(50).add(&mut h.rsc);
+    let scroll = Scroll::new(inner.add_strong(&mut h.rsc), Axis::Y).add(&mut h.rsc);
+    h.set_root((head, scroll).span(Dir::DOWN));
+
+    assert_corners!(h, scroll, (0, 100), (400, 400));
+    assert_corners!(h, inner, (0, 225), (400, 275));
+}
+
+/// A cap narrows the box the widget is asked in, which is what a scroll
+/// measures its viewport from: the content scrolls within the cap rather than
+/// within the room the cap was cut from.
+#[test]
+fn a_capped_scroll_takes_its_viewport_from_the_cap() {
+    let mut h = Harness::new((400, 200));
+    let top = rect(Color::RED).height(200).add(&mut h.rsc);
+    let bottom = rect(Color::BLUE).height(200).add(&mut h.rsc);
+    let scroll = (top, bottom).span(Dir::DOWN).scrollable().add(&mut h.rsc);
+    let capped = scroll.max_height(100).add(&mut h.rsc);
+    h.set_root(capped);
+    h.move_to((200, 50));
+
+    // 400 of content in a viewport of 100, so 300 to scroll and the end
+    // showing: the top is 300 above the box, which the window centres.
+    assert_eq!(h.region(&scroll).unwrap().size().y, Px::from_int(100));
+    assert_corners!(h, top, (0, -250), (400, -50));
+
+    h.scroll((0, 1));
     h.frame();
+    assert_corners!(h, top, (0, -200), (400, 0));
 }

tests/cases/unsettled.rs

@@ -3,43 +3,244 @@
 //! frame that had not settled: a wrapping text shaped at a width it was
 //! measured in rather than the one it was given. The rest are a widget
 //! measured again in a box its own answer had decided, where the old answer
-//! is a fixed point whatever the content now says. The last is neither: one
-//! box length, composed two ways, landing either side of the boundary that
-//! decided whether a child was drawn at all.
+//! is a fixed point whatever the content now says. The last three are
+//! 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. The last is a wrapping text handed back the width
+//! it measured, rounded to a step below the line it measured there.
+//!
+//! Each says which seed it was shrunk from, of the generator as it stood when
+//! it was found. Those numbers no longer grow those trees -- a seed names one
+//! only while the generator draws the same things in the same order, and the
+//! leaves have grown an image since -- so what is written out below is the
+//! record of the case, and the seed is where it came from.
+
+use std::collections::HashSet;
 
 use iris::harness::Harness;
 use iris::prelude::*;
+use iris::random::Branch;
 
-/// Six widgets, shrunk from a 402-widget tree the fuzzer found. Nothing about
+/// Every widget in the same place warm as cold, reported all at once: which
+/// of a dozen boxes moved is the whole of what a shrunk case has to say.
+///
+/// A list that names one widget twice is an error rather than a redundant
+/// check. `width`, `sized` and `align` give back the widget they were handed,
+/// so a fixture built through them can name one text three times, and then a
+/// case comparing six boxes compares four and says nothing about it. One
+/// fixture builds both lists, so checking the warm one checks both.
+#[track_caller]
+fn assert_same_regions(
+    warm: &Harness,
+    warm_ids: &[WidgetId],
+    cold: &Harness,
+    cold_ids: &[WidgetId],
+) {
+    assert_eq!(
+        warm_ids.len(),
+        cold_ids.len(),
+        "the warm and cold fixtures list different widgets"
+    );
+    let named: HashSet<&WidgetId> = warm_ids.iter().collect();
+    assert_eq!(
+        named.len(),
+        warm_ids.len(),
+        "a widget is listed twice: {warm_ids:?}"
+    );
+    let mut wrong = Vec::new();
+    for (i, (&w, &c)) in warm_ids.iter().zip(cold_ids).enumerate() {
+        let (got, want) = (warm.region(&w), cold.region(&c));
+        if got != want {
+            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
+}
+
+/// Ten widgets, shrunk from seed 2 at depth 5. The stack is as tall as its
+/// first child, so its other children belong in that one-line box. A cold
+/// layout used to keep the span's answer from the larger measuring box while
+/// a repaint asked it in the stack's final box.
+fn plant_stack_in_its_sizing_childs_box(h: &mut Harness) -> Vec<WidgetId> {
+    let sizing = wtext("one line, overflowing whatever it is given")
+        .size(16)
+        .wrap(false)
+        .add(&mut h.rsc);
+    let filler = rect(Color::CYAN.alpha(252)).add(&mut h.rsc);
+    let plain = wtext("one line, overflowing whatever it is given")
+        .size(16)
+        .wrap(false)
+        .add(&mut h.rsc);
+    let span = (filler, plain).span(Dir::DOWN).add(&mut h.rsc);
+    let pad = Pad {
+        padding: Padding::ZERO,
+        inner: span.add_strong(&mut h.rsc),
+    }
+    .add(&mut h.rsc);
+    let probe = rect(Color::RED).add(&mut h.rsc);
+    let wide = rect(Color::YELLOW.alpha(252)).add(&mut h.rsc);
+    let narrow = rect(Color::RED).add(&mut h.rsc);
+    let branch = Branch {
+        probe: probe.add_strong(&mut h.rsc),
+        wide: wide.add_strong(&mut h.rsc),
+        narrow: narrow.add_strong(&mut h.rsc),
+        threshold: 55.0,
+    }
+    .add(&mut h.rsc);
+    let stack = Stack {
+        children: vec![
+            sizing.add_strong(&mut h.rsc),
+            pad.add_strong(&mut h.rsc),
+            branch.add_strong(&mut h.rsc),
+        ],
+        size: StackSize::Child(0),
+    }
+    .add(&mut h.rsc);
+    h.rsc
+        .widgets_mut()
+        .set_size_rules(stack.id(), Some(LayoutLen::LEFTOVER), None);
+    h.set_root(stack);
+    vec![
+        sizing.id(),
+        filler.id(),
+        plain.id(),
+        span.id(),
+        pad.id(),
+        probe.id(),
+        wide.id(),
+        narrow.id(),
+        branch.id(),
+        stack.id(),
+    ]
+}
+
+#[test]
+fn repainting_a_stack_uses_the_box_its_sizing_child_decided() {
+    let mut warm = Harness::new((900, 1200));
+    let ids = plant_stack_in_its_sizing_childs_box(&mut warm);
+    for &id in &ids {
+        warm.rsc.widgets_mut().mark_for_redraw(id);
+    }
+    warm.frame();
+
+    let mut cold = Harness::new((900, 1200));
+    let cold_ids = plant_stack_in_its_sizing_childs_box(&mut cold);
+
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+}
+
+/// Ten widgets, shrunk from seed 108 at depth 5. The nested reverse spans
+/// evaluate the branch in successively narrower boxes. The answer from the
+/// final, decided box must be the one retained after every span is reordered.
+fn plant_branch_in_nested_reverse_spans(
+    h: &mut Harness,
+    reordered: bool,
+) -> (Vec<WidgetId>, [WeakWidget<Span>; 3]) {
+    let pair = |first: StrongWidget, second: StrongWidget| match reordered {
+        true => vec![second, first],
+        false => vec![first, second],
+    };
+    let probe = rect(Color::RED.alpha(63)).add(&mut h.rsc);
+    let wide = rect(Color::RED).add(&mut h.rsc);
+    let narrow = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
+    let branch = Branch {
+        probe: probe.add_strong(&mut h.rsc),
+        wide: wide.add_strong(&mut h.rsc),
+        narrow: narrow.add_strong(&mut h.rsc),
+        threshold: 483.0,
+    }
+    .add(&mut h.rsc);
+    let wrapped = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
+    let down = Span {
+        children: pair(
+            branch.add_strong(&mut h.rsc),
+            wrapped.add_strong(&mut h.rsc),
+        ),
+        dir: Dir::DOWN,
+        gap: Px::ZERO,
+    }
+    .add(&mut h.rsc);
+    let inner_filler = rect(Color::CYAN.alpha(63)).add(&mut h.rsc);
+    let inner = Span {
+        children: pair(
+            down.add_strong(&mut h.rsc),
+            inner_filler.add_strong(&mut h.rsc),
+        ),
+        dir: Dir::LEFT,
+        gap: Px::ZERO,
+    }
+    .height(LayoutLen::rel(1.0))
+    .add(&mut h.rsc);
+    let outer_filler = rect(Color::GREEN.alpha(63)).add(&mut h.rsc);
+    let outer = Span {
+        children: pair(
+            inner.add_strong(&mut h.rsc),
+            outer_filler.add_strong(&mut h.rsc),
+        ),
+        dir: Dir::LEFT,
+        gap: Px::ZERO,
+    }
+    .height(LayoutLen::rel(1.0))
+    .add(&mut h.rsc);
+    h.set_root(outer);
+    (
+        vec![
+            probe.id(),
+            wide.id(),
+            narrow.id(),
+            branch.id(),
+            wrapped.id(),
+            down.id(),
+            inner_filler.id(),
+            inner.id(),
+            outer_filler.id(),
+            outer.id(),
+        ],
+        [down, inner, outer],
+    )
+}
+
+#[test]
+fn reordering_nested_spans_keeps_the_answer_from_the_decided_box() {
+    let mut warm = Harness::new((900, 1200));
+    let (ids, spans) = plant_branch_in_nested_reverse_spans(&mut warm, false);
+    for span in spans {
+        warm.rsc[span].children.rotate_left(1);
+    }
+    warm.frame();
+
+    let mut cold = Harness::new((900, 1200));
+    let (cold_ids, _) = plant_branch_in_nested_reverse_spans(&mut cold, true);
+
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+}
+
+/// Four widgets, shrunk from a 402-widget tree the fuzzer found. Nothing about
 /// the tree changes -- every widget is marked for redraw and the frame is
 /// taken again -- so no box may move, and a warm frame has to land where a
 /// cold one does.
 fn plant(h: &mut Harness) -> Vec<WidgetId> {
     let plain = wtext("Wrapping").size(16).wrap(false).add(&mut h.rsc);
-    let wrapped = wtext("Wrapping shapes").size(16).wrap(true).add(&mut h.rsc);
-    let sized = wrapped.width(76).add(&mut h.rsc);
-    let aligned = sized;
+    let wrapped = wtext("Wrapping shapes")
+        .size(16)
+        .wrap(true)
+        .width(76)
+        .add(&mut h.rsc);
     h.rsc
         .widgets_mut()
-        .set_alignment(sized, Axis::X, AxisAlign::POS);
+        .set_alignment(wrapped, Axis::X, AxisAlign::POS);
     h.rsc
         .widgets_mut()
-        .set_alignment(sized, Axis::Y, AxisAlign::POS);
+        .set_alignment(wrapped, Axis::Y, AxisAlign::POS);
     let stack = Stack {
-        children: vec![plain.add_strong(&mut h.rsc), aligned.add_strong(&mut h.rsc)],
+        children: vec![plain.add_strong(&mut h.rsc), wrapped.add_strong(&mut h.rsc)],
         size: StackSize::Child(0),
     }
     .add(&mut h.rsc);
     let root = (stack,).span(Dir::RIGHT).add(&mut h.rsc);
     h.set_root(root);
-    vec![
-        plain.id(),
-        wrapped.id(),
-        sized.id(),
-        aligned.id(),
-        stack.id(),
-        root.id(),
-    ]
+    vec![plain.id(), wrapped.id(), stack.id(), root.id()]
 }
 
 /// The first frame does not reach the layout a second one does, so "cold" is
@@ -52,7 +253,7 @@ fn one_frame_is_enough() {
     let first = h.region(&ids[1]).unwrap();
     for _ in 0..3 {
         for &id in &ids {
-            h.rsc.widgets_mut().get_dyn_mut(id);
+            h.rsc.widgets_mut().mark_for_redraw(id);
         }
         h.frame();
     }
@@ -74,46 +275,30 @@ fn repainting_everything_moves_nothing() {
     let mut warm = Harness::new((640, 900));
     let ids = plant(&mut warm);
     for &id in &ids {
-        warm.rsc.widgets_mut().get_dyn_mut(id);
+        warm.rsc.widgets_mut().mark_for_redraw(id);
     }
     warm.frame();
 
     let mut cold = Harness::new((640, 900));
     let cold_ids = plant(&mut cold);
 
-    let mut wrong = Vec::new();
-    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
-        let (got, want) = (warm.region(&w), cold.region(&c));
-        if got != want {
-            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
-        }
-    }
-    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
 }
 
-/// Six widgets, shrunk from 905. Everything inside the declared 189x176 box
+/// Four widgets, shrunk from 905. Everything inside the declared 189x176 box
 /// is the same size whatever the output is, so a resize may not change any of
 /// it -- but the text comes out 3.92px narrower warm than cold.
 fn plant_fixed(h: &mut Harness) -> Vec<WidgetId> {
     let words = "Wrapping shapes one source into as many lines as the box leaves";
     let text = wtext(words).size(16).wrap(true).add(&mut h.rsc);
-    let aligned = text;
     h.rsc
         .widgets_mut()
         .set_alignment(text, Axis::X, AxisAlign::NEG);
-    let inner = (aligned,).span(Dir::RIGHT).add(&mut h.rsc);
-    let sized = inner.sized((189, 176)).add(&mut h.rsc);
+    let inner = (text,).span(Dir::RIGHT).sized((189, 176)).add(&mut h.rsc);
     let filler = rect(Color::RED).add(&mut h.rsc);
-    let root = (filler, sized).span(Dir::RIGHT).add(&mut h.rsc);
+    let root = (filler, inner).span(Dir::RIGHT).add(&mut h.rsc);
     h.state.root = Some(root.add_strong(&mut h.rsc));
-    vec![
-        text.id(),
-        aligned.id(),
-        inner.id(),
-        sized.id(),
-        filler.id(),
-        root.id(),
-    ]
+    vec![text.id(), inner.id(), filler.id(), root.id()]
 }
 
 #[test]
@@ -128,17 +313,10 @@ fn a_resize_does_not_reach_inside_a_box_of_declared_pixels() {
     let cold_ids = plant_fixed(&mut cold);
     cold.frame();
 
-    let mut wrong = Vec::new();
-    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
-        let (got, want) = (warm.region(&w), cold.region(&c));
-        if got != want {
-            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
-        }
-    }
-    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
 }
 
-/// Four widgets, shrunk from 486. A span's two children are swapped: warm by
+/// Three widgets, shrunk from 486. A span's two children are swapped: warm by
 /// moving them, cold by growing them that way. Same widgets, same sizes, one
 /// ends up 29.9px from where the other does.
 fn plant_pair(h: &mut Harness, swapped: bool) -> (Vec<WidgetId>, WeakWidget<Span>) {
@@ -162,16 +340,11 @@ fn plant_pair(h: &mut Harness, swapped: bool) -> (Vec<WidgetId>, WeakWidget<Span
         gap: Px::ZERO,
     }
     .add(&mut h.rsc);
-    let span_handle = span;
-    let aligned = span;
     h.rsc
         .widgets_mut()
         .set_alignment(span, Axis::X, AxisAlign::CENTER);
-    h.state.root = Some(aligned.add_strong(&mut h.rsc));
-    (
-        vec![wrapped.id(), plain.id(), span.id(), aligned.id()],
-        span_handle,
-    )
+    h.state.root = Some(span.add_strong(&mut h.rsc));
+    (vec![wrapped.id(), plain.id(), span.id()], span)
 }
 
 #[test]
@@ -186,17 +359,10 @@ fn swapping_two_children_lands_where_growing_them_that_way_does() {
     let (cold_ids, _) = plant_pair(&mut cold, true);
     cold.frame();
 
-    let mut wrong = Vec::new();
-    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
-        let (got, want) = (warm.region(&w), cold.region(&c));
-        if got != want {
-            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
-        }
-    }
-    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
 }
 
-/// Eight widgets, shrunk from 80. The scroll decides how wide to make its
+/// Seven widgets, shrunk from 80. The scroll decides how wide to make its
 /// content from what the content says, and hands that box down through a
 /// pass-through; the span under it was given that box once, so nothing at its
 /// own edge says the box was its own answer.
@@ -215,8 +381,7 @@ fn plant_scrolled(h: &mut Harness, swapped: bool) -> (Vec<WidgetId>, [WeakWidget
         gap: Px::ZERO,
     }
     .add(&mut h.rsc);
-    let block = rect(Color::RED).add(&mut h.rsc);
-    let fixed = block.width(87).add(&mut h.rsc);
+    let fixed = rect(Color::RED).width(87).add(&mut h.rsc);
     let mut outer_children: Vec<StrongWidget> =
         vec![fixed.add_strong(&mut h.rsc), inner.add_strong(&mut h.rsc)];
     if swapped {
@@ -238,7 +403,6 @@ fn plant_scrolled(h: &mut Harness, swapped: bool) -> (Vec<WidgetId>, [WeakWidget
             text.id(),
             filler.id(),
             inner.id(),
-            block.id(),
             fixed.id(),
             outer.id(),
             through.id(),
@@ -262,14 +426,7 @@ fn a_span_given_the_box_its_answer_decided_matches_a_cold_layout() {
     let (cold_ids, _) = plant_scrolled(&mut cold, true);
     cold.frame();
 
-    let mut wrong = Vec::new();
-    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
-        let (got, want) = (warm.region(&w), cold.region(&c));
-        if got != want {
-            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
-        }
-    }
-    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
 }
 
 /// Reports a width derived from the box it is asked in. Reading through the
@@ -293,11 +450,10 @@ impl Widget for Wider {
 fn plant_wider(h: &mut Harness, extra: f32) -> (WeakWidget<Wider>, WidgetId) {
     let content = Wider { extra }.add(&mut h.rsc);
     let scroll = Scroll::new(content.add_strong(&mut h.rsc), Axis::X).add(&mut h.rsc);
-    let root = scroll;
     h.rsc
         .widgets_mut()
         .set_alignment(scroll, Axis::X, AxisAlign::NEG);
-    h.set_root(root);
+    h.set_root(scroll);
     (content, scroll.id())
 }
 
@@ -389,12 +545,511 @@ fn a_box_that_only_rounds_past_its_fixed_children_leaves_nothing_over() {
     let (cold_ids, _) = plant_boundary(&mut cold, true);
     cold.frame();
 
-    let mut wrong = Vec::new();
-    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
-        let (got, want) = (warm.region(&w), cold.region(&c));
-        if got != want {
-            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+}
+
+/// Five widgets, shrunk by `tests/shrink.rs` from the 277 the oracle's seed
+/// 18 grows at depth 6. A scroll inside a scroll, the inner one owning a
+/// movable region of its own, and only its text marked for redraw. Nothing
+/// about the tree changes, so no box may.
+fn plant_nested_scrolls(h: &mut Harness) -> Vec<WidgetId> {
+    let text = wtext("one line, overflowing whatever it is given")
+        .size(16)
+        .wrap(false)
+        .add(&mut h.rsc);
+    let inner = Scroll::new(text.add_strong(&mut h.rsc), Axis::X).add(&mut h.rsc);
+    h.rsc.widgets_mut().set_region_node(inner.id(), true);
+    let filler = rect(Color::RED).add(&mut h.rsc);
+    h.rsc.widgets_mut().set_size_rules(
+        filler.id(),
+        Some(LayoutLen::px(87.0)),
+        Some(LayoutLen::px(24.0)),
+    );
+    let span = Span {
+        children: vec![inner.add_strong(&mut h.rsc), filler.add_strong(&mut h.rsc)],
+        dir: Dir::DOWN,
+        gap: Px::ZERO,
+    }
+    .add(&mut h.rsc);
+    let root = Scroll::new(span.add_strong(&mut h.rsc), Axis::Y).add(&mut h.rsc);
+    h.set_root(root);
+    vec![text.id(), inner.id(), filler.id(), span.id(), root.id()]
+}
+
+/// A local redraw asks a dirty widget in the box its parent gave it, and only
+/// where that box is as long as the one it was offered; anything else is a
+/// question its parent has to ask. This inner scroll's offer is the outer
+/// scroll's whole viewport and the box it was given is 24px shorter -- the
+/// height of the sized child the outer scroll snaps to the end of -- so what
+/// it must not do is settle itself. It was drawn at its offer once, and the
+/// inner scroll and its text stayed 24px too low.
+#[test]
+fn redrawing_one_widget_does_not_move_what_scrolls_around_it() {
+    let mut warm = Harness::new((900, 1200));
+    let ids = plant_nested_scrolls(&mut warm);
+    warm.rsc.widgets_mut().mark_for_redraw(ids[0]);
+    warm.frame();
+
+    let mut cold = Harness::new((900, 1200));
+    let cold_ids = plant_nested_scrolls(&mut cold);
+
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+}
+
+/// Ten widgets, of the shape `tests/shrink.rs` reduces the oracle's seed 220
+/// to. The pad owns a movable region and is the scroll's content, so the box
+/// the scroll places it in is as long as that content while the box it was
+/// offered is the viewport -- and with no padding to tell those two apart,
+/// the span inside it looked like it was still at its offer. So everything
+/// under the pad was asked again in the *placed* box, the offer resolving
+/// against the node's own entry, which holds that box: the texts kept the
+/// widths they had, the content stayed the length those widths make, and the
+/// old answer confirmed itself. What the branch adds is a tree that differs
+/// rather than a box that moved, since a probe measured at the wrong width
+/// takes the other side.
+fn plant_under_a_node(h: &mut Harness, swapped: bool) -> (Vec<WidgetId>, [WeakWidget<Span>; 2]) {
+    let probe = rect(Color::RED).add(&mut h.rsc);
+    let wide = rect(Color::GREEN).add(&mut h.rsc);
+    let narrow = rect(Color::BLUE).add(&mut h.rsc);
+    let branch = Branch {
+        probe: probe.add_strong(&mut h.rsc),
+        wide: wide.add_strong(&mut h.rsc),
+        narrow: narrow.add_strong(&mut h.rsc),
+        threshold: 213.0,
+    }
+    .add(&mut h.rsc);
+    let wrapped = 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(&mut h.rsc);
+    let plain = wtext("one line, overflowing whatever it is given")
+        .size(16)
+        .wrap(false)
+        .add(&mut h.rsc);
+    let row = |h: &mut Harness, mut children: Vec<StrongWidget>| {
+        if swapped {
+            children.rotate_left(1);
+        }
+        Span {
+            children,
+            dir: Dir::RIGHT,
+            gap: Px::ZERO,
+        }
+        .add(&mut h.rsc)
+    };
+    let texts: Vec<StrongWidget> =
+        vec![wrapped.add_strong(&mut h.rsc), plain.add_strong(&mut h.rsc)];
+    let inner = row(h, texts);
+    let pair: Vec<StrongWidget> = vec![branch.add_strong(&mut h.rsc), inner.add_strong(&mut h.rsc)];
+    let outer = row(h, pair);
+    let pad = Pad {
+        padding: Padding::ZERO,
+        inner: outer.add_strong(&mut h.rsc),
+    }
+    .add(&mut h.rsc);
+    h.rsc.widgets_mut().set_region_node(pad.id(), true);
+    let root = Scroll::new(pad.add_strong(&mut h.rsc), Axis::X).add(&mut h.rsc);
+    h.set_root(root);
+    (
+        vec![
+            probe.id(),
+            wide.id(),
+            narrow.id(),
+            branch.id(),
+            wrapped.id(),
+            plain.id(),
+            inner.id(),
+            outer.id(),
+            pad.id(),
+            root.id(),
+        ],
+        [outer, inner],
+    )
+}
+
+#[test]
+fn a_widget_under_a_region_node_is_asked_in_the_box_that_node_was_offered() {
+    let mut warm = Harness::new((900, 1200));
+    let (ids, spans) = plant_under_a_node(&mut warm, false);
+    warm.frame();
+    for span in spans {
+        warm.rsc[span].children.rotate_left(1);
+    }
+    warm.frame();
+
+    let mut cold = Harness::new((900, 1200));
+    let (cold_ids, _) = plant_under_a_node(&mut cold, true);
+    cold.frame();
+
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+}
+
+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.";
+
+fn plant_stack_resized_from_free(h: &mut Harness, fixed: bool) -> (Vec<WidgetId>, WidgetId) {
+    let sizing = rect(Color::CYAN.alpha(126)).add(&mut h.rsc);
+    h.rsc.widgets_mut().set_size_rules(sizing.id(), None, None);
+    if fixed {
+        h.rsc.widgets_mut().set_size_rules(
+            sizing.id(),
+            Some(LayoutLen::px(112)),
+            Some(LayoutLen::px(101)),
+        );
+    }
+    let text = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
+    let pad = Pad {
+        padding: Padding::ZERO,
+        inner: text.add_strong(&mut h.rsc),
+    }
+    .add(&mut h.rsc);
+    let stack = Stack {
+        children: vec![sizing.add_strong(&mut h.rsc), pad.add_strong(&mut h.rsc)],
+        size: StackSize::Child(0),
+    }
+    .add(&mut h.rsc);
+    h.set_root(stack);
+    (
+        vec![sizing.id(), text.id(), pad.id(), stack.id()],
+        sizing.id(),
+    )
+}
+
+#[test]
+fn fixing_a_stacks_sizing_child_repositions_its_overlay() {
+    let mut warm = Harness::new((900, 1200));
+    let (ids, sizing) = plant_stack_resized_from_free(&mut warm, false);
+    warm.frame();
+    warm.rsc.widgets_mut().set_size_rules(
+        sizing,
+        Some(LayoutLen::px(112)),
+        Some(LayoutLen::px(101)),
+    );
+    warm.frame();
+
+    let mut cold = Harness::new((900, 1200));
+    let (cold_ids, _) = plant_stack_resized_from_free(&mut cold, true);
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+}
+
+/// 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));
+}
+
+#[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));
+}
+
+/// Nine widgets, shrunk from seed 946 at depth 6. The column is a share of
+/// the row while its rect has room to draw and a fixed width once it has
+/// not, so the row asks it twice: in the room, where it answers a share,
+/// and in its slot, where it answers its text's width. Emptying the column
+/// changes only the first answer. A local redraw that asked only the second
+/// question kept the row as it was; the column has to defer to the row.
+fn plant_column_that_is_a_share_only_while_its_rect_fits(
+    h: &mut Harness,
+    emptied: bool,
+) -> (Vec<WidgetId>, WeakWidget<Span>, Vec<StrongWidget>) {
+    let first = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
+    let filler = rect(Color::CYAN.alpha(126)).add(&mut h.rsc);
+    let second = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
+    let mut spare: Vec<StrongWidget> =
+        vec![filler.add_strong(&mut h.rsc), second.add_strong(&mut h.rsc)];
+    let mut children: Vec<StrongWidget> = vec![first.add_strong(&mut h.rsc)];
+    if !emptied {
+        children.append(&mut spare);
+    }
+    let column = Span {
+        children,
+        dir: Dir::DOWN,
+        gap: Px::ZERO,
+    }
+    .height(159)
+    .add(&mut h.rsc);
+    let left = rect(Color::MAGENTA.alpha(189)).add(&mut h.rsc);
+    let right = rect(Color::BLUE.alpha(0)).add(&mut h.rsc);
+    let row = Span {
+        children: vec![
+            left.add_strong(&mut h.rsc),
+            column.add_strong(&mut h.rsc),
+            right.add_strong(&mut h.rsc),
+        ],
+        dir: Dir::RIGHT,
+        gap: Px::ZERO,
+    }
+    .add(&mut h.rsc);
+    let end = rect(Color::MAGENTA.alpha(189)).add(&mut h.rsc);
+    let root = Span {
+        children: vec![end.add_strong(&mut h.rsc), row.add_strong(&mut h.rsc)],
+        dir: Dir::LEFT,
+        gap: Px::ZERO,
+    }
+    .add(&mut h.rsc);
+    h.set_root(root);
+    (
+        vec![
+            first.id(),
+            filler.id(),
+            second.id(),
+            column.id(),
+            left.id(),
+            right.id(),
+            row.id(),
+            end.id(),
+            root.id(),
+        ],
+        column,
+        spare,
+    )
+}
+
+#[test]
+fn emptying_a_column_the_row_asked_twice_asks_the_row_again() {
+    let mut warm = Harness::new((900, 1200));
+    let (ids, column, _spare) =
+        plant_column_that_is_a_share_only_while_its_rect_fits(&mut warm, false);
+    warm.frame();
+    // Kept alive: dropping the last share of a widget frees its id.
+    let _removed: Vec<StrongWidget> = warm.rsc[column].children.drain(1..).collect();
+    warm.frame();
+
+    let mut cold = Harness::new((900, 1200));
+    let (cold_ids, _, _spare) =
+        plant_column_that_is_a_share_only_while_its_rect_fits(&mut cold, true);
+    cold.frame();
+
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+}
+
+/// Six widgets, shrunk from seed 59 at depth 5 (`resize-size`). The column
+/// divides the box it is given between two shares, so its drawing holds for
+/// that box's length alone, and the pads above it pass that dependency up:
+/// each one's box is a part of the box it was asked in. Padding narrowing
+/// the frame it hands down does not change that, and while it was taken to,
+/// changing the rule over the pads relocated the column's drawing into the
+/// new box instead of dividing it again.
+fn plant_two_shares_under_two_pads(h: &mut Harness, height: f32) -> Vec<WidgetId> {
+    let top = rect(Color::CYAN.alpha(126)).add(&mut h.rsc);
+    let bottom = rect(Color::RED).add(&mut h.rsc);
+    let column = (top, bottom).span(Dir::DOWN).add(&mut h.rsc);
+    let inner = Pad {
+        padding: Padding::ZERO,
+        inner: column.add_strong(&mut h.rsc),
+    }
+    .add(&mut h.rsc);
+    let outer = Pad {
+        padding: Padding::ZERO,
+        inner: inner.add_strong(&mut h.rsc),
+    }
+    .height(height)
+    .add(&mut h.rsc);
+    let beside = rect(Color::BLUE).add(&mut h.rsc);
+    h.set_root((outer, beside).span(Dir::RIGHT));
+    vec![
+        top.id(),
+        bottom.id(),
+        column.id(),
+        inner.id(),
+        outer.id(),
+        beside.id(),
+    ]
+}
+
+#[test]
+fn changing_a_rule_over_two_pads_divides_the_column_again() {
+    let mut warm = Harness::new((900, 1200));
+    let ids = plant_two_shares_under_two_pads(&mut warm, 88.0);
+    warm.frame();
+    warm.rsc
+        .widgets_mut()
+        .set_size_rules(ids[4], None, Some(LayoutLen::px(105)));
+    warm.frame();
+
+    let mut cold = Harness::new((900, 1200));
+    let cold_ids = plant_two_shares_under_two_pads(&mut cold, 105.0);
+    cold.frame();
+
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+}
+
+/// Six widgets, shrunk from seed 942 at depth 6 (`resize`). A `Branch` asks
+/// its probe in the top 40 px of its box and forwards the frame, so the
+/// scroll's own box is 40 px tall whatever the window is -- but its content
+/// is as tall as the frame, which is the window, and a scroll kept to its
+/// end has to be told when that changes. Resolving a length against the
+/// window is what reads it, so that is where the dependency is taken.
+fn plant_a_window_tall_column_in_a_short_scroll(h: &mut Harness) -> Vec<WidgetId> {
+    let leaf = rect(Color::RED).add(&mut h.rsc);
+    let column = Span {
+        children: vec![leaf.add_strong(&mut h.rsc)],
+        dir: Dir::RIGHT,
+        gap: Px::ZERO,
+    }
+    .height(rel(1.0))
+    .add(&mut h.rsc);
+    let scroll = Scroll::new(column.add_strong(&mut h.rsc), Axis::Y).add(&mut h.rsc);
+    let wide = rect(Color::BLUE).add(&mut h.rsc);
+    let narrow = rect(Color::GREEN).add(&mut h.rsc);
+    let root = Branch {
+        probe: scroll.add_strong(&mut h.rsc),
+        wide: wide.add_strong(&mut h.rsc),
+        narrow: narrow.add_strong(&mut h.rsc),
+        threshold: 55.0,
+    }
+    .add(&mut h.rsc);
+    h.set_root(root);
+    vec![leaf.id(), column.id(), scroll.id(), root.id()]
+}
+
+#[test]
+fn resizing_under_a_short_scroll_snaps_its_window_tall_content_again() {
+    let mut warm = Harness::new((1920, 1200));
+    let ids = plant_a_window_tall_column_in_a_short_scroll(&mut warm);
+    warm.frame();
+    warm.resize((640, 900));
+    warm.frame();
+
+    let mut cold = Harness::new((640, 900));
+    let cold_ids = plant_a_window_tall_column_in_a_short_scroll(&mut cold);
+    cold.frame();
+
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+}
+
+/// A scroll clamps its position against the box it is drawn in, so drawing it
+/// once at one viewport and again at another writes state the second draw then
+/// reads. That the answer is still the one a cold layout gives is a property
+/// of the clamp, not something the layout enforces.
+#[test]
+fn a_scrolled_view_resized_lands_where_a_cold_layout_puts_it() {
+    for amt in [10.0, 40.0, 90.0, 140.0] {
+        let mut warm = Harness::new((100, 100));
+        let (_, warm_scroll) = plant_wider(&mut warm, 100.0);
+        warm.move_to((50.0, 50.0));
+        warm.scroll((-amt, 0.0));
+        warm.frame();
+        warm.resize((160, 100));
+        warm.frame();
+
+        let mut cold = Harness::new((160, 100));
+        let (_, cold_scroll) = plant_wider(&mut cold, 100.0);
+        cold.move_to((50.0, 50.0));
+        cold.scroll((-amt, 0.0));
+        cold.frame();
+
+        assert_eq!(
+            warm.region(&warm_scroll),
+            cold.region(&cold_scroll),
+            "scrolled by {amt} then widened"
+        );
     }
-    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
 }

tests/chain_cost.rs

@@ -11,8 +11,6 @@
 //! The instances are two pixels wide so that vertex work dominates; a chain
 //! walk that does not show up against small quads will not show up against
 //! anything.
-//!
-//! The instance is leaked deliberately, for the reason `draw_cost.rs` gives.
 
 use iris::prelude::*;
 use iris_core::{
@@ -21,6 +19,9 @@ use iris_core::{
 };
 use wgpu::{Color as GpuColor, *};
 
+#[path = "gpu/mod.rs"]
+mod gpu;
+
 const SIZE: u32 = 1024;
 const INSTANCES: usize = 200_000;
 const FRAMES: u32 = 20;
@@ -29,18 +30,7 @@ const FRAMES: u32 = 20;
 const BATCHES: u32 = 8;
 
 fn gpu() -> Option<(Device, Queue, f32)> {
-    let all = Instance::new(InstanceDescriptor::new_without_display_handle());
-    let instance = match pollster::block_on(all.request_adapter(&RequestAdapterOptions::default()))
-    {
-        Ok(_) => all,
-        Err(_) => Instance::new(InstanceDescriptor {
-            backends: Backends::GL,
-            ..InstanceDescriptor::new_without_display_handle()
-        }),
-    };
-    let instance: &'static Instance = Box::leak(Box::new(instance));
-    let adapter =
-        pollster::block_on(instance.request_adapter(&RequestAdapterOptions::default())).ok()?;
+    let adapter = gpu::adapter()?;
     if !adapter.features().contains(Features::TIMESTAMP_QUERY) {
         println!("no timestamp queries on {:?}", adapter.get_info().name);
         return None;
@@ -55,20 +45,6 @@ fn gpu() -> Option<(Device, Queue, f32)> {
     Some((device, queue, period))
 }
 
-fn config(format: TextureFormat) -> SurfaceConfiguration {
-    SurfaceConfiguration {
-        usage: TextureUsages::RENDER_ATTACHMENT,
-        format,
-        color_space: SurfaceColorSpace::Auto,
-        width: SIZE,
-        height: SIZE,
-        present_mode: PresentMode::Fifo,
-        desired_maximum_frame_latency: 2,
-        alpha_mode: CompositeAlphaMode::Auto,
-        view_formats: vec![],
-    }
-}
-
 /// A chain `depth` slots long, and instances that all resolve through its end.
 fn fill(ui: &mut UiData, render: &mut UiRenderState, depth: usize) {
     let kind = ui.primitives.kind::<RectPrimitive>();
@@ -103,7 +79,7 @@ fn fill(ui: &mut UiData, render: &mut UiRenderState, depth: usize) {
 /// Nanoseconds the pass took on the GPU, best of `BATCHES`.
 fn pass_cost(device: &Device, queue: &Queue, period: f32, depth: usize) -> f64 {
     let format = TextureFormat::Bgra8Unorm;
-    let mut node = UiRenderNode::new(device, &config(format));
+    let mut node = UiRenderNode::new(device, &gpu::config(format, SIZE));
     let mut ui = UiData::default();
     let mut render = UiRenderState::new();
     fill(&mut ui, &mut render, depth);

tests/draw_cost.rs

@@ -13,10 +13,6 @@
 //! That is how `PrimitiveRender` was measured against a match in the renderer:
 //! 6 instructions per list drawn, against the ~5,400 wgpu spends recording
 //! one.
-//!
-//! The instance is leaked deliberately. A Vulkan loader may unload the driver
-//! when the last one drops, which can fault as a thread that used it exits --
-//! and every test runs on a spawned thread.
 
 use std::time::Instant;
 
@@ -27,6 +23,9 @@ use iris_core::{
 };
 use wgpu::{Color as GpuColor, *};
 
+#[path = "gpu/mod.rs"]
+mod gpu;
+
 const SIZE: u32 = 1024;
 const FRAMES: u32 = 200;
 /// Reported as the best of this many batches, since the mean moves by more
@@ -34,39 +33,11 @@ const FRAMES: u32 = 200;
 const BATCHES: u32 = 8;
 
 fn gpu() -> Option<(Device, Queue)> {
-    // Probed rather than assumed: there may be no Vulkan adapter, and GL is
-    // what is left when there is not.
-    let all = Instance::new(InstanceDescriptor::new_without_display_handle());
-    let instance = match pollster::block_on(all.request_adapter(&RequestAdapterOptions::default()))
-    {
-        Ok(_) => all,
-        Err(_) => Instance::new(InstanceDescriptor {
-            backends: Backends::GL,
-            ..InstanceDescriptor::new_without_display_handle()
-        }),
-    };
-    // Leaked rather than dropped: see the note at the top of the file.
-    let instance: &'static Instance = Box::leak(Box::new(instance));
-    let adapter =
-        pollster::block_on(instance.request_adapter(&RequestAdapterOptions::default())).ok()?;
+    let adapter = gpu::adapter()?;
     println!("adapter: {:?}", adapter.get_info());
     pollster::block_on(adapter.request_device(&DeviceDescriptor::default())).ok()
 }
 
-fn config(format: TextureFormat) -> SurfaceConfiguration {
-    SurfaceConfiguration {
-        usage: TextureUsages::RENDER_ATTACHMENT,
-        format,
-        color_space: SurfaceColorSpace::Auto,
-        width: SIZE,
-        height: SIZE,
-        present_mode: PresentMode::Fifo,
-        desired_maximum_frame_latency: 2,
-        alpha_mode: CompositeAlphaMode::Auto,
-        view_formats: vec![],
-    }
-}
-
 /// Every layer draws all three primitives, so the renderer takes a different
 /// path for each list it walks -- which is the case a single-primitive layer
 /// would never exercise. Images are bound per instance, so there are few.
@@ -136,7 +107,7 @@ fn fill(
 
 fn frame_cost(device: &Device, queue: &Queue, layers: usize, per_layer: usize) -> f64 {
     let format = TextureFormat::Bgra8Unorm;
-    let mut node = UiRenderNode::new(device, &config(format));
+    let mut node = UiRenderNode::new(device, &gpu::config(format, SIZE));
     let mut ui = UiData::default();
     let mut render = UiRenderState::new();
     let _handles = fill(&mut ui, &mut render, layers, per_layer);

tests/generated.rs

@@ -1,19 +1,21 @@
-//! Random trees, checked against building the same tree cold.
+//! Laying a tree out again has to land where growing it that way would.
 //!
-//! A frame reaches its layout by keeping most of the last one: movable regions
-//! or primitive boxes rewritten, some widgets drawn again, the rest untouched.
-//! The result must be the tree a cold start would have produced, so anything
-//! wrongly retained shows up as a difference in somebody's box.
+//! Every case is one of `scenario`'s, over the trees `iris::random` grows
+//! from a seed. The fast test takes a handful of seeds and the ignored one
+//! takes as many as it is asked for; both run the same cases the shrinker
+//! does over the same trees, so a seed that fails here is reduced by
 //!
-//! `iris::random` grows the tree and `examples/random.rs` draws one. A seed is
-//! the whole reproduction; `a_long_run_of_seeds_agrees` is the ignored sweep
-//! for when it is worth spending the time.
+//!     SHRINK_SEED=<seed> SHRINK_DEPTH=<depth> SHRINK_CASE=<case> \
+//!       cargo test --release --test shrink -- --ignored --nocapture
+//!
+//! `IRIS_GENERATED_SEED`, `IRIS_GENERATED_SEEDS` and `IRIS_GENERATED_DEPTH`
+//! select what the long run covers.
 
-use std::collections::HashMap;
+#[path = "scenario/mod.rs"]
+mod scenario;
 
-use iris::harness::Harness;
-use iris::prelude::*;
-use iris::random::{Aligns, Edits, Lens, Rng, SpanEdit, Tree, grow};
+use iris::random::{Edits, Plan, plan};
+use scenario::{ALL, Case, diverges, env, over_seeds};
 
 /// How deep the generator branches. The generator widens two to four ways per
 /// level, so depth is exponential in width and a deep narrow tree is not
@@ -23,562 +25,103 @@ fn depth() -> usize {
     env("IRIS_GENERATED_DEPTH", 4)
 }
 
-fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
-    std::env::var(name)
-        .ok()
-        .and_then(|value| value.parse().ok())
-        .unwrap_or(fallback)
-}
-const SEEDS: [u64; 9] = [1, 2, 3, 5, 8, 10, 13, 86, 98];
+/// The seeds the ordinary tests take: a corpus rather than a set of
+/// regression cases, since a seed names a tree only for as long as the
+/// generator draws the same things in the same order. Adding images to the
+/// leaves moved every one of them, so 20 and 86 -- which once caught a widget
+/// placed twice in a box its parent had already placed it in, and a `Scroll`
+/// fixed point settling differently -- no longer grow those trees. Both
+/// defects are pinned by the shrunk fixtures in `cases/unsettled.rs`, which
+/// are trees rather than numbers.
+const SEEDS: [u64; 10] = [1, 2, 3, 5, 8, 10, 13, 20, 86, 98];
 
-/// The same box, to a step of the grid per level of nesting between the two
-/// ways of reaching it. A move, a repaint and a row of shares land on the
-/// same number now; what is left is a box centred in a fraction of its parent
-/// against the same box centred in its own pixels. A step is a thousandth of
-/// a pixel, where this was a twentieth of one before any of it was on a grid.
-const AGREE_STEPS: i32 = 2;
-
-fn same_region(got: Option<PixelRegion>, want: Option<PixelRegion>) -> bool {
-    match (got, want) {
-        (Some(got), Some(want)) => {
-            let same = |a: Px, b: Px| (a - b).abs() <= Px::STEP.mul_int(AGREE_STEPS);
-            same(got.top_left.x, want.top_left.x)
-                && same(got.top_left.y, want.top_left.y)
-                && same(got.bot_right.x, want.bot_right.x)
-                && same(got.bot_right.y, want.bot_right.y)
-        }
-        (None, None) => true,
-        _ => false,
-    }
+fn check(seed: u64, depth: usize, case: Case) {
+    check_plan(&plan(seed, depth, &Edits::default()), seed, depth, case);
 }
 
-fn plant(h: &mut Harness, seed: u64, edits: &Edits) -> Tree {
-    let (root, tree) = grow(&mut h.rsc, seed, depth(), edits);
-    h.state.root = Some(root);
-    h.frame();
-    tree
-}
-
-fn resize_one(h: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> Lens {
-    let lens = [
-        Some(LayoutLen::px(20.0 + rng.below(180) as f32)),
-        Some(LayoutLen::px(20.0 + rng.below(180) as f32)),
-    ];
-    h.rsc
-        .widgets_mut()
-        .set_size_rules(tree.sized[idx], lens[0], lens[1]);
-    lens
-}
-
-/// Changes a few of the declared sizes, and says which, so the cold tree can
-/// be grown with the same ones.
-fn edit(h: &mut Harness, tree: &Tree, rng: &mut Rng) -> HashMap<usize, Lens> {
-    let mut edits = HashMap::new();
-    for _ in 0..4 {
-        let idx = rng.below(tree.sized.len());
-        edits.insert(idx, resize_one(h, tree, idx, rng));
-    }
-    edits
-}
-
-/// Every declared size at once, so every reader of a size in the tree has a
-/// changed descendant in the same frame and the whole dirty set has to settle
-/// together.
-fn edit_every(h: &mut Harness, tree: &Tree, rng: &mut Rng) -> HashMap<usize, Lens> {
-    (0..tree.sized.len())
-        .map(|idx| (idx, resize_one(h, tree, idx, rng)))
-        .collect()
-}
-
-/// A way of changing what a span holds. Each is a shape worth its own case:
-/// taking a child out of the middle is not the same as emptying a span, and
-/// adding one is not the same as adding three.
-#[derive(Clone, Copy, Debug)]
-enum Shuffle {
-    /// Every other child, so what is left is interleaved with what went.
-    EveryOther,
-    /// Everything but the first, which is the last step before empty.
-    AllButFirst,
-    /// Three more on the end at once.
-    AddThree,
-    /// The first out and three more on, so the count moves both ways.
-    SwapForThree,
-    /// One out of the middle and one on the end.
-    TradeOne,
-}
-
-const SHUFFLES: [Shuffle; 5] = [
-    Shuffle::EveryOther,
-    Shuffle::AllButFirst,
-    Shuffle::AddThree,
-    Shuffle::SwapForThree,
-    Shuffle::TradeOne,
-];
-
-impl Shuffle {
-    fn of(self, grown: usize) -> SpanEdit {
-        let all = |step: usize, from: usize| (from..grown).step_by(step).collect();
-        match self {
-            Self::EveryOther => SpanEdit {
-                detach: all(2, 0),
-                attach: 0,
-            },
-            Self::AllButFirst => SpanEdit {
-                detach: all(1, 1),
-                attach: 0,
-            },
-            Self::AddThree => SpanEdit {
-                detach: Vec::new(),
-                attach: 3,
-            },
-            Self::SwapForThree => SpanEdit {
-                detach: vec![0],
-                attach: 3,
-            },
-            Self::TradeOne => SpanEdit {
-                detach: vec![grown / 2],
-                attach: 1,
-            },
-        }
-    }
-}
-
-/// Applies `shuffle` to every third span, and says what it did so the cold
-/// tree can be grown that way. The widgets it takes out are given back: the
-/// last share of one must outlive the comparison, or its id is handed to
-/// something else and the two trees stop lining up.
-fn reshuffle(
-    h: &mut Harness,
-    tree: &mut Tree,
-    shuffle: Shuffle,
-) -> (HashMap<usize, SpanEdit>, Vec<StrongWidget>) {
-    let mut edits = HashMap::new();
-    let mut detached = Vec::new();
-    for (idx, span) in tree.spans.iter_mut().enumerate().step_by(3) {
-        let span_edit = shuffle.of(span.grown);
-        let mut take = span_edit.detach.clone();
-        take.sort_unstable();
-        let children = &mut h.rsc[span.id].children;
-        // Highest first, so an index means the same child however many of
-        // its neighbours are going too.
-        for j in take.into_iter().rev() {
-            if j < children.len() {
-                detached.push(children.remove(j));
-            }
-        }
-        let attach = span_edit.attach.min(span.spares.len());
-        children.extend(span.spares.drain(..attach));
-        edits.insert(idx, span_edit);
-    }
-    (edits, detached)
-}
-
-/// What a widget was configured with, so a tree the generator found can be
-/// written out by hand. A fuzz failure is a lead; the fast test that replaces
-/// it has to be buildable from what the failure printed.
-fn describe(id: WidgetId, h: &Harness) -> String {
-    let rules = h.rsc.widgets().size_rules(id);
-    let rule = |r: SizeRule| match r.exact() {
-        Some(len) => format!("{len}"),
-        None => "-".into(),
-    };
-    let align = h.rsc.widgets().alignment(id);
-    let side = |a: AxisAlign| {
-        if a == AxisAlign::NEG {
-            "neg".into()
-        } else if a == AxisAlign::CENTER {
-            "mid".into()
-        } else if a == AxisAlign::POS {
-            "pos".into()
-        } else {
-            format!("{:.2}", a.rel())
-        }
-    };
-    // A rule and an alignment are properties of whatever carries them, so
-    // they print with that widget rather than as widgets of their own.
-    let mut out = describe_widget(id, h);
-    if (rules.x, rules.y) != (SizeRule::Free, SizeRule::Free) {
-        out += &format!("[x:{},y:{}]", rule(rules.x), rule(rules.y));
-    }
-    if align != RegionAlign::default() {
-        out += &format!("@{},{}", side(align.x), side(align.y));
-    }
-    out
-}
-
-fn describe_widget(id: WidgetId, h: &Harness) -> String {
-    let label = h.rsc.widgets().label(id).to_string();
-    let Some(widget) = h.rsc.widgets().get_dyn(id) else {
-        return label;
-    };
-    let any: &dyn std::any::Any = widget;
-    if let Some(w) = any.downcast_ref::<Span>() {
-        let sign = if w.dir.sign == Sign::Neg { "-" } else { "+" };
-        return format!(
-            "Span{{dir:{:?}{sign},gap:{},n:{}}}",
-            w.dir.axis,
-            w.gap,
-            w.children.len()
+fn check_plan(grown: &Plan, seed: u64, depth: usize, case: Case) {
+    if let Some(how) = diverges(grown, case, seed) {
+        panic!(
+            "seed {seed} at depth {depth} differs after {}: {how}\n\
+             reduce it with SHRINK_SEED={seed} SHRINK_DEPTH={depth} \
+             SHRINK_CASE={} cargo test --release --test shrink -- --ignored --nocapture",
+            case.name(),
+            case.name(),
         );
     }
-    if let Some(w) = any.downcast_ref::<Pad>() {
-        let p = &w.padding;
-        return format!(
-            "Pad{{l:{},r:{},t:{},b:{}}}",
-            p.left, p.right, p.top, p.bottom
+}
+
+/// A test per case, and the list of which cases have one, from the same
+/// place. A case the ordinary suite leaves out runs only in the long scan,
+/// which nobody runs by hand.
+macro_rules! cases {
+    ($($name:ident = $case:expr,)*) => {
+        $(
+            #[test]
+            fn $name() {
+                for seed in SEEDS {
+                    check(seed, depth(), $case);
+                }
+            }
+        )*
+
+        const NAMED: [Case; [$($case,)*].len()] = [$($case,)*];
+    };
+}
+
+cases! {
+    many_widgets_redrawing_at_once_leaves_every_box_where_it_was = Case::RepaintSome,
+    everything_redrawing_at_once_leaves_every_box_where_it_was = Case::Repaint,
+    a_resize_lands_where_starting_at_that_size_would = Case::Resize,
+    a_resize_and_a_repaint_land_where_starting_that_way_would = Case::ResizeRepaint,
+    a_size_change_after_a_resize_lands_the_same_way = Case::ResizeSize,
+    a_resize_after_a_size_change_lands_the_same_way = Case::SizeResize,
+    a_size_change_lands_where_growing_it_that_way_would = Case::Size,
+    every_size_changing_at_once_lands_where_growing_it_that_way_would = Case::EverySize,
+    an_alignment_change_lands_where_growing_it_that_way_would = Case::Align,
+    giving_and_taking_a_movable_region_rebuilds_what_resolves_it = Case::RegionNode,
+    reordering_a_span_lands_where_growing_it_that_way_would = Case::Reorder,
+}
+
+/// The shuffles are one test between them, so they are the only cases `ALL`
+/// may hold without a test of their own.
+#[test]
+fn every_case_runs_without_the_long_scan() {
+    for case in ALL {
+        assert!(
+            NAMED.contains(&case) || matches!(case, Case::Shuffle(_)),
+            "{} runs only in the long seed scan; give it a case here",
+            case.name()
         );
     }
-    if let Some(w) = any.downcast_ref::<Stack>() {
-        return format!("Stack{{n:{}}}", w.children.len());
-    }
-    label
-}
-
-/// Every widget in one tree against the matching widget in the other. A
-/// mismatch prints the widget's ancestry, marking region nodes, since where
-/// two trees disagree is rarely where the cause is.
-fn assert_same(seed: u64, what: &str, warm: (&Harness, &Tree), cold: (&Harness, &Tree)) {
-    let ((wh, wt), (ch, ct)) = (warm, cold);
-    assert_eq!(wt.ids.len(), ct.ids.len(), "seed {seed}: different trees");
-    let mut drawn = 0;
-    let mut wrong = 0;
-    for (i, (&w, &c)) in wt.ids.iter().zip(&ct.ids).enumerate() {
-        let (got, want) = (wh.region(&w), ch.region(&c));
-        drawn += usize::from(got.is_some());
-        // This oracle cares where rasterization lands, not whether equivalent
-        // arithmetic produced the same f32. Keep the tolerance to one
-        // twentieth of a physical pixel, while whether a widget drew remains
-        // exact.
-        if same_region(got, want) {
-            continue;
-        }
-        wrong += 1;
-        if wrong <= 3 {
-            let mut chain = Vec::new();
-            let mut at = Some(w);
-            while let Some(id) = at {
-                let active = &wh.render.active[&id];
-                let node = match active.move_idx == active.parent_move {
-                    true => "",
-                    false => "*",
-                };
-                chain.push(format!("{}{node}", describe(id, wh)));
-                at = active.parent;
-            }
-            println!(
-                "seed {seed} after {what}: widget {i}\n  warm {got:?}\n  cold {want:?}\n  {}",
-                chain.join(" < ")
-            );
-        }
-    }
-    assert!(drawn > 0, "seed {seed}: nothing was drawn");
-    assert_eq!(wrong, 0, "seed {seed}: {wrong} widgets differ after {what}");
-}
-
-fn changed_size(seed: u64) {
-    let mut warm = Harness::new((900, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    // Not every tree grows a declared size to change.
-    if grown.sized.is_empty() {
-        return;
-    }
-
-    let mut rng = Rng::new(seed ^ 0x5eed);
-    let sizes = edit(&mut warm, &grown, &mut rng);
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let same = plant(
-        &mut cold,
-        seed,
-        &Edits {
-            sizes,
-            ..Default::default()
-        },
-    );
-    assert_same(seed, "a size change", (&warm, &grown), (&cold, &same));
-}
-
-/// Moves one widget to a different corner of the box it is given.
-fn realign_one(h: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> Aligns {
-    let mut side = || match rng.below(4) {
-        0 => None,
-        1 => Some(AxisAlign::NEG),
-        2 => Some(AxisAlign::CENTER),
-        _ => Some(AxisAlign::POS),
-    };
-    let aligns = [side(), side()];
-    for (axis, align) in [Axis::X, Axis::Y].into_iter().zip(aligns) {
-        h.rsc
-            .widgets_mut()
-            .set_alignment(tree.aligned[idx], axis, align.unwrap_or_default());
-    }
-    aligns
-}
-
-fn changed_alignment(seed: u64) {
-    let mut warm = Harness::new((900, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    if grown.aligned.is_empty() {
-        return;
-    }
-
-    let mut rng = Rng::new(seed ^ 0xa11);
-    let aligns = (0..grown.aligned.len())
-        .step_by(3)
-        .map(|idx| (idx, realign_one(&mut warm, &grown, idx, &mut rng)))
-        .collect();
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let same = plant(
-        &mut cold,
-        seed,
-        &Edits {
-            aligns,
-            ..Default::default()
-        },
-    );
-    assert_same(seed, "an alignment change", (&warm, &grown), (&cold, &same));
-}
-
-/// Giving a widget a movable region of its own, or taking it away, is a
-/// structural change: every primitive under it changes which chain resolves
-/// it. A cold tree built that way is what says the rebuild was complete.
-fn changed_region_node(seed: u64) {
-    let mut warm = Harness::new((900, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    if grown.nodes.is_empty() {
-        return;
-    }
-
-    let nodes: HashMap<usize, bool> = (0..grown.nodes.len())
-        .step_by(2)
-        .map(|idx| {
-            let id = grown.nodes[idx];
-            let was = warm.rsc.widgets().is_region_node(id);
-            warm.rsc.widgets_mut().set_region_node(id, !was);
-            (idx, !was)
-        })
-        .collect();
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let same = plant(
-        &mut cold,
-        seed,
-        &Edits {
-            nodes,
-            ..Default::default()
-        },
-    );
-    assert_same(
-        seed,
-        "a region-node change",
-        (&warm, &grown),
-        (&cold, &same),
-    );
-}
-
-fn reshuffled(seed: u64, shuffle: Shuffle) {
-    let mut warm = Harness::new((900, 1200));
-    let mut grown = plant(&mut warm, seed, &Edits::default());
-    // Some seeds grow nothing but wrappers, and a shuffle with no span to
-    // shuffle is not the same thing as one that had no effect. A span behind
-    // a branch nobody took is the same kind of nothing: it is not drawn, so
-    // shuffling it cannot move anything.
-    let shuffles = grown
-        .spans
-        .iter()
-        .step_by(3)
-        .any(|span| warm.region(&span.id.id()).is_some());
-    if !shuffles {
-        return;
-    }
-    let (spans, _held) = reshuffle(&mut warm, &mut grown, shuffle);
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let same = plant(
-        &mut cold,
-        seed,
-        &Edits {
-            spans,
-            ..Default::default()
-        },
-    );
-
-    let what = format!("{shuffle:?}");
-    assert_same(seed, &what, (&warm, &grown), (&cold, &same));
-}
-
-fn changed_every_size(seed: u64) {
-    let mut warm = Harness::new((900, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    if grown.sized.is_empty() {
-        return;
-    }
-
-    let mut rng = Rng::new(seed ^ 0xa11);
-    let sizes = edit_every(&mut warm, &grown, &mut rng);
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let same = plant(
-        &mut cold,
-        seed,
-        &Edits {
-            sizes,
-            ..Default::default()
-        },
-    );
-    assert_same(seed, "every size at once", (&warm, &grown), (&cold, &same));
-}
-
-/// Marks a spread of widgets for redraw at once. Nothing changes, so no box
-/// may either; what this exercises is the order a frame settles a dirty set
-/// in, which the other cases reach one dependency path at a time.
-fn repainted_together(seed: u64) {
-    let mut warm = Harness::new((900, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    for &id in grown.ids.iter().step_by(5) {
-        warm.rsc.widgets_mut().get_dyn_mut(id);
-    }
-    assert!(
-        !warm.rsc.widgets().needs_redraw.is_empty(),
-        "seed {seed}: nothing was marked"
-    );
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let same = plant(&mut cold, seed, &Edits::default());
-
-    let what = "many repaints at once";
-    assert_same(seed, what, (&warm, &grown), (&cold, &same));
-}
-
-fn resized(seed: u64) {
-    let mut warm = Harness::new((1920, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    warm.resize((640, 900));
-    warm.frame();
-
-    let mut cold = Harness::new((640, 900));
-    let same = plant(&mut cold, seed, &Edits::default());
-
-    assert_same(seed, "a resize", (&warm, &grown), (&cold, &same));
-}
-
-fn resized_then_changed(seed: u64) {
-    let mut warm = Harness::new((1920, 1200));
-    let grown = plant(&mut warm, seed, &Edits::default());
-    if grown.sized.is_empty() {
-        return;
-    }
-    warm.resize((640, 900));
-    warm.frame();
-
-    let mut rng = Rng::new(seed ^ 0xb0a7);
-    let sizes = edit(&mut warm, &grown, &mut rng);
-    warm.frame();
-
-    let mut cold = Harness::new((640, 900));
-    let same = plant(
-        &mut cold,
-        seed,
-        &Edits {
-            sizes,
-            ..Default::default()
-        },
-    );
-
-    let what = "a resize then a size change";
-    assert_same(seed, what, (&warm, &grown), (&cold, &same));
-}
-
-#[test]
-fn a_changed_size_lands_where_growing_it_that_way_would() {
-    SEEDS.into_iter().for_each(changed_size);
-}
-
-#[test]
-fn a_changed_alignment_lands_where_growing_it_that_way_would() {
-    SEEDS.into_iter().for_each(changed_alignment);
-}
-
-#[test]
-fn a_toggled_region_node_lands_where_growing_it_that_way_would() {
-    SEEDS.into_iter().for_each(changed_region_node);
-}
-
-#[test]
-fn every_size_changing_at_once_lands_where_growing_it_that_way_would() {
-    SEEDS.into_iter().for_each(changed_every_size);
-}
-
-#[test]
-fn many_widgets_redrawing_at_once_leaves_every_box_where_it_was() {
-    SEEDS.into_iter().for_each(repainted_together);
-}
-
-#[test]
-fn a_resize_lands_where_starting_at_that_size_would() {
-    SEEDS.into_iter().for_each(resized);
-}
-
-#[test]
-fn a_size_change_after_a_resize_lands_the_same_way() {
-    SEEDS.into_iter().for_each(resized_then_changed);
 }
 
 #[test]
 fn adding_and_removing_span_children_lands_where_growing_it_that_way_would() {
-    for shuffle in SHUFFLES {
-        for seed in SEEDS {
-            reshuffled(seed, shuffle);
+    for case in ALL {
+        if matches!(case, Case::Shuffle(_)) {
+            for seed in SEEDS {
+                check(seed, depth(), case);
+            }
         }
     }
 }
 
-/// The same property over a hundred seeds and every scenario. What it has
-/// found so far was never where the trees disagreed: a text measured in a box
-/// it was not going to get, and a widget re-measured in a box its own answer
-/// had decided. `tests/shrink.rs` is how a seed from here becomes a tree
-/// small enough to read.
 #[test]
-#[ignore = "a hundred seeds, rather than the nine the others check"]
+#[ignore = "as many seeds as it is asked for, rather than the ten the others check"]
 fn a_long_run_of_seeds_agrees() {
-    let seeds = std::env::var("IRIS_GENERATED_SEED")
+    let depth = depth();
+    let seeds: Vec<u64> = match std::env::var("IRIS_GENERATED_SEED")
         .ok()
-        .and_then(|seed| seed.parse().ok())
-        .map(|seed| seed..=seed)
-        .unwrap_or_else(|| 1..=env("IRIS_GENERATED_SEEDS", 100));
-    over_seeds(seeds.collect(), |seed| {
-        changed_size(seed);
-        changed_every_size(seed);
-        repainted_together(seed);
-        resized(seed);
-        resized_then_changed(seed);
-        for shuffle in SHUFFLES {
-            reshuffled(seed, shuffle);
-        }
-    });
-}
-
-/// Every seed on its own thread's share of them. A tree is grown, laid out
-/// and dropped inside one call, so seeds share nothing, and this is most of
-/// the time a run takes. A thread that fails takes the scope down with it,
-/// which is the same panic libtest would have seen.
-///
-/// One core short of all of them, so the machine this runs on stays usable.
-pub fn over_seeds(seeds: Vec<u64>, run: impl Fn(u64) + Sync) {
-    let threads =
-        std::thread::available_parallelism().map_or(1, |n| n.get().saturating_sub(1).max(1));
-    let chunk = seeds.len().div_ceil(threads).max(1);
-    std::thread::scope(|scope| {
-        for part in seeds.chunks(chunk) {
-            let run = &run;
-            scope.spawn(move || part.iter().for_each(|&seed| run(seed)));
+        .and_then(|v| v.parse().ok())
+    {
+        Some(seed) => vec![seed],
+        None => (1..=env("IRIS_GENERATED_SEEDS", 100_u64)).collect(),
+    };
+    over_seeds(seeds, |seed| {
+        let grown = plan(seed, depth, &Edits::default());
+        for case in ALL {
+            check_plan(&grown, seed, depth, case);
         }
     });
 }

tests/gpu/mod.rs

@@ -0,0 +1,40 @@
+//! The adapter and the surface configuration the GPU measurement rigs share,
+//! so the two cannot probe for a device in two different ways.
+
+use wgpu::*;
+
+/// An adapter on whatever this machine has, or `None` where there is none.
+///
+/// Probed rather than assumed: there may be no Vulkan adapter, and GL is what
+/// is left when there is not.
+///
+/// The instance is leaked deliberately. A Vulkan loader may unload the driver
+/// when the last one drops, which can fault as a thread that used it exits --
+/// and every test runs on a spawned thread.
+pub fn adapter() -> Option<Adapter> {
+    let all = Instance::new(InstanceDescriptor::new_without_display_handle());
+    let instance = match pollster::block_on(all.request_adapter(&RequestAdapterOptions::default()))
+    {
+        Ok(_) => all,
+        Err(_) => Instance::new(InstanceDescriptor {
+            backends: Backends::GL,
+            ..InstanceDescriptor::new_without_display_handle()
+        }),
+    };
+    let instance: &'static Instance = Box::leak(Box::new(instance));
+    pollster::block_on(instance.request_adapter(&RequestAdapterOptions::default())).ok()
+}
+
+pub fn config(format: TextureFormat, size: u32) -> SurfaceConfiguration {
+    SurfaceConfiguration {
+        usage: TextureUsages::RENDER_ATTACHMENT,
+        format,
+        color_space: SurfaceColorSpace::Auto,
+        width: size,
+        height: size,
+        present_mode: PresentMode::Fifo,
+        desired_maximum_frame_latency: 2,
+        alpha_mode: CompositeAlphaMode::Auto,
+        view_formats: vec![],
+    }
+}

tests/layout_diagnostics.rs

@@ -5,11 +5,11 @@
 //!     cargo test --release --features layout-diagnostics \
 //!       --test layout_diagnostics -- --ignored --nocapture
 //!
-//! Uninstrumented hardware totals for one phase:
+//! Build the uninstrumented test with `cargo test --release --test
+//! layout_diagnostics --no-run`, then run the emitted executable directly:
 //!
-//!     IRIS_PHASE=resize IRIS_FRAMES=1000 perf stat \
-//!       -e cycles:u,instructions:u cargo test --release \
-//!       --test layout_diagnostics -- --ignored --nocapture
+//!     IRIS_PHASE=resize IRIS_FRAMES=10000 perf stat -r 7 \
+//!       -e cycles:u,instructions:u /path/to/layout_diagnostics --ignored --nocapture
 //!
 //! `IRIS_PHASE` is `cold`, `repaint`, `many`, `size`, `scroll`, `resize`, or
 //! `all`. `IRIS_SEED`, `IRIS_DEPTH`, and `IRIS_FRAMES` select the load, and
@@ -22,6 +22,30 @@ use std::time::Instant;
 
 const OUTPUT: (f32, f32) = (1920.0, 1200.0);
 
+/// A scroll whose content fits is the same drawing in every box it still
+/// fits in, so a longer or shorter one relays out nothing. Where the content
+/// sits in that box is decided by placing its answer in the whole of it,
+/// which is a fraction of the box and holds at every length -- so the
+/// contract must not turn on the alignment. It did, and at the default
+/// alignment, which is the middle, every box change redrew the scroll.
+#[cfg(feature = "layout-diagnostics")]
+#[test]
+fn a_fitting_scroll_holds_for_every_box_its_content_fits_in() {
+    use iris::core::layout_diagnostics as diag;
+
+    for align in [Align::TOP_LEFT, Align::CENTER, Align::BOT_RIGHT] {
+        let mut harness = Harness::new((400, 200));
+        let inner = rect(Color::RED).height(50).add(&mut harness.rsc);
+        harness.set_root(inner.scrollable().align(align));
+        harness.frame();
+        let _ = diag::take();
+        // Still far longer than the 50 the content needs.
+        harness.resize((400, 180));
+        harness.frame();
+        assert_eq!(diag::take().distinct_widgets(), 0, "{align:?}");
+    }
+}
+
 #[cfg(feature = "layout-diagnostics")]
 #[test]
 fn a_selected_widget_retains_its_layout_events() {
@@ -37,8 +61,8 @@ fn a_selected_widget_retains_its_layout_events() {
     diagnostics::trace_widget(leaf.id());
     let _ = diagnostics::take();
 
-    let _ = harness.rsc.widgets_mut().get_dyn_mut(root.id());
-    let _ = harness.rsc.widgets_mut().get_dyn_mut(leaf.id());
+    harness.rsc.widgets_mut().mark_for_redraw(root.id());
+    harness.rsc.widgets_mut().mark_for_redraw(leaf.id());
     harness.frame();
 
     let report = diagnostics::take();
@@ -92,9 +116,18 @@ fn trace_selected(tree: &Tree) {
 #[cfg(not(feature = "layout-diagnostics"))]
 fn trace_selected(_: &Tree) {}
 
+/// The shape a cost is measured on must not depend on what layout measured,
+/// or two commits are compared on two different trees. See `Edits`.
+fn rig_edits() -> Edits {
+    Edits {
+        fixed_branches: true,
+        ..Default::default()
+    }
+}
+
 fn warm(seed: u64, depth: usize) -> (Harness, Tree) {
     let mut harness = Harness::new(OUTPUT);
-    let (root, tree) = grow(&mut harness.rsc, seed, depth, &Edits::default());
+    let (root, tree) = grow(&mut harness.rsc, seed, depth, &rig_edits());
     harness.state.root = Some(root);
     harness.frame();
     println!(
@@ -125,6 +158,9 @@ fn report(label: &str, mut elapsed: Vec<f64>, _harness: &Harness) {
     {
         let diagnostics = iris::core::layout_diagnostics::take();
         print!("{}", diagnostics.per_frame(frames));
+        for event in diagnostics.traces() {
+            println!("    {event:?}");
+        }
         for callsite in diagnostics.hot_text().iter().take(3) {
             let mut ancestry = Vec::new();
             let mut id = Some(callsite.id);
@@ -173,7 +209,7 @@ fn layout_cost() {
 
     if selected("cold") {
         let mut harness = Harness::new(OUTPUT);
-        let (root, tree) = grow(&mut harness.rsc, seed, depth, &Edits::default());
+        let (root, tree) = grow(&mut harness.rsc, seed, depth, &rig_edits());
         harness.state.root = Some(root);
         println!(
             "fixture: seed {seed}, depth {depth}, {} widgets",
@@ -183,7 +219,6 @@ fn layout_cost() {
         #[cfg(feature = "layout-diagnostics")]
         let _ = iris::core::layout_diagnostics::take();
         run("cold", 1, &mut harness, |_, _| {});
-        drop(tree);
     }
 
     if selected("repaint") {
@@ -191,7 +226,7 @@ fn layout_cost() {
         trace_selected(&tree);
         let leaf = tree.ids[0];
         run("repaint", frames, &mut harness, move |harness, _| {
-            let _ = harness.rsc.widgets_mut().get_dyn_mut(leaf);
+            harness.rsc.widgets_mut().mark_for_redraw(leaf);
         });
     }
 
@@ -206,7 +241,7 @@ fn layout_cost() {
         println!("marking {} of {} widgets", dirty.len(), tree.ids.len());
         run("many", frames, &mut harness, move |harness, _| {
             for &id in &dirty {
-                harness.rsc.widgets_mut().get_dyn_mut(id);
+                harness.rsc.widgets_mut().mark_for_redraw(id);
             }
         });
     }
@@ -239,6 +274,5 @@ fn layout_cost() {
         run("resize", frames, &mut harness, |harness, frame| {
             harness.resize((OUTPUT.0 - ((frame + 1) % 2) as f32 * 8.0, OUTPUT.1));
         });
-        drop(tree);
     }
 }

tests/layout_dump.rs

@@ -0,0 +1,42 @@
+//! Prints where a cold layout puts every widget of many grown trees, so two
+//! commits can be compared on cold layout alone. The warm/cold oracle cannot
+//! see a change that moves cold layout, since both of its sides move; this
+//! can, by diffing its output across the change:
+//!
+//!     IRIS_DUMP_SEEDS=400 IRIS_DUMP_DEPTH=5 cargo test --release \
+//!       --test layout_dump -- --ignored --nocapture > /tmp/before.txt
+//!
+//! then the same after, and `diff` the two. A line is one widget: the seed,
+//! its index in creation order, and its box in window pixels, or `-` where
+//! it is not drawn.
+
+use iris::harness::Harness;
+use iris::random::{Edits, grow};
+
+fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
+    std::env::var(name)
+        .ok()
+        .and_then(|value| value.parse().ok())
+        .unwrap_or(fallback)
+}
+
+#[test]
+#[ignore = "a dump to diff across commits, not a check"]
+fn every_cold_layout_is_printed() {
+    let seeds = env("IRIS_DUMP_SEEDS", 400_u64);
+    let depth = env("IRIS_DUMP_DEPTH", 5_usize);
+    let mut out = String::new();
+    for seed in 1..=seeds {
+        let mut harness = Harness::new((1920.0, 1200.0));
+        let (root, tree) = grow(&mut harness.rsc, seed, depth, &Edits::default());
+        harness.state.root = Some(root);
+        harness.frame();
+        for (index, id) in tree.ids.iter().enumerate() {
+            match harness.region(id) {
+                Some(region) => out.push_str(&format!("{seed} {index} {region:?}\n")),
+                None => out.push_str(&format!("{seed} {index} -\n")),
+            }
+        }
+    }
+    print!("{out}");
+}

tests/revision_cost.rs

@@ -194,7 +194,9 @@ fn text_memory() {
         h.frame();
     }
     report("after 40 resizes");
-    // Settled: the output holds still and one leaf repaints per frame.
+    // Settled: the output holds still and one leaf repaints per frame. Marked
+    // by taking it mutably because the revision at the top of this file has no
+    // `mark_for_redraw`, and the same source has to build against both.
     for _ in 0..10 {
         let _ = h.rsc.widgets_mut().get_dyn_mut(paragraphs[0]);
         h.frame();

tests/scenario/mod.rs

@@ -0,0 +1,514 @@
+//! The scenarios both fuzzers run, over the tree a [`Plan`] describes.
+//!
+//! One implementation rather than two. The oracle grew its trees from a seed
+//! and the shrinker grew its own, with every scenario written out on each
+//! side, so a failure the oracle found could not be handed to the shrinker:
+//! there was no tree to pass it, only a seed, and a seed cannot be made
+//! smaller. Both take a plan now, so whatever finds a counterexample can also
+//! reduce it.
+//!
+//! Each target compiles this for itself, so what only one of them calls is
+//! dead code in the other.
+#![allow(dead_code)]
+
+use iris::harness::Harness;
+use iris::prelude::*;
+use iris::random::{Edits, Kind, Plan, Rng, SpanEdit, Tree, build};
+use std::collections::HashMap;
+
+/// A seed per thread but one, since a seed grows, lays out and drops its tree
+/// alone. A failing seed still shrinks and panics on its own thread.
+pub fn over_seeds(seeds: Vec<u64>, run: impl Fn(u64) + Sync) {
+    let threads =
+        std::thread::available_parallelism().map_or(1, |n| n.get().saturating_sub(1).max(1));
+    let chunk = seeds.len().div_ceil(threads).max(1);
+    std::thread::scope(|scope| {
+        for part in seeds.chunks(chunk) {
+            let run = &run;
+            scope.spawn(move || part.iter().for_each(|&seed| run(seed)));
+        }
+    });
+}
+
+pub fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
+    std::env::var(name)
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(fallback)
+}
+
+/// The window a tree is grown in, and the one a resize takes it to.
+const OUTER: (f32, f32) = (1920.0, 1200.0);
+const INNER: (f32, f32) = (640.0, 900.0);
+const STILL: (f32, f32) = (900.0, 1200.0);
+
+/// A way of changing what a span holds. Each is a shape worth its own case:
+/// taking a child out of the middle is not the same as emptying a span, and
+/// adding one is not the same as adding three.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Shuffle {
+    /// Every other child, so what is left is interleaved with what went.
+    EveryOther,
+    /// Everything but the first, which is the last step before empty.
+    AllButFirst,
+    /// Three more on the end at once.
+    AddThree,
+    /// The first out and three more on, so the count moves both ways.
+    SwapForThree,
+    /// One out of the middle and one on the end.
+    TradeOne,
+}
+
+impl Shuffle {
+    fn of(self, grown: usize) -> SpanEdit {
+        let all = |step: usize, from: usize| (from..grown).step_by(step).collect();
+        match self {
+            Self::EveryOther => SpanEdit {
+                detach: all(2, 0),
+                attach: 0,
+            },
+            Self::AllButFirst => SpanEdit {
+                detach: all(1, 1),
+                attach: 0,
+            },
+            Self::AddThree => SpanEdit {
+                detach: Vec::new(),
+                attach: 3,
+            },
+            Self::SwapForThree => SpanEdit {
+                detach: vec![0],
+                attach: 3,
+            },
+            Self::TradeOne => SpanEdit {
+                detach: vec![grown / 2],
+                attach: 1,
+            },
+        }
+    }
+}
+
+/// What a warm tree is put through before it is compared with a cold one
+/// grown the way it was left.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Case {
+    /// Nothing changes, so no box may either. What this exercises is the
+    /// order a frame settles a dirty set in.
+    Repaint,
+    /// Every fifth widget rather than all of them: marking all of them
+    /// redraws the whole tree, which is a cold start reached the long way,
+    /// where the mixed case leaves a redrawn subtree beside a retained one.
+    RepaintSome,
+    Resize,
+    ResizeRepaint,
+    /// A resize and then a size change, so a retained answer is asked to
+    /// survive two different kinds of invalidation in a row.
+    ResizeSize,
+    /// A size change and then a resize, which is the other order and not the
+    /// same test: a length answered as a fraction of one box and kept as a
+    /// fraction of another agrees at the size it was changed at and parts
+    /// from it at every other one.
+    SizeResize,
+    /// A few declared sizes.
+    Size,
+    /// Every declared size at once, so every reader of a size has a changed
+    /// descendant in the same frame and the whole dirty set settles together.
+    EverySize,
+    Align,
+    /// Giving a widget a movable region of its own, or taking it away, is a
+    /// structural change: every primitive under it changes which chain
+    /// resolves it.
+    RegionNode,
+    /// The same children in a different order, which moves every one of them
+    /// without changing what any of them is.
+    Reorder,
+    Shuffle(Shuffle),
+}
+
+pub const ALL: [Case; 16] = [
+    Case::Repaint,
+    Case::RepaintSome,
+    Case::Resize,
+    Case::ResizeRepaint,
+    Case::ResizeSize,
+    Case::SizeResize,
+    Case::Size,
+    Case::EverySize,
+    Case::Align,
+    Case::RegionNode,
+    Case::Reorder,
+    Case::Shuffle(Shuffle::EveryOther),
+    Case::Shuffle(Shuffle::AllButFirst),
+    Case::Shuffle(Shuffle::AddThree),
+    Case::Shuffle(Shuffle::SwapForThree),
+    Case::Shuffle(Shuffle::TradeOne),
+];
+
+impl Case {
+    /// The name `CASE` selects it by, and the one a failure prints.
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Repaint => "repaint",
+            Self::RepaintSome => "repaint-some",
+            Self::Resize => "resize",
+            Self::ResizeRepaint => "resize-repaint",
+            Self::ResizeSize => "resize-size",
+            Self::SizeResize => "size-resize",
+            Self::Size => "size",
+            Self::EverySize => "every-size",
+            Self::Align => "align",
+            Self::RegionNode => "region-node",
+            Self::Reorder => "reorder",
+            Self::Shuffle(Shuffle::EveryOther) => "shuffle-every-other",
+            Self::Shuffle(Shuffle::AllButFirst) => "shuffle-all-but-first",
+            Self::Shuffle(Shuffle::AddThree) => "shuffle-add-three",
+            Self::Shuffle(Shuffle::SwapForThree) => "shuffle-swap-for-three",
+            Self::Shuffle(Shuffle::TradeOne) => "shuffle-trade-one",
+        }
+    }
+
+    pub fn named(name: &str) -> Option<Self> {
+        ALL.into_iter().find(|case| case.name() == name)
+    }
+
+    /// Grown in the first, compared in the second.
+    fn window(self) -> ((f32, f32), (f32, f32)) {
+        match self {
+            Self::Resize | Self::ResizeRepaint | Self::ResizeSize => (OUTER, INNER),
+            _ => (STILL, STILL),
+        }
+    }
+
+    /// The window the warm tree is taken to after the change, where the case
+    /// is about what the change left behind rather than about the change.
+    fn then_resize(self) -> Option<(f32, f32)> {
+        match self {
+            Self::SizeResize => Some(INNER),
+            _ => None,
+        }
+    }
+}
+
+fn mark(warm: &mut Harness, tree: &Tree, step: usize) {
+    for &id in tree.ids.iter().step_by(step) {
+        warm.rsc.widgets_mut().mark_for_redraw(id);
+    }
+}
+
+/// A length in pixels, or a cap over one: a rule that reads the box it is
+/// given is the one a resize can change the effect of without changing the
+/// rule, so a tree that never grows one leaves that unexercised.
+fn a_rule(rng: &mut Rng) -> SizeRule {
+    let len = Len::px(20.0 + rng.below(180) as f32);
+    match rng.below(4) {
+        0 => SizeRule::Max(len),
+        1 => SizeRule::Min(len),
+        _ => LayoutLen::from(len).into(),
+    }
+}
+
+fn resize_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> SizeRules {
+    let lens = SizeRules {
+        x: a_rule(rng),
+        y: a_rule(rng),
+    };
+    warm.rsc
+        .widgets_mut()
+        .set_size_rules(tree.sized[idx], lens.x, lens.y);
+    lens
+}
+
+fn realign_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> Align {
+    let side = |rng: &mut Rng| match rng.below(4) {
+        0 => None,
+        1 => Some(AxisAlign::NEG),
+        2 => Some(AxisAlign::CENTER),
+        _ => Some(AxisAlign::POS),
+    };
+    let align = Align {
+        x: side(rng),
+        y: side(rng),
+    };
+    let id = tree.aligned[idx];
+    let taken = RegionAlign::from(align);
+    for axis in Axis::BOTH {
+        warm.rsc.widgets_mut().set_alignment(id, axis, taken[axis]);
+    }
+    align
+}
+
+/// Every span's children in a different order, said both to the warm tree and
+/// to the plan the cold one is grown from.
+fn reorder(warm: &mut Harness, tree: &Tree, plan: &Plan) -> Plan {
+    for span in &tree.spans {
+        let children = &mut warm.rsc[span.id].children;
+        if !children.is_empty() {
+            children.rotate_left(1);
+        }
+    }
+    let mut out = plan.clone();
+    out.walk_mut(&mut |node| {
+        if let Kind::Span { order, .. } = &mut node.kind
+            && !order.is_empty()
+        {
+            order.rotate_left(1);
+        }
+    });
+    out
+}
+
+/// Applies `shuffle` to every third span. What it takes out is given back to
+/// the span's spares: the last share of a widget must outlive the comparison,
+/// or its id is handed to something else and the two trees stop lining up.
+fn reshuffle(warm: &mut Harness, tree: &mut Tree, shuffle: Shuffle) -> HashMap<usize, SpanEdit> {
+    let mut edits = HashMap::new();
+    for (idx, span) in tree.spans.iter_mut().enumerate().step_by(3) {
+        let edit = shuffle.of(span.grown);
+        let mut take = edit.detach.clone();
+        take.sort_unstable();
+        let children = &mut warm.rsc[span.id].children;
+        // Highest first, so an index means the same child however many of its
+        // neighbours are going too.
+        for j in take.into_iter().rev() {
+            if j < children.len() {
+                span.spares.push(children.remove(j));
+            }
+        }
+        let attach = edit.attach.min(span.spares.len());
+        let moved: Vec<_> = span.spares.drain(..attach).collect();
+        warm.rsc[span.id].children.extend(moved);
+        edits.insert(idx, edit);
+    }
+    edits
+}
+
+/// Changes the warm tree and answers with the plan a cold tree grown that way
+/// comes from. Each arm settles its own frame, so a case that changes nothing
+/// does not get a second one that could settle what the first left.
+fn change(case: Case, warm: &mut Harness, tree: &mut Tree, plan: &Plan, rng: &mut Rng) -> Plan {
+    let some_sizes = |warm: &mut Harness, tree: &Tree, rng: &mut Rng| {
+        let mut sizes = HashMap::new();
+        for _ in 0..4 {
+            if tree.sized.is_empty() {
+                break;
+            }
+            let idx = rng.below(tree.sized.len());
+            sizes.insert(idx, resize_one(warm, tree, idx, rng));
+        }
+        sizes
+    };
+    let edits = match case {
+        Case::Resize => return plan.clone(),
+        Case::Repaint | Case::ResizeRepaint => {
+            mark(warm, tree, 1);
+            warm.frame();
+            return plan.clone();
+        }
+        Case::RepaintSome => {
+            mark(warm, tree, 5);
+            warm.frame();
+            return plan.clone();
+        }
+        Case::Reorder => {
+            let out = reorder(warm, tree, plan);
+            warm.frame();
+            return out;
+        }
+        Case::Size | Case::ResizeSize | Case::SizeResize => Edits {
+            sizes: some_sizes(warm, tree, rng),
+            ..Default::default()
+        },
+        Case::EverySize => Edits {
+            sizes: (0..tree.sized.len())
+                .map(|idx| (idx, resize_one(warm, tree, idx, rng)))
+                .collect(),
+            ..Default::default()
+        },
+        Case::Align => Edits {
+            aligns: (0..tree.aligned.len())
+                .step_by(3)
+                .map(|idx| (idx, realign_one(warm, tree, idx, rng)))
+                .collect(),
+            ..Default::default()
+        },
+        Case::RegionNode => {
+            let mut nodes = HashMap::new();
+            for idx in (0..tree.nodes.len()).step_by(2) {
+                let id = tree.nodes[idx];
+                let take = !warm.rsc.widgets().is_region_node(id);
+                warm.rsc.widgets_mut().set_region_node(id, take);
+                nodes.insert(idx, take);
+            }
+            Edits {
+                nodes,
+                ..Default::default()
+            }
+        }
+        Case::Shuffle(shuffle) => Edits {
+            spans: reshuffle(warm, tree, shuffle),
+            ..Default::default()
+        },
+    };
+    warm.frame();
+    plan.edited(&edits)
+}
+
+/// What a widget was configured with, so a tree a fuzzer found can be written
+/// out by hand. A failure is a lead; the fast test that replaces it has to be
+/// buildable from what the failure printed.
+fn describe(id: WidgetId, h: &Harness) -> String {
+    let rules = h.rsc.widgets().size_rules(id);
+    // A bound prints as itself: a failure is reproduced from what it printed,
+    // and a rule shown as "no rule" cannot be written out again.
+    let rule = |r: SizeRule| match r {
+        SizeRule::Free => "-".into(),
+        SizeRule::Exact(len) => format!("{len}"),
+        SizeRule::Min(min) => format!(">{}", LayoutLen::from(min)),
+        SizeRule::Max(max) => format!("<{}", LayoutLen::from(max)),
+        SizeRule::Clamp { min, max } => {
+            format!(">{}<{}", LayoutLen::from(min), LayoutLen::from(max))
+        }
+    };
+    let align = h.rsc.widgets().alignment(id);
+    let side = |a: AxisAlign| {
+        if a == AxisAlign::NEG {
+            "neg".into()
+        } else if a == AxisAlign::CENTER {
+            "mid".into()
+        } else if a == AxisAlign::POS {
+            "pos".into()
+        } else {
+            format!("{:.2}", a.rel())
+        }
+    };
+    // A rule and an alignment are properties of whatever carries them, so
+    // they print with that widget rather than as widgets of their own.
+    let mut out = describe_widget(id, h);
+    if (rules.x, rules.y) != (SizeRule::Free, SizeRule::Free) {
+        out += &format!("[x:{},y:{}]", rule(rules.x), rule(rules.y));
+    }
+    if align != RegionAlign::default() {
+        out += &format!("@{},{}", side(align.x), side(align.y));
+    }
+    out
+}
+
+fn describe_widget(id: WidgetId, h: &Harness) -> String {
+    let label = h.rsc.widgets().label(id).to_string();
+    let Some(widget) = h.rsc.widgets().get_dyn(id) else {
+        return label;
+    };
+    let any: &dyn std::any::Any = widget;
+    if let Some(w) = any.downcast_ref::<Span>() {
+        let sign = if w.dir.sign == Sign::Neg { "-" } else { "+" };
+        return format!(
+            "Span{{dir:{:?}{sign},gap:{},n:{}}}",
+            w.dir.axis,
+            w.gap,
+            w.children.len()
+        );
+    }
+    if let Some(w) = any.downcast_ref::<Pad>() {
+        let p = &w.padding;
+        return format!(
+            "Pad{{l:{},r:{},t:{},b:{}}}",
+            p.left, p.right, p.top, p.bottom
+        );
+    }
+    if let Some(w) = any.downcast_ref::<Stack>() {
+        return format!("Stack{{n:{}}}", w.children.len());
+    }
+    label
+}
+
+/// One widget's layout as it stands: the frame its fractions resolved
+/// against, the box it was asked in, the box its drawing went in, and what
+/// it reported. In window units, which is what both trees are in.
+fn record(id: WidgetId, h: &Harness) -> String {
+    let active = &h.render.active[&id];
+    format!(
+        "rel_base {} region {} placement {} size {}",
+        active.rel_base, active.region, active.placement, active.size,
+    )
+}
+
+/// Runs `case` on the tree `plan` describes, warm and cold, and says where
+/// the two disagree. `seed` chooses only the values a case picks at random,
+/// so one plan under one case is one comparison however it was reached.
+pub fn diverges(plan: &Plan, case: Case, seed: u64) -> Option<String> {
+    let (start, end) = case.window();
+    let mut warm = Harness::new(start);
+    let (root, mut tree) = build(&mut warm.rsc, plan);
+    warm.state.root = Some(root);
+    // The frame that makes it warm: without it nothing is retained and the
+    // comparison is two cold starts agreeing with each other.
+    warm.frame();
+    if start != end {
+        warm.resize(end);
+        warm.frame();
+    }
+    let cold_plan = change(case, &mut warm, &mut tree, plan, &mut Rng::new(seed));
+    // Whatever the change left, seen at another window: an answer kept as a
+    // fraction of the wrong length is the same number of pixels where it was
+    // made and a different one everywhere else.
+    let end = match case.then_resize() {
+        Some(after) => {
+            warm.resize(after);
+            warm.frame();
+            after
+        }
+        None => end,
+    };
+
+    let mut cold = Harness::new(end);
+    let (root, cold_tree) = build(&mut cold.rsc, &cold_plan);
+    cold.state.root = Some(root);
+    cold.frame();
+
+    let mut drawn = 0;
+    for (i, (&w, &c)) in tree.ids.iter().zip(&cold_tree.ids).enumerate() {
+        let (got, want) = (warm.region(&w), cold.region(&c));
+        drawn += got.is_some() as usize;
+        if got == want {
+            continue;
+        }
+        let places: HashMap<WidgetId, usize> = tree
+            .ids
+            .iter()
+            .enumerate()
+            .map(|(i, &id)| (id, i))
+            .collect();
+        // Where two trees disagree is rarely where the cause is, so the
+        // ancestry comes with it, marking the widgets that own a region.
+        let mut chain = Vec::new();
+        let mut records = Vec::new();
+        let mut at = Some(w);
+        while let Some(id) = at {
+            let active = &warm.render.active[&id];
+            let node = match active.move_idx == active.parent_move {
+                true => "",
+                false => "*",
+            };
+            chain.push(format!("{}{node}", describe(id, &warm)));
+            // What each level was asked in on both sides, since the level
+            // where the two stop agreeing is the one to look at rather than
+            // the leaf that reported the difference.
+            let cold_id = places.get(&id).and_then(|&i| cold_tree.ids.get(i));
+            records.push(format!(
+                "    {}\n      warm {}\n      cold {}",
+                describe(id, &warm),
+                record(id, &warm),
+                cold_id.map_or("-".into(), |&id| record(id, &cold)),
+            ));
+            at = active.parent;
+        }
+        return Some(format!(
+            "widget {i}\n  warm {got:?}\n  cold {want:?}\n  {}\n{}",
+            chain.join(" < "),
+            records.join("\n"),
+        ));
+    }
+    match drawn {
+        0 => Some("nothing was drawn".into()),
+        _ => None,
+    }
+}

tests/shrink.rs

@@ -1,556 +1,38 @@
-//! A property test that shrinks its own counterexample.
+//! A fuzzer that reduces its own counterexample.
 //!
-//! `generated.rs` reproduces a failure from a seed, but a seed is not a lead
-//! anybody can read: the tree is hundreds of widgets, and reconstructing the
-//! part that matters by hand has failed every time it has been tried. This
-//! grows trees it can take apart, so a failure is reduced to the smallest
-//! tree that still shows it and printed as something to write a fast test
-//! from.
+//! A seed is not a lead anybody can read: the tree is hundreds of widgets,
+//! and reconstructing the part that matters by hand has failed every time it
+//! has been tried. This grows the trees `iris::random` describes, takes them
+//! apart, and prints the smallest one that still fails as something to write
+//! a fast test from.
 //!
 //!     cargo test --release --test shrink -- --ignored --nocapture
 //!
 //! `SHRINK_SEEDS` how many trees to try, `SHRINK_DEPTH` how deep to grow
-//! them, `SHRINK_CASE` which scenario. It is a fuzzer: run it once the
-//! ordinary tests pass, and turn what it finds into a test of its own rather
-//! than leaving a seed as the record.
+//! them, `SHRINK_CASE` which scenario or `all` for every one. `SHRINK_SEED`
+//! takes a single seed, which is how a failure `generated` printed is handed
+//! straight here: the two run the same cases over the same trees, so a seed
+//! that fails there fails here and is reduced.
+//!
+//! It is a fuzzer: run it once the ordinary tests pass, and turn what it
+//! finds into a test of its own rather than leaving a seed as the record.
 
-use iris::harness::Harness;
-use iris::prelude::*;
-use iris::random::{Branch, Rng};
+#[path = "scenario/mod.rs"]
+mod scenario;
 
-/// The same two leaves `iris::random` grows, since only one of them reads the
-/// width it is given and that is the difference that matters.
-const WORDS: &[&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.",
-];
+use iris::random::{Edits, Plan, plan};
+use scenario::{ALL, Case, diverges, env, over_seeds};
 
-const ONE_LINE: &str = "one line, overflowing whatever it is given";
-
-const OUTER: (f32, f32) = (1920.0, 1200.0);
-/// Steps of the grid two ways of reaching a box may differ by: one per level
-/// of nesting between them, and these trees are five deep. See
-/// `docs/HANDOFF.md`'s "Fixed point" in `ai-app-2` for what is left.
-const AGREE_STEPS: i32 = 2;
-const INNER: (f32, f32) = (640.0, 900.0);
-
-#[derive(Clone, Debug, PartialEq)]
-enum Node {
-    /// Words taken from [`WORDS`], and whether it wraps.
-    Text(usize, bool),
-    /// The leaf that overflows whatever box it is given rather than wrapping.
-    OneLine,
-    Rect,
-    /// Direction, gap, children in creation order, and the order they are
-    /// attached in -- separate so a tree that reorders its children
-    /// still makes the same widgets in the same order, and two
-    /// builds line up index for index.
-    Span(bool, f32, Vec<Node>, Vec<usize>),
-    Stack(Vec<Node>),
-    Pad(f32, Box<Node>),
-    Aligned(u8, u8, Box<Node>),
-    Sized(Option<LayoutLen>, Option<LayoutLen>, Box<Node>),
-    Scroll(bool, Box<Node>),
-    Branch(Box<Node>, Box<Node>, Box<Node>, f32),
-}
-
-fn axis_align(v: u8) -> Option<AxisAlign> {
-    match v % 4 {
-        0 => None,
-        1 => Some(AxisAlign::NEG),
-        2 => Some(AxisAlign::CENTER),
-        _ => Some(AxisAlign::POS),
-    }
-}
-
-fn dir(down: bool) -> Dir {
-    if down { Dir::DOWN } else { Dir::RIGHT }
-}
-
-impl Node {
-    /// Builds into `h`, pushing every id in tree order, so two builds of one
-    /// node line up index for index and their boxes can be compared.
-    fn build(
-        &self,
-        h: &mut Harness,
-        out: &mut Vec<WidgetId>,
-        spans: &mut Vec<WeakWidget<Span>>,
-        sized: &mut Vec<WidgetId>,
-    ) -> StrongWidget {
-        let id: StrongWidget = match self {
-            Node::Text(words, wrap) => {
-                let n = (*words).clamp(1, WORDS.len());
-                wtext(WORDS[..n].join(" "))
-                    .size(16)
-                    .wrap(*wrap)
-                    .add_strong(&mut h.rsc)
-            }
-            Node::OneLine => wtext(ONE_LINE).size(16).wrap(false).add_strong(&mut h.rsc),
-            Node::Rect => rect(Color::RED).add_strong(&mut h.rsc),
-            Node::Span(down, gap, kids, order) => {
-                let mut built: Vec<_> = kids
-                    .iter()
-                    .map(|k| Some(k.build(h, out, spans, sized)))
-                    .collect();
-                // `order` is a permutation, so each is taken exactly once.
-                let children = order
-                    .iter()
-                    .map(|&i| built[i].take().expect("order repeats an index"))
-                    .collect();
-                let handle = Span {
-                    children,
-                    dir: dir(*down),
-                    gap: Px::from_f32(*gap),
-                }
-                .add(&mut h.rsc);
-                // A row takes the height it is given; a column is as wide
-                // as its widest child, which needs no rule.
-                if !*down {
-                    h.rsc
-                        .widgets_mut()
-                        .set_size_rules(handle, None, Some(LayoutLen::rel(1.0)));
-                }
-                spans.push(handle);
-                handle.add_strong(&mut h.rsc)
-            }
-            Node::Stack(kids) => {
-                let children = kids.iter().map(|k| k.build(h, out, spans, sized)).collect();
-                Stack {
-                    children,
-                    size: StackSize::Child(0),
-                }
-                .add_strong(&mut h.rsc)
-            }
-            Node::Pad(p, kid) => {
-                let inner = kid.build(h, out, spans, sized);
-                Pad {
-                    padding: Padding::uniform(*p),
-                    inner,
-                }
-                .add_strong(&mut h.rsc)
-            }
-            Node::Aligned(x, y, kid) => {
-                let inner = kid.build(h, out, spans, sized);
-                for (axis, align) in [(Axis::X, axis_align(*x)), (Axis::Y, axis_align(*y))] {
-                    if let Some(align) = align {
-                        h.rsc.widgets_mut().set_alignment(&inner, axis, align);
-                    }
-                }
-                inner
-            }
-            Node::Sized(x, y, kid) => {
-                let inner = kid.build(h, out, spans, sized);
-                h.rsc.widgets_mut().set_size_rules(&inner, *x, *y);
-                sized.push(inner.id());
-                inner
-            }
-            Node::Scroll(down, kid) => {
-                let inner = kid.build(h, out, spans, sized);
-                let axis = if *down { Axis::Y } else { Axis::X };
-                Scroll::new(inner, axis).add_strong(&mut h.rsc)
-            }
-            Node::Branch(probe, a, b, at) => {
-                let probe = probe.build(h, out, spans, sized);
-                let wide = a.build(h, out, spans, sized);
-                let narrow = b.build(h, out, spans, sized);
-                Branch {
-                    probe,
-                    wide,
-                    narrow,
-                    threshold: *at,
-                }
-                .add_strong(&mut h.rsc)
-            }
-        };
-        out.push(id.id());
-        id
-    }
-
-    /// The lengths every `Sized` node would carry after `resized`, in the
-    /// order `build` pushes them.
-    fn sized_lens(&self, out: &mut Vec<(Option<LayoutLen>, Option<LayoutLen>)>) {
-        match self {
-            Node::Text(..) | Node::OneLine | Node::Rect => {}
-            Node::Span(_, _, kids, _) | Node::Stack(kids) => {
-                kids.iter().for_each(|k| k.sized_lens(out));
-            }
-            Node::Pad(_, k) | Node::Aligned(_, _, k) | Node::Scroll(_, k) => k.sized_lens(out),
-            Node::Sized(x, y, k) => {
-                k.sized_lens(out);
-                out.push((resized_len(*x), resized_len(*y)));
-            }
-            Node::Branch(p, a, b, _) => {
-                p.sized_lens(out);
-                a.sized_lens(out);
-                b.sized_lens(out);
-            }
-        }
-    }
-
-    fn size(&self) -> usize {
-        1 + match self {
-            Node::Text(..) | Node::OneLine | Node::Rect => 0,
-            Node::Span(_, _, kids, _) | Node::Stack(kids) => kids.iter().map(Node::size).sum(),
-            Node::Pad(_, k)
-            | Node::Aligned(_, _, k)
-            | Node::Sized(_, _, k)
-            | Node::Scroll(_, k) => k.size(),
-            Node::Branch(p, a, b, _) => p.size() + a.size() + b.size(),
-        }
-    }
-
-    /// Every one-step simplification: a wrapper replaced by what it wrapped, a
-    /// child dropped, a length or a word count reduced. Ordered cheapest-first
-    /// so the greedy walk takes the biggest bites early.
-    fn smaller(&self) -> Vec<Node> {
-        let mut out = Vec::new();
-        let leaf = Node::Rect;
-        match self {
-            Node::Text(words, wrap) => {
-                if *words > 1 {
-                    out.push(Node::Text(words / 2, *wrap));
-                    out.push(Node::Text(words - 1, *wrap));
-                }
-                if *wrap {
-                    out.push(Node::Text(*words, false));
-                }
-                out.push(leaf);
-            }
-            Node::OneLine => out.push(Node::Rect),
-            Node::Rect => {}
-            Node::Span(down, gap, kids, order) => {
-                out.extend(order.iter().map(|&i| kids[i].clone()));
-                for i in 0..kids.len() {
-                    if kids.len() > 1 {
-                        let mut less = kids.clone();
-                        less.remove(i);
-                        let order = (0..less.len()).collect();
-                        out.push(Node::Span(*down, *gap, less, order));
-                    }
-                }
-                if *gap != 0.0 {
-                    out.push(Node::Span(*down, 0.0, kids.clone(), order.clone()));
-                }
-                for (i, kid) in kids.iter().enumerate() {
-                    for small in kid.smaller() {
-                        let mut next = kids.clone();
-                        next[i] = small;
-                        out.push(Node::Span(*down, *gap, next, order.clone()));
-                    }
-                }
-            }
-            Node::Stack(kids) => {
-                out.extend(kids.iter().cloned());
-                for i in 0..kids.len() {
-                    if kids.len() > 1 {
-                        let mut less = kids.clone();
-                        less.remove(i);
-                        out.push(Node::Stack(less));
-                    }
-                }
-                for (i, kid) in kids.iter().enumerate() {
-                    for small in kid.smaller() {
-                        let mut next = kids.clone();
-                        next[i] = small;
-                        out.push(Node::Stack(next));
-                    }
-                }
-            }
-            Node::Pad(p, kid) => {
-                out.push((**kid).clone());
-                if *p != 0.0 {
-                    out.push(Node::Pad(0.0, kid.clone()));
-                }
-                out.extend(
-                    kid.smaller()
-                        .into_iter()
-                        .map(|k| Node::Pad(*p, Box::new(k))),
-                );
-            }
-            Node::Aligned(x, y, kid) => {
-                out.push((**kid).clone());
-                for (nx, ny) in [(0, *y), (*x, 0)] {
-                    if (nx, ny) != (*x, *y) {
-                        out.push(Node::Aligned(nx, ny, kid.clone()));
-                    }
-                }
-                out.extend(
-                    kid.smaller()
-                        .into_iter()
-                        .map(|k| Node::Aligned(*x, *y, Box::new(k))),
-                );
-            }
-            Node::Sized(x, y, kid) => {
-                out.push((**kid).clone());
-                if x.is_some() {
-                    out.push(Node::Sized(None, *y, kid.clone()));
-                }
-                if y.is_some() {
-                    out.push(Node::Sized(*x, None, kid.clone()));
-                }
-                out.extend(
-                    kid.smaller()
-                        .into_iter()
-                        .map(|k| Node::Sized(*x, *y, Box::new(k))),
-                );
-            }
-            Node::Scroll(down, kid) => {
-                out.push((**kid).clone());
-                out.extend(
-                    kid.smaller()
-                        .into_iter()
-                        .map(|k| Node::Scroll(*down, Box::new(k))),
-                );
-            }
-            Node::Branch(p, a, b, at) => {
-                out.push((**p).clone());
-                out.push((**a).clone());
-                out.push((**b).clone());
-                for small in p.smaller() {
-                    out.push(Node::Branch(Box::new(small), a.clone(), b.clone(), *at));
-                }
-                for small in a.smaller() {
-                    out.push(Node::Branch(p.clone(), Box::new(small), b.clone(), *at));
-                }
-                for small in b.smaller() {
-                    out.push(Node::Branch(p.clone(), a.clone(), Box::new(small), *at));
-                }
-            }
-        }
-        out
-    }
-}
-
-/// A declared size over about half the tree, the way `iris::random` puts them
-/// in: on the way into every child rather than as a node kind of its own, so
-/// readers of a size are dense rather than occasional.
-fn sized(rng: &mut Rng, inner: Node) -> Node {
-    if !rng.chance() {
-        return inner;
-    }
-    let len = |rng: &mut Rng| match rng.below(4) {
-        0 => Some(LayoutLen::px(20.0 + rng.below(180) as f32)),
-        1 => Some(LayoutLen::LEFTOVER),
-        _ => None,
-    };
-    Node::Sized(len(rng), len(rng), Box::new(inner))
-}
-
-fn grow(rng: &mut Rng, depth: usize) -> Node {
-    if depth == 0 {
-        return match rng.below(4) {
-            0 => Node::Text(1 + rng.below(WORDS.len()), true),
-            1 => Node::OneLine,
-            _ => Node::Rect,
-        };
-    }
-    let len = |rng: &mut Rng| match rng.below(4) {
-        0 => Some(LayoutLen::px(20.0 + rng.below(180) as f32)),
-        1 => Some(LayoutLen::LEFTOVER),
-        2 => Some(LayoutLen::rel(0.25 + rng.below(3) as f32 * 0.25)),
-        _ => None,
-    };
-    let kid = |rng: &mut Rng| {
-        let inner = grow(rng, depth - 1);
-        sized(rng, inner)
-    };
-    match rng.below(8) {
-        0 => Node::Scroll(rng.chance(), Box::new(kid(rng))),
-        1 => Node::Aligned(rng.below(4) as u8, rng.below(4) as u8, Box::new(kid(rng))),
-        2 => Node::Pad(rng.below(24) as f32, Box::new(kid(rng))),
-        3 => Node::Sized(len(rng), len(rng), Box::new(kid(rng))),
-        4 => Node::Branch(
-            Box::new(kid(rng)),
-            Box::new(kid(rng)),
-            Box::new(kid(rng)),
-            rng.below(500) as f32,
-        ),
-        5 => Node::Stack((0..2 + rng.below(2)).map(|_| kid(rng)).collect()),
-        _ => {
-            let kids: Vec<_> = (0..2 + rng.below(3)).map(|_| kid(rng)).collect();
-            let order = (0..kids.len()).collect();
-            Node::Span(rng.chance(), rng.below(3) as f32 * 4.0, kids, order)
-        }
-    }
-}
-
-#[derive(Clone, Copy, PartialEq)]
-enum Case {
-    Resize,
-    Repaint,
-    ResizeRepaint,
-    Reorder,
-    SizeChange,
-}
-
-/// A different declared length, kept the same kind so the change is to the
-/// value alone.
-fn resized_len(len: Option<LayoutLen>) -> Option<LayoutLen> {
-    let half = Rel::from_f32(0.5);
-    len.map(|len| LayoutLen {
-        px: len.px.mul(half) + Px::from_int(13),
-        rel: len.rel.mul(half),
-        leftover: len.leftover,
-    })
-}
-
-/// Every declared size changed, as a tree rather than as a change.
-fn resized(node: &Node) -> Node {
-    match node {
-        Node::Span(down, gap, kids, order) => Node::Span(
-            *down,
-            *gap,
-            kids.iter().map(resized).collect(),
-            order.clone(),
-        ),
-        Node::Stack(kids) => Node::Stack(kids.iter().map(resized).collect()),
-        Node::Pad(p, k) => Node::Pad(*p, Box::new(resized(k))),
-        Node::Aligned(x, y, k) => Node::Aligned(*x, *y, Box::new(resized(k))),
-        Node::Sized(x, y, k) => Node::Sized(resized_len(*x), resized_len(*y), Box::new(resized(k))),
-        Node::Scroll(d, k) => Node::Scroll(*d, Box::new(resized(k))),
-        Node::Branch(p, a, b, at) => Node::Branch(
-            Box::new(resized(p)),
-            Box::new(resized(a)),
-            Box::new(resized(b)),
-            *at,
-        ),
-        leaf => leaf.clone(),
-    }
-}
-
-/// Every span's children rotated by one, as a tree rather than as a change:
-/// what a warm frame reaches by moving them has to be where growing them that
-/// way lands.
-fn reordered(node: &Node) -> Node {
-    match node {
-        Node::Span(down, gap, kids, order) => {
-            let kids = kids.iter().map(reordered).collect::<Vec<_>>();
-            let mut order = order.clone();
-            order.rotate_left(1);
-            Node::Span(*down, *gap, kids, order)
-        }
-        Node::Stack(kids) => Node::Stack(kids.iter().map(reordered).collect()),
-        Node::Pad(p, k) => Node::Pad(*p, Box::new(reordered(k))),
-        Node::Aligned(x, y, k) => Node::Aligned(*x, *y, Box::new(reordered(k))),
-        Node::Sized(x, y, k) => Node::Sized(*x, *y, Box::new(reordered(k))),
-        Node::Scroll(d, k) => Node::Scroll(*d, Box::new(reordered(k))),
-        Node::Branch(p, a, b, at) => Node::Branch(
-            Box::new(reordered(p)),
-            Box::new(reordered(a)),
-            Box::new(reordered(b)),
-            *at,
-        ),
-        leaf => leaf.clone(),
-    }
-}
-
-/// Runs one scenario warm and cold and says where they disagree.
-fn diverges(node: &Node, case: Case) -> Option<String> {
-    let resizes = matches!(case, Case::Resize | Case::ResizeRepaint);
-    let repaints = matches!(case, Case::Repaint | Case::ResizeRepaint);
-    let start = if resizes { OUTER } else { INNER };
-    let mut warm = Harness::new(start);
-    let mut warm_ids = Vec::new();
-    let mut warm_spans = Vec::new();
-    let mut warm_sized = Vec::new();
-    let root = node.build(&mut warm, &mut warm_ids, &mut warm_spans, &mut warm_sized);
-    warm.state.root = Some(root);
-    // The frame that makes it warm: without it there is nothing retained and
-    // the comparison is two cold starts agreeing with each other.
-    warm.frame();
-    if resizes {
-        warm.resize(INNER);
-        warm.frame();
-    }
-    if repaints {
-        for &id in &warm_ids {
-            warm.rsc.widgets_mut().get_dyn_mut(id);
-        }
-        warm.frame();
-    }
-    if case == Case::Reorder {
-        for span in &warm_spans {
-            warm.rsc[*span].children.rotate_left(1);
-        }
-        warm.frame();
-    }
-    if case == Case::SizeChange {
-        let mut lens = Vec::new();
-        node.sized_lens(&mut lens);
-        for (id, (x, y)) in warm_sized.iter().zip(lens) {
-            warm.rsc.widgets_mut().set_size_rules(*id, x, y);
-        }
-        warm.frame();
-    }
-
-    // What the warm tree was moved into, grown that way from the start.
-    let want = match case {
-        Case::Reorder => reordered(node),
-        Case::SizeChange => resized(node),
-        _ => node.clone(),
-    };
-    let mut cold = Harness::new(INNER);
-    let mut cold_ids = Vec::new();
-    let mut cold_spans = Vec::new();
-    let mut cold_sized = Vec::new();
-    let root = want.build(&mut cold, &mut cold_ids, &mut cold_spans, &mut cold_sized);
-    cold.state.root = Some(root);
-    cold.frame();
-
-    for (i, (&w, &c)) in warm_ids.iter().zip(&cold_ids).enumerate() {
-        let (got, want) = (warm.region(&w), cold.region(&c));
-        // To a couple of steps of the grid, each a thousandth of a pixel: a
-        // move or a resize lands on the same number now, and a length
-        // measured one way against the same length composed another can
-        // still be a step out per composition between them.
-        let same = match (got, want) {
-            (Some(g), Some(c)) => {
-                let d = |a: Px, b: Px| (a - b).abs() <= Px::STEP.mul_int(AGREE_STEPS);
-                d(g.top_left.x, c.top_left.x)
-                    && d(g.top_left.y, c.top_left.y)
-                    && d(g.bot_right.x, c.bot_right.x)
-                    && d(g.bot_right.y, c.bot_right.y)
-            }
-            (None, None) => true,
-            _ => false,
-        };
-        if !same {
-            return Some(format!("widget {i}: warm {got:?} cold {want:?}"));
-        }
-    }
-    None
-}
-
-/// Takes the first simplification that still fails, until none does.
-fn shrink(mut node: Node, case: Case) -> Node {
+/// Takes the first simplification that still fails, until none does. The
+/// simplifications come biggest first, so this walks down rather than
+/// nibbling: a six-hundred-widget tree reaches single figures in a few
+/// hundred builds.
+fn shrink(mut node: Plan, case: Case, seed: u64) -> Plan {
     loop {
         let Some(next) = node
             .smaller()
             .into_iter()
-            .find(|small| diverges(small, case).is_some())
+            .find(|small| diverges(small, case, seed).is_some())
         else {
             return node;
         };
@@ -558,62 +40,64 @@ fn shrink(mut node: Node, case: Case) -> Node {
     }
 }
 
-/// One thread per core but one, each taking a share of the seeds: a tree is
-/// grown, laid out and dropped within a seed, so nothing is shared. A seed
-/// that fails shrinks on its own thread and panics there, which brings the
-/// scope down with it.
-fn over_seeds(seeds: Vec<u64>, run: impl Fn(u64) + Sync) {
-    let threads =
-        std::thread::available_parallelism().map_or(1, |n| n.get().saturating_sub(1).max(1));
-    let chunk = seeds.len().div_ceil(threads).max(1);
-    std::thread::scope(|scope| {
-        for part in seeds.chunks(chunk) {
-            let run = &run;
-            scope.spawn(move || part.iter().for_each(|&seed| run(seed)));
-        }
-    });
-}
-
-fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
-    std::env::var(name)
-        .ok()
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(fallback)
+fn cases() -> Vec<Case> {
+    match env("SHRINK_CASE", String::from("all")).as_str() {
+        "all" => ALL.to_vec(),
+        name => match Case::named(name) {
+            Some(case) => vec![case],
+            None => panic!(
+                "unknown SHRINK_CASE {name:?}; one of all, {}",
+                ALL.map(Case::name).join(", ")
+            ),
+        },
+    }
 }
 
 #[test]
 #[ignore = "a fuzzer; run it once the ordinary tests pass"]
 fn no_grown_tree_lays_out_differently_warm_than_cold() {
-    let seeds: u64 = env("SHRINK_SEEDS", 400);
     let depth: usize = env("SHRINK_DEPTH", 5);
-    let case = match env("SHRINK_CASE", String::from("resize")).as_str() {
-        "repaint" => Case::Repaint,
-        "resize-repaint" => Case::ResizeRepaint,
-        "reorder" => Case::Reorder,
-        "size-change" => Case::SizeChange,
-        _ => Case::Resize,
+    let cases = cases();
+    let seeds: Vec<u64> = match std::env::var("SHRINK_SEED")
+        .ok()
+        .and_then(|v| v.parse().ok())
+    {
+        Some(seed) => vec![seed],
+        None => (1..=env("SHRINK_SEEDS", 400_u64)).collect(),
     };
+    let count = seeds.len();
 
-    over_seeds((1..=seeds).collect(), |seed| {
-        let node = grow(&mut Rng::new(seed), depth);
-        let Some(how) = diverges(&node, case) else {
-            return;
-        };
-        let small = shrink(node.clone(), case);
-        println!(
-            "seed {seed}: {how}\ngrown {} widgets, shrank to {}\n{small:#?}",
-            node.size(),
-            small.size()
-        );
-        panic!("seed {seed} lays out differently warm than cold");
+    over_seeds(seeds, |seed| {
+        let grown = plan(seed, depth, &Edits::default());
+        for &case in &cases {
+            if diverges(&grown, case, seed).is_none() {
+                continue;
+            }
+            let small = shrink(grown.clone(), case, seed);
+            // Described from the shrunk tree: the grown tree's chain names
+            // widgets that are no longer there, and the ancestry of the
+            // failure is what a test is written from.
+            let how = diverges(&small, case, seed).unwrap_or_default();
+            println!(
+                "seed {seed} case {}: {how}\ngrown {} widgets, shrank to {}\n{small:#?}",
+                case.name(),
+                grown.size(),
+                small.size()
+            );
+            panic!(
+                "seed {seed} lays out differently warm than cold after {}",
+                case.name()
+            );
+        }
     });
-    let sizes: Vec<usize> = (1..=seeds)
-        .map(|seed| grow(&mut Rng::new(seed), depth).size())
+
+    let sizes: Vec<usize> = (1..=count as u64)
+        .map(|seed| plan(seed, depth, &Edits::default()).size())
         .collect();
-    let total: usize = sizes.iter().sum();
     println!(
-        "{seeds} trees at depth {depth} agree: {} widgets total, largest {}",
-        total,
+        "{count} trees at depth {depth} agree over {} case(s): {} widgets total, largest {}",
+        cases.len(),
+        sizes.iter().sum::<usize>(),
         sizes.iter().max().copied().unwrap_or(0)
     );
 }

tests/suite.rs

@@ -16,6 +16,8 @@ mod drift;
 mod idempotence;
 #[path = "cases/layout.rs"]
 mod layout;
+#[path = "cases/plan.rs"]
+mod plan;
 #[path = "cases/pointer.rs"]
 mod pointer;
 #[path = "cases/pointer_routing.rs"]

tests/trace_unsettled.rs

@@ -1,5 +1,5 @@
-//! Traces the six-widget tree in `unsettled.rs`, to see what box its text is
-//! actually drawn in on a first frame against a settled one.
+//! Traces the four-widget trees in `unsettled.rs`, to see what box their text
+//! is actually drawn in on a first frame against a settled one.
 
 #![cfg(feature = "layout-diagnostics")]
 
@@ -9,30 +9,25 @@ use iris::prelude::*;
 
 fn plant(h: &mut Harness) -> Vec<WidgetId> {
     let plain = wtext("Wrapping").size(16).wrap(false).add(&mut h.rsc);
-    let wrapped = wtext("Wrapping shapes").size(16).wrap(true).add(&mut h.rsc);
-    let sized = wrapped.width(76).add(&mut h.rsc);
-    let aligned = sized;
+    let wrapped = wtext("Wrapping shapes")
+        .size(16)
+        .wrap(true)
+        .width(76)
+        .add(&mut h.rsc);
     h.rsc
         .widgets_mut()
-        .set_alignment(sized, Axis::X, AxisAlign::POS);
+        .set_alignment(wrapped, Axis::X, AxisAlign::POS);
     h.rsc
         .widgets_mut()
-        .set_alignment(sized, Axis::Y, AxisAlign::POS);
+        .set_alignment(wrapped, Axis::Y, AxisAlign::POS);
     let stack = Stack {
-        children: vec![plain.add_strong(&mut h.rsc), aligned.add_strong(&mut h.rsc)],
+        children: vec![plain.add_strong(&mut h.rsc), wrapped.add_strong(&mut h.rsc)],
         size: StackSize::Child(0),
     }
     .add(&mut h.rsc);
     let root = (stack,).span(Dir::RIGHT).add(&mut h.rsc);
     h.state.root = Some(root.add_strong(&mut h.rsc));
-    vec![
-        plain.id(),
-        wrapped.id(),
-        sized.id(),
-        aligned.id(),
-        stack.id(),
-        root.id(),
-    ]
+    vec![plain.id(), wrapped.id(), stack.id(), root.id()]
 }
 
 fn dump(label: &str, report: &diag::Report, text: WidgetId) {
@@ -42,12 +37,12 @@ fn dump(label: &str, report: &diag::Report, text: WidgetId) {
             TraceEvent::DrawRequest {
                 id,
                 region,
-                pixel_size,
+                region_px,
                 ..
             } if *id == text => {
                 println!(
                     "  draw in {:.2}x{:.2}  region {region:?}",
-                    pixel_size.x, pixel_size.y
+                    region_px.x, region_px.y
                 )
             }
             TraceEvent::SizeReported { id, size } if *id == text => {
@@ -81,7 +76,7 @@ fn what_box_the_text_is_drawn_in() {
 
     for _ in 0..2 {
         for &id in &ids {
-            h.rsc.widgets_mut().get_dyn_mut(id);
+            h.rsc.widgets_mut().mark_for_redraw(id);
         }
         let _ = diag::take();
         h.frame();
@@ -93,23 +88,14 @@ fn what_box_the_text_is_drawn_in() {
 fn plant_fixed(h: &mut Harness) -> Vec<WidgetId> {
     let words = "Wrapping shapes one source into as many lines as the box leaves";
     let text = wtext(words).size(16).wrap(true).add(&mut h.rsc);
-    let aligned = text;
     h.rsc
         .widgets_mut()
         .set_alignment(text, Axis::X, AxisAlign::NEG);
-    let inner = (aligned,).span(Dir::RIGHT).add(&mut h.rsc);
-    let sized = inner.sized((189, 176)).add(&mut h.rsc);
+    let inner = (text,).span(Dir::RIGHT).sized((189, 176)).add(&mut h.rsc);
     let filler = rect(Color::RED).add(&mut h.rsc);
-    let root = (filler, sized).span(Dir::RIGHT).add(&mut h.rsc);
+    let root = (filler, inner).span(Dir::RIGHT).add(&mut h.rsc);
     h.state.root = Some(root.add_strong(&mut h.rsc));
-    vec![
-        text.id(),
-        aligned.id(),
-        inner.id(),
-        sized.id(),
-        filler.id(),
-        root.id(),
-    ]
+    vec![text.id(), inner.id(), filler.id(), root.id()]
 }
 
 #[test]