Ask the root the way every other widget is asked

The root had a layout path of its own: `root_layout` read its declared
lengths against the window, while every other widget's box came of
`Painter::widget_at`, where a rule of the widget's own -- a share with pixels
or a fraction beside it -- is compared against the offer and can take the box
past it. So a share on the root was the window whatever it asked for, which
`docs/LAYOUT_LOG.md` recorded as a gap rather than fixing, and any later rule
that reads the offer would have had to be written twice.

There is one box nobody drew, and that is the whole of what the root is
asked in. `Placing::WINDOW` says it -- the full output, fractions of the full
output, no move entry and no mask -- and `Placing::ask` is then the one place
a box is decided, called by the painter, by a local redraw, and by the root's
first draw. The root's own path is what is left of it: a widget with no
parent keeps different bookkeeping, not a different layout.

Measured in a 400 px window, a probe under each of three parents, which now
agree on every row where two of them agreed before:

    rule                      as root   wrapped   in a span
    leftover(1)                   400       400         400
    px(50) + leftover(1)          400       400         400
    px(500) + leftover(1)         500       500         500   (was 400 as root)
    rel(0.5) + leftover(1)        400       400         400
    rel(2.0) + leftover(1)        800       800         800   (was 400 as root)
    px(500)                       500       500         500
    rel(0.5)                      200       200         200

The comparison is kept on the widget asked about rather than on the asker,
which is what makes the root need nothing of its own: a window range means
the same thing at either end of an ask, `in_parent` passes one up unchanged,
and the asker ends up holding it through the child's drawing exactly as it
did when `longer_than` narrowed the asker directly. The root has no asker, so
its own record is the only place that range can live -- and `resize` already
checks that record, so a share crossing its length is caught with no new
code. `a_share_past_the_box_is_decided_again_on_either_side_of_the_crossing`
now runs at the root too: 500 at a 400 window, 900 at 900, 500 again at 400.

Two things this changes beyond the share. `DrawInfo::asked` is now the place
the parent offered rather than the place the ask came to, so a local redraw
re-decides the rule instead of re-reading the decision -- the two were the
same until a rule could move the box. And the root's `is_region_node` is
read, where the old path passed `false`: a region-node root now gets its
entry, whose translation is the identity, pinned by
`a_region_node_root_is_a_region_node`.

Format, clippy with and without layout-diagnostics, and the suite (136 + 19 +
13 + 4) are clean. The cold dump over 400 depth-5 trees is byte-identical to
`2dba90b` across all 34,571 boxes, and the three seed scans pass: 400 at
depth 5 (61s), 1,000 at depth 6 (155s), 2,000 at depth 4 (291s).

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

@@ -24,3 +24,17 @@ transforms on a move entry (scale + rotation)
     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

@@ -131,14 +131,6 @@ 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 => self.0 << (TO - SHIFT),
-            false => shift_round(self.0 as i64, SHIFT - TO) as i32,
-        })
-    }
-
     pub const fn add(self, rhs: Self) -> Self {
         Self(self.0.wrapping_add(rhs.0))
     }
@@ -246,16 +238,6 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
     }
 }
 
-/// 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,
-    }
-}
-
 const fn div_round(num: i64, den: i64) -> i64 {
     let (q, rem) = (num / den, num % den);
     match rem.unsigned_abs() * 2 >= den.unsigned_abs() {
@@ -531,15 +513,6 @@ mod tests {
         assert_eq!(Px::from_f32(-1e12), Px::MIN);
     }
 
-    #[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);
-    }
-
     #[test]
     fn lerp_takes_the_fraction_as_the_receiver() {
         let (from, to) = (Px::from_int(10), Px::from_int(20));

core/src/layout_diagnostics.rs

@@ -23,100 +23,71 @@ use std::{
     time::Instant,
 };
 
-#[derive(Clone, Copy)]
-pub(crate) enum Counter {
-    Updates,
-    DrawRequests,
-    WidgetDraws,
-    RegionNodeDraws,
-    SizeReads,
-    HintHits,
-    HintMisses,
-    ReuseAttempts,
-    ReuseExact,
-    ReuseMoved,
-    ReuseDirty,
-    ReuseWrongParent,
-    ReuseRemapped,
-    ReuseOutside,
-    ReuseWrongLayer,
-    ReuseWrongNode,
-    QueuePops,
-    DepthReads,
-    LocalRedraws,
-    SizeChanges,
-    ReaderEdges,
-    PrimitiveWrites,
-    TextRenders,
-    TextShapeHits,
-    TextShapes,
-    TextBreaks,
-    GlyphPlacements,
-    OutsidePinnedLen,
-    OutsideRelBase,
-    OutsideRegion,
+/// 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::OutsideRegion 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",
-        "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",
-        "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",
-        "reuse outside: the length it was pinned to",
-        "reuse outside: a rel base",
-        "reuse outside: a region length",
-    ];
+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)]
@@ -251,6 +222,8 @@ pub enum ReuseOutcome {
     Dirty,
     WrongParent,
     WrongLayer,
+    WrongMask,
+    WrongNode,
     Remapped,
     Outside,
     Undrawn,
@@ -380,7 +353,7 @@ pub(crate) fn reuse(id: WidgetId, outcome: ReuseOutcome) {
 }
 
 /// A drawing that cannot be reused because the box on offer is outside what
-/// it holds for, and which of the three contracts said so. They overlap: a
+/// 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(
@@ -397,10 +370,12 @@ pub(crate) fn outside(
         if holds.region_len.is_some_and(|pinned| pinned != len) {
             bump(Counter::OutsidePinnedLen);
         }
-        if !holds.window.contains(window)
-            || holds
-                .rel_base
-                .is_some_and(|pinned| pinned != rel_base[axis])
+        if !holds.window.contains(window) {
+            bump(Counter::OutsideWindow);
+        }
+        if holds
+            .rel_base
+            .is_some_and(|pinned| pinned != rel_base[axis])
         {
             bump(Counter::OutsideRelBase);
         }

core/src/orientation/align.rs

@@ -3,7 +3,7 @@ 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>,
@@ -84,14 +84,6 @@ pub struct RegionAlign {
     pub y: AxisAlign,
 }
 
-impl RegionAlign {
-    /// Both axes at the near edge: the start of a box in its own orientation.
-    pub const NEAR: Self = Self {
-        x: AxisAlign::NEG,
-        y: AxisAlign::NEG,
-    };
-}
-
 impl RegionAlign {
     pub const TOP_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::NEG);
     pub const TOP_CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::NEG);
@@ -159,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)),
         }
     }
 }
@@ -220,3 +214,4 @@ impl RegionAlign {
 }
 
 impl_axis_index!(RegionAlign => AxisAlign);
+impl_axis_index!(Align => Option<AxisAlign>);

core/src/orientation/axis.rs

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

@@ -148,20 +148,20 @@ impl LayoutLen {
     /// 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 {
+    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 {
+    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> {
+    pub fn declared(&self) -> Option<Len> {
         (self.leftover == Weight::ZERO).then(|| self.without_leftover())
     }
 
@@ -169,7 +169,7 @@ impl LayoutLen {
     /// 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 {
+    pub const fn without_leftover(&self) -> Len {
         Len::from_parts(self.rel, self.px)
     }
 

core/src/orientation/pos.rs

@@ -281,15 +281,6 @@ impl UiSpan {
     pub const fn len(&self) -> Len {
         self.end - self.start
     }
-
-    /// Both ends by the same amount, which is what moving a box without
-    /// changing its length does to every part of it.
-    pub const fn translated(self, by: Len) -> Self {
-        Self {
-            start: self.start + by,
-            end: self.end + by,
-        }
-    }
 }
 
 #[repr(C)]
@@ -300,17 +291,6 @@ pub struct UiRegion {
 }
 
 impl UiRegion {
-    /// Every part of the box by the same amount on each axis. Done to the
-    /// whole region rather than an end at a time, because that is what it is
-    /// -- and because four adds in a row are four adds, where four asked for
-    /// separately are four sequences.
-    pub const fn translated(self, x: Len, y: Len) -> Self {
-        Self {
-            x: self.x.translated(x),
-            y: self.y.translated(y),
-        }
-    }
-
     pub const FULL: Self = Self {
         x: UiSpan::FULL,
         y: UiSpan::FULL,

core/src/primitive/text.rs

@@ -133,10 +133,6 @@ impl TextBuffer {
         }
     }
 
-    pub fn new_empty() -> Self {
-        Self::new("")
-    }
-
     pub fn text(&self) -> &str {
         &self.text
     }

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,
     )
 }
 

core/src/render/shader/prelude.wgsl

@@ -26,9 +26,11 @@ 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
@@ -70,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
@@ -171,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];

core/src/ui/active.rs

@@ -51,8 +51,6 @@ pub struct ActiveData {
     /// 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,

core/src/ui/holds.rs

@@ -19,6 +19,26 @@ pub struct Holds {
     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 Holds {
     pub const ANY: Self = Self {
         lo: Px::MIN,
@@ -35,11 +55,11 @@ impl Holds {
 
     /// 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 {
+    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 {
+    pub const fn and(&self, other: Self) -> Self {
         Self {
             lo: self.lo.max(other.lo),
             hi: self.hi.min(other.hi),
@@ -57,7 +77,7 @@ impl Holds {
     /// 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 {
+    pub const fn through(&self, len: Len) -> Self {
         if self.lo.raw() == Px::MIN.raw() && self.hi.raw() == Px::MAX.raw() {
             return Self::ANY;
         }

core/src/ui/layout_holds.rs

@@ -34,7 +34,7 @@ impl AxisHolds {
         region_len: None,
     };
 
-    pub fn and(self, other: Self) -> Self {
+    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!(
@@ -53,7 +53,7 @@ impl AxisHolds {
         }
     }
 
-    pub fn covers(self, other: Self) -> bool {
+    pub fn covers(&self, other: Self) -> bool {
         self.window.covers(other.window)
             && self.region.covers(other.region)
             && self
@@ -64,7 +64,7 @@ impl AxisHolds {
 
     /// 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 {
+    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))
@@ -87,18 +87,18 @@ impl LayoutHolds {
         y: AxisHolds::ANY,
     };
 
-    pub fn and(self, other: Self) -> Self {
+    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 {
+    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 {
+    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()))

core/src/ui/painter.rs

@@ -2,8 +2,8 @@
 use crate::layout_diagnostics::{self as diag, Counter};
 use crate::{
     Axis, Declared, Holds, LayoutHolds, LayoutLen, Len, PlaceDesc, Px, PxVec2, RegionAlign, Rel,
-    RenderedText, RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextData,
-    TextureHandle, UiRegion, UiRenderState, UiRsc, UiVec2, Weight, WidgetId, Widgets,
+    RenderedText, RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextureHandle,
+    UiRegion, UiRenderState, UiRsc, UiVec2, Weight, WidgetId, Widgets,
     render::{
         GlyphPrimitive, Mask, MaskIdx, MoveIdx, Primitive, PrimitiveInst, PrimitiveKind,
         TexturePrimitive,
@@ -187,12 +187,17 @@ impl<'a> Painter<'a> {
         id: &'s StrongWidget<W>,
         place: impl Into<PlaceDesc>,
     ) -> DrawResult<'s, 'a, W> {
-        let place = self.resolve_rel_base(place.into());
+        let offer = self.resolve_rel_base(place.into());
+        let Ask {
+            rel_base,
+            region,
+            place,
+            declared,
+            holds: ask_holds,
+        } = self
+            .placing()
+            .ask(self.rsc.widgets(), self.window, id.id(), offer);
         let region_node = self.rsc.widgets().is_region_node(id.id());
-        let declared = self.declared_lens(id);
-        let align = self.rsc.widgets().alignment(id.id());
-        let (rel_base, region) =
-            place.rel_base_and_region(self.region, self.rel_base, declared, align);
         #[cfg(feature = "layout-diagnostics")]
         if region_node {
             diag::bump(Counter::RegionNodeDraws);
@@ -215,7 +220,8 @@ impl<'a> Painter<'a> {
                 rel_base,
                 region,
                 placed: place,
-                asked: place,
+                asked: offer,
+                ask_holds,
                 re_asked,
             },
             None,
@@ -282,7 +288,7 @@ impl<'a> Painter<'a> {
     /// This widget as the thing its children are placed within.
     fn placing(&self) -> Placing {
         Placing {
-            id: self.id,
+            id: Some(self.id),
             region: self.region,
             rel_base: self.rel_base,
             depth: self.depth,
@@ -291,27 +297,12 @@ impl<'a> Painter<'a> {
         }
     }
 
-    /// What a widget's rules declare its lengths to be, which whoever draws
-    /// it resolves into its rel base. Reading them depends on nothing -- the box
-    /// that comes of them is kept on the child, and `redraw` compares it
-    /// there.
-    fn declared_lens<W: ?Sized>(&self, id: &StrongWidget<W>) -> Declared {
-        self.rsc.widgets().declared_lens(id.id())
-    }
-
     /// What a child says its length is without being drawn, if it can say,
     /// as the length its draw would report: a fraction in it is resolved
     /// against this widget's rel base, which is the rel base a child asked with
     /// nothing narrowed gets. Asking counts as reading its size.
     pub fn size_hint<W: ?Sized>(&mut self, id: &StrongWidget<W>, axis: Axis) -> Option<LayoutLen> {
-        let widgets = self.rsc.widgets();
-        // A rule is the answer where there is one: it wins over whatever the
-        // widget would draw, so it has to win over what the widget says too.
-        let hint = widgets.size_rules(id.id())[axis].exact().or_else(|| {
-            widgets
-                .get_dyn(id.id())
-                .and_then(|widget| widget.size_hint(axis))
-        });
+        let hint = self.rsc.widgets().exact_len(id.id(), axis);
         let rel_base = self.rel_base[axis];
         let resolved = hint.map(|hint| hint.within_len(rel_base));
         #[cfg(feature = "layout-diagnostics")]
@@ -482,6 +473,26 @@ impl<'a> Painter<'a> {
         len.to_px(window)
     }
 
+    /// [`Len::longer_than`], asked on this widget's behalf: the windows the
+    /// comparison comes out the same way on are windows its drawing holds
+    /// for, and nowhere else does it. What a container has left for the
+    /// shares it divides is the one thing that asks.
+    ///
+    /// Narrowed rather than stated, because whatever else this widget read
+    /// about the window is a reason its drawing holds where it does too.
+    pub fn longer_than(&mut self, len: Len, than: Len, axis: Axis) -> bool {
+        let window = self.window[axis];
+        let (longer, holds) = len.longer_than(than, window);
+        debug_assert!(
+            holds.contains(window),
+            "'{}' ({:?}) compared two lengths and kept a range without this window",
+            self.label(),
+            self.id
+        );
+        self.own[axis].window = self.own[axis].window.and(holds);
+        longer
+    }
+
     /// The windows this drawing holds for, stated rather than taken: a
     /// container that branched on a length in pixels says which side of the
     /// boundary it was on, which is wider than the one window reading that
@@ -497,10 +508,6 @@ impl<'a> Painter<'a> {
         self.own[axis].window = holds;
     }
 
-    pub fn text_data(&mut self) -> &mut TextData {
-        &mut self.rsc.ui_mut().text
-    }
-
     pub fn child_layer(&mut self) {
         self.layer = self.state.layers.child(self.layer);
     }
@@ -651,24 +658,129 @@ impl Painter<'_> {
 }
 
 impl Widgets {
-    /// What a widget's box is where a rule or its own hint says so outright.
-    pub(super) fn declared_lens(&self, id: WidgetId) -> Declared {
-        let rules = self.size_rules(id);
-        let widget = self.get_dyn(id);
-        Declared::from_axes(|axis| {
-            rules[axis].declared().or_else(|| {
-                // A hint still narrows the box where no rule does, which is
-                // how a widget with a natural pixel size -- an image, a gap
-                // -- gets that size rather than the whole offer. That is the
-                // offer's business rather than a declaration's, and this
-                // falls away once a widget occupies its reported size inside
-                // the box it was offered.
-                widget
-                    .and_then(|widget| widget.size_hint(axis))
-                    .and_then(LayoutLen::declared)
-            })
+    /// What says a widget's length on one axis without drawing it, if anything
+    /// does. A rule is the answer where there is one: it wins over whatever the
+    /// widget would draw, so it has to win over what the widget says too -- a
+    /// share included, since a share is a length only to whoever divides one,
+    /// and that is the parent rather than this widget.
+    fn exact_len(&self, id: WidgetId, axis: Axis) -> Option<LayoutLen> {
+        self.size_rules(id)[axis].exact().or_else(|| {
+            // A hint still narrows the box where no rule does, which is how a
+            // widget with a natural pixel size -- an image, a gap -- gets that
+            // size rather than the whole offer. That is the offer's business
+            // rather than a declaration's, and this falls away once a widget
+            // occupies its reported size inside the box it was offered.
+            self.get_dyn(id)?.size_hint(axis)
         })
     }
+
+    /// What a widget's box is where a rule or its own hint gives one outright,
+    /// rather than a share for whoever draws it to divide.
+    pub(super) fn declared_lens(&self, id: WidgetId) -> Declared {
+        Declared::from_axes(|axis| self.exact_len(id, axis)?.declared())
+    }
+}
+
+/// One ask of a widget: the box it draws in, what its fractions are of, and
+/// what deciding those read.
+pub(super) struct Ask {
+    pub rel_base: UiVec2,
+    pub region: UiRegion,
+    /// The place the ask came to, which a rule of the widget's own can take
+    /// past the box its parent offered.
+    pub place: PlaceDesc,
+    pub declared: Declared,
+    /// What the ask itself holds for, kept on the widget asked about: a rule
+    /// compared against the offer in pixels holds only for the windows on its
+    /// side of the crossing, and that range reaches whoever asked through the
+    /// drawing it is part of. Kept on the widget asked about rather than on
+    /// the asker because the root has no asker.
+    pub holds: LayoutHolds,
+}
+
+impl Placing {
+    /// Asks about a widget at `place` of this box, with the widget's own
+    /// rules applied to what the place offers it. `place` is resolved: what
+    /// a rel base of the asker's is a fraction of, the asker worked out.
+    ///
+    /// Every ask is this one, the root's included -- there the box is the
+    /// window and nothing above narrowed it, which is what [`Self::WINDOW`]
+    /// says.
+    pub(super) fn ask(
+        &self,
+        widgets: &Widgets,
+        window: PxVec2,
+        id: WidgetId,
+        mut place: PlaceDesc,
+    ) -> Ask {
+        let align = widgets.alignment(id);
+        let mut holds = LayoutHolds::ANY;
+        // A share fills what the pixels and fraction beside it leave of the
+        // box and overflows where they are longer, which is the rule a span
+        // follows with one child. Only the overflow is a box of the child's
+        // own: a share that fits is the box it was given, which is what this
+        // place already says.
+        for axis in Axis::BOTH {
+            let (len, kept) =
+                self.share_past_the_offer(widgets, window[axis], id, place, align, axis);
+            holds[axis].window = holds[axis].window.and(kept);
+            if let Some(len) = len {
+                place[axis] = len.as_desc().fills();
+            }
+        }
+        let declared = widgets.declared_lens(id);
+        let (rel_base, region) =
+            place.rel_base_and_region(self.region, self.rel_base, declared, align);
+        Ask {
+            rel_base,
+            region,
+            place,
+            declared,
+            holds,
+        }
+    }
+
+    /// The box a widget's own share asks for where that is longer than the
+    /// box `place` gives it, and nothing where the share fits -- with the
+    /// windows that answer holds for, which is a range either way.
+    ///
+    /// A share is a length only to whoever divides one, and nothing divides a
+    /// box handed to one child: what is left of it after the pixels and the
+    /// fraction beside the share is what the share takes, so the length comes
+    /// to the whole box until those are longer than it and to them once they
+    /// are. Only that second case is a box its parent did not give, and the
+    /// crossing between them is a question in pixels.
+    fn share_past_the_offer(
+        &self,
+        widgets: &Widgets,
+        window: Px,
+        id: WidgetId,
+        place: PlaceDesc,
+        align: RegionAlign,
+        axis: Axis,
+    ) -> (Option<Len>, Holds) {
+        // A place that is the widget's placement outright is a box its parent
+        // decided, and a parent that divides one has already given the share
+        // whatever it was owed. Only an offer -- a box with the answer still
+        // to be placed inside it -- is a box a share reads.
+        if place[axis].fills {
+            return (None, Holds::ANY);
+        }
+        // A share with nothing beside it is the box whatever the box is, so
+        // there is no comparison to make and no range to keep for one.
+        let Some(stated) = widgets.exact_len(id, axis) else {
+            return (None, Holds::ANY);
+        };
+        if stated.leftover == Weight::ZERO || stated.is_only_leftover() {
+            return (None, Holds::ANY);
+        }
+        let fixed = stated
+            .without_leftover()
+            .within_len(place.base(axis, self.rel_base));
+        let offer = place.of(self.region, align)[axis].len();
+        let (longer, holds) = fixed.longer_than(offer, window);
+        (longer.then_some(fixed), holds)
+    }
 }
 
 impl LayoutLen {
@@ -679,7 +791,7 @@ impl LayoutLen {
     /// the rule already gave the region its length, and the rule's length is
     /// what the widget reports there. And an axis the parent decided from
     /// the answer is the answer already.
-    pub(super) fn fills(self, declared: Option<Len>, decided: bool) -> bool {
+    pub(super) fn fills(&self, declared: Option<Len>, decided: bool) -> bool {
         self.leftover != Weight::ZERO || declared.is_some() || decided
     }
 }
@@ -733,10 +845,7 @@ impl PlaceDesc {
         let mut rel_base = parent_rel_base;
         let mut region = given;
         for axis in Axis::BOTH {
-            let base = match self[axis].rel_base {
-                RelBase::Len(len) => len,
-                RelBase::Inherit | RelBase::WithRegion => parent_rel_base[axis],
-            };
+            let base = self.base(axis, parent_rel_base);
             let len = declared[axis]
                 .map(|len| len.within_len(base))
                 .unwrap_or(base);

core/src/ui/place.rs

@@ -1,5 +1,5 @@
 use crate::util::impl_axis_index;
-use crate::{Axis, AxisAlign, Len, PrimitiveHandle, RegionAlign, UiRegion, UiSpan};
+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.
@@ -123,6 +123,16 @@ impl PlaceDesc {
         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))

core/src/ui/render_state.rs

@@ -4,6 +4,7 @@ use crate::{
     ActiveData, Answer, Axis, Declared, DrawLayers, IdLike, LayoutHolds, LayoutLen, Len, MaskIdx,
     MoveIdx, Moves, Painter, PixelRegion, PlaceDesc, PxVec2, Rel, Size, StrongWidget, UiRegion,
     UiRsc, UiSpan, UiVec2, Weight, WidgetId, Widgets,
+    ui::painter::Ask,
     util::{HashMap, Vec2},
 };
 
@@ -23,11 +24,14 @@ pub(super) struct DrawInfo {
     /// The box the widget is asked in, in its parent region node's
     /// coordinates.
     pub region: UiRegion,
-    /// Where the widget is put, and where it was asked, as parts of the
-    /// parent's box. See [`PlaceDesc`]. The two are one ask's place until the
-    /// parent puts the answer somewhere else.
+    /// Where the widget is put, and what its parent offered it, as parts of
+    /// the parent's box. See [`PlaceDesc`]. The two are one place until a
+    /// rule of the widget's own takes it past the offer, or the parent puts
+    /// the answer somewhere else.
     pub placed: PlaceDesc,
     pub asked: PlaceDesc,
+    /// What the ask that gave it those two holds for. See [`Ask::holds`].
+    pub ask_holds: LayoutHolds,
     /// Whether the parent already asked about this widget in this draw.
     pub re_asked: bool,
 }
@@ -43,7 +47,8 @@ pub(super) struct Drawn {
 /// What a widget's children are placed in: its own box, the coordinates its
 /// drawing is in, and what else one ask of a child is decided from.
 pub(super) struct Placing {
-    pub id: WidgetId,
+    /// The widget whose box this is, and nothing for the window.
+    pub id: Option<WidgetId>,
     pub region: UiRegion,
     pub rel_base: UiVec2,
     pub depth: usize,
@@ -51,6 +56,21 @@ pub(super) struct Placing {
     pub mask: MaskIdx,
 }
 
+impl Placing {
+    /// The window, which is what the root is placed within. Nothing above the
+    /// root narrowed a box or chose where it goes, so it is asked in the whole
+    /// output and its fractions are of the whole output -- an ordinary ask,
+    /// from the one box nobody drew.
+    pub const WINDOW: Self = Self {
+        id: None,
+        region: UiRegion::FULL,
+        rel_base: UiVec2::FULL_SIZE,
+        depth: 0,
+        move_idx: MoveIdx::NONE,
+        mask: MaskIdx::NONE,
+    };
+}
+
 pub struct UiRenderState {
     pub active: HashMap<WidgetId, ActiveData>,
     pub layers: DrawLayers,
@@ -124,20 +144,21 @@ impl UiRenderState {
         }
     }
 
-    /// The root is asked about in the output. Its own rules narrow both its
-    /// rel base and box; nothing above it chose a different one.
-    fn root_info(&self, rel_base: UiVec2, region: UiRegion) -> DrawInfo {
+    /// The root's first draw: the ask [`Placing::WINDOW`] answered, with the
+    /// bookkeeping a widget with no parent carries.
+    fn root_info(&self, ask: &Ask, region_node: bool) -> DrawInfo {
         DrawInfo {
             layer: 0,
             parent: None,
-            depth: 1,
+            depth: Placing::WINDOW.depth + 1,
             parent_move: MoveIdx::NONE,
-            region_node: false,
+            region_node,
             mask: MaskIdx::NONE,
-            rel_base,
-            region,
-            placed: PlaceDesc::WHOLE,
+            rel_base: ask.rel_base,
+            region: ask.region,
+            placed: ask.place,
             asked: PlaceDesc::WHOLE,
+            ask_holds: ask.holds,
             re_asked: false,
         }
     }
@@ -184,24 +205,13 @@ impl UiRenderState {
         let _layout = diag::timer(TimerKind::FullLayout);
         self.clear(rsc);
         if let Some(id) = root {
-            let (rel_base, region) = Self::root_layout(id.id(), rsc.widgets());
-            let info = self.root_info(rel_base, region);
+            let ask =
+                Placing::WINDOW.ask(rsc.widgets(), self.output_size, id.id(), PlaceDesc::WHOLE);
+            let info = self.root_info(&ask, rsc.widgets().is_region_node(id.id()));
             self.draw_inner(id.id(), info, None, rsc);
         }
     }
 
-    /// The root's rel base and box: the window, taken in by the root's own
-    /// rules. Nothing above it narrowed anything or chose where it goes, so
-    /// its declaration is the whole of what decides either.
-    fn root_layout(id: WidgetId, widgets: &Widgets) -> (UiVec2, UiRegion) {
-        PlaceDesc::WHOLE.rel_base_and_region(
-            UiRegion::FULL,
-            UiVec2::FULL_SIZE,
-            widgets.declared_lens(id),
-            widgets.alignment(id),
-        )
-    }
-
     pub(super) fn draw_inner(
         &mut self,
         id: WidgetId,
@@ -329,7 +339,10 @@ impl UiRenderState {
             mask_slot,
             children: Vec::new(),
             size_deps: Vec::new(),
-            own: LayoutHolds::ANY,
+            // What the ask holds for is part of what the drawing holds for:
+            // a box the widget's own rule took past the offer was decided in
+            // this window, and at the root nobody else keeps that range.
+            own: info.ask_holds,
             under: Vec::new(),
             answer_under: LayoutHolds::ANY,
             depth: info.depth,
@@ -462,6 +475,7 @@ impl UiRenderState {
                         region: UiRegion::FULL,
                         placed: PlaceDesc::WHOLE,
                         asked: PlaceDesc::WHOLE,
+                        ask_holds: LayoutHolds::ANY,
                         re_asked: false,
                     },
                     rsc,
@@ -489,7 +503,6 @@ impl UiRenderState {
             primitives,
             mask_region,
             children,
-            size_deps,
             declared: rsc.widgets().declared_lens(id),
             own_align: rsc.widgets().alignment(id),
             move_idx,
@@ -570,12 +583,18 @@ impl UiRenderState {
         };
         if !active.drawn {
             #[cfg(feature = "layout-diagnostics")]
-            diag::reuse(id, ReuseOutcome::Undrawn);
+            {
+                diag::bump(Counter::ReuseUndrawn);
+                diag::reuse(id, ReuseOutcome::Undrawn);
+            }
             return false;
         }
         if active.is_region_node() != info.region_node {
             #[cfg(feature = "layout-diagnostics")]
-            diag::bump(Counter::ReuseWrongNode);
+            {
+                diag::bump(Counter::ReuseWrongNode);
+                diag::reuse(id, ReuseOutcome::WrongNode);
+            }
             return false;
         }
         // Drawn on another layer: the drawing sits in that layer's list and
@@ -591,7 +610,15 @@ impl UiRenderState {
             }
             return false;
         }
+        // Its primitives name the mask it inherited, and a masking parent
+        // that redrew pushed another: keeping them would clip them by one
+        // nothing updates again.
         if active.parent_mask != info.mask {
+            #[cfg(feature = "layout-diagnostics")]
+            {
+                diag::bump(Counter::ReuseWrongMask);
+                diag::reuse(id, ReuseOutcome::WrongMask);
+            }
             return false;
         }
         // Drawn somewhere else in the tree: its box is in coordinates it no
@@ -684,7 +711,7 @@ impl UiRenderState {
         );
         let info = DrawInfo {
             layer: active.layer,
-            parent: Some(at.id),
+            parent: at.id,
             depth: at.depth + 1,
             parent_move: at.move_idx,
             region_node: active.is_region_node(),
@@ -693,6 +720,8 @@ impl UiRenderState {
             region,
             placed: place,
             asked: active.asked,
+            // Placing decides no box: this is the one the ask already gave.
+            ask_holds: LayoutHolds::ANY,
             re_asked: active.re_asked,
         };
         self.relocate(child, placed, info, rsc);
@@ -721,7 +750,7 @@ impl UiRenderState {
             rsc.ui_mut().masks.get_mut(active.mask).region = mask_region.within(&placed);
         }
         let at = Placing {
-            id,
+            id: Some(id),
             region: placed,
             rel_base: info.rel_base,
             depth: info.depth,
@@ -800,7 +829,6 @@ impl UiRenderState {
         }
         // After the descendants, whose slots name this one as their parent.
         self.drop_slot(id);
-        active.size_deps.clear();
         active.drawn = false;
         self.active.insert(id, active);
     }
@@ -844,7 +872,6 @@ impl UiRenderState {
                 primitives: Vec::new(),
                 mask_region: None,
                 children: Vec::new(),
-                size_deps: Vec::new(),
                 move_idx: info.parent_move,
                 declared: Declared::NONE,
                 own_align: rsc.widgets().alignment(id),
@@ -1055,29 +1082,19 @@ impl UiRenderState {
         if !active.drawn {
             return true;
         }
-        // Nothing above the root resolved its rules or its alignment, so its
-        // box is its own to work out again against the output. Every other
-        // widget was given one.
-        let Some(parent) = active.parent else {
-            let (rel_base, region) = Self::root_layout(id, rsc.widgets());
-            let info = DrawInfo {
-                mask: active.parent_mask,
-                ..self.root_info(rel_base, region)
-            };
-            #[cfg(feature = "layout-diagnostics")]
-            diag::bump(Counter::LocalRedraws);
-            let old = self.remove(id, false, rsc);
-            self.draw_inner(id, info, old, rsc);
-            return true;
-        };
         let (was_answer, was_holds, was_place) = (active.answer, active.holds, active.placed);
         // The question its parent asked, asked again: the same place of the
         // box the parent was asked in, which is the box the parent's own
         // draw ran in and what its children's parts are of. Where the
         // parent's answer put its own drawing is not a question anybody
-        // asked, and nothing is asked in it here either.
-        let parent_at = self.placing_of(parent, self.active[&parent].region);
-        let (rel_base, region) = Self::ask_again(active, &parent_at, active.asked);
+        // asked, and nothing is asked in it here either. The root's parent is
+        // the window, which no draw made and no answer can move.
+        let at = match active.parent {
+            Some(parent) => self.placing_of(parent, self.active[&parent].region),
+            None => Placing::WINDOW,
+        };
+        let ask = at.ask(rsc.widgets(), self.output_size, id, active.asked);
+        let (rel_base, region) = (ask.rel_base, ask.region);
         let info = DrawInfo {
             layer: active.layer,
             parent: active.parent,
@@ -1087,8 +1104,9 @@ impl UiRenderState {
             mask: active.parent_mask,
             rel_base,
             region,
-            placed: active.asked,
+            placed: ask.place,
             asked: active.asked,
+            ask_holds: ask.holds,
             re_asked: false,
         };
         #[cfg(feature = "layout-diagnostics")]
@@ -1097,34 +1115,50 @@ impl UiRenderState {
         let old = self.remove(id, false, rsc);
         let drawn = self.draw_inner(id, info, old, rsc);
         let active = self.active.get_mut(&id).unwrap();
+        // Against the box it was asked in, which is what both contracts are
+        // about. Where the answer put the drawing is shorter than that
+        // wherever the widget reported less than it was offered.
+        let (window, rel_base, region) = (self.output_size, active.rel_base, active.region);
         // A wider contract does not invalidate the guarantee the parent kept.
-        // Retain that guarantee so widening and narrowing back do not churn it.
+        // Retain that guarantee so widening and narrowing back do not churn
+        // it -- but only where the narrower range still holds here: one this
+        // window is outside is refused by the parent's next ask, and refusing
+        // it throws away the drawing this one just made.
         if let Some(was) = was_answer
             && drawn.answer.size == was.size
             && drawn.answer.holds.covers(was.holds)
+            && was.holds.contains(window, rel_base, region)
         {
             active.answer = was_answer;
         }
-        if active.holds.covers(was_holds)
-            && was_holds.contains(self.output_size, active.rel_base, active.placement)
-        {
+        if active.holds.covers(was_holds) && was_holds.contains(window, rel_base, region) {
             active.holds = was_holds;
         }
-        if active.answer != was_answer || active.holds != was_holds {
-            // The parent retains both the answer and the drawing's validity;
-            // even an unchanged size can narrow the range safe for a resize.
-            #[cfg(feature = "layout-diagnostics")]
-            {
-                diag::bump(Counter::SizeChanges);
-                diag::bump(Counter::ReaderEdges);
+        let changed = active.answer != was_answer || active.holds != was_holds;
+        // Nothing above the root retained either, so there is nobody to tell
+        // and nowhere else the drawing has to go back to.
+        if let Some(parent) = active.parent {
+            match changed {
+                // The parent retains both the answer and the drawing's
+                // validity; even an unchanged size can narrow the range safe
+                // for a resize.
+                true => {
+                    #[cfg(feature = "layout-diagnostics")]
+                    {
+                        diag::bump(Counter::SizeChanges);
+                        diag::bump(Counter::ReaderEdges);
+                    }
+                    self.mark(parent, rsc.widgets_mut());
+                }
+                // The answer stands, so where the parent put it stands: the
+                // fresh drawing goes back there -- the same place, of the box
+                // the parent's answer chose rather than the one it was asked
+                // in.
+                false => {
+                    let at = self.placing_of(parent, self.active[&parent].placement);
+                    self.place_in(id, &at, was_place, rsc);
+                }
             }
-            self.mark(parent, rsc.widgets_mut());
-        } else {
-            // The answer stands, so where the parent put it stands: the
-            // fresh drawing goes back there -- the same place, of the box
-            // the parent's answer chose rather than the one it was asked in.
-            let at = self.placing_of(parent, self.active[&parent].placement);
-            self.place_in(id, &at, was_place, rsc);
         }
         true
     }
@@ -1135,7 +1169,7 @@ impl UiRenderState {
     fn placing_of(&self, id: WidgetId, region: UiRegion) -> Placing {
         let active = &self.active[&id];
         Placing {
-            id,
+            id: Some(id),
             region,
             rel_base: active.rel_base,
             depth: active.depth,
@@ -1150,7 +1184,7 @@ impl Size {
     /// in. Both are lengths of the window, so the comparison is in its
     /// pixels. A share is a length only to whoever divides one, so it is not
     /// a claim about this box and cannot exceed it.
-    fn within_box(self, region: UiRegion, window: PxVec2, axis: Axis) -> bool {
+    fn within_box(&self, region: UiRegion, window: PxVec2, axis: Axis) -> bool {
         let len = self[axis];
         let window = window[axis];
         len.leftover != Weight::ZERO

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/widget/size_rule.rs

@@ -22,7 +22,7 @@ impl SizeRule {
     /// 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(LayoutLen::declared)
+        self.exact().and_then(|len| len.declared())
     }
 
     /// The length this rule gives outright, whatever the widget reports --
@@ -36,14 +36,6 @@ impl SizeRule {
             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,
-        }
-    }
 }
 
 impl From<LayoutLen> for SizeRule {

core/src/widget/widgets.rs

@@ -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>
@@ -154,7 +162,7 @@ impl Widgets {
         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 +196,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,

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

@@ -8,23 +8,16 @@
 use crate::prelude::*;
 use std::collections::HashMap;
 
-/// The declared lengths of one widget carrying a size rule, by axis.
-pub type Lens = [Option<LayoutLen>; 2];
-
-/// Where one widget carrying an alignment sits, by axis. `None` uses the
-/// centered default.
-pub type Aligns = [Option<AxisAlign>; 2];
-
 /// What a test changes between two trees grown from the same seed, so the
 /// warm one can be mutated and the cold one grown that way to begin with.
 #[derive(Default)]
 pub struct Edits {
     /// Declared sizes, by the order the rules were put on.
-    pub sizes: HashMap<usize, Lens>,
+    pub sizes: HashMap<usize, SizeRules>,
     /// Which children a span has, by the order the spans were made.
     pub spans: HashMap<usize, SpanEdit>,
     /// Alignments, by the order they were put on.
-    pub aligns: HashMap<usize, Aligns>,
+    pub aligns: HashMap<usize, Align>,
     /// Which widgets own a movable region, by the order they were offered
     /// one. Region nodes change what a move writes and how deep a primitive's
     /// chain is, so a tree that never grows one leaves both untested.
@@ -176,9 +169,11 @@ pub struct Plan {
     /// it one and the offer is taken or declined; a second offer to the same
     /// widget is dropped, because two rules on one widget would settle in the
     /// order they were applied rather than in grow order.
-    pub size: Option<Lens>,
-    /// The alignment it carries, under the same one-offer rule.
-    pub align: Option<Aligns>,
+    pub size: Option<SizeRules>,
+    /// The alignment it carries, under the same one-offer rule. An axis left
+    /// out takes the centered default, which is what [`RegionAlign`] reads it
+    /// as.
+    pub align: Option<Align>,
     /// Whether it was offered a movable region of its own and what it
     /// answered. `Some(false)` is an offer declined, which still uses up the
     /// one offer, where `None` is an offer never made.
@@ -195,6 +190,9 @@ pub enum Kind {
         color: usize,
         alpha: u8,
     },
+    /// The one leaf whose own length is a number of pixels it knows before it
+    /// is drawn, which is the hint a rule beside it has to win over.
+    Image,
     /// Scrolling reads the pixel length of its box, which nothing else here
     /// does, and gives its child a box longer than its own.
     Scroll {
@@ -448,9 +446,11 @@ impl Kind {
         }
         match self {
             // The one leaf that reads the width it is given, then the one
-            // that does not, then the one that measures nothing at all.
+            // that does not, then the one that measures nothing at all. A
+            // picture measures nothing either, but its length is its own, so
+            // it steps to the leaf that takes whatever it is given.
             Kind::Wrapped => out.push(Kind::OneLine),
-            Kind::OneLine => out.push(Kind::Rect {
+            Kind::OneLine | Kind::Image => out.push(Kind::Rect {
                 color: 0,
                 alpha: 255,
             }),
@@ -632,9 +632,10 @@ struct Sow<'a> {
 
 impl Sow<'_> {
     fn leaf(&mut self) -> Plan {
-        Plan::bare(match self.rng.below(4) {
+        Plan::bare(match self.rng.below(5) {
             0 => Kind::Wrapped,
             1 => Kind::OneLine,
+            2 => Kind::Image,
             _ => {
                 let color = self.rng.below(COLORS.len());
                 let alpha = (self.rng.below(5) * 63) as u8;
@@ -651,7 +652,7 @@ impl Sow<'_> {
         }
     }
 
-    fn align(&mut self) -> Aligns {
+    fn align(&mut self) -> Align {
         let axis = |s: &mut Self| match s.rng.below(4) {
             0 => None,
             1 => Some(AxisAlign::NEG),
@@ -661,15 +662,21 @@ impl Sow<'_> {
         let (x, y) = (axis(self), axis(self));
         // Aligning on neither axis leaves the branch unexercised.
         match x.is_none() && y.is_none() {
-            true => [Some(AxisAlign::CENTER), y],
-            false => [x, y],
+            true => Align {
+                x: Some(AxisAlign::CENTER),
+                y,
+            },
+            false => Align { x, y },
         }
     }
 
     /// A declared size over half the tree, kept where a test can change it.
     fn sized(&mut self, inner: &mut Plan) {
         let take = self.rng.chance();
-        let lens = [self.len(), self.len()];
+        let lens = SizeRules {
+            x: self.len().into(),
+            y: self.len().into(),
+        };
         if !take || inner.size.is_some() {
             return;
         }
@@ -773,10 +780,6 @@ impl Sow<'_> {
         self.spans += 1;
         let edit = self.edits.spans.get(&idx).cloned().unwrap_or_default();
         let dir = self.rng.below(4);
-        // A row takes the height it is given rather than its tallest child,
-        // which is a rule beside it. Derived from an existing choice and
-        // consuming no randomness: a seed must keep growing the same tree
-        // when the generator gains another configuration.
         let gap = self.rng.below(3) as i32 * 4;
         let grown: Vec<usize> = (0..children.len()).collect();
         let order = span_edited(&grown, children.len(), spares.len(), &edit);
@@ -796,6 +799,7 @@ pub fn build<Rsc: UiRsc + 'static>(rsc: &mut Rsc, plan: &Plan) -> (StrongWidget,
     let mut build = Build {
         rsc,
         tree: Tree::default(),
+        checkerboard: None,
     };
     let root = build.node(plan);
     (root, build.tree)
@@ -804,6 +808,10 @@ pub fn build<Rsc: UiRsc + 'static>(rsc: &mut Rsc, plan: &Plan) -> (StrongWidget,
 struct Build<'a, Rsc> {
     rsc: &'a mut Rsc,
     tree: Tree,
+    /// The checkerboard, uploaded when the first image in this tree is built.
+    /// A handle is a reference to the texture, so every image after that one
+    /// clones this rather than uploading the same picture again.
+    checkerboard: Option<TextureHandle>,
 }
 
 impl<Rsc: UiRsc + 'static> Build<'_, Rsc> {
@@ -811,16 +819,14 @@ impl<Rsc: UiRsc + 'static> Build<'_, Rsc> {
         let built = self.kind(&plan.kind);
         let id = built.id();
         if let Some(lens) = plan.size {
-            self.rsc
-                .ui_mut()
-                .widgets
-                .set_size_rules(id, lens[0], lens[1]);
+            self.rsc.ui_mut().widgets.set_size_rules(id, lens.x, lens.y);
             self.tree.sized.push(id);
         }
         if let Some(align) = plan.align {
+            let resolved = RegionAlign::from(align);
             let widgets = &mut self.rsc.ui_mut().widgets;
-            for (axis, align) in [Axis::X, Axis::Y].into_iter().zip(align) {
-                widgets.set_alignment(id, axis, align.unwrap_or_default());
+            for axis in Axis::BOTH {
+                widgets.set_alignment(id, axis, resolved[axis]);
             }
             self.tree.aligned.push(id);
         }
@@ -831,6 +837,20 @@ impl<Rsc: UiRsc + 'static> Build<'_, Rsc> {
         built
     }
 
+    /// The one picture the generated trees draw: a 64x64 checkerboard of purple
+    /// and black in 8 px cells. Committed rather than drawn here, so that one
+    /// seed is one tree whatever anything else does, and included rather than
+    /// opened, so that growing a tree does not depend on a working directory.
+    fn checkerboard(&mut self) -> TextureHandle {
+        if self.checkerboard.is_none() {
+            let image = include_bytes!("assets/checkerboard.png")
+                .get_image()
+                .expect("the checkerboard is committed beside this file");
+            self.checkerboard = Some(self.rsc.ui_mut().textures.add(image));
+        }
+        self.checkerboard.clone().unwrap()
+    }
+
     fn kind(&mut self, kind: &Kind) -> StrongWidget {
         let id: StrongWidget = match kind {
             Kind::Wrapped => wtext(WORDS).size(16).wrap(true).add_strong(self.rsc),
@@ -839,6 +859,7 @@ impl<Rsc: UiRsc + 'static> Build<'_, Rsc> {
                 .wrap(false)
                 .add_strong(self.rsc),
             Kind::Rect { color, alpha } => rect(COLORS[*color].alpha(*alpha)).add_strong(self.rsc),
+            Kind::Image => Image::new(self.checkerboard()).add_strong(self.rsc),
             Kind::Scroll { axis, inner } => {
                 let inner = self.node(inner);
                 let id = Scroll::new(inner, *axis).add(self.rsc);
@@ -915,6 +936,10 @@ impl<Rsc: UiRsc + 'static> Build<'_, Rsc> {
                     gap: Px::from_int(*gap),
                 }
                 .add(self.rsc);
+                // A row takes the height it is given rather than its tallest
+                // child, which is a rule beside the span rather than anything
+                // it draws. Derived from `dir` rather than stored, so a plan
+                // that says the direction says this too.
                 if dir.axis == Axis::X {
                     self.rsc
                         .widgets_mut()

src/widget/image.rs

@@ -16,6 +16,15 @@ impl Widget for Image {
     }
 }
 
+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 }
+    }
+}
+
 pub fn image<State: UiRsc>(image: impl LoadableImage) -> impl WidgetFn<State, Image> {
     let image = image.get_image().expect("Failed to load image");
     move |state| Image {

src/widget/position/scroll.rs

@@ -24,36 +24,37 @@ impl Widget for Scroll {
             self.amt = self.content_len - self.container_len;
         }
         self.update_amt();
-        let align = painter.alignment()[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.
+        // 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 && align == AxisAlign::NEG {
+        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());
-        // 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;
-        let content = match moved || self.content_len != self.container_len {
+        // 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, anchor - self.amt);
+                let start = Len::from_parts(Rel::ZERO, -self.amt);
                 UiSpan::new(start, start.offset(self.content_len)).shifted_desc()
             }
             false => PlaceDescAxis::WHOLE,

src/widget/position/span.rs

@@ -52,25 +52,15 @@ impl Widget for Span {
 
         // 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 room = row - total.without_leftover();
-        // Whether anything is left over is a question in pixels: `rel(0.5)`
-        // beside 300 px is full at 600 and overfull at 400. Asked of `room`
-        // itself, and answered back through the same expression, so the
-        // boundary is the drawing's own and not a second way of finding it:
-        // the three cases a rounded division needed -- the fixed parts
+        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 `through` already reads. What the
-        // generated oracle checks is the consequence, since which children
-        // exist at all turns on this.
+        // 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.to_px(room, axis) > Px::ZERO;
-        if any_leftover {
-            let holds = match has_room {
-                true => Holds::from(Px::STEP..=Px::MAX),
-                false => Holds::from(Px::MIN..=Px::ZERO),
-            };
-            painter.window_holds(axis, holds.through(room));
-        }
+        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
@@ -124,7 +114,7 @@ impl Widget for Span {
             if shrinks {
                 // 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.is_px() {
                     ortho = LayoutLen::LEFTOVER;

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/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);
                 }
             }

src/widget/wrapper.rs

@@ -9,6 +9,7 @@ use std::marker::Unsize;
 ///
 /// 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>,
 }
@@ -26,11 +27,7 @@ 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)
     }
@@ -42,9 +39,3 @@ impl Wrapper {
         self.inner.replace(to)
     }
 }
-
-impl Default for Wrapper {
-    fn default() -> Self {
-        Self::empty()
-    }
-}

tests/cases/determinism.rs

@@ -69,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),
@@ -88,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::*;
 
@@ -219,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) + LayoutLen::LEFTOVER, 400),
+        (LayoutLen::px(500) + LayoutLen::LEFTOVER, 500),
+        (LayoutLen::rel(0.5) + LayoutLen::LEFTOVER, 400),
+        (LayoutLen::rel(2.0) + LayoutLen::LEFTOVER, 800),
+        (LayoutLen::px(500), 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) + 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) + LayoutLen::LEFTOVER);
+        h.frame();
+        assert_eq!(width(&h), Px::from_int(400), "wrapped: {wrapped}");
+
+        h.set_len(probe, Axis::X, LayoutLen::px(500) + 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));
@@ -858,3 +988,19 @@ fn a_collapsed_share_keeps_the_gaps_before_the_next_slot() {
         }
     }
 }
+
+/// 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));
+}

tests/cases/plan.rs

@@ -5,7 +5,9 @@
 //! and the oracle another. And reducing a plan has to end, or a shrinker
 //! searching for the smallest counterexample never returns.
 
-use iris::random::{Edits, Kind, Plan, Rng, SpanEdit, plan};
+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 {
@@ -25,11 +27,27 @@ fn some_edits(seed: u64, of: &Plan) -> Edits {
     Edits {
         sizes: pick(sized, &mut rng)
             .into_iter()
-            .map(|i| (i, [Some(LayoutLen::LEFTOVER), None]))
+            .map(|i| {
+                (
+                    i,
+                    SizeRules {
+                        x: SizeRule::Exact(LayoutLen::LEFTOVER),
+                        y: SizeRule::Free,
+                    },
+                )
+            })
             .collect(),
         aligns: pick(aligned, &mut rng)
             .into_iter()
-            .map(|i| (i, [Some(AxisAlign::POS), None]))
+            .map(|i| {
+                (
+                    i,
+                    Align {
+                        x: Some(AxisAlign::POS),
+                        y: None,
+                    },
+                )
+            })
             .collect(),
         nodes: pick(nodes, &mut rng)
             .into_iter()
@@ -51,8 +69,6 @@ fn some_edits(seed: u64, of: &Plan) -> Edits {
     }
 }
 
-use iris::prelude::*;
-
 /// 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
@@ -70,11 +86,13 @@ fn editing_a_plan_is_growing_one_with_those_edits() {
     }
 }
 
-/// Every simplification is strictly smaller, so taking them in turn reaches a
-/// fixed point instead of circling. A shrinker that can return to a tree it
-/// has already tried does not stop.
+/// 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 every_simplification_of_a_plan_is_smaller_than_it() {
+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];
@@ -119,3 +137,20 @@ fn reducing_a_plan_all_the_way_ends() {
         );
     }
 }
+
+/// 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/retained.rs

@@ -45,7 +45,6 @@ fn counted(h: &mut Harness, size: Size, reads_box: bool) -> (WeakWidget<Counted>
 
 struct Layered {
     children: [StrongWidget<Rect>; 2],
-    _revision: usize,
 }
 
 impl Widget for Layered {
@@ -65,14 +64,10 @@ fn a_redrawn_layered_widget_keeps_the_layer_it_was_entered_on() {
         rect(Color::RED).add_strong(&mut h.rsc),
         rect(Color::BLUE).add_strong(&mut h.rsc),
     ];
-    let root = Layered {
-        children,
-        _revision: 0,
-    }
-    .add(&mut h.rsc);
+    let root = Layered { children }.add(&mut h.rsc);
     h.set_root(root);
 
-    h.rsc[root]._revision += 1;
+    h.rsc.widgets_mut().mark_for_redraw(root.id());
     h.frame();
 
     let label = h.rsc.widgets().label(root.id());
@@ -181,9 +176,9 @@ fn a_repaint_that_keeps_its_size_does_not_relay_out() {
     h.set_root((first, second).span(Dir::RIGHT));
     let settled = draws.get();
 
-    // Taking mutable access is the ordinary content-change signal. This
-    // widget returns the same size, so the parent has nothing to lay out.
-    let _ = h.rsc.widgets_mut().get_dyn_mut(first.id());
+    // Marked with nothing about it changed, and it reports the same size
+    // either way, so the parent has nothing to lay out.
+    h.rsc.widgets_mut().mark_for_redraw(first.id());
     h.frame();
 
     assert_eq!(draws.get(), settled + 1);
@@ -198,7 +193,7 @@ fn a_span_child_survives_the_next_frame() {
     let bottom = rect(Color::BLUE).height(120).add(&mut h.rsc);
     h.set_root((top, bottom).span(Dir::DOWN));
 
-    h.rsc.widgets_mut().get_dyn_mut(top.id());
+    h.rsc.widgets_mut().mark_for_redraw(top.id());
     h.frame();
 
     assert_corners!(h, top, (0, 0), (400, 80));
@@ -660,7 +655,7 @@ fn a_masked_widget_redrawn_on_its_own_sets_its_mask_again() {
     let masked = inner.masked().add(&mut h.rsc);
     let other = rect(Color::RED).width(100).add(&mut h.rsc);
     h.set_root((other, masked).span(Dir::RIGHT));
-    h.rsc.widgets_mut().get_dyn_mut(masked.id());
+    h.rsc.widgets_mut().mark_for_redraw(masked.id());
     h.frame();
     assert_corners!(h, inner, (100, 0), (400, 200));
 }
@@ -774,6 +769,17 @@ fn a_subtree_that_changed_parents_settles_at_the_depth_it_moved_to() {
     );
 }
 
+/// Where a mask slot clips, in window pixels: the region it holds, carried
+/// through whatever move entry it hangs from. Taken by slot rather than by
+/// widget, so a test can name the slot it expects a redraw to keep.
+fn mask_bounds(h: &Harness, mask: MaskIdx) -> PixelRegion {
+    let mask = &h.rsc.ui().masks[mask.idx()];
+    h.render
+        .moves
+        .resolve(mask.move_idx, mask.region)
+        .to_px(h.render.output_size())
+}
+
 fn primitive_bounds(h: &Harness, id: WidgetId) -> Vec<PixelRegion> {
     h.render.active[&id]
         .primitives
@@ -919,15 +925,10 @@ fn resizing_a_fixed_frame_recomposes_its_contents_without_drawing_them() {
             primitive_bounds(&warm, leaf.id()),
             primitive_bounds(&cold, other.id())
         );
-        let mask = |h: &Harness, id: WidgetId| {
-            let active = &h.render.active[&id];
-            let mask = &h.rsc.ui().masks[active.mask.idx()];
-            h.render
-                .moves
-                .resolve(mask.move_idx, mask.region)
-                .to_px(h.render.output_size())
-        };
-        assert_eq!(mask(&warm, leaf.id()), mask(&cold, other.id()));
+        assert_eq!(
+            mask_bounds(&warm, warm.render.active[&leaf.id()].mask),
+            mask_bounds(&cold, cold.render.active[&other.id()].mask)
+        );
     }
 }
 
@@ -994,7 +995,7 @@ fn glyph_origins_compose_identically_when_drawn_and_when_retained() {
             assert_eq!(draws.get(), before);
             let retained = primitive_bounds(&h, text.id());
             assert!(!retained.is_empty());
-            let _ = h.rsc.widgets_mut().get_dyn_mut(text.id());
+            h.rsc.widgets_mut().mark_for_redraw(text.id());
             h.frame();
             assert!(draws.get() > before);
             assert_eq!(retained, primitive_bounds(&h, text.id()));
@@ -1184,15 +1185,10 @@ fn padding_and_stack_boxes_follow_the_region_without_drawing_again() {
                 assert_eq!(warm.region(&a), cold.region(&b));
                 assert_eq!(primitive_bounds(&warm, a), primitive_bounds(&cold, b));
             }
-            let mask = |h: &Harness, id: WidgetId| {
-                let active = &h.render.active[&id];
-                let mask = &h.rsc.ui().masks[active.mask.idx()];
-                h.render
-                    .moves
-                    .resolve(mask.move_idx, mask.region)
-                    .to_px(h.render.output_size())
-            };
-            assert_eq!(mask(&warm, leaf.id()), mask(&cold, other.id()));
+            assert_eq!(
+                mask_bounds(&warm, warm.render.active[&leaf.id()].mask),
+                mask_bounds(&cold, cold.render.active[&other.id()].mask)
+            );
         }
     }
 }
@@ -1374,20 +1370,14 @@ fn a_redrawn_mask_keeps_reused_primitives_clipped_when_it_moves() {
         h.set_root((first, masked).span(Dir::DOWN));
         let mask = h.render.active[&masked.id()].mask;
         let settled = draws.get();
-        h.rsc.widgets_mut().get_dyn_mut(masked.id());
+        h.rsc.widgets_mut().mark_for_redraw(masked.id());
         h.frame();
         assert_eq!(primitive_masks(&h, inner.id()), vec![mask]);
         assert_eq!(draws.get(), settled, "a mask repaint must reuse its child");
         assert_eq!(h.render.active[&masked.id()].mask, mask);
         h.set_len(first, Axis::Y, 10);
         h.frame();
-        let clip = h.rsc.ui().masks[mask.idx()];
-        let clip = h
-            .render
-            .moves
-            .resolve(clip.move_idx, clip.region)
-            .to_px(h.render.output_size());
-        assert_eq!(clip, h.region(&masked).unwrap());
+        assert_eq!(mask_bounds(&h, mask), h.region(&masked).unwrap());
         assert_corners!(h, inner, (0, 10), (400, 200));
     }
 }
@@ -1477,3 +1467,99 @@ fn a_redrawn_subtree_is_not_undrawn_by_the_parent_it_left() {
         assert_eq!(h.region(&leaf), before);
     }
 }
+
+/// A leaf that reports less than the box it is given and states which lengths
+/// of that box its drawing holds for, so a test can widen the contract
+/// without changing the answer. It counts its draws, since what a kept
+/// contract costs is whether the parent has to make it draw again.
+struct Contracted {
+    holds: std::ops::RangeInclusive<Px>,
+    size: Size,
+    draws: Rc<Cell<usize>>,
+}
+
+impl Widget for Contracted {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        self.draws.set(self.draws.get() + 1);
+        painter.holds(Axis::X, self.holds.clone());
+        self.size
+    }
+}
+
+struct CountedParent {
+    inner: StrongWidget,
+    draws: Rc<Cell<usize>>,
+}
+
+impl Widget for CountedParent {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        self.draws.set(self.draws.get() + 1);
+        painter.widget(&self.inner).size()
+    }
+}
+
+#[test]
+fn widening_what_a_drawing_holds_for_does_not_relay_out_the_parent() {
+    let mut h = Harness::new((400, 200));
+    let child = Contracted {
+        holds: Px::from_int(300)..=Px::from_int(500),
+        size: Size::from((100, 200)),
+        draws: Rc::new(Cell::new(0)),
+    }
+    .add(&mut h.rsc);
+    let draws = Rc::new(Cell::new(0));
+    let root = CountedParent {
+        inner: child.upgrade(&mut h.rsc),
+        draws: draws.clone(),
+    }
+    .add(&mut h.rsc);
+    h.set_root(root);
+    let settled = draws.get();
+
+    // The same answer, good for more boxes than before, so the guarantee the
+    // parent kept still holds.
+    h.rsc[child].holds = Px::from_int(200)..=Px::from_int(600);
+    h.frame();
+
+    assert_eq!(
+        draws.get(),
+        settled,
+        "a wider contract for the same answer is not a change to lay out"
+    );
+}
+
+/// The other half of the rule above: a kept contract is the narrower one, so
+/// it is only worth keeping where it still holds. A window the old range is
+/// outside is not one its parent can be handed back, and keeping it there
+/// throws away the drawing the widget just made.
+#[test]
+fn a_contract_this_window_is_outside_is_not_kept() {
+    let mut h = Harness::new((400, 200));
+    let leaf_draws = Rc::new(Cell::new(0));
+    let child = Contracted {
+        holds: Px::from_int(300)..=Px::from_int(500),
+        size: Size::from((100, 200)),
+        draws: leaf_draws.clone(),
+    }
+    .add(&mut h.rsc);
+    let root = CountedParent {
+        inner: child.upgrade(&mut h.rsc),
+        draws: Rc::new(Cell::new(0)),
+    }
+    .add(&mut h.rsc);
+    h.set_root(root);
+
+    // Wide enough that the old contract leaves the new box out, and the leaf
+    // is marked in the same frame -- so it settles itself first and its
+    // parent draws afterwards, asking about what it settled.
+    h.resize((600, 200));
+    h.rsc[child].holds = Px::from_int(200)..=Px::from_int(700);
+    let settled = leaf_draws.get();
+    h.frame();
+
+    assert_eq!(
+        leaf_draws.get(),
+        settled + 1,
+        "the leaf settled once and its parent kept what it settled"
+    );
+}

tests/cases/scroll.rs

@@ -113,7 +113,7 @@ fn wrapping_content_beside_a_fixed_length_is_stable_warm_and_cold() {
 
     let mut warm = Harness::new((900, 300));
     let (text, content) = plant(&mut warm);
-    warm.rsc.widgets_mut().get_dyn_mut(text);
+    warm.rsc.widgets_mut().mark_for_redraw(text);
     warm.frame();
 
     let mut cold = Harness::new((900, 300));
@@ -142,8 +142,8 @@ 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);
-    h.frame();
 }
 
 /// Content that fits sits in the viewport, not in a box of the window's

tests/cases/unsettled.rs

@@ -9,17 +9,45 @@
 //! 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;
 
+/// 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));
@@ -92,7 +120,7 @@ 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().get_dyn_mut(id);
+        warm.rsc.widgets_mut().mark_for_redraw(id);
     }
     warm.frame();
 
@@ -188,36 +216,31 @@ fn reordering_nested_spans_keeps_the_answer_from_the_decided_box() {
     assert_same_regions(&warm, &ids, &cold, &cold_ids);
 }
 
-/// Six widgets, shrunk from a 402-widget tree the fuzzer found. Nothing about
+/// 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
@@ -230,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();
     }
@@ -252,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]
@@ -306,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>) {
@@ -340,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]
@@ -364,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.
@@ -393,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 {
@@ -416,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(),
@@ -440,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
@@ -471,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())
 }
 
@@ -567,14 +545,7 @@ 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!(wrong.is_empty(), "{}", wrong.join("\n"));
+    assert_same_regions(&warm, &ids, &cold, &cold_ids);
 }
 
 /// Five widgets, shrunk by `tests/shrink.rs` from the 277 the oracle's seed
@@ -616,20 +587,13 @@ fn plant_nested_scrolls(h: &mut Harness) -> Vec<WidgetId> {
 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().get_dyn_mut(ids[0]);
+    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);
 
-    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);
 }
 
 /// Ten widgets, of the shape `tests/shrink.rs` reduces the oracle's seed 220
@@ -720,14 +684,7 @@ fn a_widget_under_a_region_node_is_asked_in_the_box_that_node_was_offered() {
     let (cold_ids, _) = plant_under_a_node(&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);
 }
 
 const PARAGRAPH: &str = "Wrapping shapes one source into as many lines as the \

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

@@ -25,10 +25,14 @@ fn depth() -> usize {
     env("IRIS_GENERATED_DEPTH", 4)
 }
 
-/// The seeds the ordinary tests take. Seven that have never failed; 86,
-/// which a `Scroll` fixed point once settled differently on; and 20, which
-/// caught a locally redrawn widget being placed twice in the box its parent
-/// had already placed it in.
+/// 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];
 
 fn check(seed: u64, depth: usize, case: Case) {
@@ -47,57 +51,50 @@ fn check_plan(grown: &Plan, seed: u64, depth: usize, case: Case) {
     }
 }
 
-macro_rules! case {
-    ($name:ident, $case:expr) => {
-        #[test]
-        fn $name() {
-            for seed in SEEDS {
-                check(seed, depth(), $case);
+/// 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,)*];
     };
 }
 
-case!(
-    many_widgets_redrawing_at_once_leaves_every_box_where_it_was,
-    Case::RepaintSome
-);
-case!(
-    everything_redrawing_at_once_leaves_every_box_where_it_was,
-    Case::Repaint
-);
-case!(
-    a_resize_lands_where_starting_at_that_size_would,
-    Case::Resize
-);
-case!(
-    a_resize_and_a_repaint_land_where_starting_that_way_would,
-    Case::ResizeRepaint
-);
-case!(
-    a_size_change_after_a_resize_lands_the_same_way,
-    Case::ResizeSize
-);
-case!(
-    a_size_change_lands_where_growing_it_that_way_would,
-    Case::Size
-);
-case!(
-    every_size_changing_at_once_lands_where_growing_it_that_way_would,
-    Case::EverySize
-);
-case!(
-    an_alignment_change_lands_where_growing_it_that_way_would,
-    Case::Align
-);
-case!(
-    giving_and_taking_a_movable_region_rebuilds_what_resolves_it,
-    Case::RegionNode
-);
-case!(
-    reordering_a_span_lands_where_growing_it_that_way_would,
-    Case::Reorder
-);
+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()
+        );
+    }
+}
 
 #[test]
 fn adding_and_removing_span_children_lands_where_growing_it_that_way_would() {
@@ -111,7 +108,7 @@ fn adding_and_removing_span_children_lands_where_growing_it_that_way_would() {
 }
 
 #[test]
-#[ignore = "as many seeds as it is asked for, 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 depth = depth();
     let seeds: Vec<u64> = match std::env::var("IRIS_GENERATED_SEED")

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

@@ -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();
@@ -195,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") {
@@ -203,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);
         });
     }
 
@@ -218,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);
             }
         });
     }
@@ -251,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/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

@@ -13,7 +13,7 @@
 
 use iris::harness::Harness;
 use iris::prelude::*;
-use iris::random::{Aligns, Edits, Kind, Lens, Plan, Rng, SpanEdit, Tree, build};
+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
@@ -190,7 +190,7 @@ impl Case {
 
 fn mark(warm: &mut Harness, tree: &Tree, step: usize) {
     for &id in tree.ids.iter().step_by(step) {
-        warm.rsc.widgets_mut().get_dyn_mut(id);
+        warm.rsc.widgets_mut().mark_for_redraw(id);
     }
 }
 
@@ -198,27 +198,32 @@ fn a_len(rng: &mut Rng) -> Option<LayoutLen> {
     Some(LayoutLen::px(20.0 + rng.below(180) as f32))
 }
 
-fn resize_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> Lens {
-    let lens = [a_len(rng), a_len(rng)];
+fn resize_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> SizeRules {
+    let lens = SizeRules {
+        x: a_len(rng).into(),
+        y: a_len(rng).into(),
+    };
     warm.rsc
         .widgets_mut()
-        .set_size_rules(tree.sized[idx], lens[0], lens[1]);
+        .set_size_rules(tree.sized[idx], lens.x, lens.y);
     lens
 }
 
-fn realign_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> Aligns {
+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 = [side(rng), side(rng)];
+    let align = Align {
+        x: side(rng),
+        y: side(rng),
+    };
     let id = tree.aligned[idx];
-    for (axis, align) in [Axis::X, Axis::Y].into_iter().zip(align) {
-        warm.rsc
-            .widgets_mut()
-            .set_alignment(id, axis, align.unwrap_or_default());
+    let taken = RegionAlign::from(align);
+    for axis in Axis::BOTH {
+        warm.rsc.widgets_mut().set_alignment(id, axis, taken[axis]);
     }
     align
 }

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) {
@@ -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]